JUnit test d'un Printemps @Async void méthode de service

J'ai un Ressort de service:

@Service
@Transactional
public class SomeService {

    @Async
    public void asyncMethod(Foo foo) {
        //processing takes significant time
    }
}

Et j'ai un test d'intégration pour cette SomeService:

@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = Application.class)
@WebAppConfiguration
@IntegrationTest
@Transactional
public class SomeServiceIntTest {

    @Inject
    private SomeService someService;

        @Test
        public void testAsyncMethod() {

            Foo testData = prepareTestData();

            someService.asyncMethod(testData);

            verifyResults();
        }

        //verifyResult() with assertions, etc.
}

Voici le problème:

  • comme SomeService.asyncMethod(..) est annoté avec @Async et
  • comme le SpringJUnit4ClassRunner adhère à la @Async sémantique

la testAsyncMethod fil de la fourche à l'appel someService.asyncMethod(testData) dans son propre thread de travail, puis directement à poursuivre l'exécution de verifyResults(), peut-être avant le précédent thread de travail a achevé ses travaux.

Comment puis-je attendre pour someService.asyncMethod(testData)'achèvement avant de vérifier les résultats? Notez que les solutions à Comment puis-je écrire un test unitaire pour vérifier async comportement à l'aide de Printemps 4 et annotations? ne s'appliquent pas ici, comme someService.asyncMethod(testData) retourne void, pas un Future<?>.

OriginalL'auteur Abdull | 2017-02-24

  1. 15

    Pour @Async sémantique être respectées, certains active @Configuration seront @EnableAsync annotation, par exemple

    @Configuration
@EnableAsync
@EnableScheduling
public class AsyncConfiguration implements AsyncConfigurer {

  //

}

    Pour résoudre mon problème, j'ai introduit un nouveau Printemps profil non-async.

    Si le non-async profil est pas active, la AsyncConfiguration est utilisé:

    @Configuration
@EnableAsync
@EnableScheduling
@Profile("!non-async")
public class AsyncConfiguration implements AsyncConfigurer {

  //this configuration will be active as long as profile "non-async" is not (!) active

}

    Si la non-async profil est active, la NonAsyncConfiguration est utilisé:

    @Configuration
//notice the missing @EnableAsync annotation
@EnableScheduling
@Profile("non-async")
public class NonAsyncConfiguration {

  //this configuration will be active as long as profile "non-async" is active

}

    Maintenant dans la problématique de la classe de test JUnit, je l'activer explicitement la "non-async" profil afin de s'excluent l'async comportement:

    @RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = Application.class)
@WebAppConfiguration
@IntegrationTest
@Transactional
@ActiveProfiles(profiles = "non-async")
public class SomeServiceIntTest {

    @Inject
    private SomeService someService;

        @Test
        public void testAsyncMethod() {

            Foo testData = prepareTestData();

            someService.asyncMethod(testData);

            verifyResults();
        }

        //verifyResult() with assertions, etc.
}
    Approche intéressante, mais cela ne fonctionne que si aucun des printemps configurations dépendent d'un exécuteur de tâches. Si l'async tests sont un problème que j'aimerais suggérer de les déplacer vers un autre infaillible de l'exécution

    OriginalL'auteur Abdull

  2. 6

    Si vous utilisez Mockito (directement ou par l'intermédiaire de Printemps de tests @MockBean), il a un mode de vérification avec un délai d'attente est exactement pour ce cas:
    https://static.javadoc.io/org.mockito/mockito-core/2.10.0/org/mockito/Mockito.html#22

    someAsyncCall();
verify(mock, timeout(100)).someMethod();

    Vous pouvez également utiliser Awaitility (trouvé sur internet, n'ai pas essayé).
    https://blog.jayway.com/2014/04/23/java-8-and-assertj-support-in-awaitility-1-6-0/

    someAsyncCall();
await().until( () -> assertThat(userRepo.size()).isEqualTo(1) );

    OriginalL'auteur jhyot

  3. 1

    Dans le cas où votre méthode renvoie CompletableFuture utilisation join méthode - documentation CompletableFuture::rejoindre.

    Cette méthode attend la méthode async à la fin et retourne le résultat. Tout rencontrées exception est levée de nouveau dans le thread principal.

    OriginalL'auteur Jan Mares