CompletableFuture de la convivialité et de l'unité de test

Je suis en train d'apprendre à propos de java 8 CompletableFuture et fini avec cette.

Poing de tous, que pensez-vous de ces lignes de code? J'ai besoin d'envoyer une requête à différents services en parallèle, et puis attendre pour eux tous de la réponse et continuer à travailler.

//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();

Et même le code est en train de faire ce que je veux, je vais avoir des problèmes pour tester la classe où ce code est. J'ai essayé d'utiliser Mockito et faire quelque chose comme:

doAnswer(invocation -> CompletableFuture.completedFuture(this.serviceAResponse))
    .when(this.serviceAExecutorService)
    .execute(any());

Où les services d'un exécuteur testamentaire et de services, les réponses sont moqueurs, mais le test ne s'arrête jamais et que le thread s'attend toujours à quelque chose dans cette ligne

CompletableFuture.allOf(serviceAFuture, serviceBFuture).join();

Le moindre indice sur ce que je suis en manque ici? Merci!!!!

OriginalL'auteur Leo | 2017-01-25

  1. 9

    Si j'étais vous, je voudrais simplement se moquer de les services A et B et de vos exécuteurs, puis de les injecter grâce à l'annotation @InjectMocks comme ils sont des champs de votre classe.

    Si vous voulez vous moquer de la méthode execute de votre Executor, vous devriez plutôt procéder comme suivant à il suffit d'appeler la méthode run de la condition Runnable:

    doAnswer(
    (InvocationOnMock invocation) -> {
        ((Runnable) invocation.getArguments()[0]).run();
        return null;
    }
).when(serviceAExecutorService).execute(any(Runnable.class));

    Donc, fondamentalement, votre test serait quelque chose comme ceci:

    @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());
}
}
    En faisant cela je reçois des NPE parce que j'ai, à se moquer de mon ExecutorService (je suis en utilisant un programme personnalisé) mais si j'utilise un moked, le test ne se termine jamais. Bien sûr, si j'utilise l'exécuteur par défaut de service, sans avoir à envoyer le mien à CompletableFuture.supplyAsync(), il fonctionne comme un charme .
    Réponse de mise à jour, veuillez vérifier à nouveau
    OUI! merci!!!! c'est ce que j'ai à faire, j'ai toujours envie de se moquer de l'ExecutionService.la méthode execute ()? C'est exactement ce que je cherchais à faire, mais dans un sens, il fonctionne.

    OriginalL'auteur Nicolas Filotto

  2. 1
      @Mock
private AsyncExecuter asyncExecuter;
@Mock
private CompletableFuture<XyzSample> xyzSampleResponse;
@Mock
private CompletableFuture<Map<String, String>> abcSampleResponse;
@Before
public void setUp() throws Exception {
abcSampleResponse = CompletableFuture.completedFuture(TestUtil.readJsonResource(
"misc_mapper_response.json", new TypeReference<Map<String, String>>() {
}));
xyzSampleResponse = CompletableFuture.completedFuture(TestUtil.readJsonResource(
"gp_facade_response.json", new TypeReference<XyzSample>() {
}));
}
@Test
public void testAbcMethod() {
Mockito.doReturn(abcSampleResponse).when(asyncExecuter)
.callPgEndpoint(TestConstants.TEST_CUSTOMER_ID);
Mockito.doReturn(xyzSampleResponse).when(asyncExecuter)
.getUserPreference(TestConstants.TEST_CUSTOMER_ID);
final ActualResponse actualResponse = globalPositionService
.getGlobalPosition(TestConstants.TEST_CUSTOMER_ID);
assertNotNull(actualResponse);
}
=====Service
public ActualResponse getGlobalPosition(final String customerId) {
final CompletableFuture<Map<String, String>> abcSampleResponse = asyncExecuter
.getProductTypeInfo();
final CompletableFuture<XyzSample> xyzSampleResponse = asyncExecuter
.getUserPreference(customerId);
try {
return new ResponseDecorator(pgResponse.get(), userPreferenceResponse.get(),
productTypeInfo.get()).decorate();
} catch (final Exception e) {
log.error("Error Occurred while building the response", e);
}
return null;
}
@Component
public class AsyncExecuter {
public CompletableFuture<XyzSample> callPgEndpoint(final String customerId) {
return CompletableFuture.completedFuture(xxx);
}
}

    OriginalL'auteur Roshan Oswal