3. Spring Cloud Contract FAQ
Prev |  | Next

# 3. Spring Cloud Contract FAQ

## 3.1 Why use Spring Cloud Contract Verifier and not X ?

For the time being Spring Cloud Contract Verifier is a JVM based tool. So it could be your first pick when you’re already creating software for the JVM. This project has a lot of really interesting features but especially quite a few of them definitely make Spring Cloud Contract Verifier stand out on the "market" of Consumer Driven Contract (CDC) tooling. Out of many the most interesting are:

- Possibility to do CDC with messaging
- Clear and easy to use, statically typed DSL
- Possibility to copy paste your current JSON file to the contract and only edit its elements
- Automatic generation of tests from the defined Contract
- Stub Runner functionality - the stubs are automatically downloaded at runtime from Nexus / Artifactory
- Spring Cloud integration - no discovery service is needed for integration tests

## 3.2 I don’t want to write a contract in Groovy!

No problem. You can write a contract in YAML!

## 3.3 What is this value(consumer(), producer()) ?

One of the biggest challenges related to stubs is their reusability. Only if they can be vastly used, will they serve their purpose. What typically makes that difficult are the hard-coded values of request / response elements. For example dates or ids. Imagine the following JSON request

    {
        "time" : "2016-10-10 20:10:15",
        "id" : "9febab1c-6f36-4a0b-88d6-3b6a6d81cd4a",
        "body" : "foo"
    }

and JSON response

    {
        "time" : "2016-10-10 21:10:15",
        "id" : "c4231e1f-3ca9-48d3-b7e7-567d55f0d051",
        "body" : "bar"
    }

Imagine the pain required to set proper value of the `time` field (let’s assume that this content is generated by the database) by changing the clock in the system or providing stub implementations of data providers. The same is related to the field called `id`. Will you create a stubbed implementation of UUID generator? Makes little sense…​

So as a consumer you would like to send a request that matches any form of a time or any UUID. That way your system will work as usual - will generate data and you won’t have to stub anything out. Let’s assume that in case of the aforementioned JSON the most important part is the `body` field. You can focus on that and provide matching for other fields. In other words you would like the stub to work like this:

    {
        "time" : "SOMETHING THAT MATCHES TIME",
        "id" : "SOMETHING THAT MATCHES UUID",
        "body" : "foo"
    }

As far as the response goes as a consumer you need a concrete value that you can operate on. So such a JSON is valid

    {
        "time" : "2016-10-10 21:10:15",
        "id" : "c4231e1f-3ca9-48d3-b7e7-567d55f0d051",
        "body" : "bar"
    }

As you could see in the previous sections we generate tests from contracts. So from the producer’s side the situation looks much different. We’re parsing the provided contract and in the test we want to send a real request to your endpoints. So for the case of a producer for the request we can’t have any sort of matching. We need concrete values that the producer’s backend can work on. Such a JSON would be a valid one:

    {
        "time" : "2016-10-10 20:10:15",
        "id" : "9febab1c-6f36-4a0b-88d6-3b6a6d81cd4a",
        "body" : "foo"
    }

On the other hand from the point of view of the validity of the contract the response doesn’t necessarily have to contain concrete values of `time` or `id`. Let’s say that you generate those on the producer side - again, you’d have to do a lot of stubbing to ensure that you always return the same values. That’s why from the producer’s side what you might want is the following response:

    {
        "time" : "SOMETHING THAT MATCHES TIME",
        "id" : "SOMETHING THAT MATCHES UUID",
        "body" : "bar"
    }

How can you then provide one time a matcher for the consumer and a concrete value for the producer and vice versa? In Spring Cloud Contract we’re allowing you to provide a dynamic value. That means that it can differ for both sides of the communication. You can pass the values:

Either via the `value` method

    value(consumer(...), producer(...))
    value(stub(...), test(...))
    value(client(...), server(...))

or using the `$()` method

    $(consumer(...), producer(...))
    $(stub(...), test(...))
    $(client(...), server(...))

You can read more about this in the Contract DSL section.

Calling `value()` or `$()` tells Spring Cloud Contract that you will be passing a dynamic value. Inside the `consumer()` method you pass the value that should be used on the consumer side (in the generated stub). Inside the `producer()` method you pass the value that should be used on the producer side (in the generated test).

| Tip
If on one side you have passed the regular expression and you haven’t passed the other, then the other side will get auto-generated.

Most often you will use that method together with the `regex` helper method. E.g. `consumer(regex('[0-9]{10}'))`.

To sum it up the contract for the aforementioned scenario would look more or less like this (the regular expression for time and UUID are simplified and most likely invalid but we want to keep things very simple in this example):

    org.springframework.cloud.contract.spec.Contract.make {
    				request {
    					method 'GET'
    					url '/someUrl'
    					body([
    					    time : value(consumer(regex('[0-9]{4}-[0-9]{2}-[0-9]{2} [0-2][0-9]-[0-5][0-9]-[0-5][0-9]')),
    					    id: value(consumer(regex('[0-9a-zA-z]{8}-[0-9a-zA-z]{4}-[0-9a-zA-z]{4}-[0-9a-zA-z]{12}'))
    					    body: "foo"
    					])
    				}
    			response {
    				status 200
    				body([
    					    time : value(producer(regex('[0-9]{4}-[0-9]{2}-[0-9]{2} [0-2][0-9]-[0-5][0-9]-[0-5][0-9]')),
    					    id: value([producer(regex('[0-9a-zA-z]{8}-[0-9a-zA-z]{4}-[0-9a-zA-z]{4}-[0-9a-zA-z]{12}'))
    					    body: "bar"
    					])
    			}
    }

| Important
Please read the Groovy docs related to JSON to understand how to properly structure the request / response bodies.

## 3.4 How to do Stubs versioning?

### 3.4.1 API Versioning

Let’s try to answer a question what versioning really means. If you’re referring to the API version then there are different approaches.

- use Hypermedia, links and do not version your API by any means
- pass versions through headers / urls

I will not try to answer a question which approach is better. Whatever suit your needs and allows you to generate business value should be picked.

Let’s assume that you do version your API. In that case you should provide as many contracts as many versions you support. You can create a subfolder for every version or append it to th contract name - whatever suits you more.

### 3.4.2 JAR versioning

If by versioning you mean the version of the JAR that contains the stubs then there are essentially two main approaches.

Let’s assume that you’re doing Continuous Delivery / Deployment which means that you’re generating a new version of the jar each time you go through the pipeline and that jar can go to production at any time. For example your jar version looks like this (it got built on the 20.10.2016 at 20:15:21) :

    1.0.0.20161020-201521-RELEASE

In that case your generated stub jar will look like this.

    1.0.0.20161020-201521-RELEASE-stubs.jar

In this case you should inside your `application.yml` or `@AutoConfigureStubRunner` when referencing stubs provide the latest version of the stubs. You can do that by passing the `+` sign. Example

    @AutoConfigureStubRunner(ids = {"com.example:http-server-dsl:+:stubs:8080"})

If the versioning however is fixed (e.g. `1.0.4.RELEASE` or `2.1.1`) then you have to set the concrete value of the jar version. Example for 2.1.1.

    @AutoConfigureStubRunner(ids = {"com.example:http-server-dsl:2.1.1:stubs:8080"})

### 3.4.3 Dev or prod stubs

You can manipulate the classifier to run the tests against current development version of the stubs of other services or the ones that were deployed to production. If you alter your build to deploy the stubs with the `prod-stubs` classifier once you reach production deployment then you can run tests in one case with dev stubs and one with prod stubs.

Example of tests using development version of stubs

    @AutoConfigureStubRunner(ids = {"com.example:http-server-dsl:+:stubs:8080"})

Example of tests using production version of stubs

    @AutoConfigureStubRunner(ids = {"com.example:http-server-dsl:+:prod-stubs:8080"})

You can pass those values also via properties from your deployment pipeline.

## 3.5 Common repo with contracts

Another way of storing contracts other than having them with the producer is keeping them in a common place. It can be related to security issues where the consumers can’t clone the producer’s code. Also if you keep contracts in a single place then you, as a producer, will know how many consumers you have and which consumer will you break with your local changes.

### 3.5.1 Repo structure

Let’s assume that we have a producer with coordinates `com.example:server` and 3 consumers: `client1`, `client2`, `client3`. Then in the repository with common contracts you would have the following setup (which you can checkout here:

    ├── com
    │   └── example
    │       └── server
    │           ├── client1
    │           │   └── expectation.groovy
    │           ├── client2
    │           │   └── expectation.groovy
    │           ├── client3
    │           │   └── expectation.groovy
    │           └── pom.xml
    ├── mvnw
    ├── mvnw.cmd
    ├── pom.xml
    └── src
        └── assembly
            └── contracts.xml

As you can see the under the slash-delimited groupid `/` artifact id folder (`com/example/server`) you have expectations of the 3 consumers (`client1`, `client2` and `client3`). Expectations are the standard Groovy DSL contract files as described throughout this documentation. This repository has to produce a JAR file that maps one to one to the contents of the repo.

Example of a `pom.xml` inside the `server` folder.

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>

    	<groupId>com.example</groupId>
    	<artifactId>server</artifactId>
    	<version>0.0.1-SNAPSHOT</version>

    	<name>Server Stubs</name>
    	<description>POM used to install locally stubs for consumer side</description>

    	<parent>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-parent</artifactId>
    		<version>1.5.16.RELEASE</version>
    		<relativePath />
    	</parent>

    	<properties>
    		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    		<java.version>1.8</java.version>
    		<spring-cloud-contract.version>1.2.7.BUILD-SNAPSHOT</spring-cloud-contract.version>
    		<spring-cloud-dependencies.version>1.3.11.BUILD-SNAPSHOT</spring-cloud-dependencies.version>
    		<excludeBuildFolders>true</excludeBuildFolders>
    	</properties>

    	<dependencyManagement>
    		<dependencies>
    			<dependency>
    				<groupId>org.springframework.cloud</groupId>
    				<artifactId>spring-cloud-dependencies</artifactId>
    				<version>${spring-cloud-dependencies.version}</version>
    				<type>pom</type>
    				<scope>import</scope>
    			</dependency>
    		</dependencies>
    	</dependencyManagement>

    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.cloud</groupId>
    				<artifactId>spring-cloud-contract-maven-plugin</artifactId>
    				<version>${spring-cloud-contract.version}</version>
    				<extensions>true</extensions>
    				<configuration>
    					<!-- By default it would search under src/test/resources/ -->
    					<contractsDirectory>${project.basedir}</contractsDirectory>
    				</configuration>
    			</plugin>
    		</plugins>
    	</build>

    	<repositories>
    		<repository>
    			<id>spring-snapshots</id>
    			<name>Spring Snapshots</name>
    			<url>https://repo.spring.io/snapshot</url>
    			<snapshots>
    				<enabled>true</enabled>
    			</snapshots>
    		</repository>
    		<repository>
    			<id>spring-milestones</id>
    			<name>Spring Milestones</name>
    			<url>https://repo.spring.io/milestone</url>
    			<snapshots>
    				<enabled>false</enabled>
    			</snapshots>
    		</repository>
    		<repository>
    			<id>spring-releases</id>
    			<name>Spring Releases</name>
    			<url>https://repo.spring.io/release</url>
    			<snapshots>
    				<enabled>false</enabled>
    			</snapshots>
    		</repository>
    	</repositories>
    	<pluginRepositories>
    		<pluginRepository>
    			<id>spring-snapshots</id>
    			<name>Spring Snapshots</name>
    			<url>https://repo.spring.io/snapshot</url>
    			<snapshots>
    				<enabled>true</enabled>
    			</snapshots>
    		</pluginRepository>
    		<pluginRepository>
    			<id>spring-milestones</id>
    			<name>Spring Milestones</name>
    			<url>https://repo.spring.io/milestone</url>
    			<snapshots>
    				<enabled>false</enabled>
    			</snapshots>
    		</pluginRepository>
    		<pluginRepository>
    			<id>spring-releases</id>
    			<name>Spring Releases</name>
    			<url>https://repo.spring.io/release</url>
    			<snapshots>
    				<enabled>false</enabled>
    			</snapshots>
    		</pluginRepository>
    	</pluginRepositories>

    </project>

As you can see there are no dependencies other than the Spring Cloud Contract Maven Plugin. Those poms are necessary for the consumer side to run `mvn clean install -DskipTests` to locally install stubs of the producer project.

The `pom.xml` in the root folder can look like this:

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    		 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>

    	<groupId>com.example.standalone</groupId>
    	<artifactId>contracts</artifactId>
    	<version>0.0.1-SNAPSHOT</version>

    	<name>Contracts</name>
    	<description>Contains all the Spring Cloud Contracts, well, contracts. JAR used by the producers to generate tests and stubs</description>

    	<properties>
    		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    	</properties>

    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.apache.maven.plugins</groupId>
    				<artifactId>maven-assembly-plugin</artifactId>
    				<executions>
    					<execution>
    						<id>contracts</id>
    						<phase>prepare-package</phase>
    						<goals>
    							<goal>single</goal>
    						</goals>
    						<configuration>
    							<attach>true</attach>
    							<descriptor>${basedir}/src/assembly/contracts.xml</descriptor>
    							<!-- If you want an explicit classifier remove the following line -->
    							<appendAssemblyId>false</appendAssemblyId>
    						</configuration>
    					</execution>
    				</executions>
    			</plugin>
    		</plugins>
    	</build>

    </project>

It’s using the assembly plugin in order to build the JAR with all the contracts. Example of such setup is here:

    <assembly xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.3"
    		  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    		  xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.3 https://maven.apache.org/xsd/assembly-1.1.3.xsd">
    	<id>project</id>
    	<formats>
    		<format>jar</format>
    	</formats>
    	<includeBaseDirectory>false</includeBaseDirectory>
    	<fileSets>
    		<fileSet>
    			<directory>${project.basedir}</directory>
    			<outputDirectory>/</outputDirectory>
    			<useDefaultExcludes>true</useDefaultExcludes>
    			<excludes>
    				<exclude>**/${project.build.directory}/**</exclude>
    				<exclude>mvnw</exclude>
    				<exclude>mvnw.cmd</exclude>
    				<exclude>.mvn/**</exclude>
    				<exclude>src/**</exclude>
    			</excludes>
    		</fileSet>
    	</fileSets>
    </assembly>

### 3.5.2 Workflow

The workflow would look similar to the one presented in the `Step by step guide to CDC`. The only difference is that the producer doesn’t own the contracts anymore. So the consumer and the producer have to work on common contracts in a common repository.

### 3.5.3 Consumer

When the consumer wants to work on the contracts offline, instead of cloning the producer code, the consumer team clones the common repository, goes to the required producer’s folder (e.g. `com/example/server`) and runs `mvn clean install -DskipTests` to install locally the stubs converted from the contracts.

| Tip
You need to have Maven installed locally

### 3.5.4 Producer

As a producer it’s enough to alter the Spring Cloud Contract Verifier to provide the URL and the dependency of the JAR containing the contracts:

    <plugin>
    	<groupId>org.springframework.cloud</groupId>
    	<artifactId>spring-cloud-contract-maven-plugin</artifactId>
    	<configuration>
    		<contractsRepositoryUrl>http://link/to/your/nexus/or/artifactory/or/sth</contractsRepositoryUrl>
    		<contractDependency>
    			<groupId>com.example.standalone</groupId>
    			<artifactId>contracts</artifactId>
    		</contractDependency>
    	</configuration>
    </plugin>

With this setup the JAR with groupid `com.example.standalone` and artifactid `contracts` will be downloaded from `http://link/to/your/nexus/or/artifactory/or/sth`. It will be then unpacked in a local temporary folder and contracts present under the `com/example/server` will be picked as the ones used to generate the tests and the stubs. Due to this convention the producer team will know which consumer teams will be broken when some incompatible changes are done.

The rest of the flow looks the same.

## 3.6 Can I have multiple base classes for tests?

Yes! Check out the Different base classes for contracts sections of either Gradle or Maven plugins.

## 3.7 How can I debug the request/response being sent by the generated tests client?

The generated tests all boil down to RestAssured in some form or fashion which relies on Apache HttpClient. HttpClient has a facility called wire logging which logs the entire request and response to HttpClient. Spring Boot has a logging common application property for doing this sort of thing, just add this to your application properties

    logging.level.org.apache.http.wire=DEBUG

### 3.7.1 How can I debug the mapping/request/response being sent by WireMock?

Starting from version `1.2.0` we turn on WireMock logging to info and the WireMock notifier to being verbose. Now you will exactly know what request was received by WireMock server and which matching response definition was picked.

To turn off this feature just bump WireMock logging to `ERROR`

    logging.level.com.github.tomakehurst.wiremock=ERROR

### 3.7.2 How can I see what got registered in the HTTP server stub?

You can use the `mappingsOutputFolder` property on `@AutoConfigureStubRunner` or `StubRunnerRule` to dump all mappings per artifact id. Also the port at which the given stub server was started will be attached.

### 3.7.3 Can I reference the request from the response?

Yes! With version 1.1.0 we’ve added such a possibility. On the HTTP stub server side we’re providing support for this for WireMock. In case of other HTTP server stubs you’ll have to implement the approach yourself.

### 3.7.4 Can I reference text from file?

Yes! With version 1.2.0 we’ve added such a possibility. It’s enough to call `file(…​)` method in the DSL and provide a path relative to where the contract lays. If you’re using YAML just use the `bodyFromFile` property.

Prev |  | Next
2. Spring Cloud Contract Verifier Introduction | Home | 4. Spring Cloud Contract Verifier Setup