Comment tester Printemps @Prévue

Si nous supposons que votre travail s'exécute dans un petit intervalles que vous voulez vraiment que votre test à attendre pour le travail à exécuter et vous voulez juste tester si l'emploi est invoquée vous pouvez utiliser la solution suivante:

Ajouter Awaitility à classpath:

<dependency>
    <groupId>org.awaitility</groupId>
    <artifactId>awaitility</artifactId>
    <version>3.1.0</version>
    <scope>test</scope>
</dependency>

Test d'écriture similaires à:

@RunWith(SpringRunner.class)
@SpringBootTest
public class DemoApplicationTests {

    @SpyBean
    private MyTask myTask;

    @Test
    public void jobRuns() {
        await().atMost(Duration.FIVE_SECONDS)
               .untilAsserted(() -> verify(myTask, times(1)).work());
    }
}

OriginalL'auteur Maciej Walkowiak

La question est: "que voulez-vous tester".

Si votre réponse est
"Je veux savoir que le Printemps s'exécute ma tâche planifiée quand je le veux",
ensuite vous testez Printemps,
pas votre code.
Ce n'est pas quelque chose que vous avez besoin de test de l'unité.

Si votre réponse est "je veux savoir que j'ai configuré ma tâche correctement",
ensuite, écrivez une application de test avec l'un des plus fréquemment tâche en cours d'exécution et vérifiez que
la tâche s'exécute lorsque vous vous attendez à exécuter.
Ce n'est pas un test de l'unité,
mais allons montrer que vous savez comment le configurer votre texte correctement.

Si la réponse est "je veux savoir que la tâche que j'ai écrit fonctionne correctement",
ensuite, vous devez unité de test de la méthode tâche.
Dans votre exemple,
vous voulez de l'unité de test de la work() méthode.
Faire cela, écrire un test unitaire qui appelle directement votre méthode de tâche (work()).
Par exemple,

public class TestMyTask
{
  @InjectMocks
  private MyTask classToTest;

  //Declare any mocks you need.
  @Mock
  private Blammy mockBlammy;

  @Before
  public void preTestSetup()
  {
    MockitoAnnotations.initMocks(this);

    ... any other setup you need.
  }

  @Test
  public void work_success()
  {
    ... setup for the test.


    classToTest.work();


    .. asserts to verify that the work method functioned correctly.
  }

OriginalL'auteur DwB

Nous pouvons utiliser au moins deux approches afin de tester les tâches planifiées avec le Printemps:

• Des tests d'intégration

Si nous utilisons le printemps de démarrage on va avoir besoin les dépendances suivantes:

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
</dependency>

Nous pourrions ajouter une count à la Task et de l'incrémenter à l'intérieur de la work méthode:

 public class MyTask {
private final AtomicInteger count = new AtomicInteger(0);
@Scheduled(fixedRate=1000)
public void work(){
this.count.incrementAndGet();
}
public int getInvocationCount() {
return this.count.get();
}
}

Puis vérifier le count:

@SpringJUnitConfig(ScheduledConfig.class)
public class ScheduledIntegrationTest {
@Autowired
MyTask task;
@Test
public void givenSleepBy100ms_whenWork_thenInvocationCountIsGreaterThanZero() 
throws InterruptedException {
Thread.sleep(2000L);
assertThat(task.getInvocationCount()).isGreaterThan(0);
}
}

• Une autre alternative est d'utiliser Awaitility comme le mentionne @maciej-walkowiak.

Dans ce cas, nous devons ajouter la Awaitility dépendance:

<dependency>
<groupId>org.awaitility</groupId>
<artifactId>awaitility</artifactId>
<version>3.1.6</version>
<scope>test</scope>
</dependency>

Et d'utiliser ses DSL pour vérifier le nombre d'invocations de la méthode work:

@SpringJUnitConfig(ScheduledConfig.class)
public class ScheduledAwaitilityIntegrationTest {
@SpyBean 
MyTask task;
@Test
public void whenWaitOneSecond_thenWorkIsCalledAtLeastThreeTimes() {
await()
.atMost(Duration.FIVE_SECONDS)
.untilAsserted(() -> verify(task, atLeast(3)).work());
}
}

Nous avons besoin de prendre en compte que même si elles sont bonnes il est préférable de se concentrer sur les tests unitaires de la logique à l'intérieur de la méthode de travail.

J'ai mis un exemple ici.

OriginalL'auteur SHoko