Many organizations aim to execute automation tests across various browsers, such as Chrome, Firefox, Edge, and others, to ensure a consistent user experience. Serenity offers the capability to run tests on different browsers, supporting this need.

We can set up multiple driver configurations using the environments section, as demonstrated below.

mvn clean verify -Denvironment=chrome

The complete framework using Serenity with JUnit5 can be found here – Testing of Web Application using Serenity with JUnit5.

We need to add serenity.conf in src/test/resources.

To apply the driver settings, simply set the environment system property to the desired environment, for example:

environments {
  chrome {
    webdriver {
      driver = chrome
      autodownload = true
      capabilities {
        browserName = "chrome"
        acceptInsecureCerts = true
        "goog:chromeOptions" {
          args = ["test-type", "ignore-certificate-errors", "headless", "--window-size=1000,800"
            "incognito", "disable-infobars", "disable-gpu", "disable-default-apps", "disable-popup-blocking"]
        }
      }
    }
  }
  edge {
    webdriver {
      capabilities {
        browserName = "MicrosoftEdge"
        "ms:edgeOptions" {
          args = ["test-type", "ignore-certificate-errors", "headless",
            "incognito", "disable-infobars", "disable-gpu", "disable-default-apps", "disable-popup-blocking"]
        }
      }
    }
  }
  firefox {
    webdriver {
      capabilities {
        browserName = "firefox"
        pageLoadStrategy = "normal"
        acceptInsecureCerts = true
        unhandledPromptBehavior = "dismiss"
        strictFileInteractability = true

        "moz:firefoxOptions" {
          args = ["-headless"],
          prefs {
            "javascript.options.showInConsole": false
          },
          log {"level": "info"},
        }
      }
    }
  }
}

Chrome Browser

To run the tests using the chrome browser, use the below command:

mvn clean verify -Denvironment="chrome"

Serenity Report shows that the tests are executed in the Chrome Browser.

Firefox Browser

To run the tests using the chrome browser, use the below command:

mvn clean verify -Denvironment="firefox"

Serenity Report shows that the tests are executed in the Firefox Browser.

Edge Browser

To run the tests using the chrome browser, use the below command:

mvn clean verify -Denvironment="edge"

Serenity Report shows that the tests are executed in the Edge Browser.

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

September 12, 2024October 17, 2024 vibssingh

How to handle token expiration and automatic refreshing of tokens in REST Assured?

Last Updated On

October 17, 2024

HOME

Handling token expiration and automatically refreshing tokens in REST Assured involves a few steps to ensure your tests can obtain a fresh token when the current one expires.

Add the below-mentioned dependencies to the Maven project.

<dependencies>
 
       <!-- Rest Assured Dependency -->
      <dependency>
         <groupId>io.rest-assured</groupId>
        <artifactId>rest-assured</artifactId>
        <version>5.4.0</version>
        <scope>test</scope>
      </dependency>

      <!-- JSON path Dependency -->
      <dependency>
         <groupId>io.rest-assured</groupId>
         <artifactId>json-path</artifactId>
         <version>5.4.0</version>
         <scope>test</scope>
      </dependency>
 
        <!-- TestNG Dependency-->
      <dependency>
          <groupId>org.testng</groupId>
         <artifactId>testng</artifactId>
         <version>7.8.0</version>
         <scope>test</scope>
       </dependency>
 
</dependencies>

Implementation Steps

Obtain Initial Access Token:– Implement a method to obtain the initial access token from the authentication server.
Store Token and Expiration Time:- Use a structure to store the access token and its expiration time.
Check Token Validity:– Before making an API request, check if the token is still valid. If it’s expired or about to expire, refresh it.
Refresh the Token:- Implement a method to refresh the token.
Update Token Storage:– Store the new token and update the expiration time after refreshing.

import io.restassured.RestAssured;
import io.restassured.response.Response;

import java.time.Instant;

public class TokenGeneration {

    private static String accessToken;
    private static Instant tokenExpiryTime;
    Response response;
    int expiresIn;

    // Method to obtain initial token
    public static String getAccessToken() {
        if (accessToken == null || isTokenExpired()) {
            refreshAccessToken();
        }
        return accessToken;
    }

    // Method to check if the token is expired
    private static boolean isTokenExpired() {
        return tokenExpiryTime == null || Instant.now().isAfter(tokenExpiryTime);
    }

    // Method to refresh token
    private static void refreshAccessToken() {
            response = RestAssured.given()
            .contentType("application/x-www-form-urlencoded")
            .formParam("grant_type", "client_credentials")
            .formParam("client_id", "your-client-id")
            .formParam("client_secret", "your-client-secret")
            .post("https://your-auth-server.com/oauth/token");

        accessToken = response.jsonPath().getString("access_token");
        expiresIn = response.jsonPath().getInt("expires_in");
        tokenExpiryTime = Instant.now().plusSeconds(expiresIn);

        System.out.println("Access Token: " + accessToken);
        System.out.println("Token Expiry Time: " + tokenExpiryTime);
    }
}

Instant.now – The now() method of Instant returns the current time from the system clock. If the current time is “2023-10-01T12:00:00Z”, “Instant.now()“ would represent this moment in time.

isAfter(tokenExpiryTime) – checks if the current time is after the token’s expiration time.

tokenExpiryTime == null || Instant.now().isAfter(tokenExpiryTime);

plusSeconds(expiresIn) – This method adds a specified number of seconds to the Instant object. If expiresIn is “3600“ seconds (which is equivalent to 1 hour), it adds an hour to the current Instant.

tokenExpiryTime = Instant.now().plusSeconds(expiresIn);

Use the Token in REST Assured Requests.

import static io.restassured.RestAssured.given;
import org.testng.annotations.Test;

public class ApiTest {

        String token = TokenGeneration.getAccessToken();
        Response response;

       @Test
       public getResponse() {
         response = given()
                .auth().oauth2(token)
                .when()
                .get("https://example.com/protected/resource")
                .then()
                .statusCode(200)
                .extract().response();

        System.out.println("Response: " + response.asString());
    }
}

Best Practices:

Token Expiry Buffer:– Consider implementing a buffer time before the actual expiry to refresh the token. This prevents the edge cases where the token might expire during an API call.

private static final long TOKEN_EXPIRY_BUFFER_SECONDS = 60;  // 1 minute buffer
    
private static boolean isTokenExpired() {
        return tokenExpiryTime == null || Instant.now().isAfter(tokenExpiryTime.minusSeconds(TOKEN_EXPIRY_BUFFER_SECONDS));
 }

Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!! Cheers!!

September 10, 2024 vibssingh

TestNG Multiple Choice Answers

Last Updated On

HOME

Are you familiar with Rest API and want to test your understanding? This post contains 25 useful TestNG multiple-choice questions (quiz) to self-test your knowledge of TestNG .

You can find the questions for the below-mentioned answers in this post – 25 Useful TestNG Multiple-Choice Questions | Self-Test Your Knowledge

Answers

1) 1) A testing framework for java inspired by JUnit

2) 2) Cédric Beust

3) 2) After

4) 2) Next Generation

5) 4) All of the above

TestNG offers extensive control over the execution of test cases, including setting dependencies, priorities, and parallel execution.

Prior to running test case X, run multiple test cases as a pre-request – TestNG allows us to set dependencies between test methods using dependsOnMethods or dependsOnGroups, so you can ensure that certain test cases run before others.

TestNG provides powerful features such as annotations, test grouping, sequencing, and parameterization, which resolve the limitations found in earlier frameworks like JUnit.

6) 4) None of the above

7) 4) All of the above

8) 2) Independently of

This means that each test case can be executed on its own without depending on the execution or results of other test cases. However, TestNG also allows us to create dependencies between test cases using the dependsOnMethods or dependsOnGroups attributes if needed.

9) 1) Java

10) 4) All of the above

11) 3) XML

In TestNG, an XML file (commonly named as testng.xml) is used to define and configure test suites, test groups, and the sequence of test execution.

12) 2) Testng.xml

Sample testng.xml

<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
<suite name="SampleSuite">
    <test name="SampleTest">
        <classes>
            <class name="com.example.MyTestClass" />
        </classes>
    </test>
</suite>

13) 4) All of the above

14) 3) Both A and B

15) 4) All of the above

16) 1) BeforeSuite

17) 3) Before each and every test method in the class i.e., the method with @BeforeMethod annotation will execute for every test method in the class

18) 2) Once before the execution of test methods in the class begins

19) 1) AfterSuite

@AfterSuite: This method is executed after all the test methods in an entire suite have been completed.

20) 2) Annotation

21) 3) BeforeTest

@BeforeTest: This method is executed before any test methods in the <test> tag in the testng.xml file, which can include multiple classes and folders.

22) 2) AfterTest

@AfterTest: This method is executed after all the test methods in the <test> tag in the testng.xml file have been run, which can include multiple classes.

23) 2) BeforeClass

@BeforeClass: This method is invoked before the first test method in the current class is executed.

24) 3) AfterClass

The annotations have different scopes:

@AfterClass: This method is invoked after all the test methods in the current class have been executed.
@AfterMethod: Runs after each individual test method.
@AfterSuite: Runs once after all the tests in the entire suite have finished.
@AfterTest: Runs after all test methods in the <test> tag of the testng.xml file.

25) 1) BeforeMethod

Each of these annotations is executed before a test method, but at different levels:

@BeforeMethod: Runs before each individual test method in the current class.
@BeforeTest: Runs before any test methods in the <test> tag in the testng.xml file.
@BeforeClass: Runs before the first test method in the current class.
@BeforeSuite: Runs once before all tests in the entire suite defined in the testng.xml file.

September 10, 2024September 10, 2024 vibssingh

25 Useful TestNG Multiple-Choice Questions | Self-Test Your Knowledge

Last Updated On

September 10, 2024

HOME

Are you familiar with TestNG and want to test your understanding? This post contains 25 useful TestNG multiple-choice questions (quiz) to self-test your knowledge.

1. What is TestNG?

Select the best answer

A testing framework for java inspired by JUnit
Programming Language
Database
All of the above

Implementation Steps

What is ToolTip?

Implementation Steps

Locate the Tooltip Element

Hover Over the Element

Retrieve Tooltip Text

Validate the Text

What is Fluent Wait?

Dependency:

Implementation Steps

Implementation Steps