I am doing a functional testing of a service A. The function is triggered by an api call 1 from service B and then at last respond (send another api call 2) to the service B. Therefore, the plan is to wiremock the service B and make a call 1 and then verify that it get a api call 2 request back.
We use wiremock in the docker compose file to simulate the service B as below:
service-b:
image: ***/wiremock-service-b
ports:
- "8081:8081"
volumes:
- ./wiremock/service-b/mappings/:/home/wiremock/mappings/
Is there any way I can get THIS service B wiremock instance (deployed in docker) using java code and triggered a call 1 and then verify a call 2 request coming back? Please help. Thanks.
If the docker compose is running, you can configure the default static WireMock client to use it as so:
import static com.github.tomakehurst.wiremock.client.WireMock.*;
configureFor("localhost", 8081);
as you are port forwarding to 8081.
See WireMock > Java configuration for further details.
You can then verify that service B was called as usual:
verify(postRequestedFor(urlEqualTo("/verify/this"))
.withHeader("Content-Type", equalTo("text/xml")));
See Wiremock > Verifying for further details.
It seems like you are mixing two approaches on your tests. I assume you are doing an integration test:
When using Wiremock, you don't need to launch your service in a Docker container. The purpose of Wiremock, is to simulate the response you receive when you call the service you are mocking. You don't really call the service in this case.
With the second approach you can use a Docker container with TestContainer. In this case, to check whether the service is called you have to test the response and check if this is your expected results. First the service (in your container) you want to call have be to exposed by an API, then in your service you are testing, you call the service with TestRestemplate or WebTestClient.
A sample code will be like this:
#Test
void integrationTest_For_Status_200() {
webTestClient.post()
.uri("THE_SERVICE_URL")
.accept(MediaType.APPLICATION_JSON)
.bodyValue(personDto)
.exchange()
.expectStatus().isOk()
.expectBody(Response.class)
.value(response -> assertAll(
() -> assertThat(response.getStatusValue()).isEqualTo(HttpStatus.OK.value()),
() -> assertThat(response.getStatusReasonPhrase()).isEqualTo(HttpStatus.OK.getReasonPhrase()),
() -> assertThat(response.getDescription()).isEqualTo(category.getDescription())
));
}
I would suggest those links bellow that will explain the approach of integration tests:
https://rieckpil.de/guide-to-springboottest-for-spring-boot-integration-tests/
https://www.freecodecamp.org/news/integration-testing-using-junit-5-testcontainers-with-springboot-example/
https://docs.spring.io/spring-framework/docs/current/reference/html/testing.html#webtestclient-tests
Related
I have a following problem: There's a service I'm mocking (for integration tests) using a docker container I run on a specific port. Because the mock service has not been updated (I don't own the code) a few endpoints that exist in the real service are not supported there.
I'm considering forking the repository and adding them myself, but other solution I'm trying is proxying all the requests via a WireMock server and stubbing only the missing endpoints. Is there a simple way to achieve this? It looks like I'd need to proxy every rest method separately, like this:
WireMockServer wireMockServer = new WireMockServer(8080);
wireMockServer.start();
// Proxy to the standalone mock server:
// GET
wireMockServer.stubFor(get(anyUrl())
.atPriority(10)
.willReturn(aResponse().proxiedFrom("http://localhost:8081/the-standalone-service")));
// POST
wireMockServer.stubFor(get(anyUrl())
.atPriority(10)
.willReturn(aResponse().proxiedFrom("http://localhost:8081/the-standalone-service")));
// PUT
wireMockServer.stubFor(put(anyUrl())
.atPriority(10)
.willReturn(aResponse().proxiedFrom("http://localhost:8081/the-standalone-service")));
...
// Overwrite only selected endpoints:
wireMockServer.stubFor(get(urlEqualTo("/the-service/users/"))
.atPriority(1)
.willReturn(aResponse()
.withHeader("Content-Type", "application/json")
.withBody("...")));
...
It took me less time to find an answer than writing the question, there's a WireMock.any() method matching all request methods, so this should suffice:
// Proxy to the standalone mock server:
wireMockServer.stubFor(WireMock.any(anyUrl())
.atPriority(10)
.willReturn(aResponse().proxiedFrom("http://localhost:8081/the-standalone-service")));
I'll confirm if it works later today.
I have a real API (https://profiles.production.service/api/person). And want to mock it using MockServer.
I'm using JUnit 5 in my integration test:
#Rule
val mockServer = MockServerContainer(DockerImageName.parse("jamesdbloom/mockserver:mockserver-5.11.2"))
mockServer.start()
....
MockServerClient("profiles.production.service", mockServer.serverPort)
.`when`(
request()
.withPath("/api/person")
.withQueryStringParameter("name", "peter")
)
.respond(
response()
.withBody("Peter the person!")
)
But actually got error:
org.mockserver.client.SocketConnectionException: Unable to resolve host profiles.production.service/<unresolved>:55070
How can I fix it?
This answer arrives too late for sure. But I am writing, just in case others come here and have a similar problem.
Looking at the documentation of the mockserver you can see an example that would make it work. Your code would need to change to:
MockServerClient(mockServer.getHost(), mockServer.getServerPort())
MockServerContainer is a docker image running on its own. So it will have a different URL than the server you need to mock.
If the problem you have is that you have hardcoded the server name on your class, then you would need to change that class. You will need to inject the server name. In your case
"https://%s:%d/api/person".format(mockServer.getHost(), mockServer.getServerPort())
I have an integration test for rest api microservers that stubs some of the external resources. Most of them work, but there is a particular one which becomes not available during the test.
Other tests stubbed the same way work
Given stubbing works when request is sent directly from the test or if called from postman while test is in Thread.sleep()
Stubbing does not work when the same request as used above is sent from one of the microservices called by the test or from postman if a microservice is paused (paused on a debug breakpoint). Other stubs work in these conditions.
#ClassRule
public static WireMockRule wireMockRule = new WireMockRule(
wireMockConfig()
.port(8080)
.usingFilesUnderDirectory("src/integration-test/resources"));
public static void stubExtService(WireMockRule wireMockRule) {
wireMockRule.stubFor(post(urlPathEqualTo("/my/url"))
.willReturn(aResponse().withHeader("Content-Type", "application/json")
.withStatus(200)
.withBodyFile("json/response.json")));
}
It sounds like the issue is that the test is finishing and WireMock shutting down before the async operation has completed. In this situation you can use Awaitility to wait (polling) for an expected request.
Here's an example in WireMock's tests:
https://github.com/tomakehurst/wiremock/blob/master/src/test/java/com/github/tomakehurst/wiremock/PostServeActionExtensionTest.java#L85
Although I have not located it in the code yet, my entry point service was responding and then processing the request asynchronously. Meanwhile, the test was receiving the response and shutting down along with WireMock, and microservices could not access the mocked resource any longer.
I have a Java project which talks to a SOAP server. I need to debug my application on my local machine. I do not want my application to get connected to the main SOAP server. I need to have a fake SOAP web server to which my application gets connected.
I want it to be as simple as possible. So, I want the server to returns a specific response for any request it receives! Is there any way by which I can reach my goal?
You don't have to build a real server for testing/debuging your code.
you can use a Mock.
This way:
you don't change your real code,
the testing code is reusable,
you don't need to implement logic, just tell it what is the expected call results
you test only your own class (there might be bugs in the soap server)
The most popular mocking framework is Mockito.
It can be as simple as:
import static org.mockito.Mockito.*;
import static org.junit.Assert.*;
#Test
public void test1() {
// create mock
MyClass test = mock(MyClass.class);
// define return value for method createSoapCall()
when(test.createSoapCall()).thenReturn(43);
// use mock in test....
assertEquals(test.createSoapCall(), 43);
}
tutorial:
http://www.vogella.com/tutorials/Mockito/article.html
official site:
http://site.mockito.org/
I wrote code which calls the Jersey client API which in turn calls a web service which is out of my control. I do not want my unit test to call the actual web service.
What is the best approach for writing a unit test for code which calls the Jersey client API? Should I use the Jersey server API to write a JAX-RS web service and then use the Jersey Test Framework for the unit test? Or should I mock out the Jersey web service calls? I have access to JMock. Or should I try another approach?
During my research, I found this discussion describing various options, but I did find a complete solution. Are there any code examples available showing a suggested JUnit approach? I could not find any in the Jersey documentation.
Here is the relevant source code:
public String getResult(URI uri) throws Exception {
// error handling code removed for clarity
ClientConfig clientConfig = new DefaultClientConfig();
Client client = Client.create(clientConfig);
WebResource service = client.resource(uri);
String result = service.accept(accept).get(String.class);
return result;
}
Here are examples of test code I would like to pass. I would like to test (1) passing in a valid URI and getting a valid string back and (2) passing in an invalid (for whatever reason -- unreachable or unauthorized) URI and getting an exception back.
#Test
public void testGetResult_ValidUri() throws Exception {
String xml = retriever.getResult(VALID_URI);
Assert.assertFalse(StringUtils.isBlank(xml));
}
#Test(expected = IllegalArgumentException.class)
public void testGetResult_InvalidUri() throws Exception {
retriever.getResult(INVALID_URI);
}
Everything above is the simple description of what my code does. In reality, there is a layer on top of that that accepts two URIs, first tries calling the first URI, and if that URI fails then it tries calling the second URI. I would like to have unit tests covering (1) the first URI succeeds, (2) the first URI fails and the second URI succeeds, and (3) both URIs fail. This code is sufficiently complex that I want to test these different scenarios using JUnit, but to do this I either need to run actual stand-in web services or mock out the Jersey client API calls.
Try to use Mockito or Easymock for mocking service calls. You need to mock only these methods which are actually used - no need to mock every method. You can creat mock object for WebResource class, then mock accept method call.
In #BeforeClass/#Before JUnit test method write something like (Mockito example)
WebResource res = mock(WebResource.class);
when(res.accept(something)).thenReturn(thatWhatYouWant);
Then in your tests you can use res object as if it was real object and call mock method on it. Instead of returning value you can also throw exceptions. Mockito is pretty cool.
Typically what you are really after is "does the way I use the Jersey Client DSL produce a request to the correct URL with the correct payload and URL parameters". Testing this with Mockito is really verbose and the setup code will usually end up looking something like this:
when(authentication.queryParam(eq("sa"), anyBoolean())).thenReturn(testAuthentication);
when(testAuthentication.resolveTemplate("channel", "smf")).thenReturn(testAuthentication);
when(testAuthentication.request(
MediaType.APPLICATION_JSON_TYPE)).thenReturn(mockRequestBuilder);
when(mockRequestBuilder.post(any(Entity.class))).thenReturn(mockResponse);
when(mockResponse.readEntity(ResponseWrapper.class)).thenReturn(successfulAuthResponse());
And this is basically just for a single REST request. It's overly verbose, and instead of testing the hoped outcome you are just replicating the steps you think are correct in using the Jersey Client DSL.
Instead of the above, I would aim for mocking a simple service. For this I've used WireMock which starts a Jetty server and where I can stub things like "expect a request to this URL, respond with this message and verify that the payload is this".
I know this is edging on an integration test and it is a bit slower than just using Mockito but I value testing the real outcome and I value the readability of the tests way more in this case.
Setup for a WireMock based Jersey Client test looks something like this:
#Test
public void exactUrlOnly() {
stubFor(get(urlEqualTo("/some/thing"))
.willReturn(aResponse()
.withHeader("Content-Type", "text/plain")
.withBody("Hello world!")));
assertThat(testClient.get("/some/thing").statusCode(), is(200));
assertThat(testClient.get("/some/thing/else").statusCode(), is(404));
}
Just implement a work-alike service and in your unit test setup start the service using HttpServerFactory.