Sachin Kumar

Yeah. My name is Sachin. I have 8 years of experience in the service industry, specifically in software testing. In this area, I have done manual testing, performance testing, and automation testing. In my previous company, I had 5 years of experience, where I focused on automation testing for performance calculating tools, such as JMeter. We also used other tools like NeoLoad for load generating and SoapUI for service virtualization, and NetDynamiq for method-level debugging. I used Selenium, Java, Ant, and Maven to run the automation scripts. In my current company, I have been working in the insurance domain for the last three years, whereas in my previous company, I worked in the e-commerce domain. As an automation tester, I have used Java, Selenium, BDD, JUnit, Maven, and other components like JavaScript. I have also been part of a CoE team, where my roles and responsibilities include designing a framework. I used singleton and factory design patterns for designing the framework. In the current projects, my roles and responsibilities involve creating test cases, identifying automation, and regularly running smoke and regression tests. We then publish the reports to the clients and provide the root cause and solution if any test cases fail in regression. This is a complete overview from my end. Apart from that, I have designed a framework for Playwright using Java technology. Playwright is a new tool in the market and is a competitor to Selenium. While Selenium has some limitations, such as synchronization issues and performance issues, Playwright does not have these issues. For defect tracking, I have used Jira, where we put all the repositories for test cases, map them to a particular defect, and so on. These are the complete details from my end.

So, if a Jenkins job fails due to a failed Selenium test, what steps need to be taken to resolve the issue. So in that case, first, we will see the logs of the Jenkins and in the logs, we will try to debug why this test is failing. For example, there are certain reasons for failing a Selenium test. Sometimes the environment is not loading, like in UAT, and whatever the environment we are testing, sometimes it is not loading. So, first, we will check if the environment is loading or not. If it is not loading, then it will give a 500 error. So, using Postman, we will trigger the same URL by using the API, so that we can get the respective things. If the environment is working fine, then we will check if any test is failing at a particular button or edit box, and these things. So, if it is failing, then we will check if any locator has been changed or if any page is not loaded. We will apply some waits, as there are waiting things or maybe many reasons for failing. For example, if we have designed some new dropdown things, then in the dropdown, if new items have been added, so that if the things are coming as an out-of-index error, index out of bounds, or some if in test we are connecting the database, so if the database is not running, these are the technical challenges. Or if the run-time frame ID is changed, so using switch to frame or many mechanisms, we will apply the wait and we will run our test in debugging mode, then we will try to resolve the issue, and it will be resolved. Then we will go with these approaches. So, these are the common things I have explained, so these are the common scenarios we can get in the failure. Apart from that, sometimes the Jenkins job is failed due to some grammatical error, for example, if someone is committed to the code, but there are some grammatical errors in the text, so that due to that also the Jenkins is failing, so that is also a scenario in which we need to check why it is failing and why it is giving the error. So, these are the mechanisms, and then for Selenium, for example, we are using IntelliJ or Eclipse, then we will put some debug pointers, then on the basis of that, we will analyze it. If we are not using IntelliJ and Eclipse, then we are using the terminal, we will go there and we will check what is going on. Because sometimes in the container, the Jenkins job is running, so the complete environment is different from what we are using in our locally. So, sometimes environments are also creating a problem, so these are from my end here.

To see, it would follow to Dynavize and fix centralization issues and sling the driver script. Okay. So in case of synchronization problem, so we have different languages. For example, I have used 2 or 3. I have used Selenium with Java, JavaScript, and Python. So if it comes for JavaScript in case of synchronization problems, we will make our function method as an async function. Right? So that in that case, we will not get any issues. But in case of Java, for example, like, we are getting some synchronization problems. Sometimes the page is loading in a very deep place, and it takes time to load. And, so, in that case, we will use the implicit wait for correcting the things and loading the URL properly in the browser. Now, but in terms of, for example, if an element is still not visible. So, the element is coming at some time. Sometimes it is coming in 5 seconds, sometimes in 30 seconds, or 60 seconds. So, in terms of that, we will have two types of waits. One is the explicit wait, and the third one is the fluent wait. So, in terms of the explicit wait, we are using it, and it will only be applicable for some types of conditions that we need to put. So, in this, we are mentioning the bit. Right? And we are giving some conditions. Likewise, for example, if an element is not coming, so that we can apply the condition in that way, and the element to be visible. So, when the element is visible in a particular time, then the function will wait. The control driver control will wait till that particular condition is not met. When it will be met, then it will go and complete the next operation. But, in terms of the fluent wait, we can also give some polling time. So, in that case, the fluent wait, we can give, like, as much time as the driver will go and check. So, in the default, if we will talk about the explicit wait, then it will take 2.5 milliseconds. For every 2 milliseconds, it is going and checking. But, in terms of that, if an element is still coming, then the element is coming in 10 milliseconds. So, using the fluent wait, we can also correct the things. So, means, so, likewise, there are two waiting mechanisms. We can correct the synchronization issues, or sometimes we need to add some hard-coded wait. If I have already explained, for example, if the environment is not loading, or in some cases, the frame is not loading in a particular condition. If window switching, we are using, so that, using the wait mechanism, we can do that.

Retail dot touch, you would take to use the page object, whatever the Selenium for enhancing the main deck. Okay. So, the page object model is a design pattern in Selenium, which is used to organize the page objects. In any framework, if we are using page objects as the main key to control the complete environment. Because using page objects, the driver will perform the operation, as per the manual also. We are going in that way, we are just clicking on a button. Sometimes we are editing. So then, likewise, these are the operations we are performing. But what are the values we are selecting on which elements we are selecting? That's our content in the pages. Right? The same way, using the page objects, we are organizing it because in the traditional approaches, all the objects are put in a single file. So that's why if anyone is using any feature file and we are using that particular function in which we have written some objects or in another file after some time, we are working. Right? And after some time, the developer changes their locators or objects so that we need to go in each and every file and correct the values. But using the page object model, we are making pages as per the objects in a page-wise manner. For example, we have a login functionality, and we are selecting a product, then we add the product to the cart. So in the case of, we are creating three pages, so in each page, we are providing, for example, login functionality. We are giving a login username and password, and then the login functionality. So this is one thing we are putting in this one class, but this is a component using the page object. This is a Java class in which we are maintaining it. For the next time, if the locator is changed and if a new feature file or if we have different types of test cases. Right? So because login functionality is used in each type of test case. So in terms of that, we can use it. But in the traditional approaches, it will create a problem because we cannot use it. So or if the selectors are this is a very simple flow, but in the case of form validation or form editing, there are 10 or 20 or 30 objects being used. So in the traditional approach, it is very hard to change and reuse the related functionality. So by using the page object model, we can correct it, and it has enhanced the reusability functionalities and maintainability. So two things we have done by using the page object model for enhancing the Selenium maintainability. This is the vital use of the page object model by using in Selenium.

Okay, so in terms of the Jenkins pipeline, we have stages for the Selenium test and reporting results. For example, if we are not using Jenkins, we are using TestNG. So in using TestNG, we are running our test, and we have an iTestListener and multiple listeners for reporting purposes, right? So in terms of that, we are calling it, and it is running the test and then producing the results. But in terms of a Jenkins pipeline, how we will do it, right? So in terms of that, we will include the stages because a Jenkins pipeline is composed of different types of stages. We can mention it. The first stage is running the Selenium test, and the second stage is reporting the results. So, two things we need to mention, and in each we are providing the action and whatever the command we are using that we will put inside it. Normally, we will not go into Jenkins pipeline details in a freestyle project. So, if we will create a freestyle project, we are providing the Git or local repository from where we need to pull the code, then we need to run our command. For example, in the Selenium test, what command we will use, then we will put it, and in the report, build, and build your report section, we will configure the particular report like that on which folder we need to take it, and then it will be in a Jenkins report. Then in Jenkins, we can see whatever the report it is generating the same things. Now, we will put all the things into stages. So, we will create two stages for it. One is for the Selenium test, and the second is for reporting. So, when we will run it, then it will be run, and then it will give the outcome, and using the console, we will see on which stage it is failing and on which stage it is giving the reporting results and everything. So, this is the answer.

So, in that case, for minimizing test flakiness in Selenium Automation. The reason behind that for flakiness is that sometimes the URL is not loading or it takes some requests time to get the response from the server. In terms of that, we have some attributes in Selenium so that request time out and page loaded time out can be set. By enabling that, we will increase the time limit for it. First, we will check it manually, how long it is taking time. For example, if any one request is taking previously, it was taking like 5 seconds, but sometimes, in some cases, it is taking 7 seconds or 8 seconds. So, respectively, we will change the value for the respective parameters. Like, as a base load wait time, we will increase it, but it will not increase like 200 seconds because browser load time is also 60 to 65 seconds. So, we will give the respective things if the particular URL is taking time to load it. And the second one is, if sometimes, the Dom's is taking time to load. Dom is very frequent. It is, it will not take time to load, but what are the images it is using in the back page then it will take time. So, in that case, we will increase the time for request time out so that it will go in a good way. And apart from that, it is also subjected to the synchronization problem. So, sometimes, for example, if a particular button is not visible and it is taking time, so that and that can also be minimized using the explicit rate, implicit rate, and fluent rate. So, using that, we will use that particular things to complete this. That's done from our end.

What we can do is to input the check for HTTP status node. Yes, so in terms of that, as per this, we are using a request.get and in which we are providing the URL and then we are capturing the response and then using assert response.status was double equals 200. So using that, we are checking a status code for it. So for improving that one, because sometimes when we are hitting the API, so API is giving the response as a 200, but responses are not coming as correct. So in that case, we can apply one more assert and in this, we can use some more attributes for the body. Likewise, if any, it is a token API, then it will give some authorization token in response or some token in response. So that token, we can verify or sometimes, for example, if some components are coming in response body, so using that assert, then we will verify the response body for that. And then secondly, different status codes are coming. For example, if it is a 400, it is coming or it is coming as a 500. So in that case, we can use some if or else condition, then inside that we will put some respective user-defined method so that when it will be running in a long way, it will give a user-friendly error message. So that anyone can read it and then complete that one. So, likewise, that we will add, or we will add the two or three things here. One is for checking some piece of code in body. What it is returning in a response. And secondly, we will use some if and else condition. So for example, if the status code is 200, then it is a success, but it may be a partial success, then we will use the body. But in terms of it coming as a 400, 500, then we will get like a user, it is a user error or it is a server-side error or some informational error. So information things that the server is returning or some headers we can also verify for, in that case, because sometimes JSON mode is returning, but the server is not returning as application/json. So in terms of that, we will also verify the headers in that case.

I'm getting some text support as Jake is made. Yeah. I'm so getting this to check. Keep a moment then. So in this particular syntax that we have three things we are using in this four things we are using in the BDD frame, but like as a given statement is for if something is given or something such types of statements are coming inside it in case of when it is some condition we are applying like as a user enters the parent credential then it means like as we are verifying some things like as users would be directed to the test. Correct. But in this particular snip so we have a but statement but it's not a part of the BDD framework. So we will use a when statement because there are two things but and when. So we will remove but and when it will come then the line will be like when the user clicks on logout. So this is also not looking good so that the user will use this one. Right? The line in that way when the user clicks on log out button so that it will be good. So this is one. So that this statement we will change. But firstly we will remove the but and in line number five and the statement will be starting with when and when will be in caps. The user and the complete statement is the user clicks on log out button. So these things we need to change. This is a mistake in this quote.

Sling event. Just checking. Yes. Correct. So in case of creation of a framework using Selenium and Jenkins. Jenkins is a CICD tool, so its use will be coming later. But in terms of Selenium and we have different types of design patterns. So, like, as in design pattern, traditional design pattern. So we have a single turn and factory design pattern and build that pattern also. So we have so many frames, so many things. So what I have used in my framework for designing things, I have used singleton as well as the factory design pattern. So in terms of singleton, we are creating a driver. We are creating an even class. So in this, we are putting a driver object as a private one so that if any class or any feature file will use that one or any class will use that type. So it will only return a single object. So that overall, we don't need to create an object every time and then it will be very maintainable for this one. Right? Second one is for doing the page object model. We are how we will store our page objects. So we will use the POM object model. So instead of Pro POM, we will use the page factory method for it. Or there are two design forms also a design pattern, and Page Factory model is also coming inside Selenium. But the problem is that in Page Factory, we don't have a cache-related thing. Like, something is present in cache that we cannot use this functionality. So it will be dependable. For example, if as per the frame I guess, for the project structure, if they want to read something from the cache, well, then we will go with the form design pattern. If we will if there is no need for caching, then we will go with the page object model. Page object factory, page factory method. So in that case, we just need to create just only create an object of page factory, then it will be loaded with all the page objects component inside it. So there are two approaches we will use for one is for this one, and then we will put the data in XML and JSON or our other things. So that this is a design for the framework. Then after that in Jenkins, we will create a job. Inside that, we will define the two different stages. One is for running the Selenium, and then the second one is for creating a report. So, likewise, that first, we will create a framework for Selenium, then we will integrate it with Jenkins so that in Jenkins, we will give that correct command, then it will go that way. So, likewise, I will use this approach for creating a framework and running it.

I employ manual testing skills to control the amount of data I download and save by setting specific parameters for the data retrieval process. I start by defining the scope of the data I need to download, including the specific fields or attributes I require. This helps me to focus on the essential information and avoid unnecessary data. Next, I use filters to narrow down the data based on specific criteria, such as date ranges, user types, or other relevant factors. This ensures that I only download the data that is relevant to my testing needs. I also use manual testing techniques such as incremental testing, where I download and test small batches of data at a time. This allows me to verify that each batch of data is accurate and complete before proceeding to the next batch. Furthermore, I employ data validation techniques to ensure that the data I download is accurate and consistent with the expected format. This involves manually reviewing the data to identify any errors or inconsistencies and taking corrective action as needed. By using these manual testing skills, I am able to control the amount of data I download and save, reducing the risk of data overload and ensuring that I only work with the data that is necessary for my testing needs. I employ manual testing skills to control the amount of data you download and save.

Discuss how you mentor junior tester in automation complex test scenario with an agile context. So, in terms of that, how we will mentor our junior tester in automating complex test scenario with an agile context. So, in that case, what strategy I will follow. So, in terms of that, first we will provide a basic understanding of the complete framework, meaning how we will design feature files, how we will design steps, and how we call a method. And then, on the basis of that, how reports are generating and in which folder they are generating. Then, we will provide basic terminology, and for 10 working days, we will give our junior testers tasks to complete. After they have completed those, we will give them an assignment to learn better. When they have done it, we will move to the second approach. For example, we will assign a user story to them in which they need to automate some test cases, and it will depend on the project to project. If no feature file is scripted previously, we will give a demo on how we design scripts, how we design steps, and in steps, how we call methods, because we are using BDD. So, it is plain language, Gherkin language. In Gherkin language, we are just writing syntax in English format, so that everyone can read it without needing any technical knowledge. So, we will help them design things like that. If any complex problems are coming up in complex test scenarios, in which we have 10 to 15 steps or validation things we need to validate, we will give them examples on how to handle these things. Sometimes we need to validate some text, second one we need to select a dropdown, so we will cover all these things in our automation application or automation framework. In that case, we will tell them to reuse already written functionalities, so that the guys can reuse it and complete it. But some real-world scenarios that are not possible to complete all the things because sometimes in real environments we need to validate some dynamic levels. So, in terms of that, we will help them like this: first, we will read rows and columns, and on the basis of that, either we can get the selected text or we are clicking on some particular link. So, likewise, test cases, we will go and daily, on a daily basis, we will put some calendar time, like 30 to 35 minutes, to talk with them, so that if they have any questions related to automation queries, or how they are facing any issues, then we will provide the respective answer for that. And if any new challenges are coming in application design, so we will look into it and then provide a solution to them. So, these are the strategies we will follow.