Automation Testing Tutorial: A Starter’s Guide With Example

Software testing is an integral part of any IT project. Testing the software more and more will ensure a better quality of your software. Now, how do you achieve it? Either you go with Manual Testing or Automation Testing.

Now sticking to manual testing can land you in trouble sometimes, as achieving Continuous Testing through manual testers can be really exhaustive. Moreover, manual testing is prone to human errors, is time-consuming, expensive, and can hit customer experience greatly.

Businesses are constantly pressured to improve, adapt, and become competitive. Keeping up with all the changes in the technology industry is an enormous challenge, and organizations, therefore, need to automate repetitive testing processes to ensure that software performs according to expectations and provides value in no time. This can happen by adopting agile methodologies to achieve shorter development cycles and accelerated Time to Market (TTM).

Having said that, in my opinion, manual testing still plays an imperative and indispensable role in the software development life cycle, though it has to be coupled with a formidable automation testing strategy.

In this automation testing tutorial, we will cover all about automation testing, the need for automation testing, and its different approaches.

Let’s get started!

Note: Split Your String — A free web based utility that instantly splits text into multiple pieces. This online tool can be used to split long web addresses, texts, word, and much more. Select a delimiter and start splitting right away!

What is Automation Testing?

Automation testing is the process of carrying out the test activities using the assistance of tools, scripts, and software by repeating pre-defined actions.

In simple terms, you can understand automation testing as a type of testing that focuses on replacing repetitive, error-prone, and time-consuming manual tasks or activities with automated scripts in order to enhance the performance of the software and efficiency.

Testing is a very crucial activity in any Software Development Lifecycle. In order to ensure a better quality of your software, you need to ensure better testing of it. Automation testing gives testers the time to focus on other quality activities like performing exploratory tests, analyzing test results, etc., by taking over the repetitive and mundane tasks like Regression tests. As a result, automation testing enables you to achieve better test coverage in a shorter period of time.

Difference between Manual and Automation Testing

Let’s see the major differences between Manual and Automation Testing:

The above differences clearly indicate the effectiveness of automation testing. However, with manual testing, you benefit from human expertise and knowledge, which an automation testing tool can never provide a match for.

Hence, an ideal approach would always be to keep a combination of Manual + Automation activities for your testing cycle.

Why Automation Testing?

Now that you have seen some of the major benefits of automation testing, let’s understand the need for automation testing through a practical use case.

You get a new feature to test in your software. You started your test plan, and there are some 50 test cases that you identified.

You started the tests and reported some 10 bugs in the first sprint. Those bugs keep getting fixed over sprints, and you have to test the updated version of the software with each build. Now, how do you ensure that the fix for one bug doesn’t affect the older working areas?

To ensure that, you need to test the complete software or perform regression testing after each bug fix. When the number of bugs in software increases or the number of features to test increases, manual testing may turn cumbersome. This is where automation testing comes in.

In such cases, you can simply automate the areas you have already tested and covered. Now, every time a new build or bug fix comes in, you can run the entire suite and easily ensure the health of your software.

Hence, with lesser time, you can achieve better coverage and quality of your software. An effective test automation strategy plays an important role in ensuring a bug-free application.

Automation testing life cycle mentioned above is a group of well-defined phases that result in an efficiently working test automation framework used to develop and maintain the software.

Which Test Cases To Automate?

Automation Testing has a lot of benefits and is well suitable for areas that require testing over and over again, but can we achieve 100% test automation?

Well, it’s difficult to achieve 100% test automation, and hence, it’s very important to determine which test case can be automated.

Let’s look at the areas where you can apply Automation Testing

• Repetitive (Regression) Tests

These are the prime candidates for automation tests, as their numbers keep on increasing with the addition of new functionalities. As a result, they become difficult to maintain, and running them manually over and over again becomes a mundane task.

• Complex Tests

Complex tests are best to automate. For example, consider the areas which require large calculations; they are always prone to human errors. Hence, automating them would always ensure the correct result of your software.

• Smoke Tests

The smoke tests which probably need to be carried out in different environments like Dev Env, QA Env, and Production Envs are also good candidates for automation testing. It would save a lot of time by running these tests through automation every time a new environment comes in. This way, you can also cover tests over different browsers or OS flavors in less time.

• Data-Driven Tests

These are the tests that require repeated testing with different data sets, and hence, automation testing can prove to be a boon in such cases.

• Performance Tests

Automation testing will help you test the software performance and load under different conditions easily and in much lesser time as compared to the manual approach.

How do you perform Automation Testing?

The below-mentioned steps are followed in the automation testing process:

1. Test Tool Selection

2. Define Scope Of Automation

3. Planning, Design & Development

4. Test Execution

5. Maintenance

Test Tool Selection

Before starting with any test automation, you need to decide which kind of tests you need to automate. Once you have the test definition ready, you need to select the correct set of tools that can help you in performing those tests. There are several testing tools available. The industry-standard tools for automated testing are based on code and code-based test scripts.

The most popular code-based web automation framework for automation testing is Selenium WebDriver, which allows you to test web applications using different browsers (Chrome, Firefox, Internet Explorer, etc.). It also supports many languages such as Java, Python, C#, etc. However, choosing the correct one is a very crucial step in an automation process.

Consider the below pointers when selecting an automation tool:

• How easy is it to develop and maintain scripts using the test tool?

• How many different platforms does the tool support? For e.g., Web, Mobile, Desktops, etc.

• How many different languages is the tool compatible with?

• Does the tool support a reporting mechanism?

Define Scope Of Automation

Now that you have selected the best-suited test tool, the next step is to define the scope of your test automation. Consider the below points while defining the scope of automation:

• The complexity of test cases

• Technical feasibility

• Common functionalities across applications

• Reusability and Scalability of test cases for cross-browser testing

Planning, Design & Development

The Planning, Design & Development phase includes the below points:

• Framework design & its features

• Test case development

• Test suite preparation, For e.g., Smoke, Sanity, Regression

• Plugging framework with some CI/CD pipeline to achieve continuous testing.

Test Execution

The scripts developed during the design phase are now executed in this phase. Execution can be performed using the automation testing tool or the test management tool, which will, in turn, invoke the test automation tool. You should start the execution of your test scripts as early as possible. This is what the Shift Left Testing approach also suggests.

In contrast to traditional models like the Waterfall Model, where testing comes into the picture at the very end of the cycle, the Shift Left Testing approach suggests moving the Testing activities “Left” or rather “earlier” in the development cycle. Thus, it involves the testers much earlier in the software development life cycle. The earlier the testers are involved, the more bugs you find, and as a result, you have a better quality product.

Maintenance

In this phase of automation testing, testing is carried out in order to determine whether the newly added functionalities are working fine or not. Maintenance and up-gradation of test suites are carried out in order to improve the effectiveness of automation scripts with each successive release cycle.

Many firms even use this phase for Shift-Right Testing. Shift-Right testing, or rather Testing In Production, happens after the software is deployed in production environments. This is mainly done in order to ensure the correct performance, stability, and usability of the application in the production environment.

Note: Online Sort List — This tool changes the order of all your list items so that they are sorted alphabetically, or numerically. Try sorting your list online now.

Different Approaches to Automation Testing

There are three main approaches that you can consider while performing automation testing.

1. Code-Driven Testing

2. Graphical User Interface Testing

3. Framework Approach

Code-Driven Testing

This testing approach is a popular method in agile software development. Here, the focus is mainly on test case execution to determine if different sections of code are performing as per expectations or not.

The idea behind code-driven testing is to use a programming language to write the unit test instead of using an external tool that provides a testing framework. The advantages are that you have full power at your disposal to create whatever tests you want, and you don’t have to deal with an external tool. The disadvantage is that it is harder to set up and run tests, so it can be more difficult to get people to do it regularly.

Graphical User Interface Testing

With the increasing complexity of software and its graphical interfaces, the need for formal GUI testing has increased dramatically. The testing process can be categorized into two main types: unit testing and functional testing.

Unit testing, which is most often driven by developers, involves a detailed analysis of each component of the application to ensure that it is operating correctly in isolation. Functional testing, on the other hand, determines whether or not all components of the application can be used as expected by the end user. This phase of GUI testing is usually performed by quality assurance analysts who are more familiar with how users interact with the application.

Test Automation Framework

A framework is a set of guidelines that help in maintaining test consistency and test structure. It also helps in achieving the maintainability, scalability, and reusability of the code across test cases.

There are four major kinds of frameworks used in automation testing:

1. Data-Driven Framework — These frameworks are focused on separating the logic of test cases and the test data separately. Here the data is treated as an input to the test script logic. Each data set can be treated as a separate test case.

A data-driven framework is a test automation framework that stores keywords and locators of elements into an external file, such as an XML file. This makes it easier for testers to build test cases because it does not require the use of object repositories.

Data-driven frameworks are often used with keyword-driven frameworks. Keywords are stored in a data file and then placed into a function library. The keywords may be written manually or generated via recording. Tests are created in the data file, which can be edited by testers without programming knowledge. The test data for each keyword is stored in the same row as the keyword, making it easy to change.

2. Keyword-Driven Framework — A keyword-driven framework is essentially a data-driven framework that is limited to accepting inputs only from an excel data source. In this type of framework, test case logic resides in a database table and is linked to one or more related tables that contain the test data. Each logical operation of the application under test is defined as a keyword, which represents some action on the application under test. The keywords are then mapped to a subroutine, which implements the functionality of the keyword and performs the desired action on the application.

The main advantage of this type of framework is that it does not require any programming skills because all the required operations can be performed using keywords. Therefore, anyone (even nonprogrammers) can create and execute test cases using this approach. However, this framework limits itself to operations that can be performed using existing keywords; no new keywords can be created because they would require programming knowledge.

3. Modular Testing Framework — Modular Testing Framework is a way to test a piece of software in isolation. Each module is tested with the same testing framework so that testing multiple modules can be done with a single line of code.

The framework is composed of two main components: Test Cases and Test Suite. A Test Case is an object that defines a series of steps or actions to be performed. The Test Suite is simply an object that contains a collection of Test Cases.

When the Test Suite is executed, it will execute each Test Case using a Test Runner object that can perform assertions on the results produced by executing the individual Test Cases.

4. Hybrid Testing Framework — Hybrid Driven Framework is a mix of both the Data-Driven and Keyword-Driven Frameworks. In this case, both keywords, as well as the test data, are externalized.

A hybrid testing framework combines the strengths of two approaches, using features of both to achieve the best of both worlds. It can be especially good at handling complex, difficult-to-test situations, and requirements.

Popular Test Automation Frameworks

Now that we have learned the basics about test automation, let’s see some of the popular test automation frameworks which are being widely used.

• Selenium— Selenium is a popular test automation framework used to validate web applications across different browsers and platforms.

• Cypress— Cypress is a JavaScript test automation solution used for web automation. It enables teams to create web test automation scripts.

• TestNG— TestNG is a powerful test automation framework for Java. It is inspired by JUnit and NUnit. It can be used to cover a wider range of test categories: unit, functional, end-to-end, integration, etc.

• WebDriverIO— WebDriverIO is an open-source testing utility for nodejs. It allows you to run Selenium tests written in JS on multiple browsers and platforms.

• Pytest— pytest is a testing framework based on python. It’s often considered to be the de-facto standard when it comes to writing unit tests for python code.

• NUnit— The NUnit Framework is a unit testing framework for all .NET languages.

• PHPUnit— PHPUnit is a programmer-oriented testing framework for PHP. It is an instance of the xUnit architecture for unit testing frameworks.

• Cucumber— Cucumber is an open-source tool that supports Behavior Driven Development(BDD) frameworks. Cucumber enables you to write test cases that anyone can easily understand regardless of their technical knowledge.

These were some of the popular test automation frameworks I have come across for different languages. However, the list doesn’t end here. There are a lot of other test automation frameworks also available in the market. You can check them and select one that best suits your overall requirements.

Example of Test Automation

Let us now see a basic test automation example. In this case, we will automate a web page making use of the Selenium framework and LambdaTest.

Selenium is an open-source framework for cross-browser and cross-platform testing of web applications. It is a suite that allows automated tests of websites and web applications in different browsers on different platforms using any programming language of your choice.

Cloud testing tools like LambdaTest offer a cloud Selenium Grid that lets you run parallel tests on an online browser farm of 3000+ browsers and operating systems. All you need to do is instantiate the remote Selenium WebDriver instead of the local Selenium WebDriver.

Here’s a quick video on performing Selenium automation testing on the LambdaTest platform.

You can also Subscribe to the LambdaTest YouTube Channel and stay updated with the latest tutorials around automated browser testing, Selenium testing, CI/CD, and more.

With LambdaTest, you don’t have to worry about downloading and configuring hundreds of browsers on your machine, as they are readily available on the online Selenium Grid. Instead, all you need to do is register on LambdaTest for free, claim your 100 free automation testing minutes, and run Selenium IDE tests on cloud.

Now that we have covered the basics of cloud Selenium Grid let’s implement a sample example using LambdaTest Selenium Grid.

Problem Statement

In the below example, I am running the same test case on Chrome (latest) + Windows 10 combination.

1. Launch Chrome browser on Windows 10.

2. Open LambdaTest sign up page.

3. Click on the Sign In button.

4. Close the web browser.

Implementation

FirstTestScriptUsingSeleniumGrid.java

package LambdaTest;

import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Listeners;
import org.testng.annotations.Test;

import java.net.MalformedURLException;
import java.net.URL;

@Listeners({util.Listener.class})
class FirstTestScriptUsingSeleniumGrid {

   public String username = "YOUR USERNAME";
   public String accesskey = "YOUR ACCESSKEY";
   public static RemoteWebDriver driver = null;
   public String gridURL = "@hub.lambdatest.com/wd/hub";

   @BeforeTest
   public void setUp() throws Exception {
       DesiredCapabilities capabilities = new DesiredCapabilities();
       capabilities.setCapability("browserName", "chrome");
       capabilities.setCapability("version", "95.0");
       capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will just get the any available one
       capabilities.setCapability("build", "FirstTestScript");
       capabilities.setCapability("name", "FirstTestScriptSample");
       try {
           driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
       } catch (MalformedURLException e) {
           System.out.println("Invalid grid URL");
       } catch (Exception e) {
           System.out.println(e.getMessage());
       }
   }

  @Test
   public void firstTestCase() {
       try {
           System.out.println("Logging into Lambda Test Sign Up Page");
           driver.get("https://accounts.lambdatest.com/register");
           WebElement pageHeader= driver.findElement(By.xpath("//a[text()='Sign In']"));
           pageHeader.click();
           System.out.println("Clicked on the Sign In Button.");
       } catch (Exception e) {

       }

   }

   @AfterTest
   public void closeBrowser() {
       driver.close();
       System.out.println("The driver has been closed.");

   }

}

GitHub

You will need the below pom.xml for importing the necessary dependencies.

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>

   <groupId>org.example</groupId>
   <artifactId>LambdaTest</artifactId>
   <version>1.0-SNAPSHOT</version>
   <dependencies>
       <dependency>
           <groupId>org.seleniumhq.selenium</groupId>
           <artifactId>selenium-api</artifactId>
           <version>4.0.0-alpha-7</version>
       </dependency>
       <dependency>
           <groupId>org.seleniumhq.selenium</groupId>
           <artifactId>selenium-remote-driver</artifactId>
           <version>4.0.0-alpha-7</version>
       </dependency>
       <dependency>
           <groupId>org.seleniumhq.selenium</groupId>
           <artifactId>selenium-chrome-driver</artifactId>
           <version>4.0.0-alpha-7</version>
       </dependency>
       <dependency>
           <groupId>org.testng</groupId>
           <artifactId>testng</artifactId>
           <version>6.14.3</version>
       </dependency>
       <dependency>
           <groupId>io.github.bonigarcia</groupId>
           <artifactId>webdrivermanager</artifactId>
           <version>4.4.3</version>
       </dependency>
   </dependencies>

   <properties>
       <maven.compiler.source>8</maven.compiler.source>
       <maven.compiler.target>8</maven.compiler.target>
   </properties>

</project>

And the below testng.xml file will be needed for running the test case.

testng.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite  name="FirstTestScriptUsingSeleniumWebDriverSuite">

   <test name="FirstTestScriptUsingSeleniumWebDriver" >
       <classes>
           <class name="LambdaTest.FirstTestScriptUsingSeleniumGrid" >
           </class>
       </classes>
   </test>
</suite>

GitHub

Code Walkthrough

• Global Variables: As tests have to be run on LambdaTest cloud Selenium Grid, we would be using the below-shown variables.

Here, you can populate the values for your corresponding username and access key, which can be collected by logging into your LambdaTest Profile Section. However, the gridURL will remain the same.

• @BeforeTest(Setup Method): In Selenium, the RemoteWebDriver class implements the WebDriver interface to execute test scripts through the Selenium RemoteWebDriver server on a remote machine.

The @BeforeTest annotation in TestNG is used to execute a set of statements before running a test suite. This method can be used for initializing the resources required for your test case.

• The below-imported class will help you in using the RemoteWebDriver class.

Here, I have used the LambdaTest Desired Capabilities Generator and have set the necessary capabilities of browser name, version, platform, etc.

• @Test(firstTestCase): In the test case, I opened the LambdaTest sign up page in the Chrome browser using the driver.get() statement. The findElement method in Selenium is used for locating the SignIn WebElement.

Here, I have used XPath in Selenium for locating the ‘Sign In’ button. To investigate the XPath of any element, you can simply right-click on it and click on Inspect. You will be able to spot the locator in the Elements tab. The click method in Selenium is used for clicking on the Sign In button.

• @AfterTest: In the AfterTest method, close the browser using the driver.close() method.

Execution

You will see the below output once you run the testng.xml file.

Once the tests are completed, Log on to LambdaTest Automation Dashboard to check the status of the test execution on LambdaTest.

You can also access the report on LambdaTest Analytics Dashboard. The dashboard shows all the details and metrics related to your tests.

Test Summary gives you a high-level overview of your test performance. It shows how many of your previous tests passed and failed and how effective each team member was in running their tests. Don’t forget to check out Test Overview for interactive visualization of how your tests are performing over time.

Note: Uppercase Text — Online tool for uppercasing all text. Generate any text in uppercase.

Conclusion

In this automation testing tutorial, we got to know what is automation testing, the differences between manual and automation testing, the need for automation testing, and a few approaches to do the same. We also saw which test cases should be automated and implemented our first automation test script with Selenium.

Investment in automation testing is essential to maintain the efficiency and effectiveness of the software development process. It is important to estimate the return on investment (ROI) of automation testing, especially when the company has a tight budget and cannot afford all the requested projects.

I hope this article helps you in taking the first step towards your automation testing journey and, as a result, helps in achieving a better quality of your software.

Happy Testing 🙂