Flex, FlexUnit: Comment tester qu'un événement est distribué deux fois?

Question

Je teste un code de distribution d'événements dans une application Flex, en utilisant la méthode addAsync de FlexUnit pour les tests que les événements sont envoyés. Grand Je jusqu'à présent, veiller à ce qu'au moins un événement a été déclenché. Cependant, je veux être un peu plus détaillée; Je veux faire en sorte que exactement l'ensemble des événements je prévois sont envoyés. Y at-il un motif de test utile (ou, même, différent cadre de test - Je suis flexible)? Pour y parvenir

J'ai essayé ce code, mais il ne semble pas s'invoquer la deuxième fois:

protected function expectResultPropertyChange(event: Event, numberOfEvents: int = 1): void {
    trace("Got event " + event + " on " + event.target + " with " + numberOfEvents + " traces left...");
    assertTrue(event.type == ResponseChangedEvent.RESPONSE_CHANGED);
    if (numberOfEvents > 1) {
        event.target.addEventListener(ResponseChangedEvent.RESPONSE_CHANGED, addAsync(expectResultPropertyChange, 1000, numberOfEvents - 1));
    }
}

public function testSomething(): void {
    requiredQuestion.addEventListener(ResponseChangedEvent.RESPONSE_CHANGED, addAsync(expectResultPropertyChange, 1000, 2));
    requiredQuestion.responseSelected("1", true);
    requiredQuestion.responseSelected("2", true);
}

Answer 1

En réponse au commentaire ...

  

Que faire si l'événement est distribué   directement? responseSelected ne   déclencher sur un événement asynchrone   objet composite, il suffit envoyé   l'événement lui-même RESPONSE_CHANGED   directement. Je ne vois pas comment cela   approche peut être moqué en utilisant votre   méthode. Rappelez-vous, je suis floue sur la   la pratique de test du modèle en l'état, donc je suis   manque probablement une solution simple   ici.

.. dans ce cas, vous n'avez pas besoin d'utiliser une maquette ou addAsync. Quelque chose comme cela va faire:

public function testSomething(): void 
{
    var requiredQuestion : RequiredQuestion = new RequiredQuestion();

    var callCount : int = 0;
    requiredQuestion.addEventListener(ResponseChangedEvent.RESPONSE_CHANGED, function(event : ResponseChangedEvent)
    {
        callCount++;
    });

    requiredQuestion.responseSelected("1", true);
    requiredQuestion.responseSelected("2", true);

    assertEquals(2, callCount);
}

Answer 2

Cela va être un exemple de haut niveau de la façon dont un problème similaire pourrait être résolu en utilisant un objet moqué de tout ce que fait l'appel ya asynchrone. Il est évident que je ne peux pas voir votre code, donc je ne peux pas vous donner un exemple précis.

Alors, comme je l'ai dit dans le commentaire, vous pouvez railler une dépendance dans une classe à des appels asynchrones faux de sorte qu'ils deviennent synchrones. Prenez la classe ci-dessous

public class RequiredQuestion extends EventDispatcher
{
    private var someAsynchronousObject : IAsynchronousObject;

    public function RequiredQuestion(someAsynchronousObject : IAsynchronousObject = null)
    {
        someAsynchronousObject = someAsynchronousObject || new AsynchronousObject();
        someAsynchronousObject.addEventListener(Event.COMPLETE, asyncCallComplete);
    }

    public function responseSelected(id : String, flag : Boolean) : void
    {
        //Will asynchronously fire the Event.COMPLETE event
        someAsynchronousObject.startAsynchrounsCall(); 
    }

    protected function asyncCallComplete(event : Event) : void
    {
        dispatchEvent(new ResponseChangedEvent(ResponseChangedEvent.RESPONSE_CHANGED));
    }
}

Par défaut, vous utilisez la classe concrète que vous voulez utiliser, à moins someAsynchronousObjec est injecté dans la classe par le constructeur. AsycnhronousObject a probablement ses propres tests unitaires ou il est dans une classe externe de sorte que vous ne voulez vraiment pas, ou besoin d'être tester ses fonctionnalités. Ce que vous pouvez faire est de créer un objet fantaisie qui implémente IAsynchronousObject qui peut être utilisé pour simuler son comportement. En utilisant le cadre de ASMock le test pourrait ressembler à ceci:

public function testSomething(): void 
{
    var mockIAsycnhronousObject :  IAsynchronousObject =
        IAsynchronousObject(mockRepository.createStrict( IAsynchronousObject));

    SetupResult.forEventDispatcher(mockIAsycnhronousObject);
    SetupResult.forCall(mockIAsycnhronousObject.startAsynchronousCall())
        .dispatchEvent(new Event(Event.COMPLETE)); // all calls to the startAsynchronousCall method and dispatch the complete event everytime it's called.

    mockRepository.replayAll();

    var requiredQuestion : RequiredQuestion = new RequiredQuestion(mockIAsycnhronousObject);

    var callCount : int = 0;
    requiredQuestion.addEventListener(ResponseChangedEvent.RESPONSE_CHANGED, function(event : ResponseChangedEvent)
    {
        callCount++;
    });

    requiredQuestion.responseSelected("1", true);
    requiredQuestion.responseSelected("2", true);

    assertEquals(2, callCount);

    mockRepository.verifyAll();
}

Ceci est juste un exemple de la façon dont se moquant peut vous aider à des tests unitaires. Il y a une richesse toute l'info là-bas sur se moquant bien qu'il soit encore très nouveau pour ActionScript (publié en Décembre). ASMock est basé sur le .net Rhino se moque donc la recherche de Rhino se moque devrait jeter un beaucoup plus de résultats si vous avez besoin d'aide.

Sans aucun doute une autre façon de penser, mais une fois que vous entrez dans ce que vous avez tendance à se demander comment vous avez obtenu par le test unitaire sans eux.