1. Overview
1.概述
MockServer is a tool for mocking/stubbing external HTTP APIs.
MockServer是一个用于模拟/存根外部HTTP API的工具。
2. Maven Dependencies
2.Maven的依赖性
To make use of MockServer in our application, we need to add two dependencies:
为了在我们的应用程序中使用MockServer，我们需要添加两个依赖项。
<dependency>
<groupId>org.mock-server</groupId>
<artifactId>mockserver-netty</artifactId>
<version>3.10.8</version>
</dependency>
<dependency>
<groupId>org.mock-server</groupId>
<artifactId>mockserver-client-java</artifactId>
<version>3.10.8</version>
</dependency>The latest version of the dependencies is available as mockserver-netty and mockserver-client.
最新版本的依赖项可作为mockserver-netty和mockserver-client。
3. MockServer Functionality
3.MockServer功能
Simply put, the tool can:
简单地说，该工具可以。
- generate and return fixed responses
- forward a request to another server
- execute callbacks
- verify a request
4. How to Run MockServer
4.如何运行MockServer？
We can start the server in a few different ways – let’s explore some of these methods.
我们可以用几种不同的方法来启动服务器–让我们来探索其中的一些方法。
4.1. Launching via Maven Plugin
4.1.通过Maven插件启动
This will launch the server during the process-test-class phase and stop at verify phase:
这将在process-test-class阶段启动服务器，在verify阶段停止。
<plugin>
<groupId>org.mock-server</groupId>
<artifactId>mockserver-maven-plugin</artifactId>
<version>3.10.8</version>
<configuration>
<serverPort>1080</serverPort>
<proxyPort>1090</proxyPort>
<logLevel>DEBUG</logLevel>
<initializationClass>org.mockserver.maven.ExampleInitializationClass</initializationClass>
</configuration>
<executions>
<execution>
<id>process-test-classes</id>
<phase>process-test-classes</phase>
<goals>
<goal>start</goal>
</goals>
</execution>
<execution>
<id>verify</id>
<phase>verify</phase>
<goals>
<goal>stop</goal>
</goals>
</execution>
</executions>
</plugin>4.2. Launching via Java API
4.2.通过Java API启动
We can use the startClientAndServer() Java API to start the server. Typically, we would start a server before running all tests:
我们可以使用startClientAndServer() Java API来启动服务器。通常情况下，我们会在运行所有测试之前启动服务器。
public class TestMockServer {
private ClientAndServer mockServer;
@BeforeClass
public void startServer() {
mockServer = startClientAndServer(1080);
}
@AfterClass
public void stopServer() {
mockServer.stop();
}
// ...
}5. Mock Clients
5.模拟客户
MockServerClient API is used for providing a capability to connect to the MockServer. It models requests and the corresponding responses from the server.
MockServerClientAPI用于提供连接到MockServer.的能力，它为来自服务器的请求和相应的响应建模。
It supports multiple operations:
它支持多种操作。
5.1. Creating Expectations With Mock Responses
5.1.用模拟答复建立期望值
Expectations are a mechanism by which we mock the request from a client and the resulting response from MockServer.
期望是一种机制，我们通过它来模拟来自客户端的请求和来自MockServer的结果响应。
To create an expectation, we need to define a request matcher and a response that should be returned.
为了创建一个期望，我们需要定义一个请求匹配器和一个应该被返回的响应。
Requests can be matched using:
请求可以用以下方式进行匹配。
- path – URL path
- query string – URL parameters
- headers – request headers
- cookies – client side cookies
- body – POST request body with XPATH, JSON, JSON schema, regular expression, exact matching plain text or body parameters
All the above parameters can be specified using plain text or regular expressions.
上述所有参数都可以用纯文本或正则表达式来指定。
And a response action will contain:
而一个响应行动将包含。
- status codes – valid HTTP status codes e.g. 200, 400 etc.
- body – it is the sequence of bytes containing any content
- headers – response headers with name and one or more values
- cookies – response cookies with name and one or more values
Let’s see how we can create an expectation:
让我们看看我们如何创建一个期望。
public class TestMockServer {
private void createExpectationForInvalidAuth() {
new MockServerClient("127.0.0.1", 1080)
.when(
request()
.withMethod("POST")
.withPath("/validate")
.withHeader("\"Content-type\", \"application/json\"")
.withBody(exact("{username: 'foo', password: 'bar'}")),
exactly(1))
.respond(
response()
.withStatusCode(401)
.withHeaders(
new Header("Content-Type", "application/json; charset=utf-8"),
new Header("Cache-Control", "public, max-age=86400"))
.withBody("{ message: 'incorrect username and password combination' }")
.withDelay(TimeUnit.SECONDS,1)
);
}
// ...
}Here, we are stubbing a POST request to the server. And we have specified that how many times we need to make this request using exactly(1) call.
在这里，我们正在向服务器存根一个POST请求。我们指定了我们需要使用exactly(1) 调用多少次这个请求。
On receiving this request, we have mocked a response with the fields like status code, headers, and response body.
在收到这个请求后，我们模拟了一个带有状态代码、头信息和响应体等字段的响应。
5.2. Forwarding a Request
5.2.转发一个请求
Expectation can be set up to forward the request. A few parameters can describe the forward action:
可以设置期望值来转发该请求。一些参数可以描述转发的动作。
- host – the host to forward to e.g. www.baeldung.com
- port – the port where the request to be forwarded, the default port is 80
- scheme – protocol to use e.g. HTTP or HTTPS
Let’s see an example of forwarding request:
让我们看一个转发请求的例子。
private void createExpectationForForward(){
new MockServerClient("127.0.0.1", 1080)
.when(
request()
.withMethod("GET")
.withPath("/index.html"),
exactly(1))
.forward(
forward()
.withHost("www.mock-server.com")
.withPort(80)
.withScheme(HttpForward.Scheme.HTTP)
);
}In this case, we have mocked a request which will hit the MockServer exactly ones and then forwarded to another server. The outer forward() method specifies the forward action and inner forward() method call helps constructing the URL and forwards the request.
在这种情况下，我们已经模拟了一个请求，它将准确地击中MockServer，然后转发到另一个服务器。外部的forward() 方法指定了转发动作，内部的forward() 方法调用帮助构建URL并转发请求。
5.3. Executing a Callback
5.3.执行一个回调
The server can be set to execute a callback when receiving a particular request. Callback action can define callback class that implements org.mockserver.mock.action.ExpectationCallback interface. It should have the default constructor and should be on the classpath.
服务器可以被设置为在收到特定请求时执行回调。回调动作可以定义实现org.mockserver.mock.action.ExpectationCallback 界面的回调类。它应该有默认的构造函数，并且应该在classpath上。
Let’s see an example of expectation with a callback:
让我们看看一个带有回调的期望的例子。
private void createExpectationForCallBack() {
mockServer
.when(
request().withPath("/callback"))
.callback(
callback()
.withCallbackClass("com.baeldung.mock.server.TestExpectationCallback")
);
}Here the outer callback() specifies the callback action and the inner callback() method specifies the instance of the callback method class.
这里外部的callback() 指定了回调动作，内部的callback() method指定了回调方法类的实例。
In this case, when MockServer receives a request with /callback, then the callback handle method implemented in the class specified will be executed:
在这种情况下，当MockServer收到一个带有/callback的请求，那么在指定的类中实现的回调处理方法将被执行。
public class TestExpectationCallback implements ExpectationCallback {
public HttpResponse handle(HttpRequest httpRequest) {
if (httpRequest.getPath().getValue().endsWith("/callback")) {
return httpResponse;
} else {
return notFoundResponse();
}
}
public static HttpResponse httpResponse = response()
.withStatusCode(200);
}5.4. Verifying Requests
5.4.核实请求
MockServerClient has an ability to check if the system under test sent a request:
MockServerClient具有检查被测系统是否发送请求的能力。
private void verifyPostRequest() {
new MockServerClient("localhost", 1080).verify(
request()
.withMethod("POST")
.withPath("/validate")
.withBody(exact("{username: 'foo', password: 'bar'}")),
VerificationTimes.exactly(1)
);
}Here, the org.mockserver.verify.VerificationTimes class is used to specify the number of times the Mock Server should match the request.
这里，org.mockserver.verify.VerificationTimes类被用来指定Mock Server应该匹配请求的次数。
6. Conclusion
6.结论
In this quick article, we have explored different functions of the MockServer. We have also explored the different APIs provided and how it can be used for testing complex systems.
在这篇快速文章中，我们探讨了MockServer的不同功能。我们还探讨了所提供的不同的API，以及如何使用它来测试复杂的系统。
As always, the complete code for this article is available over on GitHub.
一如既往，本文的完整代码可在GitHub上获得。。