🔍 Assert (from TestNG/JUnit) and
🧩 Hamcrest Matchers (from org.hamcrest) — what they are, how they differ, and how to use them in Selenium automation.

🧠 1️⃣ What is an Assertion?

🔹 Definition:

An assertion is a checkpoint that verifies whether the actual result matches the expected result in your test case.

If the condition passes → test continues.
If it fails → test stops and marks as Failed.

🧩 2️⃣ Types of Assertions (in Selenium + TestNG)

🧩 3️⃣ HARD ASSERT (TestNG)

🧠 Meaning:

Used for strict verification.
If a Hard Assert fails, test execution immediately stops at that line.

✅ Common Methods:

🧩 Example (Selenium + TestNG)

import org.testng.Assert;
import org.testng.annotations.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class PaymentAssertionTest {
    @Test
    public void verifyPaymentSuccess() {
        WebDriver driver = new ChromeDriver();
        driver.get("https://example.com/payment");

        driver.findElement(By.id("payNow")).click();
        String actualMessage = driver.findElement(By.id("paymentSuccessMsg")).getText();

        // Hard Assert
        Assert.assertEquals(actualMessage, "Payment Successful", "❌ Payment message mismatch");
        System.out.println("✅ Payment verified successfully");

        driver.quit();
    }
}

👉 If message mismatches → test stops immediately and fails.

🧩 4️⃣ SOFT ASSERT (TestNG)

🔹 Meaning:

Soft asserts don’t stop the test when they fail.
They collect all failures and report at the end using .assertAll().

✅ Syntax:

SoftAssert softAssert = new SoftAssert();
softAssert.assertEquals(actual, expected);
softAssert.assertTrue(condition);
softAssert.assertAll();  // mandatory

🧩 Example (Selenium)

import org.testng.asserts.SoftAssert;

SoftAssert softAssert = new SoftAssert();

softAssert.assertEquals(driver.getTitle(), "Payments");
softAssert.assertTrue(driver.findElement(By.id("payNow")).isDisplayed());
softAssert.assertEquals(actualMessage, "Payment Successful");

System.out.println("✅ Test continued despite assertion failures.");
softAssert.assertAll();  // Collects and reports all failures

🧠 5️⃣ Why Use Hamcrest Matchers?

🔹 Problem with Assert:

Assert syntax can be rigid and less readable when you need complex validation:

Assert.assertTrue(actualText.contains("Success"));

🔹 Solution:

Hamcrest Matchers (from org.hamcrest) allow fluent, readable, and flexible conditions like:

assertThat(actualText, containsString("Success"));

🧩 6️⃣ Hamcrest Core Concept

✅ Import:

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;

✅ Syntax:

assertThat(actualValue, matcherCondition);

🧱 7️⃣ Common Hamcrest Matchers

🧩 8️⃣ Example — Hamcrest in Selenium

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.Test;

public class HamcrestPaymentTest {

    @Test
    public void verifyPaymentConfirmation() {
        WebDriver driver = new ChromeDriver();
        driver.get("https://example.com/checkout");
        driver.findElement(By.id("payNow")).click();

        String confirmationMsg = driver.findElement(By.id("paymentSuccessMsg")).getText();

        // Hamcrest Assertions
        assertThat("✅ Payment confirmation validation",
                   confirmationMsg,
                   allOf(startsWith("Payment"), containsString("Success")));

        String url = driver.getCurrentUrl();
        assertThat(url, containsString("confirmation"));

        driver.quit();
    }
}

🟢 Output: Test passes only if message starts with “Payment” and includes “Success”.

⚙️ 9️⃣ Combining Hamcrest + TestNG SoftAssert (Advanced)

Sometimes you can use both to get readable, non-blocking checks:

SoftAssert softAssert = new SoftAssert();

try {
    assertThat(price, greaterThan(0.0));
} catch (AssertionError e) {
    softAssert.fail(e.getMessage());
}

try {
    assertThat(message, containsString("Success"));
} catch (AssertionError e) {
    softAssert.fail(e.getMessage());
}

softAssert.assertAll();

✅ Gives best of both worlds — flexible matching + multiple validation collection.

🧠 1️⃣0️⃣ Hamcrest Logical Matchers (Advanced)

🧾 1️⃣1️⃣ Real E-commerce Payment Example (Combined)

@Test
public void verifyPaymentFlow() {
    WebDriver driver = new ChromeDriver();
    driver.get("https://shopdemo.example.com");

    driver.findElement(By.id("addToCart")).click();
    driver.findElement(By.id("checkout")).click();
    driver.findElement(By.id("payNow")).click();

    String message = driver.findElement(By.id("paymentSuccessMsg")).getText();
    double totalAmount = Double.parseDouble(driver.findElement(By.id("totalAmount")).getText().replace("$", ""));

    assertThat("Verify payment confirmation message",
               message,
               allOf(containsString("Payment"), containsString("Success")));

    assertThat("Verify total amount greater than zero", totalAmount, greaterThan(0.0));

    assertThat("Verify redirection URL", driver.getCurrentUrl(), containsString("confirmation"));

    driver.quit();
}

🧠 1️⃣2️⃣ Difference Summary Table

✅ Summary in One Line

🔹 Use Assert for simple direct verifications.
🔹 Use SoftAssert when you need to collect multiple results.
🔹 Use Hamcrest Matchers when you want expressive, flexible, human-readable validation in automation frameworks.

Would you like me to show you
👉 a real-time hybrid example where TestNG, SoftAssert, and Hamcrest are used together in a single Selenium test (like full payment flow validation)?

You said:

give for rest assured

ChatGPT said:

Excellent 🔥 — now let’s go deep into Assert and Hamcrest Matchers in REST Assured,
which is extremely important for API Testing automation interviews and frameworks.

We’ll cover everything step-by-step —
✅ From basics → advanced usage → real e-commerce payment API example.

🧠 1️⃣ What is REST Assured?

REST Assured is a Java library for testing REST APIs.
It helps to:

• Send API requests (GET, POST, PUT, DELETE, etc.)

• Validate status codes, response bodies, and headers

• Perform BDD-style assertions using Hamcrest Matchers

🧩 2️⃣ Types of Assertions in REST Assured

⚙️ 3️⃣ Basic REST Assured Structure

import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;

given()
    .baseUri("https://api.example.com")
    .when()
    .get("/payment/status")
    .then()
    .statusCode(200)
    .body("status", equalTo("SUCCESS"));

✅ Here:

• given() → Setup request

• when() → Trigger API call

• then() → Verify response using Hamcrest Matchers

🧱 4️⃣ Using Assert (TestNG / JUnit) with REST Assured

You can extract response data and validate using TestNG Assert:

import io.restassured.response.Response;
import org.testng.Assert;

Response response = 
    given()
        .baseUri("https://api.example.com")
        .when()
        .get("/payment/status");

int statusCode = response.getStatusCode();
String status = response.jsonPath().getString("status");

Assert.assertEquals(statusCode, 200, "Invalid Status Code");
Assert.assertEquals(status, "SUCCESS", "Payment status failed");

🟢 Use this approach when you need detailed validation logic or multiple fields.

🧠 5️⃣ Hamcrest Matchers in REST Assured

REST Assured integrates Hamcrest for BDD-style validation directly in .then() section.

🔹 Import Required:

import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;

🔹 Example:

given()
    .baseUri("https://api.example.com")
    .when()
    .get("/order/123")
    .then()
    .statusCode(200)
    .body("orderId", equalTo(123))
    .body("payment.status", is("Success"))
    .body("items.size()", greaterThan(0));

✅ Advantages:

• Fluent and readable

• No need for explicit response extraction

• Combines multiple checks easily

🧩 6️⃣ Commonly Used Hamcrest Matchers in REST Assured

🧾 7️⃣ Real E-commerce Payment API Example

🧩 Scenario:

User makes a payment — /api/payment/confirm returns:

{
  "transactionId": "TXN12345",
  "status": "Success",
  "amount": 999.99,
  "currency": "INR",
  "message": "Payment Successful",
  "paymentMode": "UPI"
}

✅ Test Case (Hamcrest + REST Assured)

import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;
import org.testng.annotations.Test;

public class PaymentAPITest {

    @Test
    public void verifyPaymentConfirmation() {
        given()
            .baseUri("https://api.ecommerce.com")
            .contentType("application/json")
            .body("{\"orderId\":\"ORD12345\", \"amount\":999.99, \"mode\":\"UPI\"}")
        .when()
            .post("/api/payment/confirm")
        .then()
            .statusCode(200)
            .body("status", equalTo("Success"))
            .body("message", containsString("Payment"))
            .body("amount", greaterThan(0.0f))
            .body("currency", is("INR"))
            .body("paymentMode", anyOf(is("UPI"), is("Card"), is("NetBanking")));
    }
}

🟢 Here we validated:

• HTTP status

• Response fields

• Value ranges

• Logical OR for multiple payment modes

⚙️ 8️⃣ Extract + Test Using Assert + Hamcrest Hybrid

You can combine both styles for flexible logic:

import io.restassured.response.Response;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
import org.testng.Assert;

Response response = 
    given()
        .baseUri("https://api.ecommerce.com")
        .when()
        .get("/api/payment/ORD12345");

int statusCode = response.getStatusCode();
String status = response.jsonPath().getString("status");
double amount = response.jsonPath().getDouble("amount");

// TestNG assertions
Assert.assertEquals(statusCode, 200, "Invalid Status Code");
Assert.assertNotNull(status, "Status missing");

// Hamcrest matchers
assertThat(status, is("Success"));
assertThat(amount, greaterThan(0.0));

✅ Use this style when you want flexibility + detailed failure messages.

🧠 9️⃣ Validating Complex JSON Responses

Example:

{
  "orders": [
    { "id": 1, "status": "Delivered" },
    { "id": 2, "status": "Shipped" }
  ]
}

Validation:

given()
    .when()
    .get("/orders")
    .then()
    .statusCode(200)
    .body("orders.id", hasItems(1, 2))
    .body("orders.status", hasItem("Shipped"));

⚡ 1️⃣0️⃣ Validate Response Headers and Time

given()
    .when()
    .get("/api/payment/ORD12345")
    .then()
    .statusCode(200)
    .header("Content-Type", equalTo("application/json"))
    .time(lessThan(2000L)); // response within 2 seconds

💥 1️⃣1️⃣ Error Handling Example (Negative Test)

given()
    .baseUri("https://api.ecommerce.com")
    .when()
    .get("/api/payment/invalidOrder")
    .then()
    .statusCode(404)
    .body("error.message", containsString("Order not found"))
    .body("error.code", equalTo("404_NOT_FOUND"));

🧩 1️⃣2️⃣ Difference Between Assert & Hamcrest in REST Assured

🧠 1️⃣3️⃣ Chaining Multiple Conditions (allOf / anyOf)

given()
    .when()
    .get("/api/payment/ORD12345")
    .then()
    .body("message", allOf(containsString("Payment"), containsString("Success")))
    .body("status", anyOf(is("Success"), is("Completed")));

✅ Combines multiple conditions cleanly.

🧾 1️⃣4️⃣ Complete Example: Payment Module Test Flow

@Test
public void testFullPaymentFlow() {
    given()
        .baseUri("https://api.ecommerce.com")
        .contentType("application/json")
        .body("{\"userId\":1, \"orderId\":\"ORD1001\", \"amount\":500.0}")
    .when()
        .post("/api/payment/confirm")
    .then()
        .statusCode(200)
        .body("status", equalTo("Success"))
        .body("transactionId", notNullValue())
        .body("message", containsString("Successful"))
        .body("paymentMode", anyOf(is("UPI"), is("Card")))
        .body("amount", greaterThan(0.0f))
        .body("currency", is("INR"))
        .header("Content-Type", containsString("application/json"));
}

✅ 1️⃣5️⃣ Summary

Would you like me to give you a real-world API test class that covers:

• GET, POST, PUT, DELETE

• uses both Assert and Hamcrest

• for a full e-commerce payment + order API flow (end-to-end)?

You said:

json and json path in detail and give playground for practice

ChatGPT said:

Perfect 🔥 — this is one of the most important topics in API Testing and automation with REST Assured and Selenium frameworks:

Let’s go step-by-step and in-depth on 👇

JSON + JSONPath with full explanation, syntax, practical examples, and free playgrounds for hands-on practice.

🧠 1️⃣ What is JSON?

🔹 Definition:

JSON (JavaScript Object Notation) is a lightweight data-interchange format used to store and exchange data between systems — mostly between client and server in REST APIs.

It’s easy for humans to read and machines to parse.

🧩 Basic JSON Example

{
  "id": 101,
  "name": "Shreenibas",
  "email": "shree@test.com",
  "isActive": true,
  "skills": ["Java", "Selenium", "API Testing"],
  "address": {
    "city": "Bhubaneswar",
    "pin": 751024
  }
}

🧱 2️⃣ JSON Data Types

🧠 3️⃣ JSON Structure Hierarchy

🧩 4️⃣ What is JSONPath?

🔹 Definition:

JSONPath is a query language for extracting specific data from JSON.
It’s similar to XPath (for XML).

👉 It helps you navigate JSON using keys, indexes, and filters.

⚙️ 5️⃣ Basic JSONPath Syntax

🧾 6️⃣ Example JSON for Practice

Let’s use this JSON:

{
  "company": "TechCorp",
  "employees": [
    {
      "id": 1,
      "name": "Alice",
      "role": "QA",
      "skills": ["Selenium", "Java", "API Testing"],
      "salary": 60000
    },
    {
      "id": 2,
      "name": "Bob",
      "role": "Developer",
      "skills": ["Java", "SpringBoot"],
      "salary": 90000
    },
    {
      "id": 3,
      "name": "Carol",
      "role": "Manager",
      "skills": ["Leadership", "Planning"],
      "salary": 120000
    }
  ]
}

🧠 7️⃣ JSONPath Examples Explained

🧩 8️⃣ JSONPath in REST Assured

In REST Assured, JsonPath helps to extract data from API response.

Example:

import io.restassured.path.json.JsonPath;
import io.restassured.response.Response;
import static io.restassured.RestAssured.*;

Response response = 
    given()
        .baseUri("https://api.techcorp.com")
    .when()
        .get("/employees");

JsonPath json = response.jsonPath();
System.out.println(json.getString("employees[0].name"));   // Alice
System.out.println(json.getList("employees.name"));        // [Alice, Bob, Carol]
System.out.println(json.getInt("employees[1].salary"));    // 90000

⚙️ 9️⃣ JSONPath — Filtering and Conditions in REST Assured

List<String> highEarners = json.getList("employees.findAll { it.salary > 80000 }.name");
System.out.println(highEarners); // [Bob, Carol]

✅ findAll { it.condition } → Groovy syntax used by REST Assured internally.

🧩 🔟 Advanced JsonPath with Groovy (used by REST Assured)

Example:

List<Integer> salaries = json.getList("employees.salary");
int total = salaries.stream().mapToInt(Integer::intValue).sum();
System.out.println("Total Salary: " + total);

🧾 1️⃣1️⃣ Example: Extract Nested Data

String firstSkill = json.getString("employees[0].skills[1]");  // Java
List<String> allSkills = json.getList("employees.skills.flatten()");
System.out.println(allSkills);

👉 .flatten() merges all nested arrays into one.

🧠 1️⃣2️⃣ Real REST Assured Example with JSONPath

@Test
public void verifyEmployeeData() {
    Response response = 
        given()
            .baseUri("https://api.techcorp.com")
        .when()
            .get("/employees");

    JsonPath json = response.jsonPath();

    // Extract values
    List<String> names = json.getList("employees.name");
    List<Integer> salaries = json.getList("employees.salary");
    String firstRole = json.getString("employees[0].role");

    System.out.println("Names: " + names);
    System.out.println("Salaries: " + salaries);
    System.out.println("First role: " + firstRole);

    // Assertions
    assertThat(json.getString("company"), equalTo("TechCorp"));
    assertThat(json.getInt("employees.size()"), greaterThan(2));
    assertThat(names, hasItems("Alice", "Bob"));
}

🧩 1️⃣3️⃣ Common Mistakes to Avoid

🧰 1️⃣4️⃣ Tools & Playgrounds for Practice

Here are the best free JSON & JSONPath playgrounds 👇

👉 I recommend using https://jsonpath.com for live testing — just paste the sample JSON and try the queries above.

🧾 1️⃣5️⃣ Mini Practice Challenges 🧩

Use this JSON 👇 in https://jsonpath.com

{
  "store": {
    "book": [
      { "category": "reference", "price": 8.95 },
      { "category": "fiction", "price": 12.99 },
      { "category": "fiction", "price": 22.99 }
    ],
    "bicycle": {
      "color": "red",
      "price": 19.95
    }
  }
}

🧠 1️⃣6️⃣ Summary Table

Would you like me to give you a hands-on REST Assured project exercise (with sample APIs + JSONPath queries + assertions) that you can directly run in Eclipse or IntelliJ?
It will simulate a real e-commerce API (products + cart + payments).

You said:

ok

ChatGPT said:

Perfect 👍 let’s now move to a hands-on REST Assured project exercise using JSON + JSONPath with a realistic e-commerce API simulation —
so you can directly practice in Eclipse/IntelliJ or Postman and master data extraction + validation.

🏪 Realistic Scenario — E-Commerce REST API

You’re testing an E-Commerce backend that handles:

• Product catalog

• Cart operations

• Order placement

• Payment module

Each API returns JSON responses you’ll validate using REST Assured + JSONPath.

⚙️ Project Setup (pom.xml)

Make sure these dependencies exist:

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

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

    <!-- Hamcrest for assertions -->
    <dependency>
        <groupId>org.hamcrest</groupId>
        <artifactId>hamcrest</artifactId>
        <version>2.2</version>
    </dependency>
</dependencies>

🧩 Step 1️⃣ — Sample Product List API Response

GET /products

{
  "store": {
    "products": [
      {
        "id": 101,
        "name": "Laptop",
        "brand": "HP",
        "price": 75000,
        "stock": 10,
        "category": "Electronics"
      },
      {
        "id": 102,
        "name": "Smartphone",
        "brand": "Samsung",
        "price": 35000,
        "stock": 25,
        "category": "Mobiles"
      },
      {
        "id": 103,
        "name": "Shoes",
        "brand": "Puma",
        "price": 3500,
        "stock": 100,
        "category": "Fashion"
      }
    ]
  }
}

🧠 Step 2️⃣ — JSONPath Queries to Extract Data

👉 Try these in https://jsonpath.com to visualize them live.

💻 Step 3️⃣ — REST Assured Test Code

package com.ecommerce.api;

import io.restassured.path.json.JsonPath;
import io.restassured.response.Response;
import org.testng.annotations.Test;
import static io.restassured.RestAssured.*;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;

public class ProductAPITest {

    @Test
    public void verifyProductListAPI() {
        // Fake endpoint for demo (you can mock it using ReqRes or Postman Mock)
        Response response = given()
                .baseUri("https://api.mocki.io/v2/5185415ba171ea3a00704eed") // use your endpoint
            .when()
                .get("/products");

        // Validate status code
        response.then().statusCode(200);

        JsonPath json = response.jsonPath();

        // Extract values
        String firstProduct = json.getString("store.products[0].name");
        int secondProductPrice = json.getInt("store.products[1].price");
        int totalProducts = json.getList("store.products").size();

        System.out.println("First Product: " + firstProduct);
        System.out.println("Second Product Price: " + secondProductPrice);
        System.out.println("Total Products: " + totalProducts);

        // Assertions
        assertThat(firstProduct, equalTo("Laptop"));
        assertThat(secondProductPrice, greaterThan(30000));
        assertThat(totalProducts, equalTo(3));
    }
}

🧩 Step 4️⃣ — Extract and Validate with Filters

@Test
public void verifyFilterProducts() {
    Response response = get("https://mockapi.io/fake-store/products");
    JsonPath json = response.jsonPath();

    // Extract product names cheaper than 40000
    List<String> cheapProducts = json.getList("store.products.findAll { it.price < 40000 }.name");
    System.out.println("Affordable Products: " + cheapProducts);

    // Assert
    assertThat(cheapProducts, hasItems("Smartphone", "Shoes"));
}

💰 Step 5️⃣ — Simulated Payment API

POST /payment

{
  "paymentId": "P12345",
  "orderId": "O9876",
  "amount": 35000,
  "method": "UPI",
  "status": "Success",
  "transaction": {
    "timestamp": "2025-11-11T08:30:00Z",
    "bankRef": "ICIC12345",
    "currency": "INR"
  }
}

✅ Validation Example

@Test
public void verifyPaymentResponse() {
    String responseBody = "{ \"paymentId\":\"P12345\", \"orderId\":\"O9876\", \"amount\":35000, \"method\":\"UPI\", \"status\":\"Success\" }";

    JsonPath json = new JsonPath(responseBody);

    // Extract
    String status = json.getString("status");
    int amount = json.getInt("amount");

    // Assert
    assertThat(status, equalTo("Success"));
    assertThat(amount, greaterThan(0));
}

🧾 Step 6️⃣ — JSONPath Practice Challenges for You 🎯

🧠 Step 7️⃣ — Integration Idea (for Real Practice)

You can simulate the whole flow:

1. GET /products → extract product ID & price

2. POST /cart → add product to cart

3. POST /order → place order

4. POST /payment → simulate payment success

5. GET /order/{id} → verify order status = "Completed"

Each response is JSON — you’ll extract and assert data with JsonPath.

🧰 Step 8️⃣ — Recommended Practice Tools

🏁 Summary

Would you like me to add the next part —

🔹 “E-Commerce Full Flow API Automation Project” (Products → Cart → Payment → Assertions)
with end-to-end REST Assured TestNG code and reusable JSONPath extraction?

It’ll be a real-world ready mini framework example.

You said:

yes

ChatGPT said:

Perfect ⚡ — let’s build your End-to-End E-Commerce API Automation Project using REST Assured + TestNG + JSONPath + Hamcrest.

We’ll simulate a real automation tester workflow for:
🛒 Products → 🧺 Cart → 📦 Order → 💳 Payment

This will give you a mini automation framework you can run in Eclipse or IntelliJ — perfect for resume projects and interviews.

🧱 1️⃣ PROJECT STRUCTURE

ecommerce-api-automation/
│
├── pom.xml
├── src/
│   └── test/java/
│       └── com/ecommerce/tests/
│           ├── BaseTest.java
│           ├── ProductTest.java
│           ├── CartTest.java
│           ├── OrderTest.java
│           └── PaymentTest.java
└── testng.xml

⚙️ 2️⃣ pom.xml Dependencies

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

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

    <!-- Hamcrest -->
    <dependency>
        <groupId>org.hamcrest</groupId>
        <artifactId>hamcrest</artifactId>
        <version>2.2</version>
    </dependency>

    <!-- JSON -->
    <dependency>
        <groupId>org.json</groupId>
        <artifactId>json</artifactId>
        <version>20240303</version>
    </dependency>
</dependencies>

🌐 3️⃣ Mock API Setup (you can use any of these)

If you use MockAPI.io, create 4 endpoints:

GET   /products
POST  /cart
POST  /order
POST  /payment

Each will return simple JSON data.

🧩 4️⃣ BaseTest.java

Centralized setup (Base URI and reusable methods).

package com.ecommerce.tests;

import io.restassured.RestAssured;
import io.restassured.response.Response;
import org.testng.annotations.BeforeClass;

public class BaseTest {

    @BeforeClass
    public void setup() {
        RestAssured.baseURI = "https://mockapi.io/api/v1"; // Replace with your mock API base URL
    }

    public Response getRequest(String endpoint) {
        return RestAssured
                .given()
                .when()
                .get(endpoint)
                .then()
                .extract()
                .response();
    }

    public Response postRequest(String endpoint, Object body) {
        return RestAssured
                .given()
                .header("Content-Type", "application/json")
                .body(body)
                .when()
                .post(endpoint)
                .then()
                .extract()
                .response();
    }
}

🛍️ 5️⃣ ProductTest.java — Fetch and Validate Products

package com.ecommerce.tests;

import io.restassured.path.json.JsonPath;
import io.restassured.response.Response;
import org.testng.annotations.Test;

import java.util.List;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;

public class ProductTest extends BaseTest {

    @Test
    public void verifyProductList() {
        Response response = getRequest("/products");
        response.then().statusCode(200);

        JsonPath json = response.jsonPath();

        // Validate
        List<String> productNames = json.getList("store.products.name");
        System.out.println("Products: " + productNames);

        assertThat(productNames, hasItems("Laptop", "Smartphone", "Shoes"));
        assertThat(json.getInt("store.products.size()"), greaterThan(0));

        // Extract one product for next step
        int selectedProductId = json.getInt("store.products[1].id");
        System.setProperty("productId", String.valueOf(selectedProductId));
    }
}

🧺 6️⃣ CartTest.java — Add Product to Cart

package com.ecommerce.tests;

import io.restassured.path.json.JsonPath;
import io.restassured.response.Response;
import org.json.JSONObject;
import org.testng.annotations.Test;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;

public class CartTest extends BaseTest {

    @Test(dependsOnMethods = "com.ecommerce.tests.ProductTest.verifyProductList")
    public void addToCart() {
        int productId = Integer.parseInt(System.getProperty("productId"));

        JSONObject request = new JSONObject();
        request.put("productId", productId);
        request.put("quantity", 2);

        Response response = postRequest("/cart", request.toString());
        response.then().statusCode(201);

        JsonPath json = response.jsonPath();

        assertThat(json.getString("message"), equalTo("Item added to cart"));
        assertThat(json.getInt("cart.quantity"), equalTo(2));

        String cartId = json.getString("cart.id");
        System.setProperty("cartId", cartId);
    }
}

📦 7️⃣ OrderTest.java — Place an Order

package com.ecommerce.tests;

import io.restassured.path.json.JsonPath;
import io.restassured.response.Response;
import org.json.JSONObject;
import org.testng.annotations.Test;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;

public class OrderTest extends BaseTest {

    @Test(dependsOnMethods = "com.ecommerce.tests.CartTest.addToCart")
    public void placeOrder() {
        String cartId = System.getProperty("cartId");

        JSONObject request = new JSONObject();
        request.put("cartId", cartId);
        request.put("address", "Bhubaneswar, Odisha");

        Response response = postRequest("/order", request.toString());
        response.then().statusCode(201);

        JsonPath json = response.jsonPath();

        assertThat(json.getString("status"), equalTo("Order Placed"));
        assertThat(json.getString("orderId"), notNullValue());

        System.setProperty("orderId", json.getString("orderId"));
    }
}

💳 8️⃣ PaymentTest.java — Verify Payment Success

package com.ecommerce.tests;

import io.restassured.path.json.JsonPath;
import io.restassured.response.Response;
import org.json.JSONObject;
import org.testng.annotations.Test;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;

public class PaymentTest extends BaseTest {

    @Test(dependsOnMethods = "com.ecommerce.tests.OrderTest.placeOrder")
    public void verifyPaymentSuccess() {
        String orderId = System.getProperty("orderId");

        JSONObject request = new JSONObject();
        request.put("orderId", orderId);
        request.put("method", "UPI");
        request.put("amount", 35000);

        Response response = postRequest("/payment", request.toString());
        response.then().statusCode(200);

        JsonPath json = response.jsonPath();

        assertThat(json.getString("status"), equalTo("Success"));
        assertThat(json.getInt("amount"), greaterThan(0));
        assertThat(json.getString("transaction.currency"), equalTo("INR"));

        System.out.println("✅ Payment successful for order: " + orderId);
    }
}

⚡ 9️⃣ testng.xml

Run all tests in proper sequence:

<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd">
<suite name="E-Commerce API Suite">
    <test name="API Tests">
        <classes>
            <class name="com.ecommerce.tests.ProductTest"/>
            <class name="com.ecommerce.tests.CartTest"/>
            <class name="com.ecommerce.tests.OrderTest"/>
            <class name="com.ecommerce.tests.PaymentTest"/>
        </classes>
    </test>
</suite>

🧠 🔟 What You Learn Here

🧰 1️⃣1️⃣ How to Practice

1. Go to https://mockapi.io

2. Create a new project

3. Add endpoints /products, /cart, /order, /payment with JSON similar to examples above

4. Copy the base URL into your BaseTest.java

5. Run from TestNG or mvn test

You’ll see each test depend on the previous one — forming a complete e-commerce flow.

🧾 1️⃣2️⃣ Output Example (Console)

Products: [Laptop, Smartphone, Shoes]
Affordable Products: [Smartphone, Shoes]
Item added to cart
✅ Order placed successfully
✅ Payment successful for order: O12345

Let’s go step-by-step — covering all authentication types, their usage, code examples, when to use, and common errors.

🔐 Authentication in RestAssured — Complete Guide

Authentication means verifying the identity of the API client (you or your test).
Most APIs require authentication to ensure only authorized users can access data.

🧩 1️⃣ No Authentication (Open API)

👉 Description

• Public APIs that don’t require credentials.

• Example: Open weather APIs, currency converters.

✅ Example

given()
    .when()
    .get("https://api.zippopotam.us/us/90210")
.then()
    .statusCode(200)
    .log().all();

💡 When to use

• Open/public data endpoints

• Simple testing or health check APIs

🧩 2️⃣ Basic Authentication

👉 Description

• The simplest authentication type.

• Sends username and password in the header (Base64 encoded).

⚠️ Not secure if used over HTTP (always use HTTPS).

✅ Syntax

given()
    .auth()
    .basic("username", "password")
.when()
    .get("https://api.example.com/users")
.then()
    .statusCode(200);

✅ Alternate Way (Preemptive)

given()
    .auth()
    .preemptive()
    .basic("username", "password")
.when()
    .get("https://api.example.com/users")
.then()
    .statusCode(200);

💡 Difference:

🧩 3️⃣ Digest Authentication

👉 Description

• More secure version of Basic Authentication.

• Uses a hash of the password instead of sending it in plain text.

• Common in legacy enterprise systems.

✅ Example

given()
    .auth()
    .digest("username", "password")
.when()
    .get("https://api.example.com/secure/data")
.then()
    .statusCode(200);

💡 When to use

• APIs supporting Digest Authentication (older web servers or internal APIs)

🧩 4️⃣ Bearer Token / OAuth2 Token

👉 Description

• The most common modern authentication.

• Token is issued after login and sent with every request.

• Used in most REST APIs (JWT, OAuth2, API keys).

✅ Example

given()
    .auth()
    .oauth2("your_token_here")
.when()
    .get("https://api.github.com/user")
.then()
    .statusCode(200);

Or with Header manually:

given()
    .header("Authorization", "Bearer your_token_here")
.when()
    .get("https://api.github.com/user")
.then()
    .statusCode(200);

💡 When to use

• APIs using JWT, OAuth2, or token-based sessions (GitHub, Google, Jira, etc.)

🧩 5️⃣ API Key Authentication

👉 Description

• Common for public APIs where a single key identifies the client.

• Key is sent as a query param or header.

✅ Example (Header)

given()
    .header("x-api-key", "12345abcde")
.when()
    .get("https://api.weatherapi.com/v1/current.json?q=London")
.then()
    .statusCode(200);

✅ Example (Query Param)

given()
    .queryParam("appid", "your_api_key")
    .queryParam("q", "London")
.when()
    .get("https://api.openweathermap.org/data/2.5/weather")
.then()
    .statusCode(200);

💡 When to use

• External or third-party APIs (Google Maps, OpenWeather, NewsAPI, etc.)

🧩 6️⃣ Form Authentication

👉 Description

• Used when the application authenticates using a login form (HTML form submission).

• RestAssured can simulate form-based login.

✅ Example

given()
    .auth()
    .form("username", "password", new FormAuthConfig("/login", "uname", "pwd"))
.when()
    .get("https://app.example.com/home")
.then()
    .statusCode(200);

💡 Parameters:

🧩 7️⃣ OAuth 1.0

👉 Description

• Older version of OAuth (used by Twitter API v1).

• Uses consumer key, secret, token, and token secret.

✅ Example

given()
    .auth()
    .oauth("consumerKey", "consumerSecret", "accessToken", "secretToken")
.when()
    .get("https://api.twitter.com/1.1/statuses/home_timeline.json")
.then()
    .statusCode(200);

💡 When to use

• Only when working with legacy APIs (Twitter API v1.1, some banking APIs)

🧩 8️⃣ OAuth 2.0 (Access Token Flow)

👉 Description

• The modern standard for authentication (used by Google, GitHub, Azure, etc.)

• Involves:

  1. Getting access token using client credentials.

  2. Using token in further requests.

✅ Step 1: Get Token

Response tokenResponse = given()
    .formParam("client_id", "myClientId")
    .formParam("client_secret", "mySecret")
    .formParam("grant_type", "client_credentials")
.when()
    .post("https://authserver.com/oauth/token");

String accessToken = tokenResponse.jsonPath().getString("access_token");

✅ Step 2: Use Token

given()
    .header("Authorization", "Bearer " + accessToken)
.when()
    .get("https://api.example.com/resource")
.then()
    .statusCode(200);

🧩 9️⃣ Session / Cookie Based Authentication

👉 Description

• Used in traditional web apps.

• You first log in → receive a session cookie → use it for later requests.

✅ Example

Response res = given()
    .formParam("username", "admin")
    .formParam("password", "admin123")
.when()
    .post("https://app.example.com/login");

String sessionId = res.getCookie("JSESSIONID");

given()
    .cookie("JSESSIONID", sessionId)
.when()
    .get("https://app.example.com/dashboard")
.then()
    .statusCode(200);

🧠 10️⃣ Summary Table

⚙️ 11️⃣ Best Practices

✅ Always use HTTPS (never send credentials over HTTP)
✅ Use Config/Properties file for credentials, not hardcoded values
✅ Use token refresh logic for long-running tests
✅ Parameterize auth tokens for CI/CD (Jenkins secrets or environment variables)
✅ Add utility methods for token retrieval and reuse

JSON (JavaScript Object Notation) is a lightweight data-interchange format.
It is easy for humans to read and write, and easy for machines to parse and generate.

Used in:

• API responses and requests

• Config files

• Data transfer between front-end and back-end

⚙️ 2. JSON Syntax Rules

📘 3. Example JSON Structure

{
  "id": 101,
  "name": "Shreenibas",
  "email": "shree@example.com",
  "isActive": true,
  "skills": ["Java", "Selenium", "API Testing"],
  "address": {
    "city": "Bhubaneswar",
    "pincode": 751024
  }
}

🧠 4. JSON Data Types

🧰 5. JSON in Java (Parsing and Serialization)

🔹 Using org.json

import org.json.JSONObject;

public class JsonExample {
    public static void main(String[] args) {
        String jsonData = "{ \"name\": \"Shree\", \"age\": 30 }";

        JSONObject obj = new JSONObject(jsonData);
        System.out.println(obj.getString("name")); // Shree
        System.out.println(obj.getInt("age"));     // 30
    }
}

🔹 Using Jackson (faster and widely used)

➤ Convert JSON → Java Object (Deserialization)

import com.fasterxml.jackson.databind.ObjectMapper;

public class Demo {
    public static void main(String[] args) throws Exception {
        String json = "{ \"name\":\"Shree\", \"age\":30 }";

        ObjectMapper mapper = new ObjectMapper();
        Person p = mapper.readValue(json, Person.class);

        System.out.println(p.getName());
    }
}

class Person {
    private String name;
    private int age;

    // getters and setters
}

➤ Convert Java Object → JSON (Serialization)

Person p = new Person();
p.setName("Shree");
p.setAge(30);

ObjectMapper mapper = new ObjectMapper();
String jsonOutput = mapper.writeValueAsString(p);
System.out.println(jsonOutput);

Output:

{"name":"Shree","age":30}

🧪 6. JSON in Rest Assured

✅ Extract value from API response

Response res = given().get("https://api.example.com/users/1");

String name = res.jsonPath().getString("name");
int id = res.jsonPath().getInt("id");

✅ Send JSON payload in POST request

JSONObject request = new JSONObject();
request.put("name", "Shree");
request.put("job", "Tester");

given()
  .header("Content-Type", "application/json")
  .body(request.toString())
.when()
  .post("https://reqres.in/api/users")
.then()
  .statusCode(201);

🔍 7. JSON Path (for reading JSON)

🚀 8. JSON Schema Validation in Rest Assured

Used to validate API responses against predefined structure.

import static io.restassured.module.jsv.JsonSchemaValidator.matchesJsonSchemaInClasspath;

given()
  .get("/users/1")
.then()
  .assertThat()
  .body(matchesJsonSchemaInClasspath("userSchema.json"));

🧩 9. Common JSON Errors

💡 10. Practice Tasks

1. Create JSON for Employee → name, id, skills[], address{}

2. Parse JSON and extract nested values

3. Convert List of POJOs to JSON array using Jackson

4. Validate JSON response schema in RestAssured

5. Write test that compares expected and actual JSONs

Would you like me to create a practice-based JSON mini project (like validating API responses or reading test data from JSON in Selenium)?
It can be beginner → advanced in 3 levels.

You said:

json path

ChatGPT said:

Perfect 👍 — let’s now go deep into JSONPath, which is one of the most powerful and frequently asked topics for API automation (RestAssured) and JSON parsing.

🧩 JSONPath Tutorial (Complete Guide for Testers)

💡 What is JSONPath?

JSONPath is a query language for navigating and extracting data from JSON documents, just like XPath for XML.
It helps you get specific values, arrays, or nested data easily.

Example JSON:

{
  "store": {
    "book": [
      { "category": "fiction", "title": "The Alchemist", "price": 12.99 },
      { "category": "programming", "title": "Java Basics", "price": 25.50 },
      { "category": "fiction", "title": "Harry Potter", "price": 30.00 }
    ],
    "bicycle": {
      "color": "red",
      "price": 120.50
    }
  }
}

⚙️ Basic JSONPath Syntax

🧠 Examples

🧪 JSONPath in RestAssured

✅ Example 1: Extract a value

Response res = given()
    .when().get("https://reqres.in/api/users/2");

String email = res.jsonPath().getString("data.email");
System.out.println(email);

✅ Example 2: Extract nested values from JSON array

Response res = given().get("https://reqres.in/api/users?page=2");

List<String> emails = res.jsonPath().getList("data.email");
System.out.println(emails);

✅ Example 3: Conditional extraction

List<String> names = res.jsonPath()
    .getList("data.findAll { it.id > 10 }.first_name");
System.out.println(names);

👉 Here findAll { it.id > 10 } acts like a filter, returning all objects where id > 10.

🧮 JSONPath Operators

🔍 JSONPath vs XPath (Quick Comparison)

💼 JSONPath in Real API Automation

Example API Response:

{
  "data": [
    { "id": 1, "name": "John", "role": "Tester" },
    { "id": 2, "name": "David", "role": "Developer" }
  ]
}

✅ Get all names:

List<String> names = response.jsonPath().getList("data.name");

✅ Get name of user where id = 2:

String name = response.jsonPath().getString("data.find { it.id == 2 }.name");

🧪 Advanced Use — JSONPath Validation in RestAssured

given()
  .when().get("/users")
  .then()
  .body("data.find { it.id == 2 }.email", equalTo("janet.weaver@reqres.in"))
  .body("data.size()", greaterThan(0))
  .body("data.email", hasItem("janet.weaver@reqres.in"));

⚡ JSONPath + Groovy Expressions (Used Inside RestAssured)

RestAssured uses Groovy syntax, so you can apply filters like:

Example:

float maxPrice = response.jsonPath().getFloat("store.book.max { it.price }.price");
System.out.println("Max Price: " + maxPrice);

🧩 Practice Tasks

1. Extract all “fiction” book titles from given JSON.

2. Find the highest-priced book using JSONPath.

3. Get the first user whose email contains “gmail.com”.

4. Count total books having price > 20.

5. Validate JSON response fields using JSONPath in RestAssured.

Would you like me to give a practice JSON + JSONPath exercise set (with real API responses and expected outputs)?
It’ll help you master filtering, array handling, and conditional queries used in interviews.

You said:

now give same for xml

ChatGPT said:

Excellent — let’s now cover XML and XPath, just like we did for JSON and JSONPath.
This is very important for API (SOAP) testing, data validation, and automation frameworks.

🧩 XML & XPath Tutorial (Complete Guide for Testers)

💡 What is XML?

XML (eXtensible Markup Language) is a markup language used to store and transport structured data.
It’s similar to HTML, but it describes data rather than displaying it.

Example:

<store>
  <book category="fiction">
    <title>The Alchemist</title>
    <author>Paulo Coelho</author>
    <price>12.99</price>
  </book>
  <book category="programming">
    <title>Java Basics</title>
    <author>James Gosling</author>
    <price>25.50</price>
  </book>
</store>

⚙️ XML Basics

🧠 Well-formed XML Rules

1. Must have one root element

2. Every start tag must have a closing tag

3. Tags are case-sensitive

4. Attributes must be quoted

5. No overlapping tags (like <a><b></a></b> ❌)

🧩 XML vs JSON

🧪 XPath — XML Query Language

XPath (XML Path Language) is used to navigate XML documents and extract specific elements or attributes.
Think of it as JSONPath for XML.

⚙️ XPath Syntax

🔍 XPath Examples

🧩 XPath Operators

🧪 XPath in RestAssured (XML API Testing)

✅ Example 1: Verify single element

given()
  .when()
  .get("https://example.com/books.xml")
  .then()
  .body("store.book[0].title", equalTo("The Alchemist"));

✅ Example 2: Using XMLPath

Response res = given()
    .when()
    .get("https://example.com/books.xml");

String title = res.xmlPath().getString("store.book[0].title");
System.out.println(title);

✅ Example 3: Extract attribute

String category = res.xmlPath().getString("store.book[0].@category");
System.out.println(category); // fiction

🧩 Advanced XPath Queries

🧮 XPath Functions

🧰 XML Validation in RestAssured

✅ Validate XML Schema (XSD)

import static io.restassured.module.jsv.XmlSchemaValidator.matchesXsdInClasspath;

given()
  .when()
  .get("/books.xml")
  .then()
  .body(matchesXsdInClasspath("booksSchema.xsd"));

🧩 XML Parsing in Java

➤ Using DOM Parser

import javax.xml.parsers.*;
import org.w3c.dom.*;

File file = new File("books.xml");
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.parse(file);

NodeList list = doc.getElementsByTagName("book");
System.out.println("Books count: " + list.getLength());

➤ Using XPath in Java

import javax.xml.xpath.*;
import org.w3c.dom.*;

XPathFactory xFactory = XPathFactory.newInstance();
XPath xpath = xFactory.newXPath();
String expr = "//book[@category='fiction']/title/text()";
String title = xpath.evaluate(expr, doc);
System.out.println(title);

🧩 Common XML Interview Questions

1. What is XML and how is it different from HTML/JSON?

2. What is XPath and how is it used in RestAssured?

3. How to extract XML attributes using XPath?

4. How to validate XML Schema in automation?

5. Write XPath to select the last node or filter by value.

6. How to handle SOAP response in API automation?

🧠 Practice Tasks

1. Write XPath to get the 2nd <book> title.

2. Get the category attribute for all books.

3. Extract all book titles where price > 20.

4. Count total <book> nodes.

5. Validate XML response against an XSD schema.

Would you like me to now create a practice-based XML + XPath exercise set (with sample XML responses and questions like extract, filter, and validate — just like a mini project for RestAssured)?

You said:

give full diferences

ChatGPT said:

Perfect — here’s a complete comparison of JSON vs XML with every key difference clearly explained from a tester’s and automation engineer’s perspective (especially for API testing using RestAssured / Postman).

🧩 JSON vs XML — Full Comparison Table

💡 Quick Summary for Automation Testers

⚙️ Code Example (Comparison in RestAssured)

JSON Example

Response res = given()
    .contentType("application/json")
    .body("{\"name\":\"Shree\", \"age\":30}")
.when()
    .post("/createUser");

String name = res.jsonPath().getString("name");

XML Example

Response res = given()
    .contentType("application/xml")
    .body("<user><name>Shree</name><age>30</age></user>")
.when()
    .post("/createUser");

String name = res.xmlPath().getString("user.name");

🧩 Interview-Focused Key Points

⚡ Conclusion

🧩 Scenario: Complex POST Request

You need to send this nested JSON body to create an order:

{
  "orderId": 101,
  "customer": {
    "name": "Nini",
    "email": "nini@test.com",
    "address": {
      "street": "MG Road",
      "city": "Bangalore",
      "pincode": "560001"
    }
  },
  "items": [
    { "itemName": "Laptop", "quantity": 1, "price": 75000 },
    { "itemName": "Mouse", "quantity": 2, "price": 500 }
  ],
  "payment": {
    "mode": "CreditCard",
    "transactionId": "TXN12345"
  }
}

🟢 Step 1: Create POJO Classes

Address.java

public class Address {
    private String street;
    private String city;
    private String pincode;

    // Getters and Setters
    public String getStreet() { return street; }
    public void setStreet(String street) { this.street = street; }

    public String getCity() { return city; }
    public void setCity(String city) { this.city = city; }

    public String getPincode() { return pincode; }
    public void setPincode(String pincode) { this.pincode = pincode; }
}

Customer.java

public class Customer {
    private String name;
    private String email;
    private Address address;

    // Getters and Setters
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }

    public Address getAddress() { return address; }
    public void setAddress(Address address) { this.address = address; }
}

Item.java

public class Item {
    private String itemName;
    private int quantity;
    private double price;

    // Getters and Setters
    public String getItemName() { return itemName; }
    public void setItemName(String itemName) { this.itemName = itemName; }

    public int getQuantity() { return quantity; }
    public void setQuantity(int quantity) { this.quantity = quantity; }

    public double getPrice() { return price; }
    public void setPrice(double price) { this.price = price; }
}

Payment.java

public class Payment {
    private String mode;
    private String transactionId;

    // Getters and Setters
    public String getMode() { return mode; }
    public void setMode(String mode) { this.mode = mode; }

    public String getTransactionId() { return transactionId; }
    public void setTransactionId(String transactionId) { this.transactionId = transactionId; }
}

Order.java

import java.util.List;

public class Order {
    private int orderId;
    private Customer customer;
    private List<Item> items;
    private Payment payment;

    // Getters and Setters
    public int getOrderId() { return orderId; }
    public void setOrderId(int orderId) { this.orderId = orderId; }

    public Customer getCustomer() { return customer; }
    public void setCustomer(Customer customer) { this.customer = customer; }

    public List<Item> getItems() { return items; }
    public void setItems(List<Item> items) { this.items = items; }

    public Payment getPayment() { return payment; }
    public void setPayment(Payment payment) { this.payment = payment; }
}

🟢 Step 2: Build Request Body in Java (Serialization)

import io.restassured.RestAssured;
import io.restassured.http.ContentType;
import static io.restassured.RestAssured.*;
import java.util.*;

public class ComplexPostExample {
    public static void main(String[] args) {

        RestAssured.baseURI = "https://api.testing.com"; // Replace with your API URL

        // Create Address
        Address address = new Address();
        address.setStreet("MG Road");
        address.setCity("Bangalore");
        address.setPincode("560001");

        // Create Customer
        Customer customer = new Customer();
        customer.setName("Nini");
        customer.setEmail("nini@test.com");
        customer.setAddress(address);

        // Create Items
        Item item1 = new Item();
        item1.setItemName("Laptop");
        item1.setQuantity(1);
        item1.setPrice(75000);

        Item item2 = new Item();
        item2.setItemName("Mouse");
        item2.setQuantity(2);
        item2.setPrice(500);

        List<Item> itemList = new ArrayList<>();
        itemList.add(item1);
        itemList.add(item2);

        // Create Payment
        Payment payment = new Payment();
        payment.setMode("CreditCard");
        payment.setTransactionId("TXN12345");

        // Create Order
        Order order = new Order();
        order.setOrderId(101);
        order.setCustomer(customer);
        order.setItems(itemList);
        order.setPayment(payment);

        // Send POST request
        given()
            .contentType(ContentType.JSON)
            .body(order)
        .when()
            .post("/orders")
        .then()
            .statusCode(201)
            .log().all();
    }
}

✅ Rest Assured automatically converts (serializes) the nested Order object into a complex JSON request body.

🟢 Step 3: Validate Response (Deserialization)

Let’s say the API returns the same order details as response.

Order orderResponse =
    given()
        .contentType(ContentType.JSON)
        .body(order)
    .when()
        .post("/orders")
    .then()
        .statusCode(201)
        .extract()
        .as(Order.class);   // ✅ JSON → Java object (Deserialization)

System.out.println("Customer name: " + orderResponse.getCustomer().getName());
System.out.println("First item: " + orderResponse.getItems().get(0).getItemName());

🟣 Alternative: Without POJOs (Using HashMap & List)

If you don’t want to create multiple POJO classes, you can use Maps & Lists:

Map<String, Object> address = new HashMap<>();
address.put("street", "MG Road");
address.put("city", "Bangalore");
address.put("pincode", "560001");

Map<String, Object> customer = new HashMap<>();
customer.put("name", "Nini");
customer.put("email", "nini@test.com");
customer.put("address", address);

Map<String, Object> payment = new HashMap<>();
payment.put("mode", "CreditCard");
payment.put("transactionId", "TXN12345");

List<Map<String, Object>> items = new ArrayList<>();
Map<String, Object> item1 = new HashMap<>();
item1.put("itemName", "Laptop");
item1.put("quantity", 1);
item1.put("price", 75000);
items.add(item1);

Map<String, Object> item2 = new HashMap<>();
item2.put("itemName", "Mouse");
item2.put("quantity", 2);
item2.put("price", 500);
items.add(item2);

Map<String, Object> order = new HashMap<>();
order.put("orderId", 101);
order.put("customer", customer);
order.put("items", items);
order.put("payment", payment);

given()
    .contentType(ContentType.JSON)
    .body(order)
.when()
    .post("/orders")
.then()
    .statusCode(201)
    .log().body();

✅ This approach is faster for small test cases,
but POJO-based is recommended for frameworks (cleaner, reusable, and type-safe).

🧠 Interview-Ready Summary Answer

“A complex POST request in Rest Assured involves sending a nested JSON structure that includes objects, arrays, and lists.
We can achieve this by using POJO classes with proper relationships or by using HashMaps and Lists.
Rest Assured automatically performs serialization (object → JSON) and deserialization (JSON → object) using Jackson or Gson.
This approach makes test automation more scalable and maintainable for large enterprise APIs.”

🔹 Definition

• Serialization → Converting a Java object into a data format (like JSON, XML, or byte stream) for transmission or storage.

• Deserialization → Converting that data format back into a Java object.

These are used widely in API testing (Rest Assured), file storage, network communication, and Java object persistence.

🔹 Why It’s Important in API Automation

• To send Java objects as JSON/XML in the API request (Serialization).

• To read API responses (JSON/XML) and map them back to Java POJOs for validation (Deserialization).

• Makes tests type-safe, clean, and maintainable.

🔹 Commonly Used Libraries in Java

✅ Rest Assured uses Jackson by default if it’s on the classpath.

🔹 Universal Example (Works with Rest Assured or Plain Java)

Step 1: Create a POJO class

public class User {
    private String name;
    private int age;
    private String email;

    // Getters and Setters
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }

    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

Step 2: Serialization (Object → JSON) using Jackson

import com.fasterxml.jackson.databind.ObjectMapper;

User user = new User();
user.setName("Nini");
user.setAge(25);
user.setEmail("nini@test.com");

ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(user);   // ✅ Java → JSON
System.out.println(json);

Output:

{"name":"Nini","age":25,"email":"nini@test.com"}

Step 3: Deserialization (JSON → Object)

String jsonString = "{\"name\":\"Nini\",\"age\":25,\"email\":\"nini@test.com\"}";

User userObj = mapper.readValue(jsonString, User.class);  // ✅ JSON → Java
System.out.println(userObj.getEmail());

Step 4: Using in Rest Assured

Serialization (sending Java object as body):

given()
    .contentType("application/json")
    .body(user)    // Rest Assured automatically serializes using Jackson
.when()
    .post("/createUser")
.then()
    .statusCode(201);

Deserialization (converting response to POJO):

User userResponse = 
    given()
        .get("/getUser/101")
    .then()
        .extract()
        .as(User.class);   // Rest Assured uses Jackson to deserialize

🔹 Advanced Notes for Interviews

🔹 Common Interview Questions and Universal Answers

✅ In short (Universal 2-line Interview Answer):

“Serialization is converting a Java object into JSON or XML so it can be sent to an API, and Deserialization is converting JSON or XML back into a Java object. In Rest Assured, this happens automatically using Jackson or Gson libraries, which helps in sending clean requests and validating structured responses.”

fgdfgfdgdfgnfdvdg

dfgfdgdf

g

dfgdfg

dfg

gdfgdg

dg

dgd

g

g

dgdg

d

dgdgd

g

Lets Assume as a tool that allows you to act like a browser or mobile app, but from your test scripts — so you can send API calls, receive responses, and verify them.

Key Points

• Purpose → Automates testing of REST APIs.

• Language → Java (can also be used in Kotlin, Groovy, etc.).

• Integration → Works well with TestNG, JUnit, Maven, and Jenkins.

• Data formats supported → JSON, XML, HTML, and plain text.

• Assertions → Built-in BDD-style syntax (given-when-then) and Hamcrest matchers for validation.

Why QA & Automation Testers Use It

1. No need to manually create HttpURLConnection or HttpClient code.

2. Supports BDD-style syntax → given().when().then() makes scripts easy to read.

3. Can send requests with:

   • Query parameters

   • Path parameters

   • Headers

   • Cookies

   • Request body (JSON, XML, POJO)

4. Can validate:

   • Status codes

   • Response time

   • Headers

   • JSON/XML values

5. Can handle authentication (Basic, OAuth, etc.).

Before going Deep we need to know some of concept Below

• Static import

• Method chaining

• RestAssured Class Daigram

Static import in java

Java introduced the static import in JDK 1.5 . static import allows public and static members, i.e, fields and methods of a class to be used in java code without using specifying the class name.

Copy

import static packageName.ClassName.*;

let’s break down static import in Java with an example, especially in the context of RestAssured.

1️⃣ What is Static Import?

• Normally, when you call a static method or use a static field from another class, you write the class name before it:

Copy

Math.sqrt(16);
System.out.println(Math.PI);

• Static import lets you use them directly without prefixing the class name:

Copy

import static java.lang.Math.sqrt;
import static java.lang.Math.PI;

System.out.println(sqrt(16));
System.out.println(PI);

It basically makes static members look like they are in your own class.

2️⃣ Static Import in RestAssured

In RestAssured, methods like given(), when(), then(), get(), and matchers like equalTo() are static methods in their classes.

Without static import:

Copy

import io.restassured.RestAssured;
import org.hamcrest.Matchers;

RestAssured.given()
    .when().get("https://reqres.in/api/users/2")
    .then().statusCode(200)
    .body("data.first_name", Matchers.equalTo("Janet"));

With static import:

Copy

import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;

given()
    .when().get("https://reqres.in/api/users/2")
    .then().statusCode(200)
    .body("data.first_name", equalTo("Janet"));

✅ Benefits:

• Cleaner & shorter code

• More readable in BDD-style API tests

• Matches natural language style:
  given() → when() → then()

3️⃣ Full Working Example

Copy

import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;

public class StaticImportExample {
    public static void main(String[] args) {
        given()
            .baseUri("https://reqres.in")
        .when()
            .get("/api/users/2")
        .then()
            .statusCode(200)
            .body("data.first_name", equalTo("Janet"));
    }
}

Explanation:

• given() → Set up request (base URI, params, headers).

• when() → Send request (GET, POST, PUT, etc.).

• then() → Verify the response.

Method Chaining in java.

Suppose there is a java class and it contains 3 static/non-static methods and we call each method as below.

Copy

A a1 = new A();

a1.a().b().c();

NOTE: To acheive method chaining

1. A method return type should not void.

2. A method can return current class object.

3. A method can return other class object as well.

4. A method can return other interface reference object as well .

Advantage of method chaining is the code optimization.

Rest Assured Class Architecture

🧩 Core Components of RestAssured

1. RestAssured (Class)

• Role: Serves as the entry point for initiating API requests.

• Key Methods:

  • given(): Prepares a new request specification.

  • when(): Specifies the HTTP method to be executed.

  • then(): Validates the response and provides assertion methods.

  • baseUri(), basePath(), port(): Set global configurations for the API base URI, path, and port.

  • auth(): Configures authentication mechanisms.

  • proxy(): Sets up proxy configurations.

  • config(): Allows customization of the RestAssured configuration.

2. RequestSpecification (Interface)

• Role: Defines the structure and configuration of an HTTP request.

• Key Methods:

  • header(), queryParam(), formParam(): Add headers and parameters to the request.

  • body(): Sets the request body.

  • auth(): Configures authentication for the request.

  • config(): Sets specific configurations for this request.

  • spec(): Allows reuse of existing request specifications.

3. RequestSender (Interface)

• Role: Represents the action of sending an HTTP request.

• Key Methods:

  • get(), post(), put(), delete(), patch(): Execute the corresponding HTTP methods.

  • then(): Returns a Response object for further validation.

4. Response (Interface)

• Role: Represents the HTTP response received after executing a request.

• Key Methods:

  • getStatusCode(), getBody(), getHeader(): Retrieve status code, body, and headers from the response.

  • jsonPath(), xmlPath(): Parse the response body as JSON or XML.

  • then(): Returns a ValidatableResponse for assertions.

5. ValidatableResponse (Interface)

• Role: Provides methods to validate and assert the response.

• Key Methods:

  • statusCode(), body(), header(): Assert specific aspects of the response.

  • log(): Logs the response for debugging purposes.

  • extract(): Extracts data from the response for further use.

6. AuthenticationSpecification (Interface)

• Role: Defines methods for configuring authentication mechanisms.

• Key Methods:

  • basic(), certificate(), oauth2(): Configure different authentication methods.

  • preemptive(): Sets up preemptive authentication.

7. Filter (Interface)

• Role: Allows interception and modification of requests and responses.

• Key Implementations:

  • RequestLoggingFilter, ResponseLoggingFilter: Log request and response details.

  • AuthenticationFilter: Handles authentication during request execution.

  • LoggingFilter: Provides logging capabilities for requests and responses.

🔄 Method Chaining Flow

RestAssured's design supports method chaining through interfaces that return the same type or compatible types, enabling a fluent API. For example:

Copy

given()
    .baseUri("https://api.example.com")
    .header("Authorization", "Bearer token")
    .body("{ \"name\": \"John\" }")
.when()
    .post("/users")
.then()
    .statusCode(201)
    .body("name", equalTo("John"));

In this example:

• given() returns a RequestSpecification.

• Methods like baseUri(), header(), and body() return the same RequestSpecification, allowing further configuration.

• when() returns a RequestSender.

• post() executes the HTTP POST method and returns a Response.

• then() returns a ValidatableResponse for assertions.

🧩 Summary Table

1️⃣ Overview of RestAssured Class

• Package: io.restassured.RestAssured

• Type: Public class

• Role:
  The RestAssured class is the entry point for creating requests in RestAssured.
  It provides static methods to configure requests, set authentication, base URIs, logging, and more.

2️⃣ Key Static Fields

3️⃣ Key Static Methods

Request Initialization

Configuration Methods

Authentication Methods

Logging & Filters

• filters() – Apply global filters (logging, reporting)

• Common filters:

  • RequestLoggingFilter

  • ResponseLoggingFilter

  • CustomFilter (user-defined)

Example Usage

Copy

import static io.restassured.RestAssured.*;

public class RestAssuredExample {
    public static void main(String[] args) {
        // Global configuration
        baseURI = "https://reqres.in";
        port = 443;
        basePath = "/api";

        // Sending a POST request
        given()
            .header("Content-Type", "application/json")
            .body("{\"name\":\"John\", \"job\":\"Developer\"}")
        .when()
            .post("/users")
        .then()
            .statusCode(201)
            .log().all();
    }
}

Explanation:

• given() – Starts the request specification.

• when().post("/users") – Sends the HTTP POST request.

• then() – Validates the response.

• baseURI, basePath, and port are global static fields of RestAssured.

4️⃣ Internal Architecture of RestAssured Class

1. Static entry points: given(), when(), then()

2. Global configurations: Base URI, base path, port, filters, and authentication.

3. Delegation:

   • given() returns RequestSpecificationImpl

   • when() returns RequestSender

   • then() returns ValidatableResponseImpl

4. Filters & logging are applied either globally (via RestAssured.filters()) or per request (via RequestSpecification.filters()).

✅ Key Points

• RestAssured is a static utility class; you rarely instantiate it.

• Most operations use method chaining starting from given().

• It acts as a facade hiding the internal request/response objects.

• Supports global configuration and per-request customization.

1️⃣ Overview of RequestSpecification

• Package: io.restassured.specification

• Type: Interface

• Role:
  RequestSpecification represents a request configuration in RestAssured.
  It contains headers, query/form parameters, body, cookies, authentication, and more.

• Returned by RestAssured.given() and acts as the starting point for building a request.

2️⃣ Key Methods of RequestSpecification

A. Base Configuration

B. Headers and Cookies

C. Query, Form, Path Parameters

D. Request Body

E. Authentication

F. Logging and Filters

G. Miscellaneous

3️⃣ Example Usage

Copy

import static io.restassured.RestAssured.*;
import io.restassured.specification.RequestSpecification;

public class RequestSpecExample {
    public static void main(String[] args) {
        RequestSpecification request = given()
            .baseUri("https://reqres.in")
            .basePath("/api")
            .header("Content-Type", "application/json")
            .queryParam("page", 2)
            .body("{\"name\":\"John\",\"job\":\"Developer\"}")
            .auth().basic("user", "pass");

        request
            .when().post("/users")
            .then().statusCode(201)
            .log().all();
    }
}

Explanation:

1. given() → Returns RequestSpecification.

2. .baseUri(), .basePath(), .header(), .body() → Configure request.

3. .auth() → Add authentication.

4. request.when().post() → Send request.

5. .then() → Validate response.

4️⃣ Internal Flow

Copy

RestAssured.given() → RequestSpecificationImpl
    └─ Stores all headers, params, body, cookies, authentication
    └─ Can attach filters and logging
    └─ Supports method chaining
RequestSpecification → RequestSender (when()) → Response → ValidatableResponse (then())

5️⃣ Key Points

• RequestSpecification is chainable; most methods return the same object.

• Can be global or reusable by defining a RequestSpecification and passing it via .spec().

• Encapsulates all aspects of an HTTP request: headers, params, body, cookies, authentication, logging.

• Core interface in all RestAssured tests.

1️⃣ Overview of RequestSender

• Package: io.restassured.specification

• Type: Interface

• Role:
  RequestSender is responsible for sending the HTTP request built via RequestSpecification.
  It provides the HTTP method calls like get(), post(), put(), delete(), patch(), etc.

• Typically returned by .when() in RestAssured:

Copy

given()            // RequestSpecification
.when()            // returns RequestSender
    .get("/users") // executes request
.then();           // ValidatableResponse

2️⃣ Key Methods of RequestSender

A. HTTP Methods

All HTTP methods return a Response object.

B. Formatted Requests

• Methods also exist to send requests with dynamic path parameters:

Copy

get("/users/{id}", 2)       // id=2 will replace {id} in path
post("/users/{id}", 3)      // id=3 will replace {id} in path

• This supports path templating.

C. Asynchronous and Specialized Requests

• Some versions/extensions of RestAssured support async requests using async() (advanced usage).

• Multipart requests are typically configured via RequestSpecification rather than RequestSender.

3️⃣ Example Usage

Copy

import static io.restassured.RestAssured.*;

public class RequestSenderExample {
    public static void main(String[] args) {
        given()
            .baseUri("https://reqres.in")
            .basePath("/api")
            .queryParam("page", 2)
        .when()
            .get("/users")  // RequestSender executes GET
        .then()
            .statusCode(200)
            .log().all();
    }
}

Flow Explained:

1. given() → Returns RequestSpecification.

2. .when() → Returns RequestSender.

3. .get("/users") → Sends HTTP GET, returns Response.

4. .then() → Converts Response to ValidatableResponse for assertions.

4️⃣ Internal Flow

Copy

RequestSpecification → when() → RequestSender
    └─ Executes HTTP request via Apache HttpClient / Java HTTP client
    └─ Applies headers, body, params, cookies, filters
    └─ Returns Response
Response → then() → ValidatableResponse

5️⃣ Key Points

• RequestSender is stateless; it simply executes the request built by RequestSpecification.

• Supports all HTTP methods (GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS).

• Integrates path parameters and query parameters during execution.

• Works with filters, authentication, and logging applied in RequestSpecification.

If you want, I can prepare a full RestAssured architecture diagram showing RequestSpecification → RequestSender → Response → ValidatableResponse, including filters and authentication flow — it’s perfect for interview prep.

1️⃣ Overview of Response

• Package: io.restassured.response

• Type: Interface

• Role:
  Response encapsulates all the information received from the server after an HTTP request.
  It provides methods to access status codes, headers, cookies, body content, and allows parsing JSON/XML responses.

• Returned by RequestSender methods like get(), post(), put(), delete(), etc.

Copy

Response response = given()
                        .baseUri("https://reqres.in")
                        .basePath("/api")
                    .when()
                        .get("/users/2");

2️⃣ Key Methods of Response

A. Status and Line

B. Headers

C. Cookies

D. Response Body

E. JSON/XML Parsing

Example:

Copy

String firstName = response.jsonPath().getString("data.first_name");
String lastName = response.jsonPath().getString("data.last_name");

F. Validations

• then() → Converts Response into ValidatableResponse for assertions.

• Example:

Copy

response.then().statusCode(200).body("data.id", equalTo(2));

G. Miscellaneous

3️⃣ Example Usage

Copy

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

public class ResponseExample {
    public static void main(String[] args) {
        Response response = given()
                                .baseUri("https://reqres.in")
                                .basePath("/api")
                            .when()
                                .get("/users/2");

        // Status and headers
        System.out.println(response.getStatusCode());
        System.out.println(response.getHeader("Content-Type"));

        // Body as string
        System.out.println(response.asString());

        // Extract JSON value
        String firstName = response.jsonPath().getString("data.first_name");
        System.out.println(firstName);

        // Validatable
        response.then().statusCode(200).body("data.id", equalTo(2));
    }
}

4️⃣ Internal Flow

Copy

RequestSpecification → RequestSender (when()) → Response
    └─ Captures HTTP status code, headers, cookies, body
    └─ Provides methods for parsing (JSON, XML)
    └─ Supports logging and validation via then()

5️⃣ Key Points

• Response is immutable; it reflects the server’s returned data.

• Works seamlessly with JSON/XML parsing, POJO deserialization, and GPath expressions.

• Enables method chaining by converting into ValidatableResponse.

• Supports both raw data access (asString(), asByteArray()) and structured access (jsonPath(), xmlPath()).

If you want, I can continue with a detailed deep dive into ValidatableResponse next, completing the RestAssured core interface chain from RequestSpecification → RequestSender → Response → ValidatableResponse.

1️⃣ Overview of ValidatableResponse

• Package: io.restassured.response

• Type: Interface

• Role:
  ValidatableResponse represents a response after execution that can be validated/asserted.
  It is returned by Response.then() and supports method chaining for fluent assertions.

Copy

ValidatableResponse validatable = 
    given().when().get("/users/2").then();

2️⃣ Key Methods of ValidatableResponse

A. Status Code & Line Validation

Example:

Copy

response.then().statusCode(200).statusLine("HTTP/1.1 200 OK");

B. Header Validation

C. Body Validation

Example:

Copy

response.then()
        .body("data.id", equalTo(2))
        .body("data.first_name", equalTo("Janet"));

D. Cookie Validation

E. Logging

F. Extracting Data

• extract() returns ExtractableResponse<Response> to extract data for later use.

• Example:

Copy

String firstName = response.then()
                           .extract()
                           .path("data.first_name");

G. Advanced Validation

• Supports Hamcrest matchers for complex assertions:

Copy

response.then()
        .body("data.id", allOf(greaterThan(0), lessThan(10)))
        .body("data.first_name", startsWith("J"));

• Supports multiple path assertions in a single call.

3️⃣ Example Usage

Copy

import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;

public class ValidatableResponseExample {
    public static void main(String[] args) {
        given()
            .baseUri("https://reqres.in")
            .basePath("/api")
        .when()
            .get("/users/2")
        .then()
            .statusCode(200)
            .contentType("application/json; charset=utf-8")
            .body("data.id", equalTo(2))
            .body("data.first_name", equalTo("Janet"))
            .log().all();
    }
}

Explanation:

• then() → Converts Response into ValidatableResponse.

• .statusCode(), .body() → Validate status code and response body.

• .log().all() → Logs response details.

4️⃣ Internal Flow

Copy

RequestSpecification → RequestSender → Response → then() → ValidatableResponse
    └─ Provides assertion methods
    └─ Supports logging
    └─ Allows extraction for further processing

5️⃣ Key Points

• ValidatableResponse is immutable and chainable.

• Supports status, headers, body, cookies, and content-type validation.

• Works seamlessly with Hamcrest matchers for flexible and readable assertions.

• .extract() allows you to reuse response data for subsequent requests or assertions.

• Usually the last step in RestAssured chain for validation.

✅ After this, we have fully covered the RestAssured core chain:

Copy

RequestSpecification → RequestSender → Response → ValidatableResponse

1️⃣ Overview of ResponseSpecification

• Package: io.restassured.specification

• Type: Interface

• Role:
  ResponseSpecification defines reusable response expectations.
  Instead of writing the same assertions repeatedly, you can define a response specification and reuse it across multiple requests.

Copy

ResponseSpecification responseSpec = new ResponseSpecBuilder()
                                        .expectStatusCode(200)
                                        .expectContentType("application/json")
                                        .build();

• Returned by Response.then() after applying a ResponseSpecification.

2️⃣ Key Methods

A. Status & Headers

B. Body Validation

C. Cookies

D. Miscellaneous

3️⃣ Example Usage

Copy

import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;
import io.restassured.builder.ResponseSpecBuilder;
import io.restassured.specification.ResponseSpecification;

public class ResponseSpecExample {
    public static void main(String[] args) {
        // Define a reusable response specification
        ResponseSpecification responseSpec = new ResponseSpecBuilder()
            .expectStatusCode(200)
            .expectContentType("application/json; charset=utf-8")
            .expectBody("data.id", equalTo(2))
            .build();

        // Use it in a request
        given()
            .baseUri("https://reqres.in")
            .basePath("/api")
        .when()
            .get("/users/2")
        .then()
            .spec(responseSpec)
            .log().all();
    }
}

Explanation:

• ResponseSpecBuilder → Builds a reusable ResponseSpecification.

• .expectStatusCode(), .expectBody() → Define assertions.

• .spec(responseSpec) → Applies specification to the current response.

• .log().all() → Logs the validated response.

4️⃣ Benefits of ResponseSpecification

1. Reusability: Define common expectations once, use in multiple tests.

2. Readability: Keeps test code clean.

3. Maintainability: Update the spec once, all tests using it reflect changes.

4. Integration with ValidatableResponse: Applied via .spec() after then().

5️⃣ Flow in RestAssured Chain

Copy

RequestSpecification → RequestSender → Response → then() → ValidatableResponse
                                                                │
                                                                └─ spec(ResponseSpecification)

• ResponseSpecification is not mandatory, but it’s great for reusable validations.

1️⃣ Overview of ResponseSpecification

• Package: io.restassured.specification

• Type: Interface

• Role:
  ResponseSpecification defines reusable response expectations.
  Instead of writing the same assertions repeatedly, you can define a response specification and reuse it across multiple requests.

Copy

ResponseSpecification responseSpec = new ResponseSpecBuilder()
                                        .expectStatusCode(200)
                                        .expectContentType("application/json")
                                        .build();

• Returned by Response.then() after applying a ResponseSpecification.

2️⃣ Key Methods

A. Status & Headers

B. Body Validation

C. Cookies

D. Miscellaneous

3️⃣ Example Usage

Copy

import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;
import io.restassured.builder.ResponseSpecBuilder;
import io.restassured.specification.ResponseSpecification;

public class ResponseSpecExample {
    public static void main(String[] args) {
        // Define a reusable response specification
        ResponseSpecification responseSpec = new ResponseSpecBuilder()
            .expectStatusCode(200)
            .expectContentType("application/json; charset=utf-8")
            .expectBody("data.id", equalTo(2))
            .build();

        // Use it in a request
        given()
            .baseUri("https://reqres.in")
            .basePath("/api")
        .when()
            .get("/users/2")
        .then()
            .spec(responseSpec)
            .log().all();
    }
}

Explanation:

• ResponseSpecBuilder → Builds a reusable ResponseSpecification.

• .expectStatusCode(), .expectBody() → Define assertions.

• .spec(responseSpec) → Applies specification to the current response.

• .log().all() → Logs the validated response.

4️⃣ Benefits of ResponseSpecification

1. Reusability: Define common expectations once, use in multiple tests.

2. Readability: Keeps test code clean.

3. Maintainability: Update the spec once, all tests using it reflect changes.

4. Integration with ValidatableResponse: Applied via .spec() after then().

5️⃣ Flow in RestAssured Chain

Copy

RequestSpecification → RequestSender → Response → then() → ValidatableResponse
                                                                │
                                                                └─ spec(ResponseSpecification)

• ResponseSpecification is not mandatory, but it’s great for reusable validations.

1️⃣ Overview of ResponseSpecBuilder

• Package: io.restassured.builder

• Type: Class

• Role:
  ResponseSpecBuilder helps you create reusable ResponseSpecification objects.
  Instead of writing the same assertions for multiple tests, you define them once with a builder.

Copy

ResponseSpecification responseSpec = new ResponseSpecBuilder()
                                        .expectStatusCode(200)
                                        .expectContentType("application/json")
                                        .build();

• build() → Returns a ResponseSpecification object.

2️⃣ Key Methods of ResponseSpecBuilder

A. Status and Line

B. Headers

C. Body Validation

D. Cookies

E. Logging

F. Build

3️⃣ Example Usage

Copy

import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;
import io.restassured.builder.ResponseSpecBuilder;
import io.restassured.specification.ResponseSpecification;

public class ResponseSpecBuilderExample {
    public static void main(String[] args) {
        // Build reusable response specification
        ResponseSpecification responseSpec = new ResponseSpecBuilder()
            .expectStatusCode(200)
            .expectContentType("application/json; charset=utf-8")
            .expectBody("data.id", equalTo(2))
            .build();

        // Apply the response spec in a request
        given()
            .baseUri("https://reqres.in")
            .basePath("/api")
        .when()
            .get("/users/2")
        .then()
            .spec(responseSpec)   // Apply reusable spec
            .log().all();
    }
}

Explanation:

• ResponseSpecBuilder → Define common response expectations once.

• .build() → Returns ResponseSpecification.

• .spec(responseSpec) → Apply the specification to a response.

4️⃣ Benefits

1. Reusability: Define common response validations once and reuse.

2. Readability: Keeps test code clean and avoids repeated assertions.

3. Maintainability: Update the spec once, all tests reflect changes.

4. Supports Method Chaining: Fluent API for building complex validation rules.

✅ After this, we have covered all builders in RestAssured:

Copy

RequestSpecBuilder → RequestSpecification → RequestSender → Response → ValidatableResponse → ResponseS

1️⃣ Overview of AuthenticationScheme

• Package: io.restassured.authentication

• Type: Interface

• Role:
  AuthenticationScheme is the base interface for all authentication types in RestAssured.
  It allows RequestSpecification to set authentication when sending requests.

• Implemented by classes like:

  • BasicAuthScheme → Basic Authentication

  • DigestAuthScheme → Digest Authentication

  • OAuth2Scheme → OAuth2 Authentication

  • PreemptiveBasicAuthScheme → Preemptive Basic Auth

• Typically used via RequestSpecification.auth():

Copy

given().auth().basic("username", "password");

Internally, basic() creates a BasicAuthScheme object implementing AuthenticationScheme.

2️⃣ Key Methods of AuthenticationScheme

Note: Exact methods depend on the implementing class. The interface ensures any authentication scheme can be applied to a request.

3️⃣ Common Implementations

A. BasicAuthScheme

• Implements AuthenticationScheme.

• Adds Basic HTTP authentication header.

Copy

given().auth().basic("user", "pass");

B. DigestAuthScheme

• Implements AuthenticationScheme.

• Handles Digest authentication challenge-response.

Copy

given().auth().digest("user", "pass");

C. OAuth2Scheme

• Implements AuthenticationScheme.

• Adds Bearer token to Authorization header.

Copy

given().auth().oauth2("token");

D. PreemptiveBasicAuthScheme

• Implements AuthenticationScheme.

• Sends Basic Auth header immediately without waiting for server challenge.

Copy

given().auth().preemptive().basic("user", "pass");

4️⃣ Usage Example

Copy

import static io.restassured.RestAssured.*;

public class AuthenticationExample {
    public static void main(String[] args) {
        given()
            .baseUri("https://reqres.in")
            .basePath("/api")
            .auth().basic("user", "pass")   // BasicAuthScheme applied
        .when()
            .get("/users/2")
        .then()
            .statusCode(200)
            .log().all();
    }
}

Explanation:

1. auth().basic() → Creates a BasicAuthScheme.

2. AuthenticationScheme.authenticate() → Internally adds header to the request.

3. Request is executed with authentication.

5️⃣ Key Points

• AuthenticationScheme is an interface, so new authentication types can be added.

• Used by RequestSpecification to apply authentication before sending requests.

• Supports multiple types:

  • Basic

  • Digest

  • OAuth1/OAuth2

  • Preemptive authentication

• Works seamlessly with RequestSpecBuilder or RequestSpecification for reusable authentication.

If you want, I can now create a complete UML class/interface diagram for RestAssured showing:

Copy

RestAssured → RequestSpecification → RequestSender → Response → ValidatableResponse → ResponseSpecification
+ RequestSpecBuilder, ResponseSpecBuilder
+ AuthenticationScheme → Basic/Digest/OAuth
+ Filters & Logging

Sample Test Using Method chaining.

Before static import»»»

Copy

package sampleTest;

import org.testng.annotations.Test;

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

public class SampleTsetUsingMethodChaning {
    @Test
    public static void getAllEmployeesAvailable() {

    Response resp = RestAssured.get("http://49.249.28.218:8091/all-employees");
    resp.prettyPeek();
    }

}

Here we use the class name to use the get() method.

After static import»»»

Copy

package sampleTest;

import static io.restassured.RestAssured.*;

import org.testng.annotations.Test;

public class SampleTsetUsingMethodChaning2 {
    @Test
    public static void getAllEmployeesAvailable() {

    get("http://49.249.28.218:8091/all-employees")
    .prettyPeek();
    }

}

Here we not using the class name as reference ,this is the magic of static import.

ok