I'm learning about java 8 CompletableFuture and ended up with this.
Fist of all, what do you think about this lines of code? I need to send request to different services in parallel and then wait for all of them to response and continue working.
//service A
CompletableFuture<ServiceAResponse> serviceAFuture = CompletableFuture.supplyAsync(
() -> this.ServiceA.retrieve(serviceARequest), serviceAExecutorService
);
//service B
CompletableFuture<ServiceBResponse> serviceBFuture = CompletableFuture.supplyAsync(
() -> this.ServiceB.retrieve(serviceBRequest), serviceBExecutorService
);
CompletableFuture.allOf(serviceAFuture, serviceBFuture).join();
ServiceAResponse responseA = serviceAFuture.join();
ServiceBResponse responseB = serviceBFuture.join();
And even the code is doing what I want, I'm having problems testing the class where that code is. I tried using Mockito and do something like:
doAnswer(invocation -> CompletableFuture.completedFuture(this.serviceAResponse))
.when(this.serviceAExecutorService)
.execute(any());
Where executor services and services responses are mocking but the test never ends and the thread keeps waiting for something in this line
CompletableFuture.allOf(serviceAFuture, serviceBFuture).join();
Any hint on what I'm missing here? Thank you!
If I were you, I would simply mock the services A and B and your executors, then inject them thanks to the annotation @InjectMocks as they are fields of your class.
If you want mock the method execute of your Executor, you should rather proceed as next to simply call the method run of the provided Runnable:
doAnswer(
(InvocationOnMock invocation) -> {
((Runnable) invocation.getArguments()[0]).run();
return null;
}
).when(serviceAExecutorService).execute(any(Runnable.class));
So basically your test would be something like this:
@RunWith(MockitoJUnitRunner.class)
public class CompletableFutureServiceTest {
// The mock of my service A
@Mock
private ServiceA ServiceA;
// The mock of my service B
@Mock
private ServiceB ServiceB;
// The mock of your executor for the service A
@Mock
private Executor serviceAExecutorService;
// The mock of your executor for the service B
@Mock
private Executor serviceBExecutorService;
// My class in which I want to inject the mocks
@InjectMocks
private CompletableFutureService service;
@Test
public void testSomeMethod() {
// Mock the method execute to call the run method of the provided Runnable
doAnswer(
(InvocationOnMock invocation) -> {
((Runnable) invocation.getArguments()[0]).run();
return null;
}
).when(serviceAExecutorService).execute(any(Runnable.class));
doAnswer(
(InvocationOnMock invocation) -> {
((Runnable) invocation.getArguments()[0]).run();
return null;
}
).when(serviceBExecutorService).execute(any(Runnable.class));
ServiceAResponse serviceAResponse = ... // The answer to return by service A
// Make the mock of my service A return my answer
when(ServiceA.retrieve(any(ServiceARequest.class))).thenReturn(
serviceAResponse
);
ServiceBResponse serviceBResponse = ... // The answer to return by service B
// Make the mock of my service B return my answer
when(ServiceB.retrieve(any(ServiceBRequest.class))).thenReturn(
serviceBResponse
);
// Execute my method
ServiceResponse response = service.someMethod(
new ServiceARequest(), new ServiceBRequest()
);
// Test the result assuming that both responses are wrapped into a POJO
Assert.assertEquals(serviceAResponse, response.getServiceAResponse());
Assert.assertEquals(serviceBResponse, response.getServiceBResponse());
}
}