How to build Framework for Api Automation using RestAssured with Lombok

Certainly! Here's an example of a framework for API automation using RestAssured with Lombok. Lombok helps reduce boilerplate code by generating getters, setters, constructors, and other common methods automatically:

1. Project Structure:

- src
  - main
    - java
      - com.example.api
        - tests
          - APITest.java
        - data
          - TestData.java
        - utils
          - APIUtils.java
          - AssertionUtils.java
  - test
    - java
      - com.example.api
        - config
          - TestConfig.java
        - reports
          - ExtentReportListener.java

2. Dependencies:

Add the necessary dependencies to your project's build configuration. In addition to the dependencies mentioned earlier, you'll need to include Lombok as well. Here are the dependencies required for this framework:

- RestAssured

- TestNG

- ExtentReports (for reporting)

- Gson or Jackson (for JSON serialization/deserialization)

- Log4j (for logging)

- Lombok

3. Test Configuration:

Create a `TestConfig` class that sets up RestAssured and provides common configuration settings for your tests, such as base URI, base path, authentication, headers, etc.

package com.example.api.config;

import io.restassured.RestAssured;

public class TestConfig {

    public static void setup() {
        RestAssured.baseURI = "https://api.example.com";
        RestAssured.basePath = "/api";
        
        // Other configurations like authentication, headers, etc.
    }
}

4. Test Data:

Create a `TestData` class to manage test data for your API tests. This class can contain Lombok annotations for automatic generation of getters, setters, and constructors.

package com.example.api.data;

import lombok.Data;

@Data
public class TestData {

    private String userId;
    
    // Other test data variables
}

5. Test Utilities:

Create utility classes to handle common tasks in your API tests. For example, `APIUtils` can handle API request and response operations, while `AssertionUtils` can provide reusable assertion methods.

package com.example.api.utils;

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

public class APIUtils {

    public static Response getRequest(String endpoint) {
        return RestAssured.given()
                .get(endpoint);
    }
    
    // Other utility methods for different types of requests (POST, PUT, DELETE)
}

package com.example.api.utils;

import org.testng.Assert;

public class AssertionUtils {

    public static void assertStatusCode(int actualStatusCode, int expectedStatusCode) {
        Assert.assertEquals(actualStatusCode, expectedStatusCode, "Status code mismatch");
    }
    
    // Other assertion methods for response validation
}

6. Test Cases:

Create individual test classes to define your API test cases using TestNG annotations. Each test class should have methods representing different test scenarios.

package com.example.api.tests;

import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
import com.example.api.config.TestConfig;
import com.example.api.data.TestData;
import com.example.api.utils.APIUtils;
import com.example.api.utils.AssertionUtils;

public class APITest {

    @BeforeClass
    public void setup() {
        TestConfig.setup();
    }

    @Test
    public void getUserDetails() {
        TestData testData = new TestData();
        testData.setUserId("12345");
        
        String endpoint = "/users/" + testData.getUserId();
        
        // Make the API request
        Response response = APIUtils.getRequest(endpoint);
        
        // Perform assertions
        AssertionUtils.assertStatusCode(response.getStatusCode

(), 200);
        
        // Validate response body, headers, etc.
        // AssertionUtils.assertResponseBody(response.getBody(), expectedData);
    }
    
    // Other test methods for different scenarios
}

By using Lombok annotations like `@Data` in the `TestData` class, you can avoid writing boilerplate code for getters, setters, and constructors. Lombok will automatically generate those methods for you.

This framework provides a modular structure for API automation using RestAssured with the added benefit of Lombok to reduce boilerplate code. You can expand upon it by adding more test cases, utilities, and configurations as per your requirements.