Middle East Phone Number Database

Blog

Middle East Phone Number database

Testing Services Using SPRING CLOUD CONTRACT

Two popular contract testing frameworks are Spring Cloud Contract  which is a consumer contract testing framework for Spring applications, and the Pact family of  which support a variety of languages. This FTGO application is an Spring framework-based program, so in this chapter, I’m going explain how to use Spring Cloud Contract. It offers a Groovy specific language (DSL) for writing contracts. Each contract provides a concrete instance of interaction between a buyer and a service provider for example, the HTTP request and a response. Spring Cloud Contract code generates contracts for the service provider. It also creates mocks, for example, mock HTTP server, to allow tests of integration for consumers. buy Middle East Phone Number database online

Let’s say, for instance that you’re working with API Gateway and want to create a consumer contract test in order to Order Service. Figure 9.8 illustrates the process that requires collaboration together with Order Service teams. You draft contracts that outline the way that API Gateway interacts with Order Service. It is the Order Service team uses these contracts to test Order Service, and you employ the contracts for testing API Gateway. The steps are as the following: Middle East Phone Number b2b database

You create at least one contract, for example, the one listed in figure 9.1. Each contract consists in the HTTP Request which API Gateway might send to Order Service and an expected HTTP response. The contracts are given by way of an Git pull request and then and Order Service. Order Service team. Middle East Phone Number database

The Order Service team tests Order Service by using consumer contract test which Spring Cloud Contract code generates from contracts.
Order Service team Order Service team publishes the contracts used to test Order Service to a Maven repository. Middle East Phone Number b2b database

You can use the contracts published to create testing to test the API Gateway.

As you test API Gateway using the published contracts and contracts, you are able to be certain that it is compatible in conjunction with the Order Service.

Contracts are the most important element of this testing strategy. This listing provides an illustration of a Spring Cloud Contract. It comprises in an HTTP request as well as the HTTP response. Middle East Phone Number database

It is an HTTP request to the REST endpoint, GET /ordersor orderId. It refers to an HTTP response which describes an order that is to be fulfilled by the API Gateway. The Groovy contract is an integral part of the code base. Each consumer team has contracts that define the way their service works with the provider. They also provide the contracts, possibly through a Git pull request to the team of the provider. This team of providers is accountable to package the contracts into JARs JAR and publishing them into Maven. Maven repository. Consumer-side tests take from the JAR directly from Maven’s repository. Middle East Phone Number b2b database

Every contract’s request and response have two roles: test data as well as the spec-ification of the expected behaviour. When a test is conducted on the consumer side, it is utilized to set up an stub that is identical to the Mockito mock object, and mimics how Order Service behaves. Order Service. It allows API Gateway to be tested without the need to run Order Service. The provider-side test is where the test class generated invokes the service using the con-contract’s request, and then checks to see if it is able to return an answer that is consistent with that of the agreement’s. The next chapter discusses details of how to utilize Spring Cloud Con-tract. However, this time we’ll examine how to utilize mes-sending APIs. buy Middle East Phone Number database online

Middle East Phone Number mailing lists

CONSUMER CONTRACT TESTING CONSUMER CONTRACT TESTS MESSAGING APIS

The REST client isn’t the only type of user that is conditioned to use the API of a service provider. Services that subscribe to domain events and use asynchronous request/response-based communication are also consumers. They use a different service’s messaging API and they make assumptions about the nature of the API. Additionally, we must develop con-sumer contracts to test these APIs. Middle East Phone Number database providers

Spring Cloud Contract also provides the ability to test messaging-based interactions. The form of a contract and the method of use by tests is contingent upon the kind of interaction. A contract for publishing a domain event includes an example of a domain event. A test for the provider causes the provider to issue an event and verify that it’s in accordance with the event specified in the contract. A test for consumers confirms that the consumer is capable of handling the event. The next section I will describe an example of a test. Middle East Phone Number b2c database

The contract that governs an asynchronous response/request interaction is like the HTTP contract. It is comprised of two messages: a request and a response. A test performed by a provider invokes the API by using the request message from the contract and confirms that the response matches with the contract’s response. Consumer tests use the contract to create the stub subscriber. It is able to listen for the request message of the contract and responds with the specified response. The following chapter will go over the test in detail. We’ll first examine the deployment pipeline that also runs other tests. Middle East Phone Number database

The pipeline for deployment

Every service comes with a deployment pipeline. Jez Humble’s book Continuous Delivery (Addison-Wesley 2010.) describes a pipeline for deployment as the process that automates getting code from the desktop of the developer to production. As the figure 9.9 illustrates, it’s comprised of a set of stages where test suites are executed and then a final stage that deploys or releases the service. It should be completely automated, however it could also include manual steps. The deployment-ment pipeline is usually run by using the continuous Integration (CI) server like Jenkins. Middle East Phone Number b2c database

When code moves throughout the process, test suites are subject to increasingly rigorous testing in environments that are more like production. In the same way the time to execute each test suite usually increases. The goal is to give feedback on the failures of tests as quickly as is possible.

The deployment pipeline that is illustrated in figure 9.9 is comprised of the following steps:

The pre-commit test stage runs Unit tests. This is done by the developer prior to the commit of their modifications.

Commit Tests stage — Compiles the services and runs unit tests and also performs static analysis of code. Middle East Phone Number database

Integration tests stage — Runs through the tests for integration.

Component tests stage — Runs the component tests to test the service.

Deploy stage – Converts the service to production.

The CI server is responsible for the commit stage whenever the developer commits changes. It runs extremely fast thus providing quick feedback on the change. The subsequent phases take longer to complete giving more delayed feedback. If all tests are successful the final stage will be when the pipeline goes into production. Middle East Phone Number database

In this case the deployment pipeline has been completely automated from commit to deployment. However, there are instances where manual steps are required. For instance, you could require a manual test stage, for instance, the staging environment. In this scenario the code is moved to the next stage after an individual tester clicks on the button to signal that the test was successful. In another case, a pipeline for deployment for an on-premise application will release the latest versions of its service. In the future, the newly new services could be packaged into the form of a product release, and then shipped to customers. Middle East Phone Number b2c database

After we’ve examined the design of the pipeline for deployment as well as when it is executing the various types of tests, we’ll go to the lowest point of the pyramid of test and examine the process of writing unit tests for the service.

Writing unit tests for a particular service

Imagine you need to create a test that ensures it is true that FTGO Application’s Order Service correctly calculates the total of an order’s subtotal. Tests could be written which run Order Service to invoke its REST API, create an Order and then verify whether the HTTP response is in line with the expected values. The disadvantage of this approach is that, not only is the test difficult and time-consuming, but also it’s slow. In the event that these were test that compiles time for Order you’d be wasting lots of time waiting for the test to be completed. The most efficient method is to create Unit tests that test for the class Order. Middle East Phone Number customers database
There are two types of unit tests

Solitary unit test—Tests a class in isolation using mock objects for the class’s dependencies

Sociable unit test—Tests a class and its dependencies

The responsibilities of the class and its role in the architecture determine which type of test to use. Figure 9.11 shows the hexagonal architecture of a typical service and the type of unit test that you’ll typically use for each kind of class. Controller and service classes are often tested using solitary unit tests. Domain objects, such as entities and value objects, are typically tested using sociable unit tests. buy Middle East Phone Number database online

Middle East Phone Number lists

The typical testing strategy for each class is as follows:

Entities, such as Order, which as described in chapter 5 are objects with per-sistent identity, are tested using sociable unit tests.

Value objects, such as Money, which as described in chapter 5 are objects that are collections of values, are tested using sociable unit tests.

Sagas, such as CreateOrderSaga, which as described in chapter 4 maintain data consistency across services, are tested using sociable unit tests. Middle East Phone Number database providers

Domain services, such as OrderService, which as described in chapter 5 are classes that implement business logic that doesn’t belong in entities or value objects, are tested using solitary unit tests. Middle East Phone Number database

Controllers, such as OrderController, which handle HTTP requests, are tested using solitary unit tests.

Inbound and outbound messaging gateways are tested using solitary unit tests.

Let’s begin by looking at how to test entities.

Developing unit tests for entities

The following listing shows an excerpt of OrderTest class, which implements the unit tests for the Order entity. The class has an @Before setUp() method that creates an Order before running each test. Its @Test methods might further initialize Order, invoke one of its methods, and then make assertions about the return value and the state of Order.

. They are sociable unit tests for the Order class and its dependencies. You can use them as compile-time tests because they execute extremely quickly. The Order class relies on the Money value object, so it’s important to test that class as well. Let’s see how to do that. Middle East Phone Number customers database

Writing unit tests for value objects

Value objects are immutable, so they tend to be easy to test. You don’t have to worry about side effects. A test for a value object typically creates a value object in a particu-lar state, invokes one of its methods, and makes assertions about the return value. List-ing 9.3 shows the tests for the Money value object, which is a simple class that represents a money value. These tests verify the behavior of the Money class’s methods, including add(), which adds two Money objects, and multiply(), which multiplies a Money object by an integer. They are solitary tests because the Money class doesn’t depend on any other application classes.
Entities and value objects are the building blocks of a service’s business logic. But some business logic also resides in the service’s sagas and services. Let’s look at how to test those. Middle East Phone Number database

Developing unit tests for sagas

A saga, such as the CreateOrderSaga class, implements important business logic, so needs to be tested. It’s a persistent object that sends command messages to saga partic-ipants and processes their replies. As described in chapter 4, CreateOrderSaga exchanges command/reply messages with several services, such as Consumer Service and Kitchen Service. A test for this class creates a saga and verifies that it sends the expected sequence of messages to the saga participants. One test you need to write is for the happy path. You must also write tests for the various scenarios where the saga rolls back because a saga participant sent back a failure message. Middle East Phone Number customers database

One approach would be to write tests that use a real database and message broker along with stubs to simulate the various saga participants. For example, a stub for Consumer Service would subscribe to the consumerService command channel and send back the desired reply message. But tests written using this approach would be quite slow. A much more effective approach is to write tests that mock those classes that interact with the database and message broker. That way, we can focus on testing the saga’s core responsibility. buy Middle East Phone Number database online

Middle East Phone Number

Listing 9.4 shows a test for CreateOrderSaga. It’s a sociable unit test that tests the saga class and its dependencies. It’s written using the Eventuate Tram Saga testing framework (https://github.com/eventuate-tram/eventuate-tram-sagas). This frame-work provides an easy-to-use DSL that abstracts away the details of interacting with sagas. With this DSL, you can create a saga and verify that it sends the correct com-mand messages. Under the covers, the Saga testing framework configures the Saga framework with mocks for the database and messaging infrastructure. Middle East Phone Number database providers

Send a failure reply indicating that Consumer Service rejected Order.

The @Test shouldCreateOrder() method tests the happy path. The @Test should-

RejectOrderDueToConsumerVerificationFailed() method tests the scenario where

Consumer Service rejects the order. It verifies that CreateOrderSaga sends a Reject-

OrderCommand to compensate for the consumer being rejected. The CreateOrder-

SagaTest class has methods that test other failure scenarios. Middle East Phone Number business database

Let’s now look at how to test domain services.

Writing unit tests for domain services

The majority of a service’s business logic is implemented by the entities, value objects, and sagas. Domain service classes, such as the OrderService class, implement the remainder. This class is a typical domain service class. Its methods invoke entities and repositories and publish domain events. An effective way to test this kind of class is to use a mostly solitary unit test, which mocks dependencies such as repositories and messaging classes.

Listing 9.5 shows the OrderServiceTest class, which tests OrderService. It defines solitary unit tests, which use Mockito mocks for the service’s dependencies. Each test implements the test phases as follows: Middle East Phone Number database

Setup—Configures the mock objects for the service’s dependencies

Execute—Invokes a service method

Verify—Verifies that the value returned by the service method is correct and that the dependencies have been invoked correctly

Listing 9.5 A simple, fast-running unit test for the OrderService class

public class OrderServiceTest {

private OrderService orderService; private OrderRepository orderRepository; private DomainEventPublisher eventPublisher; private RestaurantRepository restaurantRepository; Middle East Phone Number business database

private SagaManager createOrderSagaManager; private SagaManager cancelOrderSagaManager; private SagaManager reviseOrderSagaManager;

@Before

public void setup() {

orderRepository = mock(OrderRepository.class); eventPublisher = mock(DomainEventPublisher.class);
restaurantRepository = mock(RestaurantRepository.class);

Create Mockito mocks for OrderService’s dependencies.

Invoke OrderService .create().

Verify that OrderService published an Order-CreatedEvent.

createOrderSagaManager = mock(SagaManager.class); Middle East Phone Number database

cancelOrderSagaManager = mock(SagaManager.class);

reviseOrderSagaManager = mock(SagaManager.class);

orderService = new OrderService(orderRepository, eventPublisher,

restaurantRepository, createOrderSagaManager, cancelOrderSagaManager, reviseOrderSagaManager);
} Create an OrderService injected Middle East Phone Number business database

with mock dependencies.
@Test Configure RestaurantRepository.findById()

public void shouldCreateOrder() { to return the Ajanta restaurant.
when(restaurantRepository

.findById(AJANTA_ID)).thenReturn(Optional.of(AJANTA_RESTAURANT_);

when(orderRepository.save(any(Order.class))).then(invocation -> { Order order = (Order) invocation.getArguments()[0];

order.setId(ORDER_ID);
Configure OrderRepository.save()
return order;
to set Order’s ID.

Order order = orderService.createOrder(CONSUMER_ID,

AJANTA_ID, CHICKEN_VINDALOO_MENU_ITEMS_AND_QUANTITIES);

verify(orderRepository).save(same(order)); Verify that Middle East Phone Number database

OrderService saved Middle East Phone Number Profile

the newly created
verify(eventPublisher).publish(Order.class, ORDER_ID, Order in the database.
singletonList(
new OrderCreatedEvent(CHICKEN_VINDALOO_ORDER_DETAILS)));
verify(createOrderSagaManager) Verify that Order-
.create(new CreateOrderSagaState(ORDER_ID,
Service created a
CHICKEN_VINDALOO_ORDER_DETAILS), CreateOrderSaga.
Order.class, ORDER_ID);
}

}

The setUp() method creates an OrderService injected with mock dependencies. The @Test shouldCreateOrder() method verifies that OrderService.createOrder() invokes OrderRepository to save the newly created Order, publishes an OrderCreated-Event, and creates a CreateOrderSaga. Middle East Phone Number id list

Middle East Phone Number listing

Now that we’ve seen how to unit test the domain logic classes, let’s look at how to unit test the adapters that interact with external systems.

Developing unit tests for controllers Middle East Phone Number database providers

Services, such as Order Service, typically have one or more controllers that handle HTTP requests from other services and the API gateway. A controller class consists of a set of request handler methods. Each method implements a REST API endpoint. A method’s parameters represent values from the HTTP request, such as path variables. It typically invokes a domain service or a repository and returns a response object.

OrderController, for instance, invokes OrderService and OrderRepository. An effective testing strategy for controllers is solitary unit tests that mock the services and repositories.

You could write a test class similar to the OrderServiceTest class to instantiate a controller class and invoke its methods. But this approach doesn’t test some import-ant functionality, such as request routing. It’s much more effective to use a mock MVC testing framework, such as Spring Mock Mvc, which is part of the Spring Framework, or Rest Assured Mock MVC, which builds on Spring Mock Mvc. Tests written using one of these frameworks make what appear to be HTTP requests and make assertions about HTTP responses. These frameworks enable you to test HTTP request routing and conversion of Java objects to and from JSON without having to make real network calls. Under the covers, Spring Mock Mvc instantiates just enough of the Spring MVC classes to make this possible. Middle East Phone Number Profile

Are these really unit tests?

Because these tests use the Spring Framework, you might argue that they’re not unit tests. They’re certainly more heavyweight than the unit tests I’ve described so far. The Spring Mock Mvc documentation refers to these as out-of-servlet-container inte-gration tests (https://docs.spring.io/spring/docs/current/spring-framework-reference/ testing.html#spring-mvc-test-vs-end-to-end-integration-tests). Yet Rest Assured Mock MVC describes these tests as unit tests (https://github.com/rest-assured/rest-assured/wiki/Usage#spring-mock-mvc-module). Regardless of the debate over termi-nology, these are important tests to write. Middle East Phone Number database

Listing 9.6 shows the OrderControllerTest class, which tests Order Service’s Order-Controller. It defines solitary unit tests that use mocks for OrderController’s depen-dencies. It’s written using Rest Assured Mock MVC , which provides a simple DSL that abstracts away the details of interacting with controllers. Rest Assured makes it easy to send a mock HTTP request to a controller and verify the response. OrderController-Test creates a controller that’s injected with Mockito mocks for OrderService and OrderRepository. Each test configures the mocks, makes an HTTP request, verifies that the response is correct, and possibly verifies that the controller invoked the mocks. Middle East Phone Number Profile

A simple, fast-running unit test for the OrderController class

public class OrderControllerTest {

private OrderService orderService; private OrderRepository orderRepository;

@Before

public void setUp() throws Exception { orderService = mock(OrderService.class); orderRepository = mock(OrderRepository.class);
controllers, message adapters tend to be simple classes that invoke domain services. Each of a message adapter’s methods typically invokes a service method with data from the message or event. Middle East Phone Number leads

We can unit test message adapters using an approach similar to the one we used for unit testing controllers. Each test instances the message adapter, sends a message to a channel, and verifies that the service mock was invoked correctly. Behind the scenes, though, the messaging infrastructure is stubbed, so no message broker is involved. Let’s look at how to test the OrderEventConsumer class. Middle East Phone Number database

Listing 9.7 shows part of the OrderEventConsumerTest class, which tests Order-EventConsumer. It verifies that OrderEventConsumer routes each event to the appro-priate handler method and correctly invokes OrderService. The test uses the Eventuate Tram Mock Messaging framework, which provides an easy-to-use DSL for writing mock messaging tests that uses the same given-when-then format as Rest Assured. Each test instantiates OrderEventConsumer injected with a mock Order-Service, publishes a domain event, and verifies that OrderEventConsumer correctly invokes the service mock.
A fast-running unit test for the OrderEventConsumer class

public class OrderEventConsumerTest {

private OrderService orderService; Middle East Phone Number id list

private OrderEventConsumer orderEventConsumer;

Middle East Phone Number leads

public void setUp() throws Exception { orderService = mock(OrderService.class);
orderEventConsumer = new OrderEventConsumer(orderService);

}

@Test Configure Middle East Phone Number address lists
public void shouldCreateMenu() { OrderEventConsumer
domain handlers.

given(). Middle East Phone Number leads

eventHandlers(orderEventConsumer.domainEventHandlers()).

Publish a Restaurant-Created event.

}
when().

aggregate(“net.chrisrichardson.ftgo.restaurantservice.domain.Restaurant”,

AJANTA_ID).

publishes(new RestaurantCreated(AJANTA_RESTAURANT_NAME, RestaurantMother.AJANTA_RESTAURANT_MENU)) Middle East Phone Number database

then().
verify(() -> { Verify that OrderEventConsumer
verify(orderService)
invoked OrderService.createMenu().
.createMenu(AJANTA_ID,

new RestaurantMenu(RestaurantMother.AJANTA_RESTAURANT_MENU_ITEMS));

})

;

}

The setUp() method creates an OrderEventConsumer injected with a mock Order-

Service. The shouldCreateMenu() method publishes a RestaurantCreated event

and verifies that OrderEventConsumer invoked OrderService.createMenu(). The

OrderEventConsumerTest class and the other unit test classes execute extremely quickly.

The unit tests run in just a few seconds.

But the unit tests don’t verify that a service, such as Order Service, properly inter-acts with other services. For example, the unit tests don’t verify that an Order can be persisted in MySQL. Nor do they verify that CreateOrderSaga sends command mes-sages in the right format to the right message channel. And they don’t verify that the RestaurantCreated event processed by OrderEventConsumer has the same structure as the event published by Restaurant Service. In order to verify that a service prop-erly interacts with other services, we must write integration tests. We also need to write component tests that test an entire service in isolation. The next chapter discusses how to conduct those types of tests, as well as end-to-end tests.Middle East Phone Number leads

Summary

Automated testing is the key foundation of rapid, safe delivery of software. What’s more, because of its inherent complexity, to fully benefit from the microservice architecture you must automate your tests.

The purpose of a test is to verify the behavior of the system under test (SUT). In this definition, system is a fancy term that means the software element being tested. It might be something as small as a class, as large as the entire applica-tion, or something in between, such as a cluster of classes or an individual ser-vice. A collection of related tests form a test suite. Middle East Phone Number database

A good way to simplify and speed up a test is to use test doubles. A test double is an object that simulates the behavior of a SUT’s dependency. There are two types of test doubles: stubs and mocks. A stub is a test double that returns values to the SUT. A mock is a test double that a test uses to verify that the SUT cor-rectly invokes a dependency. Middle East Phone Number listing 

Use the test pyramid to determine where to focus your testing efforts for your services. The majority of your tests should be fast, reliable, and easy-to-write unit tests. You must minimize the number of end-to-end tests, because they’re slow, brittle, and time consuming to write.

Writing integration tests
Services typically interact with other services. For example, Order Service, as fig-ure 10.1 shows, interacts with several services. Its REST API is consumed by API Gateway, and its domain events are consumed by services, including Order History Service. Order Service uses several other services. It persists Orders in MySQL. It also sends commands to and consumes replies from several other services, such as Kitchen Service.

In order to be confident that a service such as Order Service works as expected, we must write tests that verify that the service can properly interact with infrastructure services and other application services. One approach is to launch all the services and test them through their APIs. This, however, is what’s known as end-to-end testing, which is slow, brittle, and costly. As explained in section 10.3, there’s a role for end-to-end testing sometimes, but it’s at the top of the test pyramid, so you want to minimize the number of end-to-end tests. Middle East Phone Number id list

Middle East Phone Number Profile

A much more effective strategy is to write what are known as integration tests. As fig-ure 10.2 shows, integration tests are the layer above unit tests in the testing pyramid. They verify that a service can properly interact with infrastructure services and other ser-vices. But unlike end-to-end tests, they don’t launch services. Instead, we use a couple of strategies that significantly simplify the tests without impacting their effectiveness. Middle East Phone Number address lists

The first strategy is to test each of the service’s adapters, along with, perhaps, the adapter’s supporting classes. For example, in section 10.1.1 you’ll see a JPA per-sistence test that verifies that Orders are persisted correctly. Rather than test persistence through Order Service’s API, it directly tests the OrderRepository class. Similarly, in section 10.1.3 you’ll see a test that verifies that Order Service publishes correctly structured domain events by testing the OrderDomainEventPublisher class. The bene-fit of testing only a small number of classes rather than the entire service is that the tests are significantly simpler and faster. Middle East Phone Number listing

The second strategy for simplifying integration tests that verify interactions between application services is to use contracts, discussed in chapter 9. A contract is a concrete example of an interaction between a pair of services. As table 10.1 shows, the structure of a contract depends on the type of interaction between the services. Middle East Phone Number database

A contract consists of either one message, in the case of publish/subscribe style inter-actions, or two messages, in the case of request/response and asynchronous request/ response style interactions.

The contracts are used to test both the consumer and the provider, which ensures that they agree on the API. They’re used in slightly different ways depending on whether you’re testing the consumer or the provider: Middle East Phone Number listing

Consumer-side tests—These are tests for the consumer’s adapter. They use the contracts to configure stubs that simulate the provider, enabling you to write integration tests for a consumer that don’t require a running provider.

Provider-side tests—These are tests for the provider’s adapter. They use the con-tracts to test the adapters
using mocks for the adapters’s dependencies. Middle East Phone Number database

Later in this section, I describe examples of these types of tests—but first let’s look at how to write persistence tests. Middle East Phone Number database

Persistence integration tests

Services typically store data in a database. For instance, Order Service persists aggre-gates, such as Order, in MySQL using JPA. Similarly, Order History Service maintains a CQRS view in AWS DynamoDB. The unit tests we wrote earlier only test in-memory objects. In order to be confident that a service works correctly, we must write per-sistence integration tests, which verify that a service’s database access logic works as expected. In the case of Order Service, this means testing the JPA repositories, such as OrderRepository.

Each phase of a persistence integration test behaves as follows:

Setup—Set up the database by creating the database schema and initializing it to a known state. It might also begin a database transaction.

Execute—Perform a database operation.

Verify—Make assertions about the state of the database and objects retrieved from the database.

Teardown—An optional phase that might undo the changes made to the database by, for example, rolling back the transaction that was started by the setup phase.

Listing 10.1 shows a persistent integration test for the Order aggregate and Order-Repository. Apart from relying on JPA to create the database schema, the persistence integration tests don’t make any assumption about the state of the database. Conse-quently, tests don’t need to roll back the changes they make to the database, which avoids problems with the ORM caching data changes in memory. Middle East Phone Number database

The shouldSaveAndLoadOrder() test method executes two transactions. The first saves a newly created Order in the database. The second transaction loads the Order and verifies that its fields are properly initialized. Middle East Phone Number database

One problem you need to solve is how to provision the database that’s used in per-sistence integration tests. An effective solution to run an instance of the database during testing is to use Docker. Section 10.2 describes how to use the Docker Compose Gradle plugin to automatically run services during component testing. You can use a similar approach to run MySQL, for example, during persistence integration testing.

The database is only one of the external services a service interacts with. Let’s now look at how to write integration tests for interservice communication between applica-tion services, starting with REST.

10.1.2 Integration testing REST-based request/response style interactions

REST is a widely used interservice communication mechanism. The REST client and REST service must agree on the REST API, which includes the REST endpoints and the structure of the request and response bodies. The client must send an HTTP request to the correct endpoint, and the service must send back the response that the client expects. Middle East Phone Number database

For example, chapter 8 describes how the FTGO application’s API Gateway makes REST API calls to numerous services, including ConsumerService, Order Service, and Delivery Service. The OrderService’s GET /orders/{orderId} endpoint is one of the endpoints invoked by the API Gateway. In order to be confident that API Gateway and Order Service can communicate without using an end-to-end test, we need to write integration tests.

As stated in the preceding chapter, a good integration testing strategy is to use consumer-driven contract tests. The interaction between API Gateway and GET /orders/{orderId} can be described using a set of HTTP-based contracts. Each con-tract consists of an HTTP request and an HTTP reply. The contracts are used to test API Gateway and Order Service. Middle East Phone Number id list

Middle East Phone Number business database

Figure 10.3 shows how to use Spring Cloud Contract to test REST-based interac-tions. The consumer-side API Gateway integration tests use the contracts to configure an HTTP stub server that simulates the behavior of Order Service. A contract’s request specifies an HTTP request from the API gateway, and the contract’s response specifies the response that the stub sends back to the API gateway. Spring Cloud Con-tract uses the contracts to code-generate the provider-side Order Service integration tests, which test the controllers using Spring Mock MVC or Rest Assured Mock MVC. The contract’s request specifies the HTTP request to make to the controller, and the contract’s response specifies the controller’s expected response. Middle East Phone Number address lists

The consumer-side OrderServiceProxyTest invokes OrderServiceProxy, which has been configured to make HTTP requests to WireMock. WireMock is a tool for effi-ciently mocking HTTP servers—in this test it simulates Order Service.

On the provider side, Spring Cloud Contract generates a test class called HttpTest, which uses Rest Assured Mock MVC to test Order Service’s controllers. Test classes such as HttpTest must extend a handwritten base class. In this example, the base class BaseHttp instantiates OrderController injected with mock dependencies and calls RestAssuredMockMvc.standaloneSetup() to configure Spring MVC. Middle East Phone Number

Let’s take a closer look at how this works, starting with an example contract.

AN EXAMPLE CONTRACT FOR A REST API

A REST contract, such as the one shown in listing 10.2, specifies an HTTP request, which is sent by the REST client, and the HTTP response, which the client expects to get back from the REST server. A contract’s request specifies the HTTP method, the path, and optional headers. A contract’s response specifies the HTTP status code, optional headers, and, when appropriate, the expected body. Middle East Phone Number database

CONSUMER-DRIVEN CONTRACT INTEGRATION TESTS FOR ORDER SERVICE

The consumer-driven contract integration tests for Order Service verify that its API meets its clients’ expectations. Listing 10.3 shows HttpBase, which is the base class for the test class code-generated by Spring Cloud Contract. It’s responsible for the setup phase of the test. It creates the controllers injected with mock dependencies and configures those mocks to return values that cause the controller to generate the expected response.

The argument 1223232L that’s passed to the mock OrderRepository’s findById() method matches the orderId specified in the contract shown in listing 10.3. This test verifies that Order Service has a GET /orders/{orderId} endpoint that matches its client’s expectations.

Let’s take a look at the corresponding client test. Middle East Phone Number

CONSUMER-SIDE INTEGRATION TEST FOR API GATEWAY’S ORDERSERVICEPROXY

API Gateway’s OrderServiceProxy invokes the GET /orders/{orderId} endpoint. List-ing 10.4 shows the OrderServiceProxyIntegrationTest test class, which verifies that it conforms to the contracts. This class is annotated with @AutoConfigureStubRunner, provided by Spring Cloud Contract. It tells Spring Cloud Contract to run the Wire-Mock server on a random port and configure it using the specified contracts. Order-ServiceProxyIntegrationTest configures OrderServiceProxy to make requests to the WireMock port.