Jaichand Khatik

Hi. I'm Jason. I have around 8.8 years of experience. I'm mainly working on the, uh, 8.8 per year of experience working on the web development. And my core contributions to the organizations are, like, writing the component library and, uh, come come writing the component library and making the micro front end area for the React Native mobile applications.

Yeah. When it comes for the Jenkins applications, we have to check. Yeah. When it comes for the Jenkins pipeline, which is breaking, so there will be some error specifically. Go to the Jenkins pipeline. Click on that. It will give you a specific reason where it is failing and what is the the reason of failing. So mostly, like, if there is no changes in the recent work, then there is a, uh, problem in the some somewhere, like, on the change inside only. Like, there might be some environment issue or some some something related to the plug in.

Yeah. So test cases are very first important. So whenever the direct line it's not like, uh, let's say if it is tight deadlines are there. So very first, like, uh, you will be writing the test cases in this starting. Like, whenever you're taking the requirement gathering, that time you will be firstly writing the test cases and then you will be writing your code. So in that case, like, your testing will be more easier. Like, you need not to do this specific unit test. So your test cases will be giving you the help that could be there. The test cases are working fine or not. So if I have to specifically plan for it, like, how can we do it? So there is, like, a very first like, whenever the application is getting started, the requirement gathering is happening, and you understood that these are the things which has to be built. Write your test cases in the starting. Once that is there, then start building the application tools.

Yeah. So very first, whenever you are introducing a library, so that I assume that all the research has been already done. And then now the decision has been taken that we have to introduce that library. So in case whenever the library is getting introduced, we have to check in where we're starting, like, uh, once that application is built, uh, library is introduced. There is no legacy, um, break. In case if it is the legacy is taken, then you have to provide the specific things for the legacy first, and you have to choose the specific parts first. Okay. These are the parts which I'll be touching in the starting. I'll be testing with it. And, uh, let's say instead of working on the whole application, you can choose in a small, small chunks that I'll be finishing this one x project. Yeah. One x piece with this library and will object the how things are going. In case if the all things are fine and it is working correctly that these library let things are already working fine, then you will observe for some time, and then you will start into this for the rest of the applications. So instead of adding these changes to the whole application, it will be great like a one piece of the co one piece of the application will be touched and implemented with the library, and then the next things will be taken.

Yeah. The approach for the test driven development is, like, whenever you are you are done with whenever you are starting your application, the very first write your all the test cases, the failure test cases, the success test cases, the all the scenarios. Let's say you should be covering your test cases whenever you're writing around 80%. And once the your test cases are done, then you will start writing the code in towards it. So you will be whenever you are writing a functionality, you will be cross checking with your test case. So you will be running your test case, and you will be checking what are the things which is getting, uh, success. So whenever you are pushing your code, that time you will make sure that you're all a 100% test coverage out there. Whatever the test code test cases you have written, which is covering your 80% of the code code is, you will be pushing your code code after that.

So here, users ID. Okay. So whenever the user ID is there, await user dot find. Okay. It will give you the users, and then it is doing this part. So okay. So there is a, uh, here, the one thing is that we are doing a whole users. We are fetching first. And after that, we are filtering and we are sending it to sending back to the front end. So it will be great, like, you do the query with the specific ID instead of fine taking out the whole user array, all the users table. So let's say, like, you just don't find index ID equal to something or find the one. There are some more queries which we can use. And if we have to use it something like this only, then we it is going to be time taken in that case.

Try, catch, let, s. Okay. That's data. Alright. Okay. So whenever it is written, right, that response of the first whenever you're using a fetch, then it will return you a rest uh, promise. And, uh, whenever, like, a response dot JSON is also returning your promise. So they should be awake whenever you are sending the data back. Otherwise, that response dot JSON won't be, like, resolved before that only you're pushing the datasets. Better you add a a rate on the response dot JSON before response dot JSON. Yeah. We'll use the async of it only, but I will add 2 awaits. Like, the first is response and then response to JSON is also the promise.

Sure. So whenever it comes for the data's database schema migration, so there are, uh, there are a lot of possibilities which we have to, uh, keep in mind. So very first, the production will not be touched before it is getting tested. So very first, it will be tested on the dev environment, then it will be on the stage environment. And, uh, if we have something in middle as well, let's say QA environment or something, we'll be testing it there. And to make it better, like, very first order of the schema, it could change and whatever the things which is already added. So very first, what we will be doing, like, we will be running our migrations. So on that those migrations, we will be updating our database first. And then whatever the keys which is newly added, we will be updating that first. Let's see if we have to use the same database schema, which has got modified instead of gin getting changed. So in that case, we will be creating the all newly we will be running our scripts like a migration script we have to write. In those migrations script, you will be running your all the data things and will be getting it. Efficient way of handling database. Okay. In these migrations, also, we will be adding the all of our failure things as well. Like, let's say, failure cases in case if that could fail at any place. So we will be capturing those things as well. And, uh, should we rewrite it? Rerend it. So cascading, we have to use. Yes. Like, in case if it is failing at any point, roll back, and then start doing from the scratch or whatever the whatever the places it could fail. We'll be adding that