As testers and developers, we need reliable tools to automate testing across different platforms. In this article, we’ll take a closer look at how you can get started with Appium to build your first automated tests.

🔸Understanding Appium

• What is Appium? — Appium is a open-source project & eco system of related software designed to facilitate UI automation of many different platform. e.g., Mobile Apps (iOS, Android), Desktop Apps & Web.
• Its a Node.js program and built on top of WebDriver (Selenium — The goal of the Selenium project has been to support UI automation of web browsers) & support automation code written in many different languages (Java, JavaScript, Python).
• In order to achieve this, Appium is effectively split into four parts,

1. Appium Core — defines the core APIs
2. Drivers — implement connectivity to specific platforms
3. Clients — implement Appium’s API in specific languages
4. Plugins — change or extend Appium’s core functionality

Most software interfaces tend to share similar structures. As a result, the WebDriver specification offers automation API fundamentals , such as locating elements, interacting with them, and navigating pages or screens, that generally correspond across different platforms.

• Platform Automation Behavior — The Appium driver takes care of this role, it’s an independent, plug-in module that enables Appium to automate a specific platform.
• End goal is to simply implement Appium’s internal interfaces that correspond to the WebDriver protocol. How each driver fulfills this implementation is entirely up to it.
• e.g., Apple maintains an iOS automation technology called XCUI Test -> Appium support iOS app automation is called XCUITest Driver -> convert the WebDriver protocol to XCUITest Library calls.
• Universal programming language access — One of the key advantages of the client-server architecture is that it keeps the automation executor (the server, which performs the actions) separate from the automation controller (the client, which specifies what actions should be carried out and in what order).
• In other words, you can relatively easily make basic Appium or WebDriver features available in a new programming language, as long as it supports high-level HTTP libraries, this only requires implementing a simple HTTP client in that language.
• Client-Server Architecture in Appium

• Appium Clients — The test code you write, created by the test author, sends commands to the Appium server and receives the response.
• Clients are maintained separately. Having a good set of helper functions in one client doesn’t guarantee the same in another. Some clients receive updates more regularly.

WebElement element = driver.findElement(By.Xpath("//*[@text='Test']"))
element.click()
System.out.println(element.getText())
System.out.println(driver.getPageSource())

• Appium Drivers — In the simplest terms, a driver is a Node.js class that derives from Appium’s “BaseDriver” class.

import BaseDriver from '@appium/base-driver'

class MyDriver extends BaseDriver {
}

Technically, an Appium driver is simply code that extends other Appium code. By inheriting from “BaseDriver”, it gains a lot, “BaseDriver” is essentially an encapsulation of the entire WebDriver protocol.

🔸Getting Started with Appium + Java

1. Install basics (Pick your OS: Windows/macOS)

Essentials: Java JDK, Node.js, Android Studio (SDK + Emulator), You can also install Appium desktop/GUI, but CLI is recommended.

//install Appium, It doesn't come bundled with any drivers.
npm install -g appium

//check Appium version.
appium -v & where appium 

//After installing Appium, install UiAutomator2 or XCUITest Drivers, 
//before installing, make sure Appium server is not running (quit via Ctrl+C). 
appium driver install uiautomator2 or appium driver install xcuitest

//install multiple drivers.
appium setup

//Validating the Install.
appium driver doctor uiautomator2 

//Verify adb (Android Debug Bridge) is available.
//It’s a CLI tool that lets your computer communicate with Android devices (real or emulator).
adb devices

//Start Appium Server
appium

//--allow-cors is a flag for Appium that enables Cross-Origin Resource Sharing (CORS), allowing testing frameworks or tools (like Appium Inspector) running on a different domain than the Appium server to communicate with it.
appium --allow-cors

//Fix Appium installation issues by reinstalling a fresh latest version,
//-g means it was installed system-wide, not just inside a project.
npm uninstall -g appium
npm cache clean --force
npm install -g appium@latest

2. Set up Android automation requirements

▫️Android SDK

The simplest way to configure the Android SDK requirements is to install Android Studio. Using its SDK Manager (Settings → Appearance & Behavior → System Settings → Android SDK), we can download:

• Android SDK Platform (choose the Android platform you want to automate, e.g., API level 30)
• Android SDK Platform-Tools

• Set up the ANDROID_HOME environment variable to point to the directory where the Android SDK is installed.

▫️Java JDK

Install the Java JDK, You can download this from Oracle.

• Set up the JAVA_HOME environment variable to point to the JDK home directory

▫️Prepare the Device

If you’re using an emulator, create and launch an Android Virtual Device (AVD) through Android Studio. If you’re using a physical device, configure it for development and enable USB Debugging.

• Once the emulator or device is connected, run “adb devices” (found under $ANDROID_HOME/platform-tools/adb) to confirm that it is detected.

At this point, everything should be ready to go. If problems arise, refer to the driver docs or the official Android/Java documentation.

3. Starting with Appium

Step 1: Create a Maven Project

You can do this in “IntelliJ IDEA” or “Eclipse”. This creates a pom.xml and a src folder.

Step 2: Add Dependencies in pom.xml

<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>com.example</groupId>
 <artifactId>Appium-Automation</artifactId>
 <version>1.0-SNAPSHOT</version>

 <properties>
  <maven.compiler.source>17</maven.compiler.source>
  <maven.compiler.target>17</maven.compiler.target>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 </properties>

 <dependencies>
  <!-- Selenium Java -->
  <dependency>
   <groupId>org.seleniumhq.selenium</groupId>
   <artifactId>selenium-java</artifactId>
   <version>4.15.0</version>
  </dependency>

  <!-- Appium Java client -->
  <dependency>
   <groupId>io.appium</groupId>
   <artifactId>java-client</artifactId>
   <version>9.0.0</version>
   <exclusions>
    <!-- Exclude any unwanted Selenium dependencies -->
    <exclusion>
     <groupId>org.seleniumhq.selenium</groupId>
     <artifactId>selenium-java</artifactId>
    </exclusion>
    <exclusion>
     <groupId>org.seleniumhq.selenium</groupId>
     <artifactId>selenium-api</artifactId>
    </exclusion>
    <exclusion>
     <groupId>org.seleniumhq.selenium</groupId>
     <artifactId>selenium-os</artifactId>
    </exclusion>
   </exclusions>
  </dependency>

  <!-- TestNG -->
  <dependency>
   <groupId>org.testng</groupId>
   <artifactId>testng</artifactId>
   <version>7.8.0</version>
   <scope>test</scope>
  </dependency>

  <!-- SLF4J simple logger (optional, removes warning messages) -->
  <dependency>
   <groupId>org.slf4j</groupId>
   <artifactId>slf4j-simple</artifactId>
   <version>2.0.9</version>
  </dependency>
 </dependencies>

 <build>
  <plugins>
   <!-- Maven Surefire Plugin for TestNG -->
   <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.22.2</version>
    <configuration>
     <suiteXmlFiles>
      <suiteXmlFile>testng.xml</suiteXmlFile>
     </suiteXmlFiles>
    </configuration>
   </plugin>
  </plugins>
 </build>
</project>

Step 3: Start Appium Server

Step 4: Download prebuilt APK directly

• What is an APK? — APK stands for Android Package Kit, the file format used to install and distribute apps on Android devices.
• e.g., Android apps: *.apk , iOS apps: *.app (for simulators) & *.ipa (for real devices)
• An APK is essentially a package that contains everything an app needs to work properly:
• The app’s instructions (code)
• Visual elements (images, icons, UI)
• Audio and other media (sounds, videos)
• It ensures that the app can be installed and run smoothly on an Android device.
• Appium provides it here: ApiDemos-debug.apk (direct link) or https://github.com/saucelabs/sample-app-mobile/releases
• Save it into your project at: src/test/resources/apps/ApiDemos-debug.apk

//Add aapt to your PATH
C:\Users\UserName\AppData\Local\Android\Sdk\build-tools\34.0.1

//quick way to find 'appPackage' and 'appActivity' for any APK so you don’t have to guess
aapt dump badging D:/Learning/Source/Repos/Appium-Automation/src/test/resources/apps/Android.SauceLabs.Mobile.Sample.app.2.7.1.apk

Step 5: Write Your First Test (Android Example)

package com.appium.utils;

import java.net.MalformedURLException;
import java.net.URL;
import java.time.Duration;

import io.appium.java_client.AppiumDriver;
import io.appium.java_client.android.AndroidDriver;
import io.appium.java_client.android.options.UiAutomator2Options;
import io.appium.java_client.service.local.AppiumDriverLocalService;
import io.appium.java_client.service.local.AppiumServiceBuilder;

public class DriverFactory {

    private static AppiumDriver driver;
    private static AppiumDriverLocalService service;

    public static AppiumDriver getDriver() throws MalformedURLException {
        if (driver == null) {

            // Load config
            ConfigReader.loadProperties();

            // Start Appium server programmatically (optional)
            if (ConfigReader.get("startAppiumServer").equalsIgnoreCase("true")) {
                service = new AppiumServiceBuilder().usingAnyFreePort().build();
                service.start();
            }

            // Setup capabilities from config
            UiAutomator2Options options = new UiAutomator2Options()
                    .setPlatformName(ConfigReader.get("platformName"))
                    .setDeviceName(ConfigReader.get("deviceName"))
                    .setAutomationName(ConfigReader.get("automationName"))
                    .setAppPackage(ConfigReader.get("appPackage"))
                    .setAppActivity(ConfigReader.get("appActivity"))
                    .setApp(System.getProperty("user.dir") + "/" + ConfigReader.get("app"))
                    .setNewCommandTimeout(Duration.ofSeconds(Long.parseLong(ConfigReader.get("newCommandTimeout"))));

            URL serverURL = new URL(ConfigReader.get("appiumServerURL"));
            driver = new AndroidDriver(serverURL, options);
        }
        return driver;
    }

    public static void quitDriver() {
        if (driver != null) {
            driver.quit();
            driver = null;
        }
        if (service != null) {
            service.stop();
            service = null;
        }
    }
}

package com.appium.tests;

import com.appium.pages.LoginPage;
import com.appium.utils.DriverFactory;
import com.appium.utils.ConfigReader;
import io.appium.java_client.AppiumDriver;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.AfterMethod;

import java.io.IOException;

public class BaseTest {

    protected AppiumDriver driver;

    @BeforeMethod
    public void setUp() throws IOException {
        // Load config
        ConfigReader.loadProperties();

        // Initialize driver
        driver = DriverFactory.getDriver();

        // Login automatically if login page is visible
        LoginPage loginPage = new LoginPage(driver);
        if (loginPage.isLoginPageVisible()) {
            String username = ConfigReader.get("valid.username");
            String password = ConfigReader.get("valid.password");
            loginPage.login(username, password);
        }
    }

    @AfterMethod
    public void tearDown() {
        DriverFactory.quitDriver();
    }
}

package com.appium.pages;

import java.time.Duration;
import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;

import io.appium.java_client.AppiumBy;
import io.appium.java_client.AppiumDriver;

public class LoginPage {
    private final AppiumDriver driver;
    private final WebDriverWait wait;

    public LoginPage(AppiumDriver driver) {
        this.driver = driver;
        this.wait = new WebDriverWait(driver, Duration.ofSeconds(10));
    }

    private final By usernameField = AppiumBy.accessibilityId("test-Username");
    private final By passwordField = AppiumBy.accessibilityId("test-Password");
    private final By loginBtn = AppiumBy.accessibilityId("test-LOGIN");
    private final By errorMsg = AppiumBy.xpath(
            "//android.widget.TextView[@text=\"Username and password do not match any user in this service.\"]");

    public void enterUsername(String username) {
        WebElement user = wait.until(ExpectedConditions.visibilityOfElementLocated(usernameField));
        user.clear();
        user.sendKeys(username);
    }

    public void enterPassword(String password) {
        WebElement pass = wait.until(ExpectedConditions.visibilityOfElementLocated(passwordField));
        pass.clear();
        pass.sendKeys(password);
    }

    public void tapLogin() {
        WebElement button = wait.until(ExpectedConditions.elementToBeClickable(loginBtn));
        button.click();
    }

    public void login(String username, String password) {
        enterUsername(username);
        enterPassword(password);
        tapLogin();
    }

    public String getErrorMessage() {
        WebElement msg = wait.until(ExpectedConditions.visibilityOfElementLocated(errorMsg));
        return msg.getText();
    }

    public boolean isLoginPageVisible() {
        try {
            return wait.until(ExpectedConditions.visibilityOfElementLocated(usernameField)).isDisplayed();
        } catch (Exception e) {
            return false;
        }
    }
}

package com.appium.pages;

import com.appium.utils.ConfigReader;
import io.appium.java_client.AppiumBy;
import io.appium.java_client.AppiumDriver;

import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;

import java.time.Duration;
import java.util.List;

public class HomePage {

 private final AppiumDriver driver;
 private final WebDriverWait wait;

 public HomePage(AppiumDriver driver) {
  this.driver = driver;
  this.wait = new WebDriverWait(driver, Duration.ofSeconds(10));
 }

 private final By homePageTitle = AppiumBy.xpath("//android.widget.TextView[@text='PRODUCTS']");
 private final By productTitles = AppiumBy.xpath("//android.widget.TextView[@content-desc='test-Item title']");
 private final By toggleIcons = AppiumBy
   .xpath("//android.view.ViewGroup[@content-desc='test-Toggle']/android.widget.ImageView");
 private final By addButtons1 = AppiumBy.xpath("(//android.widget.TextView[@text=\"+\"])[1]");
 private final By addButtons2 = AppiumBy.xpath("(//android.widget.TextView[@text=\"+\"])[2]");
 private final By removeButtons = AppiumBy.xpath("//android.widget.TextView[@text=\"-\"]");
 private final By filterButton = AppiumBy.xpath(
   "//android.view.ViewGroup[@content-desc='test-Modal Selector Button']/android.view.ViewGroup/android.view.ViewGroup/android.widget.ImageView");
 private final By sortPriceLowToHigh = AppiumBy.xpath("//android.widget.TextView[@text='Price (low to high)']");

 // --- Page checks ---
 public boolean isPageLoaded() {
  return wait.until(ExpectedConditions.visibilityOfElementLocated(homePageTitle)).isDisplayed();
 }

 // --- Product list ---
 public List<WebElement> getProductTitles() {
  return wait.until(ExpectedConditions.visibilityOfAllElementsLocatedBy(productTitles));
 }

 // --- Actions ---
 public void tapToggleIcon() {
  wait.until(ExpectedConditions.visibilityOfElementLocated(toggleIcons)).click();
 }

 public void tapFirstAddButton() {
  wait.until(ExpectedConditions.visibilityOfElementLocated(addButtons1)).click();
 }

 public void tapSecondAddButton() {
  wait.until(ExpectedConditions.visibilityOfElementLocated(addButtons2)).click();
 }

 public void tapFirstRemoveButton() {
  wait.until(ExpectedConditions.visibilityOfElementLocated(removeButtons)).click();
 }

 public void tapFilterButton() {
  wait.until(ExpectedConditions.elementToBeClickable(filterButton)).click();
 }

 public void tapSortPriceLowToHigh() {
  wait.until(ExpectedConditions.elementToBeClickable(sortPriceLowToHigh)).click();
 }

 // --- Scroll and select product ---
 public void scrollToProductAndSelect(String productName) {
  String uiScroll = String.format(
    "new UiScrollable(new UiSelector().scrollable(true)).scrollIntoView(new UiSelector().text(\"%s\"))",
    productName);
  driver.findElement(AppiumBy.androidUIAutomator(uiScroll));
  driver.findElement(AppiumBy.androidUIAutomator(String.format("new UiSelector().text(\"%s\")", productName)))
    .click();
 }
}

package com.appium.tests;

import com.appium.pages.HomePage;
import io.appium.java_client.AppiumBy;
import io.appium.java_client.AppiumDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.testng.Assert;
import org.testng.annotations.Test;

import java.time.Duration;
import java.util.List;

public class HomePageTest extends BaseTest {

    private HomePage homePage;

    @Test(priority = 1)
    public void testGetAllTitlesAndSelectOnesie() {
        homePage = new HomePage(driver);
        Assert.assertTrue(homePage.isPageLoaded(), "Home page did not load.");

        List<WebElement> titles = homePage.getProductTitles();
        Assert.assertFalse(titles.isEmpty(), "No product titles found on home page.");

        System.out.println("Products visible on screen:");
        for (WebElement title : titles) {
            String text = title.getText();
            System.out.println(" - " + text);
            Assert.assertFalse(text.isEmpty(), "Product title should not be empty");
            Assert.assertTrue(title.isDisplayed(), "Product title should be visible");
        }
    }

    @Test(priority = 2)
    public void testTapAllHomePageActions() {
        homePage = new HomePage(driver);
        Assert.assertTrue(homePage.isPageLoaded(), "Home page did not load.");

        homePage.tapToggleIcon();
        homePage.tapFirstAddButton();
        Assert.assertFalse(driver.findElements(AppiumBy.xpath("//android.widget.TextView[@text='-']")).isEmpty(),
                "Remove button should appear after adding product");
        homePage.tapSecondAddButton();
        homePage.tapFirstRemoveButton();

        homePage.tapFilterButton();
        WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(5));
        Assert.assertTrue(wait.until(ExpectedConditions.visibilityOfElementLocated(
                        AppiumBy.xpath("//android.widget.FrameLayout[@resource-id='android:id/content']//android.view.ViewGroup[1]")))
                .isDisplayed(),
                "Filter modal should be visible after tapping filter button");

        homePage.tapSortPriceLowToHigh();
        homePage.tapToggleIcon();
    }

    @Test(priority = 3)
    public void selectTheItems() {
        homePage = new HomePage(driver);
        homePage.scrollToProductAndSelect("Sauce Labs Onesie");

        String productTitle = driver.findElement(AppiumBy.xpath("//android.widget.TextView[@text='Sauce Labs Onesie']")).getText();
        Assert.assertEquals(productTitle, "Sauce Labs Onesie", "Wrong product opened after scroll.");
    }
}

Step 6: Run the Test

//Add Emulator to PATH
C:\Users\<YourUser>\AppData\Local\Android\Sdk\emulator

//To use Emulator
emulator -list-avds
emulator -avd Medium_Phone_API_36.0

//To start AVD in a new state
emulator -avd Medium_Phone_API_36.0 -no-snapshot-load

//Get the Android version of your device or emulator
adb shell getprop ro.build.version.release 

4. How to setup and use Appium Inspector

Appium Inspector is a GUI tool used for inspecting mobile apps (both Android and iOS) in the context of automation testing. It allows testers and developers to interact with the app’s UI elements, understand their properties, and generate the necessary locators for writing automation scripts in Appium.

Download and install Appium Inspector: https://github.com/appium/appium-inspector/releases

• Typical Use Case

1. Before writing your automation script in Appium, you open the Appium Inspector.
2. Connect it to a real device or emulator/simulator.
3. Navigate through the app in the inspector to identify elements and understand their properties.
4. Copy the locators into your test scripts.

{
  "appium:automationName": "UiAutomator2",
  "appium:platformName": "Android",
  "appium:platformVersion": "16",
  "appium:appPackage": "com.swaglabsmobileapp",
  "appium:appActivity": "com.swaglabsmobileapp.MainActivity",
  "appium:deviceName": "Medium_Phone_API_36.0",
  "appium:app": "D:/Learning/Source/Repos/Appium-Automation/src/test/resources/apps/Android.SauceLabs.Mobile.Sample.app.2.7.1.apk"
}

https://appium.io/docs/en/latest/intro/ — Appium Documentation

https://docs.saucelabs.com/mobile-apps/automated-testing/appium/configuration/ — SauceLabs Documentation

https://testautomationu.applitools.com/appium-java-tutorial-1/ — Mobile Testing with Appium and Java By Moataz Nabil

Conclusion

Appium is a versatile and powerful tool for automating mobile application testing across Android and iOS platforms. Its support for multiple programming languages, seamless integration with testing frameworks, and ability to interact with real devices and emulators make it an invaluable choice for QA engineers and developers.

By mastering Appium, you can efficiently create, maintain, and execute automated tests, ensuring the quality, reliability, and smooth performance of your mobile applications. This ultimately helps deliver a seamless user experience, reduces manual testing effort, and accelerates the release of high-quality apps.

You’ve reached the end of the article. Here’s a sample project to begin your journey with Appium. Try cloning this repository to your machine, learn, and contribute to the open-source community.

https://github.com/Malitthh/Appium-Automation.git

Happy testing!

A message from our Founder

Hey, Sunil here. I wanted to take a moment to thank you for reading until the end and for being a part of this community.

Did you know that our team run these publications as a volunteer effort to over 3.5m monthly readers? We don’t receive any funding, we do this to support the community. ❤️

If you want to show some love, please take a moment to follow me on LinkedIn, TikTok, Instagram. You can also subscribe to our weekly newsletter.

And before you go, don’t forget to clap and follow the writer️!

Kickstarting Mobile Test Automation with Appium. was originally published in Stackademic on Medium, where people are continuing the conversation by highlighting and responding to this story.

In the world of software development, managing code changes efficiently is crucial. Whether you’re working alone or collaborating with a team, keeping track of modifications, reverting mistakes, and maintaining different versions of your project can be challenging. This is where Git, a powerful Distributed Version Control System (DVCS), comes into play.

💠 Understanding Version Control

• What is Version Control? — Version control is a system that tracks changes to files over time, allowing you to access and restore previous versions when needed. It is essential for managing code, documents, and collaborative projects efficiently.

1. Local Version Control — A common but unreliable approach to version control is manually copying files into separate directories, sometimes with timestamps. While simple, this method is prone to errors, such as overwriting or losing important changes.
2. Centralized Version Control (CVCS) — To enable collaboration, Centralized Version Control Systems (CVCS), like CVS and Subversion, were introduced. These systems store all versioned files on a central server, allowing multiple users to check out and modify files. However, they depend on a single point of failure — if the server crashes, valuable data can be lost.
3. Distributed Version Control (DVCS) — Distributed systems like Git solve this issue by allowing every user to maintain a complete copy of the repository, including its entire history. This means that even if the central server fails, the data can be restored from any local copy, ensuring better reliability and redundancy.

💠 A Brief History of Git

Necessity often drives innovation, and Git is a prime example. Before its creation, the Linux kernel project managed changes manually through patches and archived files. In 2002, they adopted BitKeeper, a proprietary version control system that simplified collaboration.

However, in 2005, BitKeeper revoked free access due to disputes with the Linux community, leaving developers without a reliable tool. This prompted Linus Torvalds, the creator of Linux, to develop Git.

Git was built with key objectives:

• Speed and efficiency
• A simple yet flexible design
• Robust branching support for parallel development
• A distributed system where every user has a full repository copy
• Scalability for handling large projects like the Linux kernel

Since its release in 2005, Git has become one of the most widely used version control systems, valued for its speed, reliability, and powerful branching capabilities.

💠 Git Basics

This section introduces fundamental Git commands that you’ll use regularly for managing your projects efficiently.

• The Three States

The key to understanding Git is recognizing its three main file states, Git tracks files through three main states: Modified, Staged, Committed

The typical Git workflow follows these steps:

1. Modify files in your working directory.
2. Stage specific changes that you want to include in the next commit, adding them to the staging area.
3. Commit the staged changes, creating a permanent snapshot in your Git repository.

🔸Installing Git

Before using Git, you need to ensure it’s installed on your computer. Even if it’s already present, updating to the latest version is recommended. You can install Git using a package manager or another installer of your choice.

// Installing on macOS
$ brew install git

// Installing on Windows
https://git-scm.com/download/win

🔸First-Time Git Setup

After installing Git, it’s a good idea to configure your environment. These settings are typically done once per computer and persist across updates. The most important initial setup is setting your user name and email address, as Git associates this information with every commit you make.

$ git config --global user.name "Cpt Mactavish"
$ git config --global user.email mactavish@example.com

🔸Getting a Git Repository

You can get a Git repository in one of two ways:

• You can convert an existing local directory into a Git repository by initializing version control with Git.

# for macOS
$ cd /Users/cptmactavish/sample_git_project
# for Windows
$ cd C:/Users/cptmactavish/sample_git_project

# type
$ git init
# By default, when you initialize a new Git repository using git init, Git creates a branch called 'main'.
# This creates a new subdirectory named .git that contains all of your necessary repository files

• If you have an existing project and want to start tracking its files with Git, you need to add them to version control and make an initial commit. You can do this by running,

$ git add *.ts
$ git add LICENSE
$ git commit -m 'Initial project version'

This stages the files you want to track and commits them to your repository, marking the starting point of version control for your project.

# Go to your GitHub (or GitLab/Bitbucket) repo and copy the HTTPS or SSH URL.
# It'll look like this, 
https://github.com/username/reponame.git
# Then run,
git remote add origin https://github.com/username/reponame.git
# Now verify,
git remote -v
# You should see,
origin  https://github.com/username/reponame.git (fetch)
origin  https://github.com/username/reponame.git (push)
# Push your branch, since you're on master, run,
git push -u origin master #-u flag sets upstream tracking

• You can create a local copy of an existing Git repository by cloning it. This allows you to work on the project independently while staying connected to the original repository.

$ git clone https://github.com/sampleuser/sample_git_project

🔸Recording Changes to the Repository

After setting up your Git repository, the next step is to track changes and commit them.

▪ Check which files have changed

$ git status
$ git status -s

▪ Add a file to the staging area

# The git add command serves multiple purposes. It is primarily used to track new files, stage changes before committing, and mark merge-conflicted files as resolved. 
# This command moves changes from the working directory to the staging area, preparing them for the next commit.
$ git add README.md

▪ Commit the staged changes with a message

# Capitalized, short (50 chars or less) summary
$ git commit -m “Add a new file”

▪ Add all modified files at once

$ git add .

▪ lists all the files that are currently being tracked by Git in your repository.

# Files that are in the index (staged) and under Git tracking
git ls-files
# Does not include: Untracked files (not yet added with git add), Ignored files (in .gitignore)

▪ Viewing the Commit History

# You can see a record of all commits made in your repository.
$ git log
$ git log --oneline

▪ Ignoring Files

To prevent Git from tracking certain files, such as logs or build artifacts, you can create a .gitignore file that defines patterns for files to ignore. Here’s an example:

# The command cat in this context is a Unix/Linux command that stands for "concatenate". It is used to display the contents of a file in the terminal.
$ cat .gitignore

# Ignore node modules and build files
# Ignores the node_modules folder (common in Node.js projects)
node_modules/
# Ignores the dist folder (typically contains build output)
dist/
# Ignore log files
*.log
# Ignore Screenshots
screenshots/
# Ignores all files ending in .o or .a (main.o / lib.a)
*.[oa]
# Ignore ResponseData
/src/projectName/responseData

▪ Undoing Things

If you commit too soon and need to include additional changes or fix the commit message, you can use,

# This allows you to modify the previous commit by adding new changes or editing the commit message without creating a new commit.
$ git commit --amend

#  Deletes file from disk and Git tracking
git rm file.txt

# Removes the file(s)/directory from Git's tracking without deleting them from your computer.
git rm -r --cached
git rm -r --cached node_modules

▪ Unstaging a Staged File

If you accidentally stage multiple files using git add * but want to unstage one while keeping the changes, you can use the following command:

# to unstage a file
git reset HEAD <file>

🔸Working with Remotes

To collaborate on a Git project, you must manage remote repositories — versions of your project hosted online or on a network. You can have multiple remote repositories, each with read-only or read/write access. Effective collaboration requires pushing and pulling data between these repositories to share updates and stay in sync with others.

The “upstream branch” is the remote branch that your local branch is linked to (i.e., tracks). It is usually used to:

• Pull changes (git pull) from that branch
• Push changes (git push) to that branch

# This -u (or --set-upstream) sets the upstream branch so that next time you can just use
git push -u origin feature/login
git push --set-upstream origin master
# Mainly need when you create a new branch locally & trying to push it without specify the remote branch

▪ Fetching, Pulling & Pushing with Remotes

# The command fetches all new data from the remote repository that is not yet present in your local repository.
$ git fetch <remote>

# You can use the git pull command to fetch the latest changes from a remote branch and merge them into your current branch automatically. 
# This can simplify your workflow and keep your local repository up to date.
$ git pull <remote>

# When your project is ready to be shared, you need to push it to a remote repository.
$ git push origin master

Conclusion

By now, you are equipped with the essential Git skills needed to work locally. You can create or clone repositories, make and track changes, stage and commit updates, and reviewing the repository’s history.

Happy Learning!

Basics of API Testing & Rest Assured.

API automation is an essential skill in the realm of software testing, and Rest Assured is one of the most popular tools for this purpose, especially for Java developers. This guide aims to provide a structured approach to learning Rest Assured, making your journey smoother and more efficient.

Step 1: Understand the Basics of API and REST

Before diving into Rest Assured, it’s crucial to have a solid understanding of what APIs (Application Programming Interfaces) and REST (Representational State Transfer) are. Here’s a brief overview:

• API: An interface that allows different software applications to communicate with each other.
• REST: A set of principles for designing networked applications. It relies on stateless, client-server communication, typically over HTTP.

Step 2: Set Up Your Development Environment

To work with Rest Assured, you need to set up your development environment. Here’s how you can do it:

1. Install Java Development Kit (JDK): Ensure you have JDK installed on your system. You can download it from the Oracle website.
2. Install an Integrated Development Environment (IDE): Popular choices include IntelliJ IDEA, Eclipse.
3. Set Up Maven: Rest Assured is available as a Maven dependency, so you’ll need to have Maven installed. You can download Maven from the Apache Maven website. (When you create a Maven project in Eclipse or IntelliJ IDEA you typically don’t need to manually install Maven because those IDEs comes with its own embedded version of Maven)
4. Create a Maven Project: In your IDE, create a new Maven project. This will allow you to manage dependencies easily.

Step 3: Add Rest Assured Dependency

Add Rest Assured to your Maven project by including the following dependency in your pom.xml file:

<!-- REST Assured dependency -->
  <dependency>
   <groupId>io.rest-assured</groupId>
   <artifactId>rest-assured</artifactId>
   <version>4.4.0</version>
   <scope>test</scope>
  </dependency>

Make sure to check for the latest version on the Maven Repository.

https://mvnrepository.com/

Step 4: Learn the Basics of Rest Assured

Rest Assured provides a simple and intuitive syntax for making HTTP requests and validating responses. Here’s a basic example of how to make a GET request:

@Test(priority=1)
void addaNewPet() {
     given()
         .contentType("application/json")
         .body("{ \"id\": 7, \"category\": { \"id\": 5, \"name\": \"Bravo\" }, \"name\": \"Bravo\", \"photoUrls\": [ \"abcdefg.lk\" ], \"tags\": [ { \"id\": 7, \"name\": \"Bravo\" } ], \"status\": \"pending\" }")
     .when()
         .post("https://petstore.swagger.io/v2/pet")
     .then()
         .statusCode(200);
 }

Just to make sure it’s created, you can go to the Petstore Swagger mentioned below, and find the GET method to find the pet by ID. Pass the ID value you gave here, and the created pet will be there.

Using the BDD (Behavior-Driven Development) format provided by Rest Assured is a common and recommended way to write tests for RESTful APIs because it makes the tests readable and easier to understand.

Explanation of given(), when() & then()

• given(): Sets up the request. Here, you specify headers, parameters, request body, etc.
• when(): Describes the action that triggers the request, such as get, post, put, delete, etc.
• then(): Validates the response. Here, you assert the status code, response body, headers, etc.

While the BDD format is recommended for its readability and alignment with BDD practices, Rest Assured also supports a non-BDD format:

@Test(priority=1)
 void addANewPet() {
     RequestSpecification request = RestAssured.given();
     request.contentType("application/json");
     request.body("{ \"id\": 7, \"category\": { \"id\": 5, \"name\": \"Bravo\" }, \"name\": \"Bravo\", \"photoUrls\": [ \"abcdefg.lk\" ], \"tags\": [ { \"id\": 7, \"name\": \"Bravo\" } ], \"status\": \"pending\" }");

     Response response = request.post("https://petstore.swagger.io/v2/pet");
     Assert.assertEquals(response.getStatusCode(), 200);
 }

Step 5: Running The Script

You can run the script using the TestNG plugin. Make sure the TestNG plugin is installed in Eclipse. Simply add the TestNG dependency to your project. You can install TestNG via the Eclipse Marketplace. Then, click on the test class and select, Run As -> TestNG Test.

Step 6: Explore Advanced Features

Once you’re comfortable with the basics, explore the advanced features of Rest Assured:

• Path Parameters: Learn how to handle dynamic paths in your requests.
• Query Parameters: Understand how to add query parameters to your requests.
• Headers: Discover how to add headers to your requests.
• Authentication: Explore how to handle different types of authentication.
• Assertions: Learn how to make assertions on the response data.

Step 7: Practice with Real APIs

To gain practical experience, practice by automating real APIs. Some good options include:

e.g., Reqres, https://petstore.swagger.io/

These APIs provide a variety of endpoints that you can use to practice different types of requests and validations.

e.g., https://www.postman.com/templates/collections/tags/quality-engineers/

Conclusion

Learning Rest Assured for API automation is a valuable skill that can significantly enhance your testing capabilities. By following this structured approach, you’ll be able to master Rest Assured and apply it effectively in your projects. Remember, practice is key to becoming proficient, so keep experimenting with different APIs and scenarios.

Happy learning!

In the fast-paced world of software development, ensuring the quality and reliability of applications is crucial. Test automation frameworks are essential to this process because they offer an organized and effective method of performing tests. Still, it can be difficult to choose the best framework for your project given the wide range of options. This blog aims to guide you through the key considerations and steps to help you make an informed decision.

Understanding Test Automation Frameworks

A test automation framework is a structured approach & a set of guidelines or rules used for automate software testing or repetitive tasks. Enhancing efficiency and accuracy. The functionality and complexity of frameworks vary, ranging from simple record-and-playback tools to broad data-driven and behavior-driven development (BDD) frameworks.

To get started, let’s begin with a scenario,

“MediClaim Portal,” designed to enhance the efficiency of medical claims processing. A policyholder logs into the portal and uploads their surgery invoice, doctor’s prescription, and medical reports. The ML-AI-powered system swiftly processes these documents, extracting crucial information such as surgery details, incurred costs, and doctor’s notes, and generates a concise summary. This summary is presented in a clear format for the medical staff to review. The staff receives a notification of the policyholder’s submission and accesses the dedicated dashboard to review the summarized information alongside the original documents. Satisfied with the completeness and accuracy of the information, the staff approves the policyholder’s claim. The policyholder is then notified of the approval and the expected reimbursement date via both email and a push notification on the mobile app.

By following these steps, you can decide which tools or frameworks to use for the project,

Step 1: Make A List Of Features & Project Requirements

Understanding the specific needs of your project is the first step. Consider factors like,

• Cross-browser Testing — The web application must be compatible with all major browsers including Internet Explorer, Safari, Chrome, Opera, Firefox, and Microsoft Edge.
• Mobile Automation on Both iOS and Android Devices — The application has native mobile versions for both Android and iOS.
• Tab and Iframe Support — The web application includes iframes on each page and links that open in new tabs.

“An inline frame (iframe) is a HTML element that loads another HTML page within the document. It essentially puts another webpage within the parent page.”

• API Automation — Automate tests to validate data collection and communication through APIs across different interfaces.
• Performance Testing— Ensure that the performance of the project is thoroughly tested to measure response times and scalability under various user loads and usage scenarios. This includes assessing the system’s ability to handle concurrent document processing and maintaining optimal performance levels across different operational conditions.
• Data-driven Testing — Implement tests using various data inputs (e.g., different medical claim scenarios) to validate application behavior.
• Database Automation — Develop automated tests to validate data stored in the database related to medical claims and user interactions.

Step 2: Team Expertise

By carefully assessing your team’s skills and aligning them with the specific requirements of the project, you can make informed decisions on selecting automation tools and frameworks. Prioritize capabilities such as iframe handling alongside broader considerations of programming language proficiency, testing experience, and long-term strategic alignment.

Step 3: Ease of Use

The framework should be easy to set up and use. A steep learning curve can delay the testing process and affect productivity. Look for frameworks with good documentation and community support.

Step 4: Scalability and Flexibility

Choose a framework that can scale with your project. It should be flexible enough to integrate with various tools and adapt to changing requirements. This is crucial for long-term projects where needs may evolve.

Step 5: Integration with CI/CD Pipelines

In modern development environments, continuous integration and continuous deployment (CI/CD) are standard practices. Ensure that the framework you choose seamlessly integrates with CI/CD tools.

Step 6: Cost

While some frameworks are open-source and free, others may require a license. Consider your budget and evaluate whether the features of a paid framework justify its cost.

Step 7: Shortlist Tools and Frameworks

Once you’ve researched and compared existing tools, narrow down your options to create a shortlist of tools and frameworks that best meet your project’s requirements. Consider the following criteria,

Note: Correction to be made for the table “The comparison table lists the tools in the columns and the requirements in the rows. The cells contain information about each tool’s properties concerning each requirement, along with priority details, as specified in the ‘ISTQB CTAL-TAE Syllabus v2.0’.”

Step 8: Conduct Proof of Concept (PoC)

Before committing fully, conduct a Proof of Concept (PoC) with the shortlisted tools to validate their suitability for the project.

Conclusion

Selecting a suitable test automation framework is an important decision that can greatly influence the efficacy and efficiency of your testing process. You can choose the framework that best suits your needs by carefully considering the features of several frameworks, your team’s experience, and the requirements of your project. Keep in mind that the objective is to maximize the testing effort while improving the software’s quality and dependability.

Performance Testing

In today’s digital age, web applications and services are expected to deliver high performance and reliability to meet user expectations. To ensure your applications can handle real-world traffic and load, performance testing is crucial, What is Performance Testing, is a term for measuring how a system or application performs overall, this could include testing for evaluate the speed, scalability, reliability, responsiveness & resource usage of an application under expected & peak load condition.

Types of Load Testing

There are several types, here are a few examples

1. Load Testing — Load testing involves testing the stability and response time of a system by applying a load that is typically less than or average to the design number of users. e.g. AverageLoad, Smoke
2. Stress Testing — In stress testing, you increase the load or resource usage to above average level that system’s capacity.
3. Spike Testing — Spike testing increases to extremely high loads in a very short or non-existent ramp-up time. In the same way, the ramp-down is very fast or non-existent, letting the process iterate only once.
4. Soak Testing — Soak testing, also known as endurance testing, is a type of performance testing that focuses on assessing how a system performs over an extended period under a consistent, sustained load.

Performance Testing does use some Mathematical and Statistical Concepts.

Let’s break it down in a practical way.

1. Averages, Median, Percentiles & Response Times

• Mean (μ) (Avg) — when you see “Avg response time” in tools, it usually means arithmetic mean.

• Problem: A few very slow requests can hide inside a good-looking average.
• e.g., 100, 110, 120, 130, 5000 → Average = 1,092ms, But 4 out of 5 users were fast.
• Median (50th Percentile) — the middle value when data is sorted. Useful because avg can be skewed by outliers.

Most real systems fail not because of average, but because of slow outliers.

e.g., [100, 200, 2000] → mean = 766ms, but median = 200ms

• Percentiles (p90, p95, p99th) — shows what % of requests completed within a certain time. often more valuable than mean.

e.g., [100,200,300,400,500] — Sort the data (ascending)

• p = percentile (95 in our case)
• n = number of data points (5 here)

• Rank = 5.7 → the 95th percentile is between the 5th and 6th value.
• But we only have 5 values → so we interpolate between the 5th value (500) and the “next” value (which doesn’t exist, so we take it as the max = 500).
• p95–95% of responses were equal to or faster than this value, ≤ 500ms.

This exposes tail latency, which users actually feel. Most requests are fast. A small percentage are much slower, and that slow end stretches out like a long tail on a graph.

Cloud systems naturally produce long-tail latency due to shared resources, queueing effects, and dependency fan-out, which is why percentiles matter more than averages.

Why cloud systems naturally produce long tails,

1. Shared infrastructure
2. Queueing theory (Little’s Law in action)
3. Garbage collection & memory management
4. Network unpredictability
5. Dependency fan-out
6. Cold starts & autoscaling

• The slowest (5%) took longer than 500ms.

you can say it like this, “The system’s p95 latency is 500ms, meaning 95% of requests complete within this time, with only the slowest 5% exceeding it”

Average shows overall performance, but percentiles show user experience. A good average can hide slow requests, while p95 ensures most users aren’t affected by latency spikes.

2. Variability & Spread

• Standard deviation (σ) — measures how spread out response times are from the mean, indicate the system stability.

e.g., Low σ → most response times are clustered near the mean → system is predictable. High σ → response times are spread out → some users are much slower than others.

• a low σ → stable system, a high σ → inconsistent response time

But how do we decide “low” vs “high”? There’s no single universal threshold, but here are ways industry people judge it:

• Compare σ to the Mean (Coefficient of Variation)

• CV < 0.1 (10%) → very stable system.
• CV 0.1–0.3 (10–30%) → acceptable variance.
• CV > 0.3 (30%+) → unstable/unpredictable.

e.g., Mean = 200ms, σ = 20ms → CV = 0.1 → stable, Mean = 200ms, σ = 120ms → CV = 0.6 → unstable.

• Compare Across Test Runs / Baselines

e.g., Run load test today → σ = 30ms, Run same test after deployment → σ = 200ms.

• Variance — square of standard deviation

3. Growth & Load Patterns

• Linear — increase at a constant rate
• Exponential — extreme scaling

4. Queuing & Capacity Concepts

• Littles Law in Performance Testing — Little’s Law helps in estimating the number of concurrent users or requests in a system based on the arrival rate and average response time.

• L = avg concurrent requests in system
• λ = arrival rate (req/sec)
• W = avg response time

Meaning: on average, 5 requests are “inside” the system at any moment.

e.g., You send 100 req/sec, but system can only process 60 req/sec.

• λ (arrival rate) = 100 req/sec (you’re still sending them).
• Throughput (completion rate) = 60 req/sec.
• Queue builds up → L increases.
• This is why arrival rate ≠ throughput under stress.

KPIs (key performance indicators) for Performance Testing

1. Throughput — which tells you how many requests were sent per second on average during the test execution.

2. Response Time — (e.g., for Acceptor API, for e2e flow to complete)

x₁ = each response time, n = number of requests

3. Latency & Percentile Values — Latency is generally considered to be the amount of time it takes from when a request is made by the user to the time it takes for the response to get back to that user.

4. Error Rate — Percentage of failed requests. (means some requests completely failed, e.g., timeouts, server error.)

5. Resources Utilizations

When initiating Performance Testing, it’s crucial to follow these steps:

1. Define the performance objectives.
2. Design and identify the key scenarios.
3. Design the test environment.
4. Develop the test script.
5. Execute the tests.
6. Analyze the results.
7. Optimize and retest.

Now, let’s shift our focus to k6.

K6

K6 is a developer-centric, open-source performance testing tool designed to be simple, efficient, and scriptable. It allows you to write test scripts in JavaScript, making it accessible to developers with various backgrounds and expertise levels.

Why Choose K6 for Performance Testing?

1. Ease of Use
2. Open Source
3. Scripting Flexibility
4. High Performance

Getting Started with K6 and JavaScript

Let’s take a closer look at how to create performance tests using K6 and JavaScript.

Installation — Start by installing K6 using your package manager (e.g., npm or Homebrew). Once installed, you can verify its version and check the available options using the command-line interface.

for Windows (Winget is a package manager for Windows that allows you to easily install and manage various software packages),
    "winget install k6" or "winget install --id k6.k6"
for Mac,
    "brew install k6"
for version check,
    "k6 --version"

1. Initialize a new Node.js project, This creates a package.json file to manage dependencies.

mkdir k6-performance  # Create a folder named 'k6-performance'
cd k6-performance     # Navigate into the folder
npm init -y           # Initialize a Node.js project with default settings (creates package.json)

2. Install required dependencies.

npm install typescript ts-loader webpack webpack-cli eslint prettier dotenv json-loader --save-dev

3. Configure TypeScript (tsconfig.json) — tsconfig.json file is a configuration file for TypeScript projects. It defines compiler options and settings to control how TypeScript compiles .ts files into JavaScript.

4. Set Up Webpack (webpack.config.js) — file is a configuration file for Webpack, a powerful module bundler used in JavaScript applications. It defines how Webpack processes, transforms, and bundles files like JavaScript, TypeScript, CSS, and images.

5. Create a folder structure to organize your scripts, common actions, testdata, and other resources. A common structure could be,

k6-performance/
├── dist/                             # Compiled files
├── node_modules/                     # Dependencies
├── src/                              # Source code
│   ├── perf_tests/                   # Test scripts
│   │   ├── Petstore/
│   │   │   ├── GET_APIs/
│   │   │   │   ├── petstoreService.ts
│   │   │   ├── POST_APIs/
│   │   │   │   ├── getCorrelationId.ts
│   ├── testdata/                     # Test data
├── .eslintignore                     # ESLint ignore rules
├── .eslintrc.js                      # ESLint config
├── common.env                        # Environment variables
├── package.json                      # Node.js config
├── package-lock.json
├── Performance_Test_Report.md        # Documentation
├── README.md                         # Project Readme
├── run_k6.sh                         # Shell script to execute tests
├── tsconfig.json                     # TypeScript config
├── webpack.config.js                 # Webpack config
└── k6.exe                            # K6 CLI tool

6. Add ESLint & Prettier

7. Write Your First Test Script — Create a new TypeScript file for your test script. K6 provides a simple and intuitive API to define your test scenarios. You can set up HTTP requests, specify user flows, and define thresholds for performance metrics such as response time and error rates.

This is a basic outline for creating a beginner-level K6 framework.

Sample POST script below,

import http from "k6/http";
import { check } from "k6";

export const options = {
    thresholds: {
        http_req_duration: ["p(95)<7000"],
        http_req_duration: ["p(75)<9500"], 
        checks: ["rate>0.95"],
        http_req_failed: ["rate<0.1"],
    },
    noConnectionReuse: true,
    scenarios: {
        constant_scenario: {
            executor: 'constant-arrival-rate',
            duration: '30s',
            rate: 10,
            timeUnit: '1s',
            preAllocatedVUs: 50,
            maxVUs: 100,
        }
    }
};

export default function () {
    let data = {
        Data: "K6 is a developer-centric, open-source performance testing tool designed to be simple, efficient, and scriptable. It allows you to write test scripts in JavaScript, making it accessible to developers with various backgrounds and expertise levels.",
        Department: "Grafana",
        Software: "K6",
        Date: "23/02/2025",
        Url: "https://sample.swagger.io/english/list"
    };

    const params = {
        headers: {
            "Content-Type": "application/json",
            Accept: "*/*",
            Token: "sample_token",
        },
    };

    const url = "https://petstore.swagger.io/v2/pet";
    const res = http.post(url, JSON.stringify(data), params);
    const req = JSON.parse(res.body);
    console.log(req.request_id, res.status);

    check(res, {
        "is status 202": (rs) => rs.status === 202,
    });

}

Test Scenarios & Executors — To simulate user behavior, define one or more test scenarios within your script. Each scenario should include HTTP requests to various endpoints of your application. You can control the number of virtual users, ramp-up periods, and test duration.

1. Shared Iterations — A fixed total number of iterations is shared among a set number of virtual users (VUs).
   Iterations are distributed between VUs, but not evenly, some VUs may do more work than others. The test ends when all iterations are complete.
2. Per VU Iterations — Each VU executes an exact and fixed number of iterations. Total iterations = VUs × iterations per VU. This is useful when you want exactly the same load (in terms of iterations) from each VU.
3. Constant VUs — A fixed number of VUs runs for a specified duration, executing as many iterations as possible within that time.
   This models constant concurrent users running the test workload.
4. Ramping VUs — A changing (ramped) number of VUs over time runs as many iterations as possible. You define a series of stages to increase/decrease target VUs. This lets you simulate load changing over the test period.
5. Constant Arrival Rate — A fixed iteration start rate (e.g., iterations per second) is maintained for a specified period. It dynamically adjusts the number of VUs as needed to try to keep that rate steady, regardless of iteration execution time.
6. Ramping Arrival Rate — A changing iteration start rate over time. i.e., the rate of iteration starts increases or decreases based on stages. k6 will adjust the number of VUs dynamically to meet that target rate schedule.

Overall average RPM = (start + end) / 2 x Duration
  
  {target:4, duration:"1m"} - e.g., Avg RPM = (4 x 1) = 4 Requests
  {target:6, duration:"2m"} - e.g., Avg RPM = (4 + 6) / 2 = 5 RPM x 2 = 10 Requests
  {target:10, duration:"3m"} - e.g., Avg RPM = (6 + 10) / 2 = 8 RPM x 3 = 24 Requests 
  {target:20, duration:"4m"} - e.g., Avg RPM = (10 + 20) / 2 = 15 RPM x 4 = 60 Requests
 
e.g., Avg RPM = 98 Requests
e.g., Avg RPM = (4 + 20) / 2 = 12 RPM x 10 = 120 Requests (upper bound)

Assertions — K6 allows you to set assertions (Checks) to validate the Boolean condition in your tests. Testers often use checks to validate that the system is responding with the expected content.

check(res, {
            //'HTTP Status is 200 or 201': (rs) => rs.status === 200 || 201,
            'HTTP Status is 200 or 201': (rs) => rs.status === 200 || rs.status === 201,
            'Response Body "Status"': (rs) => {
                const responseBody = rs?.json();
                const checkStatus = responseBody?.Status === 'DONE';
                console.log(`Response Body Check Result for Request ID ${reqid}: ${checkStatus}`);
                return checkStatus; 
            }
        });
// The ?. operator in JavaScript and TypeScript is called the optional chaining operator. 
// It allows you to safely access deeply nested properties of an object without having to check if each level exists, preventing runtime errors.

Execution — Run your K6 test script using the command line. K6 will simulate user behavior, gather performance data, and generate insightful reports. You can customize the output format and specify thresholds for performance metrics.

- How to run Locally - K6 run path of the test,
K6 run 'copy path'

Reporting & Visualizations

To complement the performance test results executed using k6, we have included additional supporting artifacts to enhance analysis and visibility. A detailed summary table outlining key performance metrics is provided in the attached Word document. Furthermore, a custom Python script has been developed to generate a percentile distribution graph from the database-exported results, allowing for deeper insight into response time behavior across various thresholds.

https://github.com/Malitthh/medium-content-hub/blob/master/docs/Sample%20Performance%20Test%20Report.docx
https://github.com/Malitthh/medium-content-hub/blob/master/code/job_duration_analyzer.py

Reference

• Throughput vs Latency - Difference Between Computer Network Performances - AWS
• Types of load testing | Grafana Labs

Conclusion

Performance testing is essential for ensuring the reliability and scalability of your web applications. K6, with its JavaScript scripting capabilities, provides a user-friendly and powerful solution for performance testing. Its open-source nature, ease of use, and scripting flexibility make it a top choice for developers and testers alike.

By leveraging K6 and JavaScript, you can simulate user behavior, analyze performance metrics, and identify areas for improvement in your application. This combination enables you to deliver a robust and high-performance user experience, ultimately leading to greater user satisfaction and the success of your digital projects.

Happy learning!

A message from our Founder

Hey, Sunil here. I wanted to take a moment to thank you for reading until the end and for being a part of this community.

Did you know that our team run these publications as a volunteer effort to over 3.5m monthly readers? We don’t receive any funding, we do this to support the community. ❤️

If you want to show some love, please take a moment to follow me on LinkedIn, TikTok, Instagram. You can also subscribe to our weekly newsletter.

And before you go, don’t forget to clap and follow the writer️!

Mastering Performance Testing with K6 and JavaScript. was originally published in Stackademic on Medium, where people are continuing the conversation by highlighting and responding to this story.

Playwright Introduction

Playwright is an open-source testing library developed using TypeScript by Microsoft. As a robust and versatile tool, Playwright allows developers and testers to conduct end-to-end testing of web applications efficiently. Leveraging the capabilities of TypeScript, Playwright offers a seamless and user-friendly experience for creating robust test suites.

Comparison of Playwright and Cypress

Both Playwright and Cypress are well-known testing tools, yet they have differences. Here are some variations:

Advantages of Playwright

1. Cross-Browser Support: Playwright supports multiple browsers, including Chrome, Firefox, WebKit (Safari), and Microsoft Edge. This allows you to run tests on different browsers easily, ensuring your web application works consistently across various environments.
2. Automating Complex Scenarios: Playwright can handle more complex web application scenarios, such as file downloads, handling browser dialogs, and interacting with web components like iframes and shadow DOM elements.
3. Speed and Performance: Playwright is designed for speed and improved performance. It can execute tests faster, making the testing process more efficient.
4. Parallel Testing: Playwright has built-in support for parallel testing, allowing you to run tests concurrently across multiple browser instances, which can significantly reduce test execution time.
5. Headless and Headful Mode: Playwright supports both headless (no GUI) and headful (with GUI) modes, giving you the flexibility to choose the appropriate mode based on your testing needs.
6. Mobile Device Emulation: Playwright allows you to emulate mobile devices and test your web application’s responsiveness and behavior on different screen sizes.
7. Support for Multiple Programming Languages: Playwright offers bindings for various programming languages, including JavaScript, TypeScript, Python, and C#, making it accessible to developers from different tech stacks.
8. Robust Wait and Synchronization Mechanisms: Playwright provides advanced wait and synchronization mechanisms, ensuring that your tests interact with the web application at the right moments, improving test reliability.
9. Community and Support: Playwright has an active community and is actively maintained by Microsoft, which means you can find resources, documentation, and community support to help you get started and resolve any issues you encounter.

Setting up the Playwright Environment

Setting up a Playwright environment is easy. Here are the steps:

1.Install Node.js and set “NODE_HOME” environmental variable.
2.Create a new Playwright working directory.
3.Navigate to the working directory in the terminal.
4.Run “npm init playwright@latest” to initialize the project.

Here’s an example of a Playwright Script:

import { test, expect } from "@playwright/test";
import commons from "../../pages/commons.page";

test.describe("Playwright 101: Beginner's Guide", async () => {
  //Qmetry - SwagLabs-TC-001
  test("Add to Cart", async ({ page }) => {
    const common = new commons(page);
    const randomData = commons.generateRandomData();

    await common.login('standard_user', 'secret_sauce');
    await common.addtoCart();
    await common.checkoutProcess(randomData);
  });
});

Few Playwright Commands:

• Running the Tests

1. npx playwright test --ui - UI mode
2. npx playwright test - run all tests
3. npx playwright test AddtoCart.spec.ts - run a specific test
4. npx playwright test AddtoCart.spec.ts --project chromium --headed - run a specific test with UI with specific browser
5. npx playwright codegen --test-id-attribute="data-cy" - playwright recorder

• Report Generation

1. npx playwright show-report - to view the report

Page Object Model in Playwright

The Page Object Model (POM) is a design pattern for organizing test code in a way that makes it easier to maintain and reuse. In Playwright, the POM can be implemented using custom commands and page objects. Here’s an example of how to implement the POM in Playwright:

1. Create a new folder called “pages” in the root of your project.
2. Create a new file in the “pages” folder called “commons.page.ts”.
3. In “commons.page.ts”, create a new class called “commons”.
4. Add methods to the “commons” class for locating and interacting with the elements.
5. Under “e2e” folder create a script “AddtoCart.spec.ts”
6. In “AddtoCart.spec.ts” here u can create an object of commons page and access methods to the script.

Here’s an example of how the “commons.ts” file might look:

const { test, expect } = require("@playwright/test");
import { Locator, Page } from "@playwright/test";

export class commons {
  readonly page: Page;
  readonly usernameInputField:Locator;
  readonly passowrdInputField:Locator;
  readonly loginButton:Locator;
  readonly pageTitle:Locator;

  constructor(page: Page) {
    this.page = page;
    this.usernameInputField = page.getByPlaceholder("Username");
    this.passowrdInputField = page.getByPlaceholder("Password");
    this.loginButton = page.locator('[data-test="login-button"]');
    this.pageTitle = page.getByText('Swag Labs');
  }

  /**
   * @description Navigate to base URL
   * @example common.navigateToBaseUrl()
   */
  async navigateToBaseUrl() {
    await this.page.goto('/');
  }

  /**
   * @description Login to the application
   * @param username: any
   * @param password: any
   * @example common.login(userName, Password)
   */
  async login(username: any, password: any ) {
    await this.page.goto('/');
    await this.usernameInputField.click();
    await this.usernameInputField.fill(username);
    await this.passowrdInputField.click();
    await this.passowrdInputField.fill(password);
    await this.loginButton.click();
    expect (this.pageTitle).toBeVisible();
  }

  async addtoCart() {
    await this.addToCartBackpackButton.click();
    await this.addToCartTShirtButton.click();
    await this.addToCartJacketButton.click();
    await this.shoppingCartLink.click();
  }

  static generateRandomData() {
    const randomFirstName = `Soap${Math.floor(Math.random() * 100)}`;
    const randomLastName = `Mactavish${Math.floor(Math.random() * 100)}`;
    const randomZip = Math.floor(Math.random() * 10000);
    return {
      namefirst: randomFirstName,
      namelast: randomLastName,
      zip: randomZip.toString(),
    };
  }
}
export default commons;

And here’s an example of how the “AddtoCart.spec.ts” file might look:

import { test, expect } from "@playwright/test";
import commons from "../../pages/commons.page";

test.describe("Playwright 101: Beginner's Guide", async () => {
  //Qmetry - SwagLabs-TC-001
  test("Add to Cart", async ({ page }) => {
    const common = new commons(page);
    const randomData = commons.generateRandomData();

    await common.login('standard_user', 'secret_sauce');
    await common.addtoCart();
    await common.checkoutProcess(randomData);
  });
});

Creating a Framework

Creating a Playwright framework involves organizing your test code, defining reusable functions, and structuring the project to facilitate easy maintenance and scalability.

Create a folder structure to organize your tests, page objects, utilities, and other resources. A common structure could be,

├── e2e (to store your test scripts)
│   ├── AddtoCart.spec.ts
│   ├── dashboard.spec.ts
│   └── ...
├── pages (to store your web elements and methods relevent to your scripts)
│   ├── commons.page.ts
│   ├── Dashboard.Page.ts
│   └── ...
├── supports (to store Utill files, and commands files)
│   ├── commands.ts
│   └── ...
├── fixtures (to store test data files)
│   ├── testData.json
│   ├── Excel.xls
│   └── ...
└── playwright.config.ts
└── tsconfig.json
└── package-lock.json
└── package.json

This is a basic outline for creating a beginner-level Playwright framework. Depending on your project’s requirements, you can add more advanced features like test reporting, data-driven testing, parallel execution, etc.

https://playwright.dev/docs/intro — Playwright Documentation

Conclusion

In Summary, Playwright is a powerful end-to-end testing framework developed by Microsoft. It offers developers a simple and effective approach to creating and executing tests. With its distinctive features like automated waiting, real-time reloads, and powerful debugging tools, Playwright has become a popular choice among engineers for web application testing.

You’ve reached the end of the article. Here’s a sample project to begin your journey with Playwright. Try cloning this repository to your machine, learn, and contribute to the open-source community.

https://github.com/Malitthh/playwright-automation.git

In the world of software development, agile testing has become an essential part of the process. Agile testing is a methodology that emphasizes collaboration, flexibility, and speed in the testing phase of software development. It focuses on continuous feedback, early defect detection, and continuous improvement. In this article, we will discuss what agile testing is, the principles behind it, the different methodologies, the agile testing lifecycle, the role of a tester in an agile team.

We will also cover best practices for implementing agile testing in your organization, common challenges faced by teams when adopting agile testing, and the impact of agile testing on software quality and customer satisfaction.

What is Agile Testing?

• Agile testing is a technique for software testing that aligns with the agile methodology.
• It gives importance to testing throughout the software development process, rather than just at the end. The approach involves continuous testing and feedback, fostering collaboration between development and testing teams and prioritizing the delivery of top notch software.

Agile Testing Principles

There are four core principles of agile testing:

• Testing is an integral part of the software development process.
• Test early and often.
• Embrace change and adapt to it.
• Collaborate and communicate with the development team.

Agile Testing Methodologies

There are several agile testing methodologies that teams can use. Some of the popular ones include:

• Scrum: A framework that emphasizes iterative and incremental development. Testing is done in sprints, with each sprint delivering a potentially shippable product increment.
• Extreme Programming (XP): A methodology that emphasizes continuous integration, automated testing, and customer involvement.
• Kanban: A method that emphasizes visualizing workflow, limiting work in progress, and delivering small batches of work.

Agile Testing Lifecycle

The agile testing lifecycle is an iterative process that involves the following phases:

• Test Planning: This involves defining the scope of testing, identifying the testing objectives, and creating a test plan.
• Test Design: This involves creating test cases based on the requirements and design of the software.
• Test Execution: This involves running the tests and reporting any defects.
• Test Reporting: This involves reporting the results of the testing, including any defects found and their severity.
• Test Retesting: This involves retesting any defects that were found and fixed during the previous phases of testing to ensure that they have been completely resolved and that there are no new defects introduced as a result of the fixes.
• Test Closure: This involves completing the testing process and analyzing the results to identify areas for improvement.

Role of a Tester in an Agile Team

In an agile team,

• The role of the tester is to ensure that the software being developed meets the quality standards set by the team.
• The Tester works closely with the developers and other team members to identify potential defects and provide feedback on the software’s functionality.
• The Tester is responsible for creating test plans, executing tests, and reporting any defects found.
• They are also involved in the continuous improvement process by providing feedback on the testing process and suggesting areas for improvement.

Best Practices for Implementing Agile Testing in Your Organization

Implementing agile testing in your organization can be challenging. Here are some best practices to help you successfully adopt agile testing:

• Train your team: Make sure that your team is trained on agile testing principles and methodologies. Provide them with the necessary tools and resources to implement agile testing.
• Collaborate with your team: Encourage collaboration between your development and testing teams. This will help to ensure that everyone is working towards the same goals and that testing is integrated throughout the software development lifecycle.
• Prioritize testing: Make sure that testing is a priority and that it is integrated throughout the software development lifecycle. This will help to ensure that defects are caught early and that the software is delivered on time and with high quality.
• Automate testing: Use automation tools to automate as much testing as possible. This will help to ensure that testing is done consistently and efficiently.
• Focus on continuous improvement: Encourage your team to continuously improve the testing process. This will help to ensure that the team is always learning and improving, and that the testing process is as effective as possible.

Common Challenges Faced by Teams When Adopting Agile Testing

Adopting agile testing can be challenging. Here are some common challenges that teams face:

• Resistance to change: Some team members may be resistant to changing the way they work. This can make it difficult to adopt agile testing.
• Lack of resources: Teams may not have the necessary resources to implement agile testing effectively. This can include tools, training, and personnel.
• Lack of collaboration: Teams may struggle to collaborate effectively, which can make it difficult to integrate testing throughout the software development lifecycle.
• Lack of expertise: Teams may not have the necessary expertise in agile testing to implement it effectively.
• Lack of leadership support: Without support from leadership, it can be difficult to implement agile testing effectively.

The Impact of Agile Testing on Software Quality and Customer Satisfaction

• Agile testing can greatly influence the quality of software and satisfaction of customers. By detecting defects in the early stages of development, agile testing ensures timely delivery of high quality software. This, in turn, enhances customer satisfaction and fosters loyalty.
• Moreover, integrating testing into every phase of software development enables agile testing to pinpoint areas of enhancement and facilitates continuous learning and improvement for the team.

Conclusion

Testing in an agile environment plays a vital role in software development. It puts great importance on teamwork, adaptability and efficiency during the testing stage of software creation. Through the adoption of proven agile testing methods, teams can effectively incorporate agile testing into their workflow and tackle common obstacles. By placing emphasis on ongoing enhancement and integrating testing throughout the entire software development process, teams can enhance software quality and ultimately satisfy customers.

Automation testing has become a crucial component of the software development life cycle as software development processes continue to advance. Software testers and developers may build reliable automated tests with Selenium Java that can run on several platforms and browsers.

Azure Pipelines, on the other hand, is a powerful continuous integration and continuous deployment (CI/CD) platform that enables developers to build, test, and deploy applications. By integrating Selenium Java automation project with Azure Pipelines, software development teams can automate the testing process and deliver quality software quickly.

This article will walk you through the integration of a Selenium Java automation project with Azure Pipelines, outlining how to use YAML files, how to build using Maven, and the benefits of this approach.

Step 1: Create a Java project with Selenium WebDriver The first step is to create a Java project with Selenium WebDriver, which will contain the test cases to be executed. This project can be created using an Integrated Development Environment (IDE) such as Eclipse or IntelliJ IDEA. Once the project has been made, include all necessary Selenium WebDriver dependencies in the POM.xml file.

Here is an example POM.xml file,

<?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>com.Test.automationframwork</groupId>
    <artifactId>TestWeb</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>

        <!-- https://mvnrepository.com/artifact/org.testng/testng -->
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>7.0.0</version>
        </dependency>
        <!-- https://mvnrepository.com/rg.seleniumhq.selenium/selenium-java -->
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-java</artifactId>
            <version>3.141.59</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.uncommons/reportng -->
        <dependency>
            <groupId>org.uncommons</groupId>
            <artifactId>reportng</artifactId>
            <version>1.1.4</version>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.seleniumhq.selenium/selenium-firefox-driver -->
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-firefox-driver</artifactId>
            <version>3.141.59</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.seleniumhq.selenium/selenium-chrome-driver -->
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-chrome-driver</artifactId>
            <version>3.141.59</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.seleniumhq.selenium/selenium-edge-driver -->
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-edge-driver</artifactId>
            <version>3.141.59</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/io.github.bonigarcia/webdrivermanager -->
        <dependency>
            <groupId>io.github.bonigarcia</groupId>
            <artifactId>webdrivermanager</artifactId>
            <version>3.7.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.maven.plugins/maven-compiler-plugin -->
        <dependency>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.6</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.aventstack/extentreports -->
        <dependency>
            <groupId>com.aventstack</groupId>
            <artifactId>extentreports</artifactId>
            <version>4.1.7</version>
        </dependency>
        <dependency>
            <groupId>com.relevantcodes</groupId>
            <artifactId>extentreports</artifactId>
            <version>2.41.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.maven.plugins/maven-surefire-plugin -->
        <dependency>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>3.0.0-M5</version>
        </dependency>

    </dependencies>

    <profiles>
        <!-- regression -->
        <profile>
            <id> regression </id>
            <build>
                <pluginManagement>
                    <plugins>
                        <plugin>
                            <artifactId>maven-surefire-plugin</artifactId>
                            <version> 2.18.1</version>
                            <configuration>
                                <suiteXmlFiles>
                                    <suiteXmlFile>
                                        RegressionSuite.xml
                                    </suiteXmlFile>
                                </suiteXmlFiles>
                            </configuration>
                        </plugin>
                    </plugins>
                </pluginManagement>
            </build>
        </profile>
    </profiles>

    <build>
        <sourceDirectory>src</sourceDirectory>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

Step 2: Create a repository in Azure DevOps The next step is to create a repository in Azure DevOps to store the Java project. To do this, go to Azure DevOps, create a new project, and after that, create a new repository inside the project.

• Step 3: Configure the Build Pipeline using YAML. To configure the build pipeline using YAML, you need to create a YAML file in your repository. The YAML file defines the build configuration.

Here is an example YAML file,

# Starter pipeline
# Start with a minimal pipeline that you can customize to build and deploy your code.
# Add steps that build, run tests, deploy, and more:
# https://aka.ms/yaml

trigger: none

stages:
  - stage: test
    pool:
      vmImage: windows-latest
    jobs:
      - job: myjob
        steps:

        - task: Maven@3
          inputs:
            mavenPomFile: ‘pom.xml’
            mavenOption: ‘-Xmx3072m’
            javaHomeOption: ‘JDKVersion’
            jdkArchitectureOption: ‘x64'
            publishJUnitResults: true
            testResultsFiles: ‘**/surefire-reports/TEST-*.xml’
            testRunTitle: ‘dev_Test_Results’
            options: ‘-P regression'
            #goals: 'package'
            mavenAuthenticateFeed: false
            effectivePomSkip: false
            sonarQubeRunAnalysis: false

This code is a YAML file that defines a basic Azure Pipeline for building and testing.

• The pipeline has one stage, test, which consists of one job, myjob.
• The trigger section indicates that this pipeline is not triggered by any events. This is useful for pipelines that are intended to be manually triggered.
• The stages section defines the stages of the pipeline. Here, there is only one stage, test.
• The pool section specifies the virtual machine image that should be used for the stage. As you can see, the windows-latest image is used.
• The jobs section defines the jobs that should be run in the stage. In here, there is only one job, myjob.
• The steps section lists the tasks that should be run in the job. In this YAML, the only step is a Maven task, Maven@3.
• The Java application must be built and tested via the Maven task. It requires a number of input parameters, all of which are listed in the inputssection.
• The mavenPomFile input specifies the location of the pom.xml file, which is the Maven project file.

Step 4: Add a test task After configuring the build pipeline, add a task to run the test cases in the pipeline.

Step 5: Publish the test results online. Use the test reporting functionality in Azure Pipelines to publish the test results once the test cases have been run. This enables you to evaluate the test findings and, if necessary, take corrective action. Add a new job to the pipeline and use the test reporting option to do this. The test result format and file path should then be specified.

Step 6: Trigger the pipeline Once you have configured the pipeline, you can trigger it manually or automatically whenever changes are made to the repository. This can be done by selecting the appropriate trigger option in the pipeline settings.

The advantages of integrating an automation suite with Azure, including:

1. Faster and more dependable software delivery: By automating the build, testing, and deployment processes, you can reduce the time it takes to deliver product while also making sure that it is thoroughly and consistently tested.
2. Better collaboration and communication: The automation suite for Azure offers a single platform for development, testing, and deployment, which makes it easier for developers, testers, and other stakeholders to collaborate and communicate.
3. Better software: You can run tests fast and simply using Azure’s automation suite, ensuring that your software is of high quality and satisfies your customers’ needs.
4. Greater scalability and flexibility: Automation suite for Azure gives you the opportunity to expand your testing and deployment processes fast and efficiently.
5. Better reporting and visibility: Azure’s automation package offers real-time insight into the state of your software delivery pipeline, allowing you to see issues as they occur and take appropriate action

Conclusion

There are several advantages for Testers and companies in integrating a Selenium Java automation project with Azure Pipelines and utilizing YAML files for the work. Teams can guarantee accurate and reliable results. Additionally, teams can speed up their development and deployment workflows and reduce the time it takes for the applications to reach the market by utilizing the strength of Azure Pipelines and its connection with other tools and services. Continuous testing enables businesses to have confidence in the quality of their software and provide value to consumers with each release.

Cypress Introduction

The open-source testing tool Cypress enables Testers to create comprehensive tests for web applications. A quick, dependable, and user-friendly testing environment for web applications is offered by this JavaScript-based framework. In comparison to other well-known testing tools like Selenium, Cypress is a relatively new tool, but because to its numerous benefits, it has already become quite popular among Testers.

Comparison of Cypress and Selenium

Both Cypress and Selenium are well-known testing tools, yet they have numerous differences. Here are some significant variations:

Advantages of Cypress

Cypress has many advantages over other testing tools. Here are some of the key advantages:

• Easy to install and set up
  Cypress is easy to install and set up. It comes with a built-in test runner and does not require any additional dependencies or setup.
• Fast and reliable
  Cypress is fast and reliable. It runs tests directly in the browser, which makes it faster and more reliable than other testing tools.
• Easy to debug
  Cypress is easy to debug. It provides a built-in test runner that allows developers to easily debug their tests.
• Easy to use
  Cypress is easy to use. It has a simple and intuitive API that allows developers to write tests quickly and easily.
• Automatic waiting
  Cypress automatically waits for commands and assertions to complete before moving on to the next command, which makes tests more reliable.

Disadvantages of Cypress

While Cypress has many advantages, there are also some disadvantages to using it. Here are some of the key disadvantages:

• Limited Browser Support

Cypress has expanded its browser support over time, but it still primarily supports Chromium-based browsers (Chrome, Edge, Electron) and Firefox. While Safari support is not natively available, it is possible to run tests in WebKit using experimental features. However, cross-browser testing is still more limited compared to Selenium and Playwright.

• Limited Testing Capabilities

Cypress is primarily designed for end-to-end (E2E) testing but has expanded to support component testing as well. However, it still lacks native support for API testing, visual regression testing, and extensive mobile browser automation. While workarounds exist, tools like Playwright may offer more flexibility in these areas.

Setting up the Cypress Environment

Setting up a Cypress environment is easy. Here are the steps:

1.Install Node.js and set “NODE_HOME” environmental variable.
2.Create a new Cypress working directory.
3.Navigate to the working directory in the terminal.
4.Run “npm init -y” to initialize the project.
5.Install Cypress by running “npm install cypress — save-dev”.

Here’s an example of a simple Cypress Script:

describe('Test Suite', function(){
    it('Verify title of the page',()=>{
        cy.visit('https://demo.nopcommerce.com');
        cy.title().should('eq','nopCommerce demo store');
    })
})

6. Open Cypress by running “npx cypress open”.

Using Locators in Cypress

Cypress provides several ways to locate elements on a web page, including CSS selectors, XPath selectors, and custom attributes. Here’s an example of how to locate an element using a CSS selector:

cy.get('#my-element').click()

This code uses the cy.get() command to locate an element with the ID “my-element” and then clicks on it. Cypress also provides several other commands for interacting with UI elements, including type(), select(), and check() etc.

Interacting with UI Elements

In addition to locating elements, Cypress provides several commands for interacting with UI elements. Here’s an example of how to fill out a form in Cypress:

cy.get('#name').type('Soap Mactavish')
cy.get('#email').type('soap24@abc.com')
cy.get('#submit-button').click()

This code uses the type() command to fill out the “name” and “email” fields, and then clicks on the “submit” button.

Use data-test attributes instead of generic id/class selectors to avoid flakiness.

Page Object Model in Cypress

The Page Object Model (POM) is a design pattern that helps organize test code, making it more maintainable and reusable. In Cypress, the POM can be implemented using JavaScript/TypeScript classes and custom commands.

Steps to Implement POM in Cypress,

1. Create a “pages” folder in the root of your project.
2. Create a new file in the “pages” folder, e.g., LoginPage.js.
3. Define a class in LoginPage.js that encapsulates the locators and methods for interacting with the login page.
4. Use Cypress commands (cy.get) inside the class methods for interacting with page elements.
5. Use the page object in test files to keep test logic clean.
6. (Optional) Create custom Cypress commands to simplify login logic.
   Here’s an example of how the “LoginPage.js” file might look:

class LoginPage {
  visit() {
    cy.visit('/login')
  }

  fillUsername(username) {
    cy.get('[data-test=username]').type(username)  // Use data-test attributes for better stability
  }

  fillPassword(password) {
    cy.get('[data-test=password]').type(password)
  }

  submit() {
    cy.get('[data-test=submit-button]').click()
  }

  login(username, password) {
    this.visit()
    this.fillUsername(username)
    this.fillPassword(password)
    this.submit()
  }
}

export default new LoginPage()

And here’s an example: Using LoginPage.js in a Test

import LoginPage from '../pages/LoginPage'

describe('Login Test', () => {
  it('should log in successfully', () => {
    LoginPage.login('testuser', 'password123')
    cy.url().should('include', '/dashboard')  // Assertion to verify login success
  })
})

(Optional) Using Cypress Custom Commands

Instead of calling LoginPage.login(), you can define a Cypress custom command in commands.js:

import LoginPage from '../pages/LoginPage'

Cypress.Commands.add('login', (username, password) => {
  LoginPage.login(username, password)
})

Now you can use cy.login() in your tests:

describe('Login Test', () => {
  it('should log in successfully', () => {
    cy.login('testuser', 'password123')
    cy.url().should('include', '/dashboard')
  })
})

https://docs.cypress.io/guides/overview/why-cypress — Cypress Documentation

Conclusion

In summary, Cypress is an effective end-to-end testing framework that gives engineers a simple and effective approach to create and execute tests. Cypress has quickly become a favorite among engineers thanks to its distinctive features including automated waiting, real-time reloads, and powerful debugging tools.

Happy learning!

A software testing approach called integration testing combines separate system components or units and evaluates them all at once. Integration testing is used to find dependencies and conflicts between components and make sure the merged system satisfies both functional and non-functional requirements.

Integration Testing Introduction

Integration testing is a step in the software testing process that follows unit testing. It verifies that the interactions between the individual components or modules of a system work as intended when combined. Integration testing helps to identify any gaps or flaws in the integration of the system components and to ensure that the system behaves as expected.

How Integration Testing Works

Integration testing starts after the successful completion of unit testing. In integration testing, the individual units or components of a system are combined and tested as a group. The integration process involves testing the interactions between the components, including data exchange and control flow. The main objective is to ensure that the components work together seamlessly and that the system meets the specified requirements.

What Integration Testing Does

Integration testing verifies the functional and non-functional requirements of a system. It helps to identify any issues with the integration of components and to ensure that the system behaves as expected. This type of testing is especially important in systems that are composed of multiple components or modules, such as software applications and web services.

Why Integration Testing is Done

Integration testing is an important step in the software development process because it helps to identify issues early in the development cycle. This type of testing helps to reduce the risk of defects and to ensure that the system is reliable and of high quality. Integration testing also helps to identify any dependencies between the components and to ensure that the system behaves as expected.

Benefits of Integration Testing

• Early identification of issues
• Improved reliability and quality
• Better understanding of system behavior
• Improved efficiency and cost-effectiveness
• Reduced risk of defects

Example of Integration Testing

An example of integration testing is testing a shopping cart system. The individual components of the system, such as the product catalog, shopping cart, and payment processing module, are tested separately.

During integration testing, the components are combined and tested as a group to ensure that the interactions between the components work as expected.

Automation of Integration Testing

Integration testing can be automated using various tools and languages, such as JUnit, TestNG, and Java. Automated integration testing can help to reduce the time and effort required for manual testing and to increase the efficiency of the testing process.

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class IntegrationTest {
  
  @Test
  public void testIntegration() {
    // set up test data
    ProductCatalog productCatalog = new ProductCatalog();
    ShoppingCart shoppingCart = new ShoppingCart();
    PaymentProcessor paymentProcessor = new PaymentProcessor();
 
    // add a product to the shopping cart
    Product product = productCatalog.getProduct("Hoops 3.0 Low Classic Vintage Shoes");
    shoppingCart.addItem(product);
 
    // process payment
    paymentProcessor.processPayment(shoppingCart);
 
    // verify that payment was processed successfully
    assertEquals("Success", shoppingCart.getPaymentStatus());
  }
}

In this code, the IntegrationTest class sets up a Selenium WebDriver to simulate a user’s interactions with a web application, such as navigating to a webpage, entering search keywords, and clicking on search results. The HomePage and SearchResultPage classes define the structure of the web pages and provide methods for interacting with the page elements.

The setUp method is annotated with @Before, which means it will be run before each test case. The tearDown method is annotated with @After, which means it will be run after each test case. The test Integration method is annotated with @Test, which means it is a test case that will be run by JUnit.

This integration test uses the Page Object Model design pattern, which allows for a clear separation of concerns between the test code and the page code. The test code is focused on verifying the expected behavior of the application, while the page code is focused on representing the structure of the pages and providing methods for interacting with the pages. This helps to make the test code more readable, maintainable, and reusable.

Conclusion

Integration testing is a crucial phase in the software development process that aids in the early detection of issues and ensures that the system performs as planned. Automated integration testing may improve testing process effectiveness and lower mistake risk.