ROHIT PATIL

So I have done my graduation in computer science from a college called Bangalore, which is affiliated with you. From there, I was picked as an intern into Sharma as a tester. I've been doing manual testing as well as automation testing through this internship. Post which I got converted as a tester, full-time tester. There, I have started doing automation testing, especially at the regression and system testing level. Before that, initially, we do the black box system through manual testing. And then once panel testing is done or black box testing is done, we do all the automation testing. So I have been using Selenium as well as a plan for that. I have done a couple of years on that. Post which I have joined a company called Qualitest, where I have done performance testing a little bit, using tools like Epic as well as JMeter. And then post which I came back to, which is now also called Oracle. I have been doing automation testing as well as some kind of management. Basically, to look after three teams, each team having 4 to 5 associates, to make sure that the quality is up to the mark, especially with respect to the number of defects that have been linked to the client. Find the pattern, and then report that to the respective stakeholders to make the right decisions with respect to the test status, strategy, so that we approve the right test cases and execute at the right time. So, my current roles and responsibilities are to do the automation test scripting, and then look after all the reviews that have come up for automation scripts and make sure that we do the right testing at the right time for all the three products that I look after. This is my current role and responsibilities, day in and day out. Thank you.

So, I haven't transferred to the API testing, so I don't have experience in this area.

So I would definitely look at the log file of the job to see where it has failed, especially that specific step it has failed. We'll have the logs with respect to which step has been fixed. So I look into that and make sure there's enough dynamic wait that is required. Usually, we see a lot of test cases fail because of that. So I'll make sure there's enough weight and elements are located properly, and the page is ready to interact with those elements. So the log file is the first thing I would look at. And also, if time permits, I look at the previous jobs that have been passed or failed. If it's passed, I'll definitely look at that. What's the difference? Whether it's in the script or it's in the application itself. Right? So if I see screen prints, if there is an exception, usually that we have in our admission scripts. So I'll check for the exceptions that have been logged out of this free job, and I'll make sure I understand the exception well and then fix it in the script. Thank you.

So as rightly asked, there are many scripts that fail because of synchronization issues. I would make sure that explicit waits are in place before we interact with the elements, to make sure that the elements are fully present or located in the DOM. For example, if I have to use explicit wait, I'll use it with the expected conditions, input the expected conditions as you see, and define wait as web driver wait, driver. Let's say that you have to wait for an explicit time of, like, 10 or 20 seconds, so I'll give 20 seconds. Then I'll wait until, in the brackets, I'll use accordingly whatever the requirement is. For example, the presence of all items, present or located, and then provide the XPATH or whatever element that is there, and make sure that it is fully ready. This will make sure that the application we are testing and the script we have are in sync. It should not be that the script is executing faster than the application itself. That is where we see most of the scripts fail. And also, if there's a requirement to use implicit waits, to make sure the driver is waiting till all the elements in the DOM are located, we'll use that also. So it depends on the situation, but especially using explicit waits, we can handle synchronization issues.

okay so as the Selenium organization or team also suggests the page object model, and we also use the page object model in our products as well. So let's say there is an e-commerce website that we need to or are trying to automate. I have a folder called pages or directory or package, so specifically by the package that we have, we have packages in the directory basically. Inside that, we'll have different pages for the different Python files, basically for the different pages in the e-commerce site. For example, the login page, the home page, and then maybe the search page if required, and then maybe the R2 card page, and then the payment page, and then finally the log off page, which we can combine with the login page as well. So, we define the respective methods or functions in the respective pages as well, and the elements, or the locators, or the selectors, whatever is required with respect to those pages. We define it there. For example, let's say there is a login function that has to be written. I would write that in the login page, and then whatever the elements that are required, such as selectors, locators, or CSS, or whatever it is, I would define there and I will call that in my test file, so the test function, especially. So, we call that login method and assert that the user is logged in successfully or not in the test function. In the home page, again, I would have some elements, such as the title bar or home page elements, basically, inside that, like search elements, and all the how to what are the elements that we need to search for. So then, to make sure that the set has happened properly, we use the selectors, and to make sure that the login is appropriate and we have the user now in the home page, then similarly for search, R2 card, and then finally payment, and then log off. So, respective elements would be required in the respective pages, and we write respective methods and functions that are required in the respective pages, and use all of them in the test function.

So, this is something that we haven't done. We kept functional testing to only switch functional testing, we haven't integrated that to test the performance of the application. But, I think we can do it by measuring the wait time, that page is taking as well as having the execution times recorded especially with respect to certain functions or certain tests. Right? So, let's say that if I have to log in, see how much time that function has taken to log in and compare that with the expected time. For example, if the login has to happen in just like 5 seconds and you have the requirements of that login has to happen in 5 seconds and use the time method that is in the time package that is there with Python. So both time and import time. Importing time also imports time, start current time, basically, and then have one more time implemented at the end of the test or end of the function test function and see how much time has elapsed. And if that time falls within the 5 seconds, for example, in our case, the login has to happen, then go ahead and pass it, and your performance of the application is good enough to proceed. Otherwise, the functional testing can still continue, but performance testing is failed. So this is, I think, we can implement to make sure that the applications are performing well and tested well through functional or not selenium testing as well. Thank you.

So as mentioned previously, I won't work much on the API testing, but I guess what we're looking at here is let's not get started. I'm not really sure, so I mean, we're done.

Okay, as previously mentioned with respect to the weights answer, I see that there are no weights basically implemented in any of this. For example, the first and second lines, where you get the example of come open. You haven't waited or this snippet doesn't wait for the username to appear. So definitely before it appears, the script might fail. So, again, as I mentioned, I would definitely use explicit weights here. I would import the web driver wait as well as the expected conditions, as you see. And then, we define a generic function somewhere, in my utils or helper functions, where I would wait for each element or any element using a generic function that I would write. For example, wait until wait dot until expected conditions, item presence of or presence of item or presence of all located items, and then the locator, and then call that function in this, to make sure that the user name is appeared first. And then, again, wait for the password, and then wait for the login button to appear if there's a password. So we don't really need to wait for the login button, but as a safety step, we can still use that and then click. So that's how I would definitely implement weights here to make sure that all the pages are loaded before they are interacted. Thank you.

Very concise plan for integrating security testing. So, when done with security testing, I'm not really sure. Maybe I would definitely look for trying to log in using most technically used user names and passwords to make sure that our application is not easily hackable or something like that. So I would log in using general user names and passwords to make sure that the application is secure to log in. And apart from that, they don't have much. I don't know about secure testing, but I would definitely boost some libraries that are there to do the testing, like penetration testing and all of those, and integrate that with my test script, like during each phase. For example, log in or search or add to cart. And then especially at the payment site, make sure that even if you provide the wrong PIN or wrong values to make the payment, it's not accepting that. So I would definitely do that kind of security testing as far as I know.

So, as I have mentioned before in the introduction also, we still do manual testing, there is no automation testing without manual testing, that is what I believe in, the effective manual testing will catch a lot of defects that are client's laws compared to automation testing because mostly automation testing has the primary workflows of the application to make sure that they have not been broken and we have high confidence in releasing the product to the clients. So, we test as fast as possible, but the true testing can only happen through manual testing that we do to make sure that we find the defects that have been recently introduced by the developers. So process-wise, if we talk, after the unit testing, when the developers give us the code or the application, I'll come up with a scenario matrix to understand what the impact is and I'll update the automation tests that are primary workflows that are in the scenario matrix and I'll take out some scenarios which can be done exploratory as part of exploratory testing and for the automation testing at this level, I will definitely look at the exploratory testing scenarios that are left out within the scenario matrix and I'll test all those scenarios as well. And then finally, once integration testing is done, we'll move to system testing or regression testing where we'll run all our tests that are for this product. So the strategy would be automation testing, unit testing especially, and then again, automation testing with respect to particular workflows and along with that exploratory testing, especially manual testing to find defects that are wide in nature and also some scenarios where we cannot automate, like date and time scenarios or color identification and all those things. So there, we do manual testing along with that, impact scenarios, and then finally system testing or regression testing where we run the full automation test suite and then finally release it to the clients. Thank you.

So currently, I do that. So I would suggest that the junior tester start automating as early as possible as the developer picks up the story. I ask the tester to pick up the story. So it happens that usually once the UI is ready, then the promotion testing or promotion tester starts the scripting. But actually, that shouldn't be the case. So we both should start at the same time. Although, there'll be no code to automate or there's no UI to automate sometimes, but there will be something that can be tested or at least documented at the end of the story from the developer. So we'll try to understand that. So it won't become a complex test scenario at the end of the day. So bit by bit, if they understand and start documenting, at least the black script, I would say, with just the step teams or even just the comments also is fine to start with. Right? As the developer keeps on developing, the tester should also keep on automating, of how much ever it is that, just if it is just, to start with another two lines and then keep it going. Right? Every sprint by sprint. So I believe there's no development that happens the entire application or the entire project workflow that can happen in just one iteration or one sprint. So it takes time, obviously. So during this time, the developer and testers can also utilize this time to understand the functionality. And then once the functionality is understood, I guess, I just believe that it's not that complex to document. Sometimes, the dynamic XPaths and all those things are there, but we can use to find the patterns, what kind of pattern they follow, to build those attributes so we can use those and then start the junior tester to start with basic purposes and then keep on automating it and keep on rolling it. So first of all, it won't be context in that way. And then the reviews, especially. Right? So once you develop something as a test, adjust you on the document and upload it for the review. As a senior tester or lead, we have to make sure that it is correct and he's on the right path and provide the feedback that's actually required and then ask him to report it. Right? So that's how I think I could do it. So break it to smaller pieces, and as the developer progresses, the tester should also progress, and then the frequent reviews to give the regular feedback so that you can go on the test. Thank you.