2. Spring Cloud Contract Verifier Introduction
Prev |  | Next

# 2. Spring Cloud Contract Verifier Introduction

Spring Cloud Contract Verifier enables Consumer Driven Contract (CDC) development of JVM-based applications. It moves TDD to the level of software architecture.

Spring Cloud Contract Verifier ships with Contract Definition Language (CDL). Contract definitions are used to produce the following resources:

- JSON stub definitions to be used by WireMock when doing integration testing on the client code (client tests). Test code must still be written by hand, and test data is produced by Spring Cloud Contract Verifier.
- Messaging routes, if you’re using a messaging service. We integrate with Spring Integration, Spring Cloud Stream, Spring AMQP, and Apache Camel. You can also set your own integrations.
- Acceptance tests (in JUnit 4, JUnit 5 or Spock) are used to verify if server-side implementation of the API is compliant with the contract (server tests). A full test is generated by Spring Cloud Contract Verifier.

## 2.1 History

Before becoming Spring Cloud Contract, this project was called Accurest. It was created by Marcin Grzejszczak and Jakub Kubrynski from (Codearte.

The `0.1.0` release took place on 26 Jan 2015 and it became stable with `1.0.0` release on 29 Feb 2016.

## 2.2 Why a Contract Verifier?

Assume that we have a system consisting of multiple microservices:

### 2.2.1 Testing issues

If we wanted to test the application in top left corner to determine whether it can communicate with other services, we could do one of two things:

- Deploy all microservices and perform end-to-end tests.
- Mock other microservices in unit/integration tests.

Both have their advantages but also a lot of disadvantages.

Deploy all microservices and perform end to end tests

Advantages:

- Simulates production.
- Tests real communication between services.

Disadvantages:

- To test one microservice, we have to deploy 6 microservices, a couple of databases, etc.
- The environment where the tests run is locked for a single suite of tests (nobody else would be able to run the tests in the meantime).
- They take a long time to run.
- The feedback comes very late in the process.
- They are extremely hard to debug.

Mock other microservices in unit/integration tests

Advantages:

- They provide very fast feedback.
- They have no infrastructure requirements.

Disadvantages:

- The implementor of the service creates stubs that might have nothing to do with reality.
- You can go to production with passing tests and failing production.

To solve the aforementioned issues, Spring Cloud Contract Verifier with Stub Runner was created. The main idea is to give you very fast feedback, without the need to set up the whole world of microservices. If you work on stubs, then the only applications you need are those that your application directly uses.

Spring Cloud Contract Verifier gives you the certainty that the stubs that you use were created by the service that you’re calling. Also, if you can use them, it means that they were tested against the producer’s side. In short, you can trust those stubs.

## 2.3 Purposes

The main purposes of Spring Cloud Contract Verifier with Stub Runner are:

- To ensure that WireMock/Messaging stubs (used when developing the client) do exactly what the actual server-side implementation does.
- To promote ATDD method and Microservices architectural style.
- To provide a way to publish changes in contracts that are immediately visible on both sides.
- To generate boilerplate test code to be used on the server side.

| Important
Spring Cloud Contract Verifier’s purpose is NOT to start writing business features in the contracts. Assume that we have a business use case of fraud check. If a user can be a fraud for 100 different reasons, we would assume that you would create 2 contracts, one for the positive case and one for the negative case. Contract tests are used to test contracts between applications and not to simulate full behavior.

## 2.4 How It Works

This section explores how Spring Cloud Contract Verifier with Stub Runner works.

### 2.4.1 A Three-second Tour

This very brief tour walks through using Spring Cloud Contract:

- the section called “On the Producer Side”
- the section called “On the Consumer Side”

You can find a somewhat longer tour here.

#### On the Producer Side

To start working with Spring Cloud Contract, add files with `REST/` messaging contracts expressed in either Groovy DSL or YAML to the contracts directory, which is set by the `contractsDslDir` property. By default, it is `$rootDir/src/test/resources/contracts`.

Then add the Spring Cloud Contract Verifier dependency and plugin to your build file, as shown in the following example:

    <dependency>
    	<groupId>org.springframework.cloud</groupId>
    	<artifactId>spring-cloud-starter-contract-verifier</artifactId>
    	<scope>test</scope>
    </dependency>

The following listing shows how to add the plugin, which should go in the build/plugins portion of the file:

    <plugin>
    	<groupId>org.springframework.cloud</groupId>
    	<artifactId>spring-cloud-contract-maven-plugin</artifactId>
    	<version>${spring-cloud-contract.version}</version>
    	<extensions>true</extensions>
    </plugin>

Running `./mvnw clean install` automatically generates tests that verify the application compliance with the added contracts. By default, the tests get generated under `org.springframework.cloud.contract.verifier.tests.`.

As the implementation of the functionalities described by the contracts is not yet present, the tests fail.

To make them pass, you must add the correct implementation of either handling HTTP requests or messages. Also, you must add a correct base test class for auto-generated tests to the project. This class is extended by all the auto-generated tests, and it should contain all the setup necessary to run them (for example `RestAssuredMockMvc` controller setup or messaging test setup).

Once the implementation and the test base class are in place, the tests pass, and both the application and the stub artifacts are built and installed in the local Maven repository. The changes can now be merged, and both the application and the stub artifacts may be published in an online repository.

#### On the Consumer Side

`Spring Cloud Contract Stub Runner` can be used in the integration tests to get a running WireMock instance or messaging route that simulates the actual service.

To do so, add the dependency to `Spring Cloud Contract Stub Runner`, as shown in the following example:

    <dependency>
    	<groupId>org.springframework.cloud</groupId>
    	<artifactId>spring-cloud-starter-contract-stub-runner</artifactId>
    	<scope>test</scope>
    </dependency>

You can get the Producer-side stubs installed in your Maven repository in either of two ways:

- By checking out the Producer side repository and adding contracts and generating the stubs by running the following commands:

      $ cd local-http-server-repo
      $ ./mvnw clean install -DskipTests

  | Tip
  The tests are being skipped because the Producer-side contract implementation is not in place yet, so the automatically-generated contract tests fail.

- By getting already-existing producer service stubs from a remote repository. To do so, pass the stub artifact IDs and artifact repository URL as `Spring Cloud Contract Stub Runner` properties, as shown in the following example:

      stubrunner:
        ids: 'com.example:http-server-dsl:+:stubs:8080'
        repositoryRoot: https://repo.spring.io/libs-snapshot

Now you can annotate your test class with `@AutoConfigureStubRunner`. In the annotation, provide the `group-id` and `artifact-id` values for `Spring Cloud Contract Stub Runner` to run the collaborators' stubs for you, as shown in the following example:

    @RunWith(SpringRunner.class)
    @SpringBootTest(webEnvironment=WebEnvironment.NONE)
    @AutoConfigureStubRunner(ids = {"com.example:http-server-dsl:+:stubs:6565"},
    		stubsMode = StubRunnerProperties.StubsMode.LOCAL)
    public class LoanApplicationServiceTests {

| Tip
Use the `REMOTE` `stubsMode` when downloading stubs from an online repository and `LOCAL` for offline work.

Now, in your integration test, you can receive stubbed versions of HTTP responses or messages that are expected to be emitted by the collaborator service.

### 2.4.2 A Three-minute Tour

This brief tour walks through using Spring Cloud Contract:

- the section called “On the Producer Side”
- the section called “On the Consumer Side”

You can find an even more brief tour here.

#### On the Producer Side

To start working with `Spring Cloud Contract`, add files with `REST/` messaging contracts expressed in either Groovy DSL or YAML to the contracts directory, which is set by the `contractsDslDir` property. By default, it is `$rootDir/src/test/resources/contracts`.

For the HTTP stubs, a contract defines what kind of response should be returned for a given request (taking into account the HTTP methods, URLs, headers, status codes, and so on). The following example shows how an HTTP stub contract in Groovy DSL:

    package contracts

    org.springframework.cloud.contract.spec.Contract.make {
    	request {
    		method 'PUT'
    		url '/fraudcheck'
    		body([
    			   "client.id": $(regex('[0-9]{10}')),
    			   loanAmount: 99999
    		])
    		headers {
    			contentType('application/json')
    		}
    	}
    	response {
    		status OK()
    		body([
    			   fraudCheckStatus: "FRAUD",
    			   "rejection.reason": "Amount too high"
    		])
    		headers {
    			contentType('application/json')
    		}
    	}
    }

The same contract expressed in YAML would look like the following example:

    request:
      method: PUT
      url: /fraudcheck
      body:
        "client.id": 1234567890
        loanAmount: 99999
      headers:
        Content-Type: application/json
      matchers:
        body:
          - path: $.['client.id']
            type: by_regex
            value: "[0-9]{10}"
    response:
      status: 200
      body:
        fraudCheckStatus: "FRAUD"
        "rejection.reason": "Amount too high"
      headers:
        Content-Type: application/json;charset=UTF-8

In the case of messaging, you can define:

- The input and the output messages can be defined (taking into account from and where it was sent, the message body, and the header).
- The methods that should be called after the message is received.
- The methods that, when called, should trigger a message.

The following example shows a Camel messaging contract expressed in Groovy DSL:

    			def contractDsl = Contract.make {
    				label 'some_label'
    				input {
    					messageFrom('jms:delete')
    					messageBody([
    							bookName: 'foo'
    					])
    					messageHeaders {
    						header('sample', 'header')
    					}
    					assertThat('bookWasDeleted()')
    				}
    			}

The following example shows the same contract expressed in YAML:

    label: some_label
    input:
      messageFrom: jms:delete
      messageBody:
        bookName: 'foo'
      messageHeaders:
        sample: header
      assertThat: bookWasDeleted()

Then you can add Spring Cloud Contract Verifier dependency and plugin to your build file, as shown in the following example:

    <dependency>
    	<groupId>org.springframework.cloud</groupId>
    	<artifactId>spring-cloud-starter-contract-verifier</artifactId>
    	<scope>test</scope>
    </dependency>

The following listing shows how to add the plugin, which should go in the build/plugins portion of the file:

    <plugin>
    	<groupId>org.springframework.cloud</groupId>
    	<artifactId>spring-cloud-contract-maven-plugin</artifactId>
    	<version>${spring-cloud-contract.version}</version>
    	<extensions>true</extensions>
    </plugin>

Running `./mvnw clean install` automatically generates tests that verify the application compliance with the added contracts. By default, the generated tests are under `org.springframework.cloud.contract.verifier.tests.`.

The following example shows a sample auto-generated test for an HTTP contract:

    @Test
    public void validate_shouldMarkClientAsFraud() throws Exception {
        // given:
            MockMvcRequestSpecification request = given()
                    .header("Content-Type", "application/vnd.fraud.v1+json")
                    .body("{\"client.id\":\"1234567890\",\"loanAmount\":99999}");

        // when:
            ResponseOptions response = given().spec(request)
                    .put("/fraudcheck");

        // then:
            assertThat(response.statusCode()).isEqualTo(200);
            assertThat(response.header("Content-Type")).matches("application/vnd.fraud.v1.json.*");
        // and:
            DocumentContext parsedJson = JsonPath.parse(response.getBody().asString());
            assertThatJson(parsedJson).field("['fraudCheckStatus']").matches("[A-Z]{5}");
            assertThatJson(parsedJson).field("['rejection.reason']").isEqualTo("Amount too high");
    }

The preceding example uses Spring’s `MockMvc` to run the tests. This is the default test mode for HTTP contracts. However, JAX-RS client and explicit HTTP invocations can also be used. (To do so, change the `testMode` property of the plugin to `JAX-RS` or `EXPLICIT`, respectively.)

Since 2.1.0, it is also possible to use `RestAssuredWebTestClient`with Spring’s reactive `WebTestClient` run under the hood. This is particularly recommended while working with Reactive, `Web-Flux`-based applications. In order to use `WebTestClient` set `testMode` to `WEBTESTCLIENT`.

Here is an example of a test generated in `WEBTESTCLIENT` test mode:

    [source,java,indent=0]

    @Test
    	public void validate_shouldRejectABeerIfTooYoung() throws Exception {
    		// given:
    			WebTestClientRequestSpecification request = given()
    					.header("Content-Type", "application/json")
    					.body("{\"age\":10}");

    		// when:
    			WebTestClientResponse response = given().spec(request)
    					.post("/check");

    		// then:
    			assertThat(response.statusCode()).isEqualTo(200);
    			assertThat(response.header("Content-Type")).matches("application/json.*");
    		// and:
    			DocumentContext parsedJson = JsonPath.parse(response.getBody().asString());
    			assertThatJson(parsedJson).field("['status']").isEqualTo("NOT_OK");
    	}

Apart from the default JUnit 4, you can instead use JUnit 5 or Spock tests, by setting the plugin `testFramework` property to either `JUNIT5` or `Spock`.

| Tip
You can now also generate WireMock scenarios based on the contracts, by including an order number followed by an underscore at the beginning of the contract file names.

The following example shows an auto-generated test in Spock for a messaging stub contract:

    [source,groovy,indent=0]

    given:
    	 ContractVerifierMessage inputMessage = contractVerifierMessaging.create(
    		\'\'\'{"bookName":"foo"}\'\'\',
    		['sample': 'header']
    	)

    when:
    	 contractVerifierMessaging.send(inputMessage, 'jms:delete')

    then:
    	 noExceptionThrown()
    	 bookWasDeleted()

As the implementation of the functionalities described by the contracts is not yet present, the tests fail.

To make them pass, you must add the correct implementation of handling either HTTP requests or messages. Also, you must add a correct base test class for auto-generated tests to the project. This class is extended by all the auto-generated tests and should contain all the setup necessary to run them (for example, `RestAssuredMockMvc` controller setup or messaging test setup).

Once the implementation and the test base class are in place, the tests pass, and both the application and the stub artifacts are built and installed in the local Maven repository. Information about installing the stubs jar to the local repository appears in the logs, as shown in the following example:

    [INFO] --- spring-cloud-contract-maven-plugin:1.0.0.BUILD-SNAPSHOT:generateStubs (default-generateStubs) @ http-server ---
    [INFO] Building jar: /some/path/http-server/target/http-server-0.0.1-SNAPSHOT-stubs.jar
    [INFO]
    [INFO] --- maven-jar-plugin:2.6:jar (default-jar) @ http-server ---
    [INFO] Building jar: /some/path/http-server/target/http-server-0.0.1-SNAPSHOT.jar
    [INFO]
    [INFO] --- spring-boot-maven-plugin:1.5.5.BUILD-SNAPSHOT:repackage (default) @ http-server ---
    [INFO]
    [INFO] --- maven-install-plugin:2.5.2:install (default-install) @ http-server ---
    [INFO] Installing /some/path/http-server/target/http-server-0.0.1-SNAPSHOT.jar to /path/to/your/.m2/repository/com/example/http-server/0.0.1-SNAPSHOT/http-server-0.0.1-SNAPSHOT.jar
    [INFO] Installing /some/path/http-server/pom.xml to /path/to/your/.m2/repository/com/example/http-server/0.0.1-SNAPSHOT/http-server-0.0.1-SNAPSHOT.pom
    [INFO] Installing /some/path/http-server/target/http-server-0.0.1-SNAPSHOT-stubs.jar to /path/to/your/.m2/repository/com/example/http-server/0.0.1-SNAPSHOT/http-server-0.0.1-SNAPSHOT-stubs.jar

You can now merge the changes and publish both the application and the stub artifacts in an online repository.

Docker Project

In order to enable working with contracts while creating applications in non-JVM technologies, the `springcloud/spring-cloud-contract` Docker image has been created. It contains a project that automatically generates tests for HTTP contracts and executes them in `EXPLICIT` test mode. Then, if the tests pass, it generates Wiremock stubs and, optionally, publishes them to an artifact manager. In order to use the image, you can mount the contracts into the `/contracts` directory and set a few environment variables.

#### On the Consumer Side

`Spring Cloud Contract Stub Runner` can be used in the integration tests to get a running WireMock instance or messaging route that simulates the actual service.

To get started, add the dependency to `Spring Cloud Contract Stub Runner`:

    <dependency>
    	<groupId>org.springframework.cloud</groupId>
    	<artifactId>spring-cloud-starter-contract-stub-runner</artifactId>
    	<scope>test</scope>
    </dependency>

You can get the Producer-side stubs installed in your Maven repository in either of two ways:

- By checking out the Producer side repository and adding contracts and generating the stubs by running the following commands:

      $ cd local-http-server-repo
      $ ./mvnw clean install -DskipTests

  | Note
  The tests are skipped because the Producer-side contract implementation is not yet in place, so the automatically-generated contract tests fail.

- Getting already existing producer service stubs from a remote repository. To do so, pass the stub artifact IDs and artifact repository URl as `Spring Cloud Contract Stub Runner` properties, as shown in the following example:

      stubrunner:
        ids: 'com.example:http-server-dsl:+:stubs:8080'
        repositoryRoot: https://repo.spring.io/libs-snapshot

Now you can annotate your test class with `@AutoConfigureStubRunner`. In the annotation, provide the `group-id` and `artifact-id` for `Spring Cloud Contract Stub Runner` to run the collaborators' stubs for you, as shown in the following example:

    @RunWith(SpringRunner.class)
    @SpringBootTest(webEnvironment=WebEnvironment.NONE)
    @AutoConfigureStubRunner(ids = {"com.example:http-server-dsl:+:stubs:6565"},
    		stubsMode = StubRunnerProperties.StubsMode.LOCAL)
    public class LoanApplicationServiceTests {

| Tip
Use the `REMOTE` `stubsMode` when downloading stubs from an online repository and `LOCAL` for offline work.

In your integration test, you can receive stubbed versions of HTTP responses or messages that are expected to be emitted by the collaborator service. You can see entries similar to the following in the build logs:

    2016-07-19 14:22:25.403  INFO 41050 --- [           main] o.s.c.c.stubrunner.AetherStubDownloader  : Desired version is + - will try to resolve the latest version
    2016-07-19 14:22:25.438  INFO 41050 --- [           main] o.s.c.c.stubrunner.AetherStubDownloader  : Resolved version is 0.0.1-SNAPSHOT
    2016-07-19 14:22:25.439  INFO 41050 --- [           main] o.s.c.c.stubrunner.AetherStubDownloader  : Resolving artifact com.example:http-server:jar:stubs:0.0.1-SNAPSHOT using remote repositories []
    2016-07-19 14:22:25.451  INFO 41050 --- [           main] o.s.c.c.stubrunner.AetherStubDownloader  : Resolved artifact com.example:http-server:jar:stubs:0.0.1-SNAPSHOT to /path/to/your/.m2/repository/com/example/http-server/0.0.1-SNAPSHOT/http-server-0.0.1-SNAPSHOT-stubs.jar
    2016-07-19 14:22:25.465  INFO 41050 --- [           main] o.s.c.c.stubrunner.AetherStubDownloader  : Unpacking stub from JAR [URI: file:/path/to/your/.m2/repository/com/example/http-server/0.0.1-SNAPSHOT/http-server-0.0.1-SNAPSHOT-stubs.jar]
    2016-07-19 14:22:25.475  INFO 41050 --- [           main] o.s.c.c.stubrunner.AetherStubDownloader  : Unpacked file to [/var/folders/0p/xwq47sq106x1_g3dtv6qfm940000gq/T/contracts100276532569594265]
    2016-07-19 14:22:27.737  INFO 41050 --- [           main] o.s.c.c.stubrunner.StubRunnerExecutor    : All stubs are now running RunningStubs [namesAndPorts={com.example:http-server:0.0.1-SNAPSHOT:stubs=8080}]

### 2.4.3 Defining the Contract

As consumers of services, we need to define what exactly we want to achieve. We need to formulate our expectations. That is why we write contracts.

Assume that you want to send a request containing the ID of a client company and the amount it wants to borrow from us. You also want to send it to the /fraudcheck url via the PUT method.

Groovy DSL.

    /*
     * Copyright 2013-2019 the original author or authors.
     *
     * Licensed under the Apache License, Version 2.0 (the "License");
     * you may not use this file except in compliance with the License.
     * You may obtain a copy of the License at
     *
     *      https://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing, software
     * distributed under the License is distributed on an "AS IS" BASIS,
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     * See the License for the specific language governing permissions and
     * limitations under the License.
     */

    package contracts

    org.springframework.cloud.contract.spec.Contract.make {
    	request { // (1)
    		method 'PUT' // (2)
    		url '/fraudcheck' // (3)
    		body([ // (4)
    			   "client.id": $(regex('[0-9]{10}')),
    			   loanAmount : 99999
    		])
    		headers { // (5)
    			contentType('application/json')
    		}
    	}
    	response { // (6)
    		status OK() // (7)
    		body([ // (8)
    			   fraudCheckStatus  : "FRAUD",
    			   "rejection.reason": "Amount too high"
    		])
    		headers { // (9)
    			contentType('application/json')
    		}
    	}
    }

    /*
    From the Consumer perspective, when shooting a request in the integration test:

    (1) - If the consumer sends a request
    (2) - With the "PUT" method
    (3) - to the URL "/fraudcheck"
    (4) - with the JSON body that
     * has a field `client.id` that matches a regular expression `[0-9]{10}`
     * has a field `loanAmount` that is equal to `99999`
    (5) - with header `Content-Type` equal to `application/json`
    (6) - then the response will be sent with
    (7) - status equal `200`
    (8) - and JSON body equal to
     { "fraudCheckStatus": "FRAUD", "rejectionReason": "Amount too high" }
    (9) - with header `Content-Type` equal to `application/json`

    From the Producer perspective, in the autogenerated producer-side test:

    (1) - A request will be sent to the producer
    (2) - With the "PUT" method
    (3) - to the URL "/fraudcheck"
    (4) - with the JSON body that
     * has a field `client.id` that will have a generated value that matches a regular expression `[0-9]{10}`
     * has a field `loanAmount` that is equal to `99999`
    (5) - with header `Content-Type` equal to `application/json`
    (6) - then the test will assert if the response has been sent with
    (7) - status equal `200`
    (8) - and JSON body equal to
     { "fraudCheckStatus": "FRAUD", "rejectionReason": "Amount too high" }
    (9) - with header `Content-Type` matching `application/json.*`
     */

YAML.

    request: # (1)
      method: PUT # (2)
      url: /fraudcheck # (3)
      body: # (4)
        "client.id": 1234567890
        loanAmount: 99999
      headers: # (5)
        Content-Type: application/json
      matchers:
        body:
          - path: $.['client.id'] # (6)
            type: by_regex
            value: "[0-9]{10}"
    response: # (7)
      status: 200 # (8)
      body:  # (9)
        fraudCheckStatus: "FRAUD"
        "rejection.reason": "Amount too high"
      headers: # (10)
        Content-Type: application/json;charset=UTF-8

    #From the Consumer perspective, when shooting a request in the integration test:
    #
    #(1) - If the consumer sends a request
    #(2) - With the "PUT" method
    #(3) - to the URL "/fraudcheck"
    #(4) - with the JSON body that
    # * has a field `client.id`
    # * has a field `loanAmount` that is equal to `99999`
    #(5) - with header `Content-Type` equal to `application/json`
    #(6) - and a `client.id` json entry matches the regular expression `[0-9]{10}`
    #(7) - then the response will be sent with
    #(8) - status equal `200`
    #(9) - and JSON body equal to
    # { "fraudCheckStatus": "FRAUD", "rejectionReason": "Amount too high" }
    #(10) - with header `Content-Type` equal to `application/json`
    #
    #From the Producer perspective, in the autogenerated producer-side test:
    #
    #(1) - A request will be sent to the producer
    #(2) - With the "PUT" method
    #(3) - to the URL "/fraudcheck"
    #(4) - with the JSON body that
    # * has a field `client.id` `1234567890`
    # * has a field `loanAmount` that is equal to `99999`
    #(5) - with header `Content-Type` equal to `application/json`
    #(7) - then the test will assert if the response has been sent with
    #(8) - status equal `200`
    #(9) - and JSON body equal to
    # { "fraudCheckStatus": "FRAUD", "rejectionReason": "Amount too high" }
    #(10) - with header `Content-Type` equal to `application/json;charset=UTF-8`

### 2.4.4 Client Side

Spring Cloud Contract generates stubs, which you can use during client-side testing. You get a running WireMock instance/Messaging route that simulates the service. You would like to feed that instance with a proper stub definition.

At some point in time, you need to send a request to the Fraud Detection service.

    ResponseEntity<FraudServiceResponse> response = restTemplate.exchange(
    		"http://localhost:" + port + "/fraudcheck", HttpMethod.PUT,
    		new HttpEntity<>(request, httpHeaders), FraudServiceResponse.class);

Annotate your test class with `@AutoConfigureStubRunner`. In the annotation provide the group id and artifact id for the Stub Runner to download stubs of your collaborators.

    @RunWith(SpringRunner.class)
    @SpringBootTest(webEnvironment = WebEnvironment.NONE)
    @AutoConfigureStubRunner(ids = {
    		"com.example:http-server-dsl:+:stubs:6565" }, stubsMode = StubRunnerProperties.StubsMode.LOCAL)
    public class LoanApplicationServiceTests {

After that, during the tests, Spring Cloud Contract automatically finds the stubs (simulating the real service) in the Maven repository and exposes them on a configured (or random) port.

### 2.4.5 Server Side

Since you are developing your stub, you need to be sure that it actually resembles your concrete implementation. You cannot have a situation where your stub acts in one way and your application behaves in a different way, especially in production.

To ensure that your application behaves the way you define in your stub, tests are generated from the stub you provide.

The autogenerated test looks, more or less, like this:

    @Test
    public void validate_shouldMarkClientAsFraud() throws Exception {
        // given:
            MockMvcRequestSpecification request = given()
                    .header("Content-Type", "application/vnd.fraud.v1+json")
                    .body("{\"client.id\":\"1234567890\",\"loanAmount\":99999}");

        // when:
            ResponseOptions response = given().spec(request)
                    .put("/fraudcheck");

        // then:
            assertThat(response.statusCode()).isEqualTo(200);
            assertThat(response.header("Content-Type")).matches("application/vnd.fraud.v1.json.*");
        // and:
            DocumentContext parsedJson = JsonPath.parse(response.getBody().asString());
            assertThatJson(parsedJson).field("['fraudCheckStatus']").matches("[A-Z]{5}");
            assertThatJson(parsedJson).field("['rejection.reason']").isEqualTo("Amount too high");
    }

## 2.5 Step-by-step Guide to Consumer Driven Contracts (CDC)

Consider an example of Fraud Detection and the Loan Issuance process. The business scenario is such that we want to issue loans to people but do not want them to steal from us. The current implementation of our system grants loans to everybody.

Assume that `Loan Issuance` is a client to the `Fraud Detection` server. In the current sprint, we must develop a new feature: if a client wants to borrow too much money, then we mark the client as a fraud.

Technical remark - Fraud Detection has an `artifact-id` of `http-server`, while Loan Issuance has an artifact-id of `http-client`, and both have a `group-id` of `com.example`.

Social remark - both client and server development teams need to communicate directly and discuss changes while going through the process. CDC is all about communication.

The server side code is available here and the client code here.

| Tip
In this case, the producer owns the contracts. Physically, all the contract are in the producer’s repository.

### 2.5.1 Technical note

If using the SNAPSHOT / Milestone / Release Candidate versions please add the following section to your build:

Maven.

    <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>

Gradle.

    repositories {
    	mavenCentral()
    	mavenLocal()
    	maven { url "https://repo.spring.io/snapshot" }
    	maven { url "https://repo.spring.io/milestone" }
    	maven { url "https://repo.spring.io/release" }
    }

### 2.5.2 Consumer side (Loan Issuance)

As a developer of the Loan Issuance service (a consumer of the Fraud Detection server), you might do the following steps:

1. Start doing TDD by writing a test for your feature.
2. Write the missing implementation.
3. Clone the Fraud Detection service repository locally.
4. Define the contract locally in the repo of Fraud Detection service.
5. Add the Spring Cloud Contract Verifier plugin.
6. Run the integration tests.
7. File a pull request.
8. Create an initial implementation.
9. Take over the pull request.
10. Write the missing implementation.
11. Deploy your app.
12. Work online.

Start doing TDD by writing a test for your feature.

    @Test
    public void shouldBeRejectedDueToAbnormalLoanAmount() {
    	// given:
    	LoanApplication application = new LoanApplication(new Client("1234567890"),
    			99999);
    	// when:
    	LoanApplicationResult loanApplication = service.loanApplication(application);
    	// then:
    	assertThat(loanApplication.getLoanApplicationStatus())
    			.isEqualTo(LoanApplicationStatus.LOAN_APPLICATION_REJECTED);
    	assertThat(loanApplication.getRejectionReason()).isEqualTo("Amount too high");
    }

Assume that you have written a test of your new feature. If a loan application for a big amount is received, the system should reject that loan application with some description.

Write the missing implementation.

At some point in time, you need to send a request to the Fraud Detection service. Assume that you need to send the request containing the ID of the client and the amount the client wants to borrow. You want to send it to the `/fraudcheck` url via the `PUT` method.

    ResponseEntity<FraudServiceResponse> response = restTemplate.exchange(
    		"http://localhost:" + port + "/fraudcheck", HttpMethod.PUT,
    		new HttpEntity<>(request, httpHeaders), FraudServiceResponse.class);

For simplicity, the port of the Fraud Detection service is set to `8080`, and the application runs on `8090`.

If you start the test at this point, it breaks, because no service currently runs on port `8080`.

Clone the Fraud Detection service repository locally.

You can start by playing around with the server side contract. To do so, you must first clone it.

    $ git clone https://your-git-server.com/server-side.git local-http-server-repo

Define the contract locally in the repo of Fraud Detection service.

As a consumer, you need to define what exactly you want to achieve. You need to formulate your expectations. To do so, write the following contract:

| Important
Place the contract under `src/test/resources/contracts/fraud` folder. The `fraud` folder is important because the producer’s test base class name references that folder.

Groovy DSL.

    /*
     * Copyright 2013-2019 the original author or authors.
     *
     * Licensed under the Apache License, Version 2.0 (the "License");
     * you may not use this file except in compliance with the License.
     * You may obtain a copy of the License at
     *
     *      https://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing, software
     * distributed under the License is distributed on an "AS IS" BASIS,
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     * See the License for the specific language governing permissions and
     * limitations under the License.
     */

    package contracts

    org.springframework.cloud.contract.spec.Contract.make {
    	request { // (1)
    		method 'PUT' // (2)
    		url '/fraudcheck' // (3)
    		body([ // (4)
    			   "client.id": $(regex('[0-9]{10}')),
    			   loanAmount : 99999
    		])
    		headers { // (5)
    			contentType('application/json')
    		}
    	}
    	response { // (6)
    		status OK() // (7)
    		body([ // (8)
    			   fraudCheckStatus  : "FRAUD",
    			   "rejection.reason": "Amount too high"
    		])
    		headers { // (9)
    			contentType('application/json')
    		}
    	}
    }

    /*
    From the Consumer perspective, when shooting a request in the integration test:

    (1) - If the consumer sends a request
    (2) - With the "PUT" method
    (3) - to the URL "/fraudcheck"
    (4) - with the JSON body that
     * has a field `client.id` that matches a regular expression `[0-9]{10}`
     * has a field `loanAmount` that is equal to `99999`
    (5) - with header `Content-Type` equal to `application/json`
    (6) - then the response will be sent with
    (7) - status equal `200`
    (8) - and JSON body equal to
     { "fraudCheckStatus": "FRAUD", "rejectionReason": "Amount too high" }
    (9) - with header `Content-Type` equal to `application/json`

    From the Producer perspective, in the autogenerated producer-side test:

    (1) - A request will be sent to the producer
    (2) - With the "PUT" method
    (3) - to the URL "/fraudcheck"
    (4) - with the JSON body that
     * has a field `client.id` that will have a generated value that matches a regular expression `[0-9]{10}`
     * has a field `loanAmount` that is equal to `99999`
    (5) - with header `Content-Type` equal to `application/json`
    (6) - then the test will assert if the response has been sent with
    (7) - status equal `200`
    (8) - and JSON body equal to
     { "fraudCheckStatus": "FRAUD", "rejectionReason": "Amount too high" }
    (9) - with header `Content-Type` matching `application/json.*`
     */

YAML.

    request: # (1)
      method: PUT # (2)
      url: /fraudcheck # (3)
      body: # (4)
        "client.id": 1234567890
        loanAmount: 99999
      headers: # (5)
        Content-Type: application/json
      matchers:
        body:
          - path: $.['client.id'] # (6)
            type: by_regex
            value: "[0-9]{10}"
    response: # (7)
      status: 200 # (8)
      body:  # (9)
        fraudCheckStatus: "FRAUD"
        "rejection.reason": "Amount too high"
      headers: # (10)
        Content-Type: application/json;charset=UTF-8

    #From the Consumer perspective, when shooting a request in the integration test:
    #
    #(1) - If the consumer sends a request
    #(2) - With the "PUT" method
    #(3) - to the URL "/fraudcheck"
    #(4) - with the JSON body that
    # * has a field `client.id`
    # * has a field `loanAmount` that is equal to `99999`
    #(5) - with header `Content-Type` equal to `application/json`
    #(6) - and a `client.id` json entry matches the regular expression `[0-9]{10}`
    #(7) - then the response will be sent with
    #(8) - status equal `200`
    #(9) - and JSON body equal to
    # { "fraudCheckStatus": "FRAUD", "rejectionReason": "Amount too high" }
    #(10) - with header `Content-Type` equal to `application/json`
    #
    #From the Producer perspective, in the autogenerated producer-side test:
    #
    #(1) - A request will be sent to the producer
    #(2) - With the "PUT" method
    #(3) - to the URL "/fraudcheck"
    #(4) - with the JSON body that
    # * has a field `client.id` `1234567890`
    # * has a field `loanAmount` that is equal to `99999`
    #(5) - with header `Content-Type` equal to `application/json`
    #(7) - then the test will assert if the response has been sent with
    #(8) - status equal `200`
    #(9) - and JSON body equal to
    # { "fraudCheckStatus": "FRAUD", "rejectionReason": "Amount too high" }
    #(10) - with header `Content-Type` equal to `application/json;charset=UTF-8`

The YML contract is quite straight-forward. However when you take a look at the Contract written using a statically typed Groovy DSL - you might wonder what the `value(client(…​), server(…​))` parts are. By using this notation, Spring Cloud Contract lets you define parts of a JSON block, a URL, etc., which are dynamic. In case of an identifier or a timestamp, you need not hardcode a value. You want to allow some different ranges of values. To enable ranges of values, you can set regular expressions matching those values for the consumer side. You can provide the body by means of either a map notation or String with interpolations. Consult the Chapter 8, Contract DSL section for more information. We highly recommend using the map notation!

| Tip
You must understand the map notation in order to set up contracts. Please read the Groovy docs regarding JSON.

The previously shown contract is an agreement between two sides that:

- if an HTTP request is sent with all of

  - a `PUT` method on the `/fraudcheck` endpoint,
  - a JSON body with a `client.id` that matches the regular expression `[0-9]{10}` and `loanAmount` equal to `99999`,
  - and a `Content-Type` header with a value of `application/vnd.fraud.v1+json`,

- then an HTTP response is sent to the consumer that

  - has status `200`,
  - contains a JSON body with the `fraudCheckStatus` field containing a value `FRAUD` and the `rejectionReason` field having value `Amount too high`,
  - and a `Content-Type` header with a value of `application/vnd.fraud.v1+json`.

Once you are ready to check the API in practice in the integration tests, you need to install the stubs locally.

Add the Spring Cloud Contract Verifier plugin.

We can add either a Maven or a Gradle plugin. In this example, you see how to add Maven. First, add the `Spring Cloud Contract` BOM.

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

Next, add the `Spring Cloud Contract Verifier` Maven plugin

    <plugin>
    	<groupId>org.springframework.cloud</groupId>
    	<artifactId>spring-cloud-contract-maven-plugin</artifactId>
    	<version>${spring-cloud-contract.version}</version>
    	<extensions>true</extensions>
    	<configuration>
    		<packageWithBaseClasses>com.example.fraud</packageWithBaseClasses>
    		<convertToYaml>true</convertToYaml>
    	</configuration>
    </plugin>

Since the plugin was added, you get the `Spring Cloud Contract Verifier` features which, from the provided contracts:

- generate and run tests
- produce and install stubs

You do not want to generate tests since you, as the consumer, want only to play with the stubs. You need to skip the test generation and execution. When you execute:

    $ cd local-http-server-repo
    $ ./mvnw clean install -DskipTests

In the logs, you see something like this:

    [INFO] --- spring-cloud-contract-maven-plugin:1.0.0.BUILD-SNAPSHOT:generateStubs (default-generateStubs) @ http-server ---
    [INFO] Building jar: /some/path/http-server/target/http-server-0.0.1-SNAPSHOT-stubs.jar
    [INFO]
    [INFO] --- maven-jar-plugin:2.6:jar (default-jar) @ http-server ---
    [INFO] Building jar: /some/path/http-server/target/http-server-0.0.1-SNAPSHOT.jar
    [INFO]
    [INFO] --- spring-boot-maven-plugin:1.5.5.BUILD-SNAPSHOT:repackage (default) @ http-server ---
    [INFO]
    [INFO] --- maven-install-plugin:2.5.2:install (default-install) @ http-server ---
    [INFO] Installing /some/path/http-server/target/http-server-0.0.1-SNAPSHOT.jar to /path/to/your/.m2/repository/com/example/http-server/0.0.1-SNAPSHOT/http-server-0.0.1-SNAPSHOT.jar
    [INFO] Installing /some/path/http-server/pom.xml to /path/to/your/.m2/repository/com/example/http-server/0.0.1-SNAPSHOT/http-server-0.0.1-SNAPSHOT.pom
    [INFO] Installing /some/path/http-server/target/http-server-0.0.1-SNAPSHOT-stubs.jar to /path/to/your/.m2/repository/com/example/http-server/0.0.1-SNAPSHOT/http-server-0.0.1-SNAPSHOT-stubs.jar

The following line is extremely important:

    [INFO] Installing /some/path/http-server/target/http-server-0.0.1-SNAPSHOT-stubs.jar to /path/to/your/.m2/repository/com/example/http-server/0.0.1-SNAPSHOT/http-server-0.0.1-SNAPSHOT-stubs.jar

It confirms that the stubs of the `http-server` have been installed in the local repository.

Run the integration tests.

In order to profit from the Spring Cloud Contract Stub Runner functionality of automatic stub downloading, you must do the following in your consumer side project (`Loan Application service`):

Add the `Spring Cloud Contract` BOM:

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

Add the dependency to `Spring Cloud Contract Stub Runner`:

    <dependency>
    	<groupId>org.springframework.cloud</groupId>
    	<artifactId>spring-cloud-starter-contract-stub-runner</artifactId>
    	<scope>test</scope>
    </dependency>

Annotate your test class with `@AutoConfigureStubRunner`. In the annotation, provide the `group-id` and `artifact-id` for the Stub Runner to download the stubs of your collaborators. (Optional step) Because you’re playing with the collaborators offline, you can also provide the offline work switch (`StubRunnerProperties.StubsMode.LOCAL`).

    @RunWith(SpringRunner.class)
    @SpringBootTest(webEnvironment = WebEnvironment.NONE)
    @AutoConfigureStubRunner(ids = {
    		"com.example:http-server-dsl:+:stubs:6565" }, stubsMode = StubRunnerProperties.StubsMode.LOCAL)
    public class LoanApplicationServiceTests {

Now, when you run your tests, you see something like this:

    2016-07-19 14:22:25.403  INFO 41050 --- [           main] o.s.c.c.stubrunner.AetherStubDownloader  : Desired version is + - will try to resolve the latest version
    2016-07-19 14:22:25.438  INFO 41050 --- [           main] o.s.c.c.stubrunner.AetherStubDownloader  : Resolved version is 0.0.1-SNAPSHOT
    2016-07-19 14:22:25.439  INFO 41050 --- [           main] o.s.c.c.stubrunner.AetherStubDownloader  : Resolving artifact com.example:http-server:jar:stubs:0.0.1-SNAPSHOT using remote repositories []
    2016-07-19 14:22:25.451  INFO 41050 --- [           main] o.s.c.c.stubrunner.AetherStubDownloader  : Resolved artifact com.example:http-server:jar:stubs:0.0.1-SNAPSHOT to /path/to/your/.m2/repository/com/example/http-server/0.0.1-SNAPSHOT/http-server-0.0.1-SNAPSHOT-stubs.jar
    2016-07-19 14:22:25.465  INFO 41050 --- [           main] o.s.c.c.stubrunner.AetherStubDownloader  : Unpacking stub from JAR [URI: file:/path/to/your/.m2/repository/com/example/http-server/0.0.1-SNAPSHOT/http-server-0.0.1-SNAPSHOT-stubs.jar]
    2016-07-19 14:22:25.475  INFO 41050 --- [           main] o.s.c.c.stubrunner.AetherStubDownloader  : Unpacked file to [/var/folders/0p/xwq47sq106x1_g3dtv6qfm940000gq/T/contracts100276532569594265]
    2016-07-19 14:22:27.737  INFO 41050 --- [           main] o.s.c.c.stubrunner.StubRunnerExecutor    : All stubs are now running RunningStubs [namesAndPorts={com.example:http-server:0.0.1-SNAPSHOT:stubs=8080}]

This output means that Stub Runner has found your stubs and started a server for your app with group id `com.example`, artifact id `http-server` with version `0.0.1-SNAPSHOT` of the stubs and with `stubs` classifier on port `8080`.

File a pull request.

What you have done until now is an iterative process. You can play around with the contract, install it locally, and work on the consumer side until the contract works as you wish.

Once you are satisfied with the results and the test passes, publish a pull request to the server side. Currently, the consumer side work is done.

### 2.5.3 Producer side (Fraud Detection server)

As a developer of the Fraud Detection server (a server to the Loan Issuance service):

Create an initial implementation.

As a reminder, you can see the initial implementation here:

    @RequestMapping(value = "/fraudcheck", method = PUT)
    public FraudCheckResult fraudCheck(@RequestBody FraudCheck fraudCheck) {
    return new FraudCheckResult(FraudCheckStatus.OK, NO_REASON);
    }

Take over the pull request.

    $ git checkout -b contract-change-pr master
    $ git pull https://your-git-server.com/server-side-fork.git contract-change-pr

You must add the dependencies needed by the autogenerated tests:

    <dependency>
    	<groupId>org.springframework.cloud</groupId>
    	<artifactId>spring-cloud-starter-contract-verifier</artifactId>
    	<scope>test</scope>
    </dependency>

In the configuration of the Maven plugin, pass the `packageWithBaseClasses` property

    <plugin>
    	<groupId>org.springframework.cloud</groupId>
    	<artifactId>spring-cloud-contract-maven-plugin</artifactId>
    	<version>${spring-cloud-contract.version}</version>
    	<extensions>true</extensions>
    	<configuration>
    		<packageWithBaseClasses>com.example.fraud</packageWithBaseClasses>
    		<convertToYaml>true</convertToYaml>
    	</configuration>
    </plugin>

| Important
This example uses "convention based" naming by setting the `packageWithBaseClasses` property. Doing so means that the two last packages combine to make the name of the base test class. In our case, the contracts were placed under `src/test/resources/contracts/fraud`. Since you do not have two packages starting from the `contracts` folder, pick only one, which should be `fraud`. Add the `Base` suffix and capitalize `fraud`. That gives you the `FraudBase` test class name.

All the generated tests extend that class. Over there, you can set up your Spring Context or whatever is necessary. In this case, use Rest Assured MVC to start the server side `FraudDetectionController`.

    /*
     * Copyright 2013-2019 the original author or authors.
     *
     * Licensed under the Apache License, Version 2.0 (the "License");
     * you may not use this file except in compliance with the License.
     * You may obtain a copy of the License at
     *
     *      https://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing, software
     * distributed under the License is distributed on an "AS IS" BASIS,
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     * See the License for the specific language governing permissions and
     * limitations under the License.
     */

    package com.example.fraud;

    import io.restassured.module.mockmvc.RestAssuredMockMvc;
    import org.junit.Before;

    public class FraudBase {

    	@Before
    	public void setup() {
    		RestAssuredMockMvc.standaloneSetup(new FraudDetectionController(),
    				new FraudStatsController(stubbedStatsProvider()));
    	}

    	private StatsProvider stubbedStatsProvider() {
    		return fraudType -> {
    			switch (fraudType) {
    			case DRUNKS:
    				return 100;
    			case ALL:
    				return 200;
    			}
    			return 0;
    		};
    	}

    	public void assertThatRejectionReasonIsNull(Object rejectionReason) {
    		assert rejectionReason == null;
    	}

    }

Now, if you run the `./mvnw clean install`, you get something like this:

    Results :

    Tests in error:
      ContractVerifierTest.validate_shouldMarkClientAsFraud:32 » IllegalState Parsed...

This error occurs because you have a new contract from which a test was generated and it failed since you have not implemented the feature. The auto-generated test would look like this:

    @Test
    public void validate_shouldMarkClientAsFraud() throws Exception {
        // given:
            MockMvcRequestSpecification request = given()
                    .header("Content-Type", "application/vnd.fraud.v1+json")
                    .body("{\"client.id\":\"1234567890\",\"loanAmount\":99999}");

        // when:
            ResponseOptions response = given().spec(request)
                    .put("/fraudcheck");

        // then:
            assertThat(response.statusCode()).isEqualTo(200);
            assertThat(response.header("Content-Type")).matches("application/vnd.fraud.v1.json.*");
        // and:
            DocumentContext parsedJson = JsonPath.parse(response.getBody().asString());
            assertThatJson(parsedJson).field("['fraudCheckStatus']").matches("[A-Z]{5}");
            assertThatJson(parsedJson).field("['rejection.reason']").isEqualTo("Amount too high");
    }

If you used the Groovy DSL, you can see, all the `producer()` parts of the Contract that were present in the `value(consumer(…​), producer(…​))` blocks got injected into the test. In case of using YAML, the same applied for the `matchers` sections of the `response`.

Note that, on the producer side, you are also doing TDD. The expectations are expressed in the form of a test. This test sends a request to our own application with the URL, headers, and body defined in the contract. It also is expecting precisely defined values in the response. In other words, you have the `red` part of `red`, `green`, and `refactor`. It is time to convert the `red` into the `green`.

Write the missing implementation.

Because you know the expected input and expected output, you can write the missing implementation:

    @RequestMapping(value = "/fraudcheck", method = PUT)
    public FraudCheckResult fraudCheck(@RequestBody FraudCheck fraudCheck) {
    if (amountGreaterThanThreshold(fraudCheck)) {
    	return new FraudCheckResult(FraudCheckStatus.FRAUD, AMOUNT_TOO_HIGH);
    }
    return new FraudCheckResult(FraudCheckStatus.OK, NO_REASON);
    }

When you execute `./mvnw clean install` again, the tests pass. Since the `Spring Cloud Contract Verifier` plugin adds the tests to the `generated-test-sources`, you can actually run those tests from your IDE.

Deploy your app.

Once you finish your work, you can deploy your change. First, merge the branch:

    $ git checkout master
    $ git merge --no-ff contract-change-pr
    $ git push origin master

Your CI might run something like `./mvnw clean deploy`, which would publish both the application and the stub artifacts.

### 2.5.4 Consumer Side (Loan Issuance) Final Step

As a developer of the Loan Issuance service (a consumer of the Fraud Detection server):

Merge branch to master.

    $ git checkout master
    $ git merge --no-ff contract-change-pr

Work online.

Now you can disable the offline work for Spring Cloud Contract Stub Runner and indicate where the repository with your stubs is located. At this moment the stubs of the server side are automatically downloaded from Nexus/Artifactory. You can set the value of `stubsMode` to `REMOTE`. The following code shows an example of achieving the same thing by changing the properties.

    stubrunner:
      ids: 'com.example:http-server-dsl:+:stubs:8080'
      repositoryRoot: https://repo.spring.io/libs-snapshot

That’s it!

## 2.6 Dependencies

The best way to add dependencies is to use the proper `starter` dependency.

For `stub-runner`, use `spring-cloud-starter-stub-runner`. When you use a plugin, add `spring-cloud-starter-contract-verifier`.

## 2.7 Additional Links

Here are some resources related to Spring Cloud Contract Verifier and Stub Runner. Note that some may be outdated, because the Spring Cloud Contract Verifier project is under constant development.

### 2.7.1 Spring Cloud Contract video

You can check out the video from the Warsaw JUG about Spring Cloud Contract:

### 2.7.2 Readings

- Slides from Marcin Grzejszczak’s talk about Accurest
- Accurest related articles from Marcin Grzejszczak’s blog
- Spring Cloud Contract related articles from Marcin Grzejszczak’s blog
- Groovy docs regarding JSON

## 2.8 Samples

You can find some samples at samples.

Prev |  | Next
1. Spring Cloud Contract | Home | 3. Spring Cloud Contract FAQ