automation

vibssingh

How to install Playwright in Windows?

HOME

In this tutorial, I will explain the steps to install Playwright on a Window machine. To install Playwright on a Windows machine, you will typically use Node.js and the npm (Node Package Manager).

Table of Contents

  1. System Requirements
  2. Implementation Steps
    1. Install Node.js and npm
    2. Create a Project Directory
    3. Install Playwright
    4. Create a new Playwright project
    5. Running the Example Test through Terminal
    6. HTML Test Reports

System Requirements:

  • Node.js version 18 or higher
  • npm (comes with Node.js)
  • Windows 10+, macOS 12+, or Ubuntu 20.04+
  • At least 2GB free disk space for browser binaries
  • Visual Studio for Code is already installed.

Visual Studio for Code must be installed. If it is not already installed, please refer to this tutorial – How to Install Visual Studio Code on Windows.

Below are the step-by-step instructions to get Playwright up and running on Windows:

Implementation Steps:

1. Install Node.js and npm

Please refer the below tutorial to install node.js.

How to install node.js on windows 11

2. Create a Project Directory

Open Command Prompt or PowerShell. Make a new directory for your Playwright project and navigate into it:

The new empty folder “playwright-demo-project” is created in Documents/Playwright folder.

3. Install Playwright

Open Visual Studio for Code. Install “Playwright Test for VSCode” from Microsoft via the Extensions tab.

Once the plugin is installed. We can see a new Funnel icon called Testing as shown in the image.

4. Create a new Playwright project

Go to File and select Open Folder we have created earlier – playwright-demo-project.

We can see the project is opened in VS code.

Go to the terminal in this project and open a New Terminal.

Type the below command in the terminal

npm init playwright@latest

When prompted, choose / confirm:

  • TypeScript or JavaScript (default: TypeScript)
  • Tests folder name (default: tests, or e2e if tests already exists)
  • Add a GitHub Actions workflow (recommended for CI) – Initial project, so mentioned False
  • Install Playwright browsers (default: yes)

Playwright downloads required browser binaries and creates the scaffold below.

playwright.config.ts         # Test configuration
package.json
package-lock.json            # Or yarn.lock / pnpm-lock.yaml
tests/
  example.spec.ts            # Minimal example test

The playwright.config centralizes configuration: target browsers, timeouts, retries, projects, reporters and more. In existing projects dependencies are added to your current package.json.

tests/ contains a minimal starter test. tests-examples/ provides richer samples (e.g. a todo app) to explore patterns.

5. Running the Example Test through Terminal

By default tests run headless in parallel across Chromium, Firefox and WebKit (configurable in playwright.config). Output and aggregated results display in the terminal.

npx playwright test

6. HTML Test Reports

After a test run, the HTML Reporter provides a dashboard filterable by the browser, passed, failed, skipped, flaky and more. Click a test to inspect errors, attachments and steps. It auto-opens only when failures occur; open manually with the command below.

npx playwright show-report

The report is also present in playwright-report folder with the name of “index.html”.

Summary:
1. Install Node.js.
2. Initialize npm project.
3. Install Playwright.
4. Run a test script to verify your setup.
5. View Test report – Index.html report

To know more about Playwright, please refer to this documentation – https://playwright.dev/docs.

vibssingh

Playwright Tutorials

Last Updated Date

HOME

Playwright is a modern and powerful end-to-end testing framework developed by Microsoft, specifically designed for the automation of web applications.  It supports programming languages like Java, Python, C#, and NodeJS. Playwright comes with Apache 2.0 License and is most popular with NodeJS with Javascript/Typescript.

Chapter 1 How to install node.js on windows 11
Chapter 2 How to Install Visual Studio Code on Windows
Chapter 3 Why Choose Playwright for Browser Automation?
Chapter 4 How to install Playwright in Windows?
Chapter 5 How to run tests in UI mode in Playwright
Chapter 6 How to Specify Browsers in Playwright Tests
Chapter 7 Automate Playwright Tests with Command-Line Options
Chapter 8 How to Attach Screenshots in Playwright for Failed Tests
Chapter 9 Unlocking Playwright: Test Reports with Tags and Annotations – NEW
Chapter 10 Mastering Snapshot Testing with Playwright – NEW

API Testing

Chapter 1 How to Execute GET Requests in Playwright
Chapter 2 How to Execute POST Requests in Playwright
Chapter 3 How to Execute PUT Requests in Playwright – NEW
Chapter 4 How to Execute PATCH Requests in Playwright – NEW
Chapter 5 How to Execute DELETE Requests in Playwright – Coming Soon
Chapter 6 How to add custom headers in Playwright? – Coming Soon
Chapter 7 Handle Query Parameters in Playwright – Coming Soon
Chapter 8 Send JSON File as Payload in Playwright – Coming Soon
Chapter 9 Send XML File as Payload in Playwright – Coming Soon
vibssingh

Why Choose Playwright for Browser Automation?

HOME

Table of Contents

  1. What is Playwright?
  2. Features of Playwright
  3. Disadvantages of Playwright
  4. Why choose Playwright Automation?

What is Playwright?

Playwright is a modern and powerful end-to-end testing framework developed by Microsoft, specifically designed for the automation of web applications.  It supports programming languages like Java, Python, C#, and NodeJS. Playwright comes with Apache 2.0 License and is most popular with NodeJS with Javascript/Typescript.

Playwright was created by the same engineering team that built Puppeteer. The Playwright team created Playwright to extend Puppeteer’s UI automation capabilities to all rendering engines, no longer just supporting Chromium.

Features of Playwright

Cross-Browser Support:

Playwright can automate web pages across all major browsers. This includes Chromium, which is used by Google Chrome, Firefox, and WebKit, which is used by Safari. These capabilities allow for extensive cross-browser testing.

2. Multi-Language Support:

Playwright is available in several programming languages, including JavaScript, TypeScript, Python, .NET, and Java, making it accessible to a wide range of developers.

3. Multi-Platform Compatibility:

 It supports running tests on various operating systems, including Windows, macOS, and Linux.

4. Auto-Waiting

Playwright waits for elements to be actionable prior to performing actions. It also has a rich set of introspection events. The combination of the two eliminates the need for artificial timeouts – the primary cause of flaky tests.

5. Mobile Emulation

Playwright allows you to emulate mobile devices, such as iPhones and iPads. You can test how your web application behaves on different screen sizes and orientations.

6. Headless Mode

Playwright run tests in visible or headless mode efficiently. It allows testing in headless mode, that means executing browser actions without displaying the UI. This method is faster and suitable for CI/CD pipelines.

7. Video Recording

Playwright automatically records videos of your tests, which can be useful for debugging and for creating visual regression tests.

8. Built-in Test Assertions and Features

Playwright supports assertions and various testing features directly integrated within its framework, allowing testers to verify results seamlessly. Checks are automatically retried until the necessary conditions are met.

9. Visual and Screenshot Testing

Playwright supports visual and screenshot testing helping you capture full-page screenshots, element snapshots, and video recordings.

10. Network Interception and Customization

It allows manipulation and interception of network requests. This feature can be used for testing API calls in isolation. Additionally, it helps in simulating network conditions like offline mode.

11. Code Generation

Playwright includes a code generator. It can generate code for your tests. This feature saves you time and reduces the risk of errors.

12. Shadow DOM and iframe support

Playwright selectors can pierce deep DOM structures and handle nested frames seamlessly.

13. Browser contexts

Playwright creates a browser context for each test. Browser context is equivalent to a brand new browser profile. This delivers full test isolation with zero overhead. Creating a new browser context only takes a handful of milliseconds.

14. Authentication state reuse

Save the authentication state of the context and reuse it in all the tests. This bypasses repetitive log-in operations in each test, yet delivers full isolation of independent tests.

15. Accessibility testing

It includes tools for testing web accessibility, helping ensure that web applications are usable by people with disabilities.

Disadvantages of Playwright

1.Community and Ecosystem

The Playwright ecosystem and community are growing. However, they are smaller compared to more established tools like Selenium. This size difference can affect the availability of plugins and extensions.

2. Learning Curve:

Playwright’s API can be somewhat complex for users new to web testing frameworks. The ability to handle multiple contexts and browsers simultaneously might be overwhelming for beginners who are more familiar with simpler tools.

3. Resource Consumption

Running tests across multiple browsers simultaneously can be resource-intensive. Ensuring that the testing environment can handle the load without affecting performance might require additional infrastructure or optimizations.

4. Rapid Development Changes

As Playwright is actively developed, frequent changes and version updates are necessary. These changes help to keep up with the latest features and fixes. However, they can potentially impact long-term project stability.

5. Limited Built-in Integrations

Compared to some other tools like Cypress, Playwright has fewer out-of-the-box integrations with third-party services (e.g., dashboards).

6. Debugging Complexity

Debugging may require deeper knowledge of asynchronous code, especially where modern applications have complex behaviors needing careful handling within tests.

Why choose Playwright Automation?

Deciding when to use the Playwright framework for web testing involves evaluating several factors. These factors relate to your project’s specific requirements. You should also consider the capabilities of Playwright and your existing infrastructure.

As of end of 2025, the current snapshot of Microsoft Playwright on Github:

  • Active Users: 426.0k
  • Forks (copy of a repository that you manage): 4.8k
  • Releases: 154 (This shows how active they are in fixing and releasing new features)

Ease of Installation and Setup

Playwright’s setup is straightforward. It includes automatic download of compatible browsers. This reduces initial configuration overhead. Other frameworks require manual installation of browser drivers.

Cross-Browser Testing Needs

Playwright offers robust support for Chromium, Firefox, and WebKit, enabling comprehensive cross-browser testing from a single API. If this is critical for your project, Playwright is a strong candidate.

Parallel execution

Playwright’s ability to run tests in parallel across isolated browser contexts significantly reduces execution time.

CI/CD Integration Support

Playwright supports CI/CD integration. It even provides docker images for some language bindings.

To know more about Playwright, please refer to this website – https://playwright.dev/.

vibssingh

API Automation with REST Assured, Cucumber and TestNG

Last Updated On

HOME

Cucumber is not an API automation tool, but it works well with other API automation tools.

There are 2 most commonly used Automation Tools for JVM to test API – Rest-Assured and Karate. In this tutorial, I will use RestAssured with Cucumber and TestNG for API Testing.

Table of Contents

  1. What is Rest Assured?
  2. What is Cucumber?
  3. Dependency List
  4. Project Structure
  5. Implementation Steps
    1. Download and Install Java
    2. Download and setup Eclipse IDE on the system
    3. Setup Maven
    4. Create a new Maven Project
    5. Install the Cucumber Eclipse plugin for the Eclipse project (Eclipse Only)
    6. Create source folder src/test/resources
    7. Add dependencies to the project
    8. Add Maven Compiler Plugin and Surefire Plugin
    9. Create a feature file under src/test/resources
    10. Create the Step Definition class or Glue Code
    11. Create a TestNG Cucumber Runner class
    12. Create a testng.xml file
    13. Run the tests from TestNG
    14. Run the tests from the testng.xml
    15. TestNG Report Generation
    16. Run the tests from the Command Line
    17. Cucumber Report Generation

What is Rest Assured?

REST Assured is a Java library that provides a domain-specific language (DSL) for writing powerful, maintainable tests for RESTful APIs. REST Assured can be used easily in combination with existing unit testing frameworks, such as JUnit and TestNG. Rest assured, no matter how complex the JSON structures are, Rest Assured has methods to retrieve data from almost every part of the request and response.

What is Cucumber?

Cucumber is one such open-source tool, which supports Behaviour Driven Development(BDD). In simple words, Cucumber can be defined as a testing framework, driven by plain English. It serves as documentation, automated tests, and development aid – all in one.

Each scenario is a set of steps that the Cucumber must complete. Cucumber validates the software’s compliance with the specification and generates a report indicating success or failure for each scenario.

The cucumber must adhere to some basic syntax rules known as Gherkin to comprehend the scenarios.

In this tutorial, I will explain creating a framework for the testing of Rest API in Cucumber BDD.

Dependency List

  1. Cucumber – 7.18.0
  2. Java 17
  3. TestNG – 7.10.2
  4. Maven – 3.9.6
  5. Rest Assured – 5.4.0
  6. Maven Compiler – 3.13.0
  7. Maven Surefire – 3.2.5

Project Structure

Implementation Steps

Step 1 – Download and Install Java

Cucumber and Rest-Assured need Java to be installed on the system to run the tests. Click here to learn How to install Java.

Step 2 – Download and setup Eclipse IDE on the system

The Eclipse IDE (integrated development environment) provides strong support for Java developers. Click here to learn How to install Eclipse.

Step 3 – Setup Maven

To build a test framework, we need to add several dependencies to the project. Click here to learn How to install Maven.

Step 4 – Create a new Maven Project

File -> New Project-> Maven-> Maven project-> Next -> Enter Group ID & Artifact ID -> Finish

Click here to learn How to create a Maven project

Step 5 – Install the Cucumber Eclipse plugin for the Eclipse project (Eclipse Only)

The Cucumber plugin is an Eclipse plugin that allows Eclipse to understand the Gherkin syntax. Cucumber Eclipse Plugin highlights the keywords present in the Feature File. To install Cucumber Eclipse Plugin, please refer to this tutorial – How to install Cucumber Eclipse Plugin.

Step 6 – Create source folder src/test/resources

Create source folder src/test/resources to create test scenarios in the Feature file.

A new Maven Project is created with 2 folders – src/main/java and src/test/java. To create test scenarios, we need a new source folder called – src/test/resources. To create this folder, right-click on your Maven project ->select New ->Java, and then Source Folder.

Mention the source folder name as src/test/resources and click the Next button. This will create a source folder under your new Maven project.

Step 7 – Add dependencies to the project

Add Rest Assured, Cucumber, and TestNG dependencies in the pom.xml/build.gradle.
REST Assured includes JsonPath and XmlPath as transitive dependencies.

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <rest.assured.version>5.4.0</rest.assured.version>
    <cucumber.version>7.18.0</cucumber.version>
    <testng.version>7.10.2</testng.version>
    <maven.compiler.plugin.version>3.13.0</maven.compiler.plugin.version>
    <maven.compiler.source>17</maven.compiler.source>
    <maven.compiler.target>17</maven.compiler.target>
    <maven.surefire.plugin.version>3.2.5</maven.surefire.plugin.version>
  </properties>

  <dependencies>

    <!-- Rest Assured -->
    <dependency>
      <groupId>io.rest-assured</groupId>
      <artifactId>rest-assured</artifactId>
      <version>${rest.assured.version}</version>
      <scope>test</scope>
    </dependency>

    <!-- Cucumber with TestNG -->
    <dependency>
      <groupId>io.cucumber</groupId>
      <artifactId>cucumber-testng</artifactId>
      <version>${cucumber.version}</version>
    </dependency>

    <!-- Cucumber with Java -->
    <dependency>
      <groupId>io.cucumber</groupId>
      <artifactId>cucumber-java</artifactId>
      <version>${cucumber.version}</version>
    </dependency>

    <!-- TestNG -->
    <dependency>
      <groupId>org.testng</groupId>
      <artifactId>testng</artifactId>
      <version>${testng.version}</version>
      <scope>test</scope>
    </dependency>

  </dependencies>

Step 8 – Add Maven Compiler Plugin and Surefire Plugin

The compiler plugin is used to compile the source code of a Maven project. This plugin has two goals, which are already bound to specific phases of the default lifecycle:

  • compile – compile main source files
  • testCompile – compile test source files
 <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>${maven.compiler.plugin.version}</version>
        <configuration>
          <source>${maven.compiler.source}</source>
          <target>${maven.compiler.target}</target>
        </configuration>
      </plugin>

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>${maven.surefire.plugin.version}</version>
        <configuration>
          <suiteXmlFiles>
            <suiteXmlFile>testng.xml</suiteXmlFile>
          </suiteXmlFiles>
        </configuration>
      </plugin>
    </plugins>
  </build>

The complete POM.xml will look like something below:

<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>RestAPI_Cucumber_TestNG_Demo</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>RestAPI_Cucumber_TestNG_Demo</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <rest.assured.version>5.4.0</rest.assured.version>
    <cucumber.version>7.18.0</cucumber.version>
    <testng.version>7.10.2</testng.version>
    <maven.compiler.plugin.version>3.13.0</maven.compiler.plugin.version>
    <maven.compiler.source>17</maven.compiler.source>
    <maven.compiler.target>17</maven.compiler.target>
    <maven.surefire.plugin.version>3.2.5</maven.surefire.plugin.version>
  </properties>

  <dependencies>

    <!-- Rest Assured -->
    <dependency>
      <groupId>io.rest-assured</groupId>
      <artifactId>rest-assured</artifactId>
      <version>${rest.assured.version}</version>
      <scope>test</scope>
    </dependency>

    <!-- Cucumber with TestNG -->
    <dependency>
      <groupId>io.cucumber</groupId>
      <artifactId>cucumber-testng</artifactId>
      <version>${cucumber.version}</version>
    </dependency>

    <!-- Cucumber with Java -->
    <dependency>
      <groupId>io.cucumber</groupId>
      <artifactId>cucumber-java</artifactId>
      <version>${cucumber.version}</version>
    </dependency>

    <!-- TestNG -->
    <dependency>
      <groupId>org.testng</groupId>
      <artifactId>testng</artifactId>
      <version>${testng.version}</version>
      <scope>test</scope>
    </dependency>

  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>${maven.compiler.plugin.version}</version>
        <configuration>
          <source>${maven.compiler.source}</source>
          <target>${maven.compiler.target}</target>
        </configuration>
      </plugin>

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>${maven.surefire.plugin.version}</version>
        <configuration>
          <suiteXmlFiles>
            <suiteXmlFile>testng.xml</suiteXmlFile>
          </suiteXmlFiles>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

Step 9 – Create a feature file under src/test/resources

Create a folder with name features. Now, create the feature file in this folder. The feature file should be saved with the extension .feature. This feature file contains the test scenarios created to test the application. The Test Scenarios are written in Gherkins language in the format of Given, When, Then, And, But.

Below is an example of a Test Scenario where we are using the GET method to get the information from the API.

Feature: Validation of get method

  @GetUserDetails
  Scenario Outline: Send a valid Request to get user details

    Given I send a request to the URL to get user details
    Then the response will return status <statusCode> and id <id> and email "<employee_email>" and first name "<employee_firstname>" and last name "<employee_lastname>"

    Examples:
    | statusCode | id  | employee_email          | employee_firstname | employee_lastname |
    | 200        | 2   | janet.weaver@reqres.in  | Janet              | Weaver            |

Step 10 – Create the Step Definition class or Glue Code

StepDefinition acts as an intermediate to your runner and feature file. It stores the mapping between each step of the scenario in the Feature file. So when you run the scenario, it will scan the step definition file to check the matched glue or test code.

import io.cucumber.java.en.Given;
import io.cucumber.java.en.Then;
import io.restassured.http.ContentType;
import io.restassured.response.ValidatableResponse;

import static io.restassured.RestAssured.given;
import static org.hamcrest.Matchers.equalTo;

public class APIDemoDefinitions {

    private ValidatableResponse validatableResponse;
    private String endpoint = "https://reqres.in/api/users/2";

    @Given("I send a request to the URL to get user details")
    public void sendRequest(){
        validatableResponse = given().contentType(ContentType.JSON)
                .when().get(endpoint).then();

        System.out.println("Response :"+validatableResponse.extract().asPrettyString());
    }

    @Then("the response will return status {int} and id {int} and email {string} and first name {string} and last name {string}")
    public void verifyStatus(int expectedStatusCode, int expectedId, String expectedEmail, String expectedFirstName, String expectedLastName){

        validatableResponse.assertThat().statusCode(expectedStatusCode).body("data.id",equalTo(expectedId)).and()
                .body("data.email",equalTo(expectedEmail)).body("data.first_name",equalTo(expectedFirstName))
                .body("data.last_name",equalTo(expectedLastName));

    }
}

To use REST assured effectively it’s recommended to statically import methods from the following classes:

io.restassured.RestAssured.*
io.restassured.matcher.RestAssuredMatchers.*
org.hamcrest.Matchers.*

Step 11 – Create a TestNG Cucumber Runner class

A runner will help us run the feature file and act as an interlink between the feature file and the StepDefinition Class.

import io.cucumber.testng.AbstractTestNGCucumberTests;
import io.cucumber.testng.CucumberOptions;

@CucumberOptions(tags = "", features = {"src/test/resources/features"}, glue = {"com.example.stepdefinitions"},
        plugin = {})
public class CucumberRunnerTests extends AbstractTestNGCucumberTests {

}

Note:- The name of the Runner class should end with Test otherwise we can’t run the tests using Command-Line.

Step 12 – Create a testng.xml file

Create a testng.xml at the root of the project.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd">
<suite name="Suite">
    <test  name="Rest Assured, Cucumber with TestNG Test">
        <classes>
            <class name="com.example.runner.CucumberRunnerTests"/>
        </classes>
    </test> <!-- Test -->
</suite> <!-- Suite -->

Step 13 – Run the tests from TestNG

You can execute the test script by right-clicking on TestRunner class -> Run As TestNG (Eclipse).

You can execute the test script by right-clicking on TestRunner class -> Run CucumberRunnerTests (IntelliJ).

Step 14 – Run the tests from the testng.xml

Right-click on the testng.xml. Click on Run’...\testng.xml’.

Step 15 – TestNG Report Generation

TestNG generates various types of reports under the test-output or target folder like emailable-report.html, index.html, and testng-results.xml.

We are interested in the ‘emailable-report.html’ report. Open “emailable-report.html“, as this is an HTML report, and open it with the browser. The below image shows emailable-report.html.

emailable-report.html

Index.html

TestNG also produces “index.html” report, and it resides under the test-output folder. The below image shows the index.html report.

Step 16 – Run the tests from the Command Line

Run the below command in the command prompt to run the tests and to get the test execution report.

mvn clean test

The output of the above program is

Step 17 – Cucumber Report Generation

To get Cucumber Test Reports, add cucumber.properties under src/test/resources and add the below instruction in the file.

cucumber.publish.enabled=true

The complete code can be found here – vibssingh/RestAPI_Cucumber_TestNG_Demo.

We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!

vibssingh

How to pass Access token generated by OAuth2 to a request in API Testing

Last Updated On

HOME

Many REST API endpoints require authentication to return the response. To authenticate the request, we will need to provide an authentication token with the required scopes or permissions. First, we need to generate an access token. Then, we pass it to the second request to get the desired response.

What is an Access Token?

An access token is a credential that is used to authenticate and authorize requests made to an API. It proves the user’s identity and permissions. This allows them to access protected resources or perform specific actions within the API.

Access tokens are usually represented as strings of characters (e.g., alphanumeric) that are generated by the server and provided to clients upon successful authentication. Access tokens often have an expiration time associated with them, after which they become invalid. This helps ensure security by limiting their lifespan.

Using access tokens helps ensure secure communication between clients and servers by preventing unauthorized access to protected resources. Without a valid access token, requests may be rejected or limited in their scope.

Access tokens enable stateless communication between client and server. This means that each request contains all necessary authentication and authorization information within itself. This eliminates the need for servers to store session-related data, improving scalability and reducing overhead.


Let us create a class that will generate the access token.

AbstractHelper

public class AbstractHelper {
    
   String token;
   String accessToken;
   JsonPath jsonPath;

    public String generateToken() throws IOException {

        token = given().auth().preemptive()
                .basic(username, password)
                .contentType("application/x-www-form-urlencoded")
                .formParam("grant_type", "client_credentials")
                .when().post("https://example.com/accesstoken").asString();

        System.out.println("Token :" + token);

        jsonPath = new JsonPath(token);
        accessToken = jsonPath.getString("access_token");
        System.out.println("Access Token :" + accessToken);
        return accessToken;
    }

}

In the above example, a token is generated as shown below.

It is a JSON Response. We need only the token part and not the {“access_token”} part. So we have used the below command to extract the token part only.

JsonPath jsonPath = new JsonPath(token);
accessToken = jsonPath.getString("access_token");

What is Oauth2()?

OAuth 2.0 (Open Authorization 2.0) is an industry-standard protocol for authorization and delegation of access to protected resources on the web. It allows users to securely grant limited access to their resources hosted on one website or application. This site is called the “resource server.” The access is given to another website or application, which is called the “client.”

Below is a test. We are passing the token generated in the previous request for authentication. This token is used in another request with oauth2().

AccessToken_Example

import java.io.IOException;

public class AccessToken_Example extends AbstractHelper {

    Response response;
    
   @Test
    public void testRequest() throws IOException {

        response = RestAssured.given()
                .auth().oauth2(generateToken())
                .when().get("https://localhost/8080/coreid").then()
                .extract()
                .response();

        System.out.println("Response :" + response.asString());
        int statusCode = response.getStatusCode();

        Assert.assertEquals(200,statusCode);
    }
}

The output of the above program is

Summary:

1. Access tokens are obtained through an authentication process. This may include logging in with a username and password or using a third-party authentication service like OAuth.
2. Once authenticated, the access token contains information about the user’s permissions and privileges within the system. Use this access token and pass it to another request to get the required response.

vibssingh

CI/CD Interview Questions and Answers 2025

Last Updated On

HOME

1. What is CI/CD Pipeline?

CI/CD stands for Continuous Integration and Continuous Delivery (or Continuous Deployment), and it refers to a set of software development practices aimed at improving the efficiency, reliability, and speed of the software development and release process.

2. What’s the difference between continuous integration, continuous delivery, and continuous deployment?

Continuous Integration (CI) is a development practice wherein developers frequently merge their code modifications into a central repository. This integration occurs multiple times throughout the day and is validated through automated tests and a build procedure. This approach helps in mitigating integration issues, identifying and rectifying bugs early in the development phase, and iteratively testing and refining the code.

Continuous Delivery (CD) involves the automatic deployment of all code modifications to test and/or production environments following the completion of the build process. Continuous Delivery ensures that deployments are both predictable and consistently scheduled.

Continuous Deployment (CD): The most critical stage of the pipeline is continuous deployment. By following this practice, you will be able to release all changes that have passed all stages of the production pipeline to your customers on time. Code changes can be made live much more quickly at this stage because there is little human interaction.

3. What are the benefits of the CI/CD Pipeline?

1. CI encourages frequent integration of code changes, promoting collaboration among team members. Developers can work on their features independently, knowing that automated processes will catch integration issues.

2. CI/CD automates the software delivery process, reducing manual interventions and streamlining workflows. This results in quicker development cycles and faster releases to production.

3. Automated testing in the CI phase helps identify bugs, errors, and integration issues early in the development cycle. This allows for prompt resolution and prevents the accumulation of issues that could be more challenging to address later.

4. CI improves transparency by detecting early-stage failures like build failures, merge issues, integration test failures, etc.

5. Automation in the CI/CD pipeline reduces the need for manual steps, minimizing the risk of human error and freeing up developers and operators to focus on more strategic and creative tasks. This also increases the quality of the code.

4. What are the popular CI/CD Tools?

There are several popular CI/CD (Continuous Integration/Continuous Delivery) tools available that help automate various stages of the software development lifecycle. Here are some widely used CI/CD tools:

1. Jenkins is an open-source automation server that supports building, deploying, and automating any project. It has a large and active community, extensive plugin support, and is highly customizable.

2. Travis CI is a cloud-based CI service that integrates with GitHub repositories. It’s known for its simplicity and ease of use, and it’s commonly used for open-source projects.

3. GitLab provides built-in CI/CD capabilities as part of its platform. It allows users to define CI/CD pipelines using a .gitlab-ci.yml file in the repository. GitLab CI/CD is tightly integrated with GitLab’s version control features.

4. CircleCI is a cloud-based CI/CD platform that supports the automation of the software development process. It integrates with popular version control systems, such as GitHub and Bitbucket.

5. GitHub Actions is a CI/CD and automation service provided by GitHub. It allows developers to define workflows using YAML files within the repository. GitHub Actions seamlessly integrates with GitHub repositories.

6. Atlassian Bamboo is a CI/CD server that integrates with other Atlassian tools like Jira and Bitbucket. It supports building, testing, and deploying applications.
TeamCity:

7. TeamCity, developed by JetBrains, is a CI/CD server with support for various build and deployment scenarios. It has a user-friendly interface and integrates with popular version control systems.

8. Azure DevOps, previously known as Visual Studio Team Services (VSTS), provides a set of development tools, including CI/CD capabilities. It integrates with Microsoft’s Azure cloud services.

5. What are “Artifacts” in the context of CI/CD, and why are they important?

Artifacts are the output of a CI/CD pipeline, typically binary or deployable files such as executables, libraries, Docker images, or Reports.

1. Storing artifacts in dedicated repositories enables easy access and sharing among team members involved in the CI/CD pipeline.

2. Artifacts ensure that deployments are consistent and reproducible across different environments.

3. Artifacts provide a way to track and manage different versions of your software.

6. What are the major phases of the CI/CD pipeline?

There are four phases of the CI/CD pipeline. These are as follows.

1. Source – The first phase in a CI/CD pipeline is the creation of source code, where developers translate requirements into functional algorithms, behaviors, and features.

2. Build – The build process draws source code from a repository, establishes links to relevant libraries, modules, and dependencies, and compiles (builds) all these components into an executable (.exe) file.

3. Test – The source code has already completed some static testing, and the completed build now enters the next CI/CD phase of comprehensive dynamic testing. This usually starts with basic functional or unit testing to verify that new features and functions work as intended, and regression testing to ensure that new changes or additions do not accidentally break any previously working features.

4. Deploy – The deployment step typically involves creating a deployment environment — for example, provisioning resources and services within the data center — and moving the build to its deployment target, such as a server.

7. How do you trigger a CI/CD pipeline?

A CI/CD pipeline can be triggered in several ways. It can be activated by Code Push, scheduled trigger, manual initiation, and Continuous Integration.

8. What is version control?

Version control involves the use of a central repository where teammates can commit changes to files and sets of files. The purpose of version control is to track every line of code, and to share, review, and synchronize changes between team members. The following are some of the most popular version control tools:

  • Mercurial
  • Subversion (SVN)
  • Concurrent Version System (CVS)
  • Perforce
  • Bazaar
  • Bitkeeper
  • Fossil

9. What is git?

Git is a mature, actively maintained open-source revision control system used by thousands of developers around the world.
It enables developers to track changes in their source code during software development.

10. What is git repository?

A Git repository is a storage where all the code alterations and version histories for a particular project are kept. A Git repository is the .git/ folder inside a project. This repository tracks all changes made to files in your project, building a history over time. Meaning, if you delete the .git/ folder, then you delete your project’s history.

11. What is git branch?

In Git, a branch is a parallel line of development that represents an independent line of work within a Git repository. Branches let developers code without affecting the work of other team members.

12. What is merging?

Merging in Git refers to the process of integrating changes from one branch into another. When developers work on separate branches to implement features, bug fixes, or other changes, merging is used to combine those changes back into a common branch, often the main or default branch.

13. What is test coverage?

Test coverage is a metric that measures how much of the codebase is covered by tests. A 100% coverage means that every line of the code is tested at least by one test case.

14. What is the role of automation in CI/CD?

1. Automation is used to trigger and execute builds automatically whenever changes are made to the version control repository.

2. It also ensures process uniformity and lowers the possibility of human error.

3. Automation is used to set up and configure monitoring and observability tools. Automated monitoring provides insights into the health and performance of applications in real-time.

15. How to write CI/CD pipeline in Jenkins?

To write a CI/CD pipeline in Jenkins, Install Jenkins and required plugins, Set up version control such as Git, Create a Jenkins file with build, test, and deploy stages, and Save Jenkinsfile to the repository. Then, Create a Jenkins job linked to the Jenkinsfile and trigger the job for the automated CI/CD process.

16. What is a Jenkins file?

A Jenkins file is a text file that contains a pipeline’s configuration. It outlines the pipeline’s stages, such as build, test, and deployment, as well as the actions that must be taken at each one.

Example of a Jenkins File:

pipeline {
    agent any
 
    stages {
        stage('Test') {
            steps {
                bat "mvn -D clean test"
            }
 
            post {                
                // If Maven was able to run the tests, even if some of the test
                // failed, record the test results and archive the jar file.
                success {
                   publishHTML([
                       allowMissing: false, 
                       alwaysLinkToLastBuild: false, 
                       keepAll: false, 
                       reportDir: 'target/surefire-reports/', 
                       reportFiles: 'emailable-report.html', 
                       reportName: 'HTML Report', 
                       reportTitles: '', 
                       useWrapperFileDirectly: true])
                }
            }
        }
    }
}

17. What is docker?

Docker is an open platform for developing, shipping, and running applications using containers. Containers allow a developer to package up an application with all the parts it needs, such as libraries and other dependencies, and ship it all out as one package. This ensures that the application runs consistently across different environments.
A Dockerfile is a text file that contains instructions for building a Docker image. It specifies the base image, the application code, dependencies, and other configuration settings needed to create the image.

18. What is a container?

A container is a standard unit of software that packages up code and all its dependencies so the application runs quickly and reliably from one computing environment to another.

19. What is Kubernetes?

Kubernetes, often abbreviated as K8s, is an open-source container orchestration platform designed to automate the deployment, scaling, and management of containerized applications. Kubernetes can automatically scale the number of containers based on demand. It can also distribute incoming network traffic across multiple containers to ensure optimal performance and availability.

1. Service discovery and load balancing Kubernetes can expose a container using the DNS name or using their own IP address. If traffic to a container is high, Kubernetes can load balance and distribute the network traffic so that the deployment is stable.

2. Kubernetes supports rolling updates, allowing applications to be updated with minimal downtime. If an update causes issues, Kubernetes supports easy rollbacks to a previous version.

3. Kubernetes restarts containers that fail, replaces containers, kills containers that don’t respond to your user-defined health check, and doesn’t advertise them to clients until they are ready to serve.

4. Kubernetes lets you store and manage sensitive information, such as passwords, OAuth tokens, and SSH keys. You can deploy and update secrets and application configuration without rebuilding your container images, and without exposing secrets in your stack configuration.

20. What is blue-green deployment?

Blue-green deployment is a deployment approach in which new versions of an application are deployed and tested in two identical environments, blue and green.
The old version can be called the blue environment while the new version can be known as the green environment. Once production traffic is fully transferred from blue to green, blue can standby in case of rollback or pulled from production and updated to become the template upon which the next update is made.

21. What is canary deployment?

Canary deployment is a method of application deployment in which just a small percentage of production traffic is sent to a new version of the application, with the majority of traffic still being handled by the older version. As a result, the new version can be tested and validated before being implemented across the board in the production environment.

22. What is observability?

Observability is the ability to understand and diagnose the behavior of a complex system, such as a software application, using real-time monitoring and metrics.

23. What is Grafana?

  1. Grafana is an open-source analytics and monitoring platform that integrates with various data sources to help users visualize and understand their data. It is widely used for monitoring and observability in IT systems, providing a flexible and customizable interface for creating dashboards, charts, and graphs.
  2. Users can create dashboards that display real-time or historical data through the use of panels and visualizations.
  3. Grafana allows users to set up alert rules based on defined thresholds or conditions. When an alert is triggered, Grafana can send notifications via various channels, such as email, Slack, or other supported notification services.
  4. Grafana supports user authentication and authorization. Users can be organized into teams with specific access permissions, ensuring secure access control to dashboards and data sources.

24. What is Prometheus?

Prometheus is an open-source systems monitoring and alerting toolkit originally built at SoundCloud.
Prometheus employs a pull-based model, where it regularly scrapes (pulls) metrics from endpoints exposed by the systems being monitored. This model is well-suited for dynamic and containerized environments.
Prometheus Query Language (PromQL) is a powerful query language that allows users to retrieve and analyze metrics data. It supports various aggregation functions, filtering, and mathematical operations.
Prometheus includes a built-in alerting system that allows users to define alert rules based on metric thresholds or conditions. When an alert is triggered, Prometheus can send notifications to external systems.

25. How do you ensure the security of the CI/CD pipeline?

1. To prevent unauthorized access to the pipeline and its components, access controls and authentication procedures must be put in place.

2. Finding security flaws by checking code and dependencies for vulnerabilities and using static and dynamic analysis methods.

3. Avoid storing sensitive information, such as API keys and credentials, directly in CI/CD configuration files or scripts. Use secure vaults or secret management tools to store and retrieve secrets securely. Ensure that secrets are not exposed in logs.

4. Implementing a safe build process that includes using trustworthy sources for dependencies and signing builds to confirm their legitimacy.

5. Regularly scan dependencies and libraries for known vulnerabilities. Utilize tools that can identify and report on security vulnerabilities in third-party dependencies. Update dependencies to patched versions to mitigate potential risk.

26. What are some challenges in implementing CI/CD?

1. Integrating CI/CD practices into existing legacy systems can be challenging.

2. Managing dependencies, especially in large projects, can be complex. Dependency management issues may arise from compatibility problems, version conflicts, or unavailability of required dependencies.

3. Security is a critical aspect of software development, and integrating security into CI/CD pipelines is a challenge. Ensuring secure coding practices, vulnerability scanning, and compliance checks requires careful consideration.

4. Integrating CI/CD pipelines with external tools, services, or platforms can be challenging. Ensuring compatibility and smooth interactions with tools like version control systems, issue trackers, and cloud services is essential.

27. Can you explain the concept of “Infrastructure as Code” (IaC) and provide an example of an IaC tool?

Infrastructure as Code (IaC) is the practice of managing and provisioning infrastructure using code and automation.  Instead of manually configuring servers, networks, and other infrastructure components, IaC allows developers to define and manage their infrastructure through code. One popular example of an IaC tool is Terraform which uses a domain-specific language (HCL — HashiCorp Configuration Language) to describe infrastructure resources and their relationships. With Terraform, you can create, update, and manage infrastructure as code, making it easier to version control and maintain infrastructure configurations.

28. Is CI/CD pipeline can be targeted by attackers?

Yes, CI/CD pipeline can be targeted by the attackers. CI/CD pipelines have access to various sensor data, such as server passwords, repositories, API keys, and so on. If the CI/CD system is not properly secured, then it can be targeted by attackers. A few ways of securing the CI/CD systems are as follows.

Finding security flaws by checking code and dependencies for vulnerabilities and using static and dynamic analysis methods.

To prevent unauthorized access to the pipeline and its components, access controls and authentication procedures must be put in place.

29. What is the meaning of trunk-based development in CI/CD?

Trunk-based development is a software development approach that emphasizes frequent integration of code changes into a shared main branch, often referred to as the “trunk” or “master” branch. In the context of CI/CD, trunk-based development promotes continuous integration by encouraging developers to merge their changes into the main branch multiple times throughout the day.

30. Describe the role of container orchestration tools in CI/CD.

Container orchestration tools like Kubernetes automate the deployment, scaling, and management of containerized applications in CI/CD pipelines.

31. What is chaos engineering?

Chaos engineering is the practice of intentionally introducing failures and chaos into a system to test its resilience and reliability.

32. What is a microservices architecture?

A microservices architecture divides an application into smaller, independent services that can be developed, deployed, and scaled separately.

33. What is a canary analysis?

Canary analysis involves releasing a small subset of changes to a limited audience to assess their impact before a full deployment.