Aaradhya Jain

I am and I have over 3.9 years of experience working as a QA automation. Currently, I am working as an associate consultant for Capgemini. My expertise lies between mobile and web automation, primarily using tools like Selenium, APM, Cucumber, and TestNG. I have worked on Java and Python, and other various languages as per the requirement. Apart from that, I have worked on API automation, primarily using tools like Postman and frameworks. In my current job role, I have written many test scripts and automation scripts. I have created test cases, test planning, and executed them on automated and manual devices as per the requirement. Apart from this, I completed my graduation from Thirthankar Mahaveer University, Muratabad, and I am pursuing a degree of BTEC with computer science. After my graduation, I started my professional journey here in Capgemini. This is a brief about my self. So, let me start from my background, which is related to my project details. I have worked for a banking client in a project named as digital platform. It is a cloud-based web application that provides the capability of testing or development. It does provide the capability of testing for manual and automated browsers and mobile on the cloud-based platform. It is kind of similar to the huge names that you might be aware of, like BrowserStack, Expedia Test, and some more. So, what is the main advantage of this particular system? It is inside a banking network, and it doesn't require crossing the network layer to connect with the outside network. So, this is an on-premise solution that provides mobile automation testing, mobile manual testing, browser automation, and browser manual testing, and some other parts of testing of the mobile and web app, like accessibility testing, network throttling, and performance-related things. All these things are available on our web-based solution, which is named as digital platform. My role in this particular project is primarily working as a QA automation. I have done many automation scripts for the web, complete web UI, which is available for the users. Apart from that, I have worked on the mobile application parts for developing automation scripts for different banking applications. I have also written automation scripts to provide capability of some features in this particular platform. This is a brief about my background. I hope it is pretty much clear for you. Thank you.

Okay, so in my current projects or experience, we have started from data-driven approaches in recent frameworks. The main advantage of these kinds of approaches is that we have kept the complete data of different fields in a separate document, either it's an Excel file or a JSON file. And we're fetching the data to use in our automation scripts. The main advantage of these particular files is that you just don't need to go to different lines in the code to change that particular data. You just need to provide the key of that particular thing, and then you can easily modify those data values in these files, which are available in a separate folder. So, data-driven approaches are very useful when you're working on multiple kinds of test cases, test data, and different situations. It's better than the keyword-driven approaches. In the keyword-driven approaches, you're limited to using one value at a time, or you need to maintain all that structure in a particular file. Instead of that, we're using data-driven kinds of structures. It's also helpful while working on parallel data types or parallel testing or more than one user. If you want to run a particular test case with different users, then you can use the data-driven approaches. One more advantage of this particular approach is the data provider functionality, which is available in the automation part. It creates an object of each data for each test data or each test user in a separate object, either a map or a dictionary in terms of languages, or it can be a list, so we can access the data as per our need and use it for different test cases or for the same test case with multiple data and multiple test users.

So one of the most used technologies for iOS or APM in Android in the APM, what we can do is we can attach a capability of auto-accepting alerts in an automation script. What it will do is it will automatically allow the pop-up or alert while we are using the automation. When we go to post-automation post notifications on the device side, the ban strategy to use these kinds of structures is to create some locators which are not limited to a particular notification, either that has an accept button or it has an okay button or some kind of positive button level, which we need to accept, or we have a decline option. So, what is the better approach of what we are doing here? We are taking a generic locator to click on that particular button or functionality to handle these kinds of pop-ups in both of the devices for Android and iOS. And this is pretty much helpful in different situations. Also, it is not limited to a particular device or particular vendor. It will work on different vendors. As per the different vendors, post-notification pop-ups or the kind of pop-ups we are handling like this.

How do we balance the trade-offs between test execution speed and reliability when writing mobile automation scripts? So, whenever we are executing the automations on mobile devices, to make it more reliable, faster, and of better automation scripts, what we are doing is using explicit weights with different functionalities, for example, visibility of elements, locating of the element, elements being clickable, and these kinds of things. Instead of using a dynamic static bit, we are providing a dynamic bit position or dialing to make a type of condition where it will wait till a particular condition is fulfilled, and then it will start executing those things. Also, we are providing a particular time in which, if that time is exceeded, it should fail. For example, we have provided 20 seconds to fulfill that particular condition. If the condition is not fulfilled in 20 seconds, the particular steps will fail. By using these things, we are using the reliable automation script. Apart from this, we are also optimizing our test scripts in the criticality of the test case. We are just highlighting which is required for sanity and which is required for regression as per the requirement. We will run only those test cases as per the criticality of the deployment or the changes or the release. Also, we are using the correct locator, which is the most powerful or the most fast, we can save accessibility ID available for a particular locator. We will try to use the accessibility ID or the source ID first. Apart from that, if there is missing accessibility ID, then we will try to use the XPath, and then we will take other locators. Apart from that, if there are situations where we can run parallel executions on different devices, on different providers, for example, APM grade or these kinds of solutions that we have. So we can run parallel applications for different test cases on different devices. This will make our execution faster. And one more thing we can do here is instead of installing the application each and every time, we can just provide the app once, and then we will launch for different activities. So by using these things, we can optimize our scripts. Apart from this, we can also manage our logs and debugging enhancement parts to make our executions more reliable by writing the automation script. So if something went wrong, it will capture the screenshots on the particular step and all those things will be handled properly in our auto reset. This will be helpful to make the execution speed more and the auto reset script sort of reliable.

Whenever we're using CICD tools like Jenkins, we're using different kinds of frameworks such as Maven, Gradle, or anything else. So, for example, if we're using a Maven kind of structure and we're using the test engine inside it, we'll use some profiles to start the execution. Just after completing the execution, we're fetching all the reports from the test engine files, test engine reports, or from our differently generated report column, which is available on a different folder structure. Just after the completion of the Jenkins pipeline, we'll trigger one mail or send the report of complete execution after the automation completion, whether it's getting failed, passed, or anything is available. We can execute some listeners, which will fetch the report on a particular location, and then it will summarize the report and send to different mailers, and also share the complete report, complete execution timings to complete these steps and all those things on our different particular environment, or we can say it will save somewhere where it's required. By using these kinds of structures, we can integrate testNG results in the CICD pipeline tools, which will provide you a better update of your reporting and results of that particular framework.

As you know, you have provided with the company use page of that model structure and tested it. Please explain the likely issue you see here with the login method and implementation. Username, look at our buyer dot ID. The buyer dot ID login button locator is here, and we are using login. So what I can see in this particular class which is provided, in this course embed. So here, we are writing a login test in the login method, and you are using different kinds of locators, username, password, and login button locators in that particular method. And, what we are doing, we are creating those locators in that same file, which has all the test cases, which have all the test methods available. What we should do, while we are following the page object model kind of structure, we should use these locators in a separate file. Either it is an interface file or a different file. So in a different locate, interface, we can separately keep these locators for different pages. For example, we can create an interface named as login page elements, and there we can store all these required locators. And then we can implement that locator in our login page test file, and we can use them on our different methods. What is the benefit of this particular thing? If in the future there might be any changes in a particular locator, then you just don't need to go and change your script in the particular test file or test methods. You just need to change the locators in that element related interface, which is more flexible in terms of the changes of the locator. So it will not affect the overall code. It will keep all the locators and methods separately, so we can easily change those elements as per our requirement. So this approach we can use while we are following the page object structure.

The user enters admin and password 123, then the users would redirect to the dashboard page. So one thing which is clearly available, we are sending the data, like password and all those things in that particular feature script. I think this is not correct. We should provide some data-driven kind of structure in which all the test data are suitable, and it will pick the data from there. Then we can provide the data from it. Apart from that, it has provided the data in a single column kind of a structure, which is not a proper format in the term of Gherkin language. We should provide in a double quotation marker to the consistency and to lead the different parsing errors. And in these lines, the lines we are using when then these are the things are not in a proper way. The line "then and the users would be redirected to the dashboard page" is incorrectly combined. Instead of "then and," we can use "given," "when," and "then" in the correct structure. So the correct form can be: when the user enters admin and password, then the user should be redirected to the dashboard page. These kinds of things, we can use in terms of the language to correct these things.

Explain your approaches to refactor a complex method that interacts with both Android and iOS elements using APM and effort to reduce code in duplication. Okay. So, in such cases, what we can do is, first of all, finalize whether the locators are similar for both of the OS levels, or we can use some generic type of locators. So we can use them for both of the devices, or both types of OS. Apart from that, we can also use abstract platform-specified behavior where we can provide such locators and methods which will return the same method, but it will return as per the driver's face of the model. Also, we should use the page object model kind of structure as per different pages of the devices. We can use a platform-agnostic utility layer where we can use click and send keys and these types of text in relevant to the iOS or Android kind of structure. We can simply use the send keys or click and these kinds of methods. And sometimes some functionalities might be there for different features or different OS levels. For example, sometimes swipe or scroll will not be the same in Android and iOS. So what we can do is create a separate method for swipe, and in that, we can implement both structures for Android and iOS. And whether we are calling a method which is irrelevant to the OS level, so what we can do is capture the capability of that particular session, whether it is an Android session or an iOS session. And as per the session, we can use that swipe kind of structure. Also, we can commonly use the accents and the different things for both types of platforms. For example, whether we are working on a login page, so we are providing some usernames, some password fields, and then we will click on the login button. So we can write these things in a single common file, and we can use those things as per our locators, which are available. It should be the same whether it is for Android or iOS. We are providing our look at it like that whether it will pick for both of the data types. If it is not working for both types, then what we can do? One more thing we can add in the parameters of our automation script execution. We can write our test cases in such a manner where it will pick the methods from different classes or fields, whether we are defining some methods for Android, we are defining some methods for iOS. So whenever we are running the automation, we will provide a tag with a platform name, whether it is running for Android or it is for iOS. Then, in the test cases, it should pick the methods as per the OS level. So in the test script, we will not change it if it is for different OS. By using these kinds of things, we can achieve this reduced code thing for the different Android and iOS.

We are using our own developed platform like a digital platform, which provides the same kind of structure. So we are less frequently using this kind of solution for BrowserStack or all those things. What we are doing is providing the capabilities in our automation script, which is not dependent on other scripts. This is the main part whenever we are working on any cloud-based platforms. We are providing the capabilities of the driver to create a session on different devices on different cloud-based platforms. For example, if you want to run a session on BrowserStack, there might be some capability changes. But the rest of the part, which is related to your automation script and your test cases, should not be changed as per their framework or platform. If we want to execute a script on a different OS or device level, you just need to check the capabilities of those devices. You need to grab the hub URL and the username or password required to run your automation on that particular cloud-based platform. Then you can add those things in your capability. While creating the session, you just need to provide all the things related to the device, such as the automation name, device name, platform name, platform version, and so on. Then you can hit a request to create a remote session, whether it is for an APM driver, an iOS driver, or an Android driver, applicable for your device. Once you get a driver, you can execute your automation script on any solution. Only the configuration part may change when you are working on this particular cloud-based solution. Apart from that, there are some other functionalities we can utilize while working on such solutions. We can run parallel executions on multiple devices at the same time. If there are multiple test cases not dependent on each other, we can run those on parallel basis. We can provide capabilities like running automations on some Android devices, not specific to any device. We will provide capability like that, and we will configure our framework in our test engine file or some other file to run it on parallel basis, on parallel execution. Then we can run those scripts on parallel basis. Also, there are some factors for app upload or app kind of things. In terms of tags, we will provide our application to a particular API, which will return a token to us. Then we can add that token in our automation script, and we'll start the run on that particular application. These kinds of strategies we can use.

How do you set up and use Jenkins for continuous test execution of your automation suite? While working on Jenkins in the automation suite, the main part of this is to not be dependent on a local machine for automation. For example, if you want to run some APM automation, you can use an APM-grade browser stack on any solution. And whether you want to execute that on Jenkins, you just need to use some architecture like Maven or Gradle, and provide a structure on clicking a command, on hitting a command, which file will start running, which tags will get opened, and which execution will get started. So, these things need to be specified in our project. While configuring the Jenkins pipeline, we will provide all the required information, like from which Git locations it will pick the data, from which branch it will take our latest code, and which versions of Java and Python it should use. We will also provide the commands to execute the test script, and it will start executing those things. Apart from this, we can also provide the scheduled time on Jenkins whenever it should start. We can trigger some pipelines to run on a daily basis, or on a specific date, or on weekends. We can also use Jenkins to send emails if the pipeline fails or something goes wrong. Apart from that, we can use some other features provided by Jenkins. For example, after the execution is complete, if you want to share the complete report with some other user, you can write a script to handle that task, and that script will automatically get triggered once your Jenkins pipeline is completed, whether it's passed or failed or something went wrong. We can use this for different functionalities.