Listen to this blog
As we pass by the different industry revolutions the usage of machines in doing the manual activities has helped in their transformation. Similarly, in the software revolution, usage of tools to do the manual testing activity has literally increased the industry throughput due to the following factors.
- Automation doesn’t only help a team in reducing the man-hours spent in business but also helping us the cost.
- With the implementation of automation in a project, we can conduct thorough testing quite frequently to ensure nothing breaks in the system right after quick sprints in the agile model of SDLC.
- It’s quite evident that the system never tires with the multiple executions that we can ensure greater accuracy.
What is Automation testing?
In layman terms it is the usage of tool which can mimic the user action on the software application and perform functional validation without any human intervention or with minimal human intervention.
Levels of testing
Below are a few of test types that are performed as they are required in the Software Testing Life Cycle.
Unit testing:-This is the basic level of testing as soon as a software component is built. The purpose of Unit testing is to ensure that the component does what it is expected to function. This is basically taken care of by the development team and most of it is automated (Example – J-unit, N-unit, jasmine).
System testing: These are the end to end tests that the independent QA writes to ensure the application is best tested and also to uncover any minimal flaw that exists in the system. These tests can fall under UI validation, API validation and DB validation (Example – Selenium, UFT, Test Complete, Tosca, etc.)
Acceptance testing: This is the final level of testing which is taken care of by the Business team to certify the business requirement is met. Mostly Automated scripts developed in System testing will be utilized for Acceptance Testing as well. Acceptance testing scenarios will most probably the subset of System testing scenarios
All these levels of testing can be automated depending on the organization culture and commitment
Types of Automation testing:
Given a careful study of the above different levels of testing it’s time to look at the type of testing in which automation can be achieved.
UI Automation:-This test adds a lot of value to the business considering the fact that the UI is the main layer through which the user interacts more. This is all about impersonating the user actions by clicking on a button, checkbox and sending some information to the text fields and finally saving and navigating across pages. This has widely opted in the business as it has the ability to find the defects that can be foreseen to happen at the user site.
API Automation:- Application Programming Interface is the middle layer between UI and DB. Data is transferred between the database and User Interface is mostly through API calls.
Eg: Rest/ SOAP API tests
Database Automation:- These tests are used to validate the recordset of the database based on certain conditions and with the certain expected results based on certain events.
Eg: JDBC- connecting to the DB and performing validations
Windows Automation:- Given the limitation of selenium- web driver can only talk to browser through http protocol, there are cases where we need to perform some interactions with windows, in that case, we have some test tools which helps us achieve the tasks. We can even integrate with other tests as needed
Eg: Eg: Coded UI, Sikuli, AutoIT
Identifying Automation Candidate:
So far we understood that Automation can help us in lot better ways to conduct different levels of testing in quick time and very accurately. But in order for this approach to be more beneficial, we must take care of certain things before we get into automation.
ROI (Return on investment): – We should understand what way we get benefitted in return when we spend resources to perform the Automation. We gather information like frequency of releases, # of a test to execute, cost to perform one round of test execution and cost to perform a round of automated execution.
Tool identification through Feasibility study: – This is must and can’t be avoided. A feasibility study is assessing Application under test with the set of identified automation tools to validate the best tool to be used for Automating the Application
Application stability: – Ideally in order to automate the application in best standards we must consider its. If there are frequent crashes, Application slowness due to infrastructure issues, etc would not yield the better results that we are looking for.
Setting up the Tool Infrastructure
Below are the points to consider which helps in deciding the tool Infrastructure.
- Nature of Organization, it’s business and their security consideration
- Application types, release frequency, Technology stacks, 3rd party plugin, and customization
- Overall timeline taken for testing / release / Application
- Volume of Test cases / Application and its frequency of usage for each release
- Current tool stack it has from the Test Management perspective
- Environment Management and tool procurement process
- Automation feasibility outcome based on evaluation
- Organization willingness to spend on tools procurement
- Budget required to train and upskill the resources/resource need for Automation
Based on the above pointers and based on the ranking of tool evaluation and other cost consideration Organization has to decide which tool stack it can rely on to maximize the Automation coverage.
Initiate the discussion with the vendor to set up tools in their premise.
Automation framework is the set of rules, guidelines, and templates which when implemented helps an automation tester to write the script with ease to get the desired outcome of code re-usability, portability by reducing script maintenance cost.
Pre-requisite for Framework
Below are the components of Framework
- Programming language
- Automation tool
- Build tool
- Dependency management tool
- Version control system
- Reports and logging generation
Programming language:-This can be chosen by considering the development technical standards and also keeping in mind that whether or not the selection is cost-oriented or an open-source one and finally there has to be a community to overcome certain challenges if we face and support from vendor if it is commercial
Eg; java,c#, python, ruby, perl..etc
Java- widely used because of its open-source feature and rich library and best community than many other languages
IDE:-This is an acronym for an integrated development environment, based on the language and need we should be selecting the proper one to make the assignments hassle free
Eg: Eclipse, Intellij, Visual studio
Eclipse is widely used as it has got more community and rich features and an open-source one, IntelliJ is used mostly as well, it has got open as well licensed editor
Automation Tool:- based on the type of test and type of application and after analyzing the capabilities of a tool we should be picking this.
Eg: Selenium-webdriver, katalon studio, serenity, protractor, Rest API, RPA..etc
Build tool:- Build tools help to pull the latest code from source control, compile it and package it to trigger the execution
Eg: Maven, Gradle, Ant
Maven is widely used given its capabilities and the community it has
Test runner:- When we write some program it’s important to be executed as we need to verify the outcome of what it is being designed for. When developing a framework to trigger tests we should have the best test runner to help with more options to execute tests better such as executing tests multiple times, group execution, passing parameters and so on.
Eg: TestNG, Junit, N-Unit, jasmine are some test runners that are used, but with selenium, it is advised to go with testNG
Dependency management tool- When a sophisticated framework is developed, we may require so many third-party libraries and it is essential to integrate them as well. In order to achieve this, we should have the jar files from those libraries loaded into the binary path of the project, so that the project can recognize them. Loading on to the system may cause a greater problem as it may incur problem when it’s opened in a separate system, how do we overcome?
The concept of dependency management, can help us overcome the problem with the use of the tool Maven or Gradle. It provides a file called (POM.xml) when a maven project is created and we must mention the information of a particular dependency, then it goes and check in the local repository if it doesn’t present it automatically downloads for us locally through the internet. So when we share the project to someone else and opened the POM.xml does the same thing i.e. download things to the system from maven central repository if they don’t exist That way we can ensure the centralization of a dependency across the team. Also, it helps us to have the same and right information in the project.
Version Controlling system:- This system helps us to ensure the changes done to the code base by various teammates are properly merged. With the concept of pulls and pushes to the branches to the repository, we can achieve this. This brings a centralized system where all the persons in the team should look up. There are a few tools which help us doing this
Eg: Git Hub, Bit Bucket, SVN
Reports and logging mechanism:- Without reporting and logging mechanism no framework is completed. While reporting helps us understanding the test results in more easy fashion logging will help us in understanding what happened with a particular test.
Report tool:- Extent reports, allure reports and testing reports
Logging tool:- Log4j
CI/CD:- Continuous integration and deployment is buzzing in recent times as this is believed as a best standard to follow to ensure the code base is built properly and very frequently execution is happening. We can set the goals and pre-actions, Triggers and post- actions with this tool.
Eg: Jenkins, Teamcity
Roadmap for a manual tester to become automation tester
First of all fingers crossed!!!
First please set up a mind that every automation tester today is a manual tester before in some or other way in his/her previous assignments. It’s all about having an open mind to upskill and believing in themselves. Below steps would help in getting that done by self-exercise
Analyze your skillset first as what is known and then what should be learned from the above-mentioned toolset.
Start working on learning basics of a programming language with some real-time tasks for implementation (focus should only be on programming language –java, C# as per choice)
Interact with Automation tester as what concepts are widely used and focus on learning those concepts
Do more practical exercise on the topics that you have learned
Browse and understand the problems faced by people related to the topics learnt and implement to get those refined
Try to study the pain areas and try to improvise code written by using the concepts learned in the programming language (Oops – for instance)
Learn different frameworks available in the market and implement those
Learn other tool integration and practice
Do a mock project covering all the learned topics and demonstrate to the colleagues and get a suggestion for improvement
Provide training sessions on these tools to the beginners and clarify all their queries
Voila, you are an automation tester!!!!