Spring Cloud Contract Testing Example: A Guide for Developers
If you are a developer who works with microservices, you are likely familiar with the challenges of creating and maintaining contracts between different services. Testing these contracts can be time-consuming and error-prone. That`s where Spring Cloud Contract comes in. This framework allows you to create and test contracts between microservices easily and efficiently.
In this article, we will provide a step-by-step guide to creating and testing a Spring Cloud Contract example. By the end of this tutorial, you will have a better understanding of how to use Spring Cloud Contract to automate the testing of your microservices.
Step 1: Set Up Your Project
The first step is to create a new Java project. You can use any Integrated Development Environment (IDE) you prefer, but we recommend using IntelliJ IDEA or Eclipse. Make sure that you have the Spring Boot and Spring Cloud Contract plugins installed in your IDE.
Once you have set up your project, you will need to add the Spring Cloud Contract dependency to your pom.xml file or build.gradle file. This can be done by adding the following code to your file:
Maven:
“`
org.springframework.cloud
spring-cloud-starter-contract-verifier
3.0.3
test
“`
Gradle:
“`
dependencies {
testCompile(`org.springframework.cloud:spring-cloud-starter-contract-verifier:3.0.3`)
}
“`
Step 2: Create the Contract
The next step is to create a contract between the producer and the consumer. The producer is the microservice that provides data, while the consumer is the microservice that consumes it. We will create a simple contract that specifies the format of the data that the producer will provide.
To create the contract, create a new folder in your project called contracts. Inside the contracts folder, create a new folder called producer. This folder will contain the contract for the producer.
Create a new file in the producer folder called contract.groovy. This file will contain the contract definition. Here is an example contract:
“`
package contracts.producer
import org.springframework.cloud.contract.spec.Contract
Contract.make {
description `A request for a customer`
request {
method `GET`
url `/customer/12345`
headers {
header(`Content-Type`, `application/json`)
}
}
response {
status 200
headers {
header(`Content-Type`, `application/json`)
}
body([
name: `John Doe`,
email: `johndoe@example.com`
])
}
}
“`
This contract specifies that the producer will respond with a 200 status code and a JSON body containing the name and email of the customer with the ID 12345.
Step 3: Test the Contract
Once you have created the contract, you can test it against the consumer. To do this, create a new folder in your project called test. Inside the test folder, create a new file called ContractTest.groovy.
This file will contain the test that verifies that the contract is met. Here is an example of a test that verifies the contract we created in step 2:
“`
package com.example.contract
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.ExtendWith
import org.springframework.boot.test.autoconfigure.restdocs.AutoConfigureRestDocs
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
import org.springframework.cloud.contract.stubrunner.junit.StubRunnerExtension
import org.springframework.test.context.junit.jupiter.SpringExtension
import org.springframework.test.web.servlet.MockMvc
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders
import org.springframework.test.web.servlet.result.MockMvcResultMatchers
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
@ExtendWith(SpringExtension::class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.MOCK)
@AutoConfigureMockMvc
@AutoConfigureRestDocs
@ExtendWith(StubRunnerExtension::class)
class ContractTest {
@Autowired
private MockMvc mockMvc
@Test
void shouldReturnCustomer() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get(“/customer/12345”))
.andExpect(MockMvcResultMatchers.status().isOk())
.andExpect(MockMvcResultMatchers.content().json(“`
{
“name”: “John Doe”,
“email”: “johndoe@example.com”
}
“`))
}
}
“`
This test verifies that the producer responds with a 200 status code and a JSON body containing the name and email of the customer with the ID 12345.
Step 4: Build and Deploy
Once you have verified that the contract is met, you can build and deploy your microservices. You can use any deployment tool you prefer, but we recommend using Docker and Kubernetes.
Conclusion
Spring Cloud Contract is a powerful framework that allows you to create and test contracts between microservices easily and efficiently. By following the steps outlined in this tutorial, you can create and test a Spring Cloud Contract example in no time. With Spring Cloud Contract, you can automate the testing of your microservices and ensure that they are working as expected. Happy coding!