API-First with OpenAPI

        OpenAPIControllersPlugin {
            openapiFile "src/main/resources/public/apis/openapi.yml"
        }

/**
 * REST controller for CustomerApi.
 */
@RestController
@RequestMapping("/api")
public class CustomerApiController implements CustomerApi {

    private final Logger log = LoggerFactory.getLogger(getClass());

    @Autowired
    private NativeWebRequest request;


    private CustomerService customerService;

    @Autowired
    public CustomerApiController setCustomerService(CustomerService customerService) {
        this.customerService = customerService;
        return this;
    }


    private CustomerDTOsMapper mapper = CustomerDTOsMapper.INSTANCE;

    public CustomerApiController(CustomerService customerService) {

        this.customerService = customerService;

    }

    public Optional<NativeWebRequest> getRequest() {
        return Optional.ofNullable(request);
    }


    @Override
    public ResponseEntity<CustomerDTO> createCustomer(CustomerDTO reqBody) {
        log.debug("REST request to createCustomer: {}", reqBody);
        var input = mapper.asCustomer(reqBody);
        var customer = customerService.createCustomer(input);
        CustomerDTO responseDTO = mapper.asCustomerDTO(customer);
        return ResponseEntity.status(201).body(responseDTO);
    }

    @Override
    public ResponseEntity<CustomerDTO> getCustomer(Long id) {
        log.debug("REST request to getCustomer: {}", id);
        var customer = customerService.getCustomer(id);
        if (customer.isPresent()) {
            CustomerDTO responseDTO = mapper.asCustomerDTO(customer.get());
            return ResponseEntity.status(200).body(responseDTO);
        } else {
            return ResponseEntity.notFound().build();
        }
    }

    @Override
    public ResponseEntity<CustomerDTO> updateCustomer(Long id, CustomerDTO reqBody) {
        log.debug("REST request to updateCustomer: {}, {}", id, reqBody);
        var input = mapper.asCustomer(reqBody);
        var customer = customerService.updateCustomer(id, input);
        if (customer.isPresent()) {
            CustomerDTO responseDTO = mapper.asCustomerDTO(customer.get());
            return ResponseEntity.status(200).body(responseDTO);
        } else {
            return ResponseEntity.notFound().build();
        }
    }

    @Override
    public ResponseEntity<Void> deleteCustomer(Long id) {
        log.debug("REST request to deleteCustomer: {}", id);
        customerService.deleteCustomer(id);
        return ResponseEntity.status(204).build();
    }

    @Override
    public ResponseEntity<CustomerPaginatedDTO> searchCustomers(Integer page, Integer limit, List<String> sort, CustomerSearchCriteriaDTO reqBody) {
        log.debug("REST request to searchCustomers: {}, {}, {}, {}", page, limit, sort, reqBody);
        var input = mapper.asCustomerSearchCriteria(reqBody);
        var customerPage = customerService.searchCustomers(input, pageOf(page, limit, sort));
        var responseDTO = mapper.asCustomerPaginatedDTO(customerPage);
        return ResponseEntity.status(200).body(responseDTO);
    }

    protected Pageable pageOf(Integer page, Integer limit, List<String> sort) {
        Sort sortOrder = sort != null ? Sort.by(sort.stream().map(sortParam -> {
            String[] parts = sortParam.split(":");
            String property = parts[0];
            Sort.Direction direction = parts.length > 1 ? Sort.Direction.fromString(parts[1]) : Sort.Direction.ASC;
            return new Sort.Order(direction, property);
        }).toList()) : Sort.unsorted();
        return PageRequest.of(page != null ? page : 0, limit != null ? limit : 10, sortOrder);
    }
}

        SpringWebTestClientPlugin {
            openapiFile "src/main/resources/public/apis/openapi.yml"
        }

    @Test
    void testCreateCustomer_201() {
        var requestBody = """
                {
                  "email": "jane.doe@example.com",
                  "name": "Jane Doe",
                  "addresses": [
                    {
                      "city": "Othertown",
                      "street": "456 Elm St"
                    }
                  ],
                  "paymentMethods": [
                    {
                      "type": "VISA",
                      "cardNumber": "6543210987654321"
                    }
                  ]
                }
                """;

        webTestClient.method(POST).uri("/api/customers")
            .accept(MediaType.APPLICATION_JSON)
            .contentType(MediaType.APPLICATION_JSON)
            .bodyValue(requestBody)
            .exchange()
            .expectStatus().isEqualTo(201)
            .expectHeader().contentType(MediaType.APPLICATION_JSON)
            .expectBody()
            .jsonPath("$.id").isNotEmpty()
            .jsonPath("$.version").isNotEmpty()
            .jsonPath("$.name").isNotEmpty()
            .jsonPath("$.email").isNotEmpty()
            .jsonPath("$.addresses").isNotEmpty()
            .jsonPath("$.addresses").isArray()
            .jsonPath("$.addresses[0].street").isNotEmpty()
            .jsonPath("$.addresses[0].city").isNotEmpty()
            .jsonPath("$.paymentMethods").isNotEmpty()
            .jsonPath("$.paymentMethods").isArray()
            .jsonPath("$.paymentMethods[0].id").isNotEmpty()
            .jsonPath("$.paymentMethods[0].version").isNotEmpty()
            .jsonPath("$.paymentMethods[0].type").isNotEmpty()
            .jsonPath("$.paymentMethods[0].cardNumber").isNotEmpty();
    }

        SpringWebTestClientPlugin {
            openapiFile "src/main/resources/public/apis/openapi.yml"
            groupBy businessFlow
            businessFlowTestName CreateUpdateDeleteCustomerIntegrationTest
            operationIds createCustomer,updateCustomer,deleteCustomer,getCustomer
        }

package io.zenwave360.example.adapters.web;

import io.zenwave360.example.adapters.web.model.CustomerDTO;
import io.zenwave360.example.adapters.web.model.PaymentMethodTypeDTO;
import org.junit.jupiter.api.Test;
import org.springframework.http.MediaType;

import static org.springframework.http.HttpMethod.*;

/**
* Business Flow Test for: createCustomer, getCustomer, updateCustomer, deleteCustomer.
*/
class CreateUpdateDeleteCustomerIntegrationTest extends BaseWebTestClientTest {

    /**
    * Business Flow Test for: createCustomer, getCustomer, updateCustomer, deleteCustomer.
    */
    @Test
    void testCreateUpdateDeleteCustomerIntegrationTest() {
        // createCustomer: createCustomer
        var customerRequestBody0 = """
                {
                  "email": "jane.doe@example.com",
                  "name": "Jane Doe",
                  "addresses": [
                    {
                      "city": "Othertown",
                      "street": "456 Elm St"
                    }
                  ],
                  "paymentMethods": [
                    {
                      "type": "VISA",
                      "cardNumber": "6543210987654321"
                    }
                  ]
                }
                """;

        var createCustomerResponse0 = webTestClient.method(POST).uri("/api/customers")
            .accept(MediaType.APPLICATION_JSON)
            .contentType(MediaType.APPLICATION_JSON)
            .bodyValue(customerRequestBody0)
            .exchange()
            .expectStatus().isEqualTo(201)
            .expectHeader().contentType(MediaType.APPLICATION_JSON)
            .returnResult(CustomerDTO.class);

    
        // getCustomer: getCustomer
        var id = createCustomerResponse0.getResponseBody().blockFirst().getId();

        var getCustomerResponse1 = webTestClient.method(GET).uri("/api/customers/{id}", id)
            .accept(MediaType.APPLICATION_JSON)
            .exchange()
            .expectStatus().isEqualTo(200)
            .expectHeader().contentType(MediaType.APPLICATION_JSON)
            .returnResult(CustomerDTO.class);

    
        // updateCustomer: updateCustomer
        CustomerDTO customerRequestBody2 = getCustomerResponse1.getResponseBody().blockFirst();
        customerRequestBody2.setName("updated");
        customerRequestBody2.setEmail("updated@email.com");
        customerRequestBody2.getPaymentMethods().get(0).setType(PaymentMethodTypeDTO.VISA);

        var updateCustomerResponse2 = webTestClient.method(PUT).uri("/api/customers/{id}", id)
            .accept(MediaType.APPLICATION_JSON)
            .contentType(MediaType.APPLICATION_JSON)
            .bodyValue(customerRequestBody2)
            .exchange()
            .expectStatus().isEqualTo(200)
            .expectHeader().contentType(MediaType.APPLICATION_JSON)
            .returnResult(CustomerDTO.class);

    
        // deleteCustomer: deleteCustomer

        webTestClient.method(DELETE).uri("/api/customers/{id}", id)
            .accept(MediaType.APPLICATION_JSON)
            .exchange()
            .expectStatus().isEqualTo(204);


        // getCustomer: getCustomer (not found)
        webTestClient.method(GET).uri("/api/customers/{id}", id)
                .accept(MediaType.APPLICATION_JSON)
                .exchange()
                .expectStatus().isEqualTo(404);
    }


}

        OpenAPIKaratePlugin {
            openapiFile "src/main/resources/public/apis/openapi.yml"
        }

@openapi-file=src/main/resources/public/apis/openapi.yml
Feature: CustomerApi

Background:
* url baseUrl
# * def auth = { username: '', password: '' }
* def authHeader = call read('classpath:karate-auth.js') auth
* configure headers = authHeader || {}

@operationId=createCustomer
Scenario: createCustomer

Given path '/customers'
And request
"""
{
  "name" : "name-iv8wf61cpxe13fa3j0",
  "email" : "kraig.hermann@gmail.com",
  "addresses" : [ {
    "street" : "street-wivpwm357mj4r1",
    "city" : "Connellyside"
  } ],
  "paymentMethods" : [ {
    "type" : "VISA",
    "cardNumber" : "cardNumber-ydvoeke77t3z"
  } ]
}
"""
When method post
Then status 201
* def createCustomerResponse = response
* def customerId = response.id
# TODO: Add response validation


@operationId=getCustomer
Scenario: getCustomer

* def pathParams = { id: 53 }
Given path '/customers/', pathParams.id
When method get
Then status 200
* def getCustomerResponse = response
* def customerId = response.id
# TODO: Add response validation


@operationId=updateCustomer
Scenario: updateCustomer

* def pathParams = { id: 53 }
Given path '/customers/', pathParams.id
And request
"""
{
  "name" : "name-t58rqm1n6zb",
  "email" : "reta.wiza@gmail.com",
  "addresses" : [ {
    "street" : "street-e2pn9ih8t7du14h93",
    "city" : "East Genesis"
  } ],
  "paymentMethods" : [ {
    "type" : "MASTERCARD",
    "cardNumber" : "cardNumber-qx3ag249vxzjgkh"
  } ]
}
"""
When method put
Then status 200
* def updateCustomerResponse = response
* def customerId = response.id
# TODO: Add response validation


@operationId=deleteCustomer
Scenario: deleteCustomer

* def pathParams = { id: 89 }
Given path '/customers/', pathParams.id
When method delete
Then status 204
* def deleteCustomerResponse = response
# TODO: Add response validation


@operationId=searchCustomers
Scenario: searchCustomers

Given path '/customers/search'
And def queryParams = { page: 71, limit: 20, sort: ['name:asc'] }
And request
"""
{
  "name" : "name-xrx9m9s1",
  "email" : "tyron.heidenreich@yahoo.co",
  "city" : "Bellamouth",
  "state" : "state-y1x18r2h"
}
"""
When method post
Then status 201
* def searchCustomersResponse = response
* def customerPaginatedId = response.id
# TODO: Add response validation

        OpenAPIKaratePlugin {
            openapiFile "src/main/resources/public/apis/openapi.yml"
            groupBy businessFlow
            businessFlowTestName CreateUpdateDeleteCustomerKarateTest
            operationIds createCustomer,updateCustomer,deleteCustomer,getCustomer
        }

@openapi-file=src/main/resources/public/apis/openapi.yml
Feature: CreateUpdateDeleteCustomerKarateTest

Background:
* url baseUrl
# * def auth = { username: '', password: '' }
* def authHeader = call read('classpath:karate-auth.js') auth
* configure headers = authHeader || {}

@business-flow
@operationId=createCustomer,updateCustomer,deleteCustomer,getCustomer
Scenario: CreateUpdateDeleteCustomerKarateTest

# createCustomer
Given path '/customers'
And request
"""
{
  "id" : 21,
  "version" : 13,
  "name" : "name-5ugq20772n1",
  "email" : "rosaria.hyatt@gmail.com",
  "addresses" : [ {
    "street" : "street-z",
    "city" : "West Edmundbury"
  } ],
  "paymentMethods" : [ {
    "id" : 37,
    "version" : 10,
    "type" : "MASTERCARD",
    "cardNumber" : "cardNumber-9c2xzm77ig5"
  } ]
}
"""
When method post
Then status 201
* def createCustomerResponse = response
* def customerId = response.id
# TODO: Add response validation


# updateCustomer
* def pathParams = { id: 2 }
Given path '/customers/', pathParams.id
And request
"""
{
  "id" : 79,
  "version" : 7,
  "name" : "name-mu8j1eqcaoy2a7ex9uup1",
  "email" : "jerica.emmerich@hotmail.co",
  "addresses" : [ {
    "street" : "street-7ug0jz4c5ghumuz2yst",
    "city" : "Sydneychester"
  } ],
  "paymentMethods" : [ {
    "id" : 30,
    "version" : 82,
    "type" : "MASTERCARD",
    "cardNumber" : "cardNumber-f"
  } ]
}
"""
When method put
Then status 200
* def updateCustomerResponse = response
* def customerId = response.id
# TODO: Add response validation


# deleteCustomer
* def pathParams = { id: 42 }
Given path '/customers/', pathParams.id
When method delete
Then status 204
* def deleteCustomerResponse = response
# TODO: Add response validation


# getCustomer
* def pathParams = { id: 71 }
Given path '/customers/', pathParams.id
When method get
Then status 404
* def getCustomerResponse = response
* def customerId = response.id
# TODO: Add response validation