Contrôler la fin d'un test d'automatisation - Espresso

Question

J'ai une situation inhabituelle que je teste.J'utilise Espresso pour rédiger mes tests.Je sais qu'Espresso et InstrumentationTestCase ne sont pas destinés à faire cela.

J'ai un Listener que j'ai créé dans l'une de mes classes qui m'informera d'un changement d'une certaine valeur.J'utilise l'écouteur dans ma suite de tests.

Lorsque j'obtiens la valeur de l'auditeur, je dois affirmer que la valeur a été modifiée en tant que telle.

Mon problème est que le test se terminera avant que je reçoive la valeur de l'auditeur.

    private void sendSpeedChanges() {
    setStaticSpeed(new Random().nextInt(10) + 2);
    try {
        runTestOnUiThread(new Runnable() {
            @Override
            public void run() {
                consoleActivity.onSpeedChanged(getStaticSpeed(), false);
            }
        });
    } catch (Throwable throwable) {
        throwable.printStackTrace();
    }

}

private void createSpeedDelegate() {
    EspressoMachineValues.setOnSpeedChangeListener(new EspressoMachineValues.OnSpeedChangeListener() {
        @Override
        public void onSpeedChanged(double speed) {
            //assert speed is correct.
            assertTrue(getStaticSpeed() == speed);
        }
    });

}

Ce sont les deux méthodes que j'utilise.Le createSpeedDelegate() est appelé au tout début.Puis j'appelle sendSpeedChanges.Je dois faire cela X fois.

---

NOTE:

• Il faut environ 200 millisecondes pour récupérer les informations (en moyenne).
• Je ne peux pas appeler sendSpeedChanges() jusqu'à ce que j'aie vérifié la valeur onSpeedChange()
• je ne peux pas utiliser Thread.sleep(); parce que l'auditeur est sur le fil principal.

j'ai essayé ajouter un getInstrumentation().wait(2000); et aussi getInstrumentation().waitForIdleSync(); Évidemment, ni l’un ni l’autre ne fonctionne.

Dans un monde parfait, je ferais ceci :

   for (int i = 0; i < 42; i++) {
        sendSpeedChanges();
        i++;
    }

Mais cela n’attendra pas que la valeur soit vérifiée.Et si j'attends la valeur, le programme d'exécution du test pense que tous les tests sont terminés et se termine.

Ma question est-ce qu'il y aurait un moyen de contrôler la fin du test ?Même si mes tests apparaître être fait.

Answer 1

Dans votre test, vous devrez créer une instruction de contrôle qui maintient ce test en cours d'exécution aussi longtemps que vous souhaitez qu'il soit exécuté.

while(myTestNeedsToRun) {
    if(speedChangeReceived) {
        sendSpeedChange();
        speedChangeReceived = false;
    }
}

private void createSpeedDelegate() {
   EspressoMachineValues.setOnSpeedChangeListener(new EspressoMachineValues.OnSpeedChangeListener() {
    @Override
    public void onSpeedChanged(double speed) {
        //assert speed is correct.
        assertTrue(getStaticSpeed() == speed);
        speedChangedReceived = true;
    }
});

Une fois que vous décidez que vous avez terminé d'exécuter votre test, définissez simplement myTestNeedsToRun = false et puis votre test se terminera.

Answer 2

Vous pouvez également créer un IdlingResource pour surveiller votre vitesse.IdlingResource est le moyen utilisé par Espresso pour vérifier que le thread principal est inactif ou qu'aucune AsyncTask n'est en cours d'exécution dans le pool AsyncTask.

Jetez un oeil à coutingIdlingResource classe dans le code source de la bibliothèque.Vous pourriez implémenter quelque chose de similaire à cela.Dans votre cas, cela pourrait ressembler à ceci :

[...]

private int mTargetSpeed;
private volatile ResourceCallback resourceCallback;

@Override
public boolean isIdleNow() {
  boolean isIdle = false;
  if (getStaticSpeed() == mTargetSpeed) {
     isIdle = true;
     resourceCallback.onTransitionToIdle();
  } else {
     isIdle = false;
  }

  return isIdle;
}

Sur vos tests, à chaque fois que vous souhaitez attendre que la vitesse atteigne le niveau souhaité, vous devez faire :

[...]
SpeedIdlingResource speedIdlingResource = new SpeedIdlingResource ("my_idling_resource");
Espresso.registerIdlingResources(speedIdlingResource);

De cette façon, Espresso bloquera jusqu'à ce que votre ressource inactive indique au framework que votre SpeedMonitor est inactif.C'est une bonne chose car vous exploitez tout le cadre de synchronisation Espresso pour surveiller lorsque vous avez atteint la vitesse cible, de sorte que vos tests seraient plus fiables et plus rapides que de faire une attente occupée.