Cucumber with Rest Assured for API BDD

@api
Feature: User Management API
 
  Background:
    Given the API is available at the base URL
 
  @smoke
  Scenario: Create a new user successfully
    When I send a POST request to "/users" with:
      | name  | Alice Smith    |
      | email | alice@test.com |
      | role  | admin          |
    Then the response status code should be 201
    And the response should contain field "id"
    And the response field "name" should equal "Alice Smith"
 
  Scenario: Get a user by ID
    Given a user exists with name "Bob" and email "bob@test.com"
    When I send a GET request to "/users/{userId}"
    Then the response status code should be 200
    And the response field "name" should equal "Bob"
 
  Scenario: Delete a user
    Given a user exists with name "Carol" and email "carol@test.com"
    When I send a DELETE request to "/users/{userId}"
    Then the response status code should be 204

public class TestContext {
    // ... existing driver, authToken fields ...
    private Response lastResponse;
    private String lastCreatedId;
 
    public Response getLastResponse() { return lastResponse; }
    public void setLastResponse(Response response) { this.lastResponse = response; }
 
    public String getLastCreatedId() { return lastCreatedId; }
    public void setLastCreatedId(String id) { this.lastCreatedId = id; }
}

package stepdefinitions;
 
import context.TestContext;
import io.cucumber.datatable.DataTable;
import io.cucumber.java.en.And;
import io.cucumber.java.en.Given;
import io.cucumber.java.en.Then;
import io.cucumber.java.en.When;
import io.restassured.http.ContentType;
import io.restassured.response.Response;
 
import java.util.Map;
import static io.restassured.RestAssured.*;
import static org.junit.jupiter.api.Assertions.*;
 
public class UserApiSteps {
    private final TestContext context;
 
    public UserApiSteps(TestContext context) {
        this.context = context;
    }
 
    @Given("the API is available at the base URL")
    public void apiIsAvailable() {
        baseURI = System.getProperty("apiBaseUrl", "https://reqres.in/api");
    }
 
    @When("I send a POST request to {string} with:")
    public void postWithBody(String endpoint, DataTable dataTable) {
        Map<String, String> body = dataTable.asMap();
        Response response = given()
            .contentType(ContentType.JSON)
            .body(body)
        .when()
            .post(endpoint);
        context.setLastResponse(response);
        if (response.getStatusCode() == 201) {
            context.setLastCreatedId(response.jsonPath().getString("id"));
        }
    }
 
    @When("I send a GET request to {string}")
    public void getRequest(String endpoint) {
        String resolvedPath = endpoint.replace("{userId}", context.getLastCreatedId());
        Response response = given()
        .when()
            .get(resolvedPath);
        context.setLastResponse(response);
    }
 
    @When("I send a DELETE request to {string}")
    public void deleteRequest(String endpoint) {
        String resolvedPath = endpoint.replace("{userId}", context.getLastCreatedId());
        Response response = given()
        .when()
            .delete(resolvedPath);
        context.setLastResponse(response);
    }
 
    @Given("a user exists with name {string} and email {string}")
    public void createUserForTest(String name, String email) {
        Response response = given()
            .contentType(ContentType.JSON)
            .body(Map.of("name", name, "email", email))
        .when()
            .post("/users");
        context.setLastCreatedId(response.jsonPath().getString("id"));
    }
 
    @Then("the response status code should be {int}")
    public void verifyStatusCode(int expected) {
        assertEquals(expected, context.getLastResponse().getStatusCode(),
            "Unexpected status code. Body: " + context.getLastResponse().getBody().asString());
    }
 
    @And("the response should contain field {string}")
    public void responseContainsField(String fieldName) {
        assertNotNull(context.getLastResponse().jsonPath().get(fieldName),
            "Field '" + fieldName + "' was not found in response: "
            + context.getLastResponse().getBody().asString());
    }
 
    @And("the response field {string} should equal {string}")
    public void responseFieldEquals(String field, String expected) {
        String actual = context.getLastResponse().jsonPath().getString(field);
        assertEquals(expected, actual,
            "Field '" + field + "' expected '" + expected + "' but was '" + actual + "'");
    }
}

@ui @api
Scenario: User created via API appears in the admin dashboard
  Given a user is created via API with name "Alice" and email "alice@test.com"
  When the admin navigates to the user management page
  Then "Alice" should appear in the user list