Flex, FlexUnit: Come verificare che un evento viene inviato due volte?

Question

sto testando un codice spedizione evento in un'applicazione Flex, utilizzando il metodo del addAsync FlexUnit per la prova che gli eventi vengono inviati. Grande finora, posso assicurare che almeno un evento è stato licenziato. Tuttavia, voglio essere un po 'più dettagliato; Voglio assicurare che esattamente l'insieme degli eventi mi aspetto sono spediti. C'è un modello di prova utile (o, addirittura, framework di test diverso -! Sono flessibile)? Per ottenere questo risultato

Ho provato questo codice, ma non sembrano avere invocato la seconda volta:

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

In risposta al commento ...

  

Che cosa succede se l'evento viene inviato   direttamente? responseSelected non lo fa   attivare un evento asincrono su una   oggetto composto, semplicemente inviato   l'evento in sé RESPONSE_CHANGED   direttamente. Non riesco a vedere come questo   approccio può essere preso in giro con la tua   metodo. Intendiamoci, io sono confusa sulla   pratica test finto come-è, quindi sono   probabilmente manca una soluzione semplice   qui.

.. in quel caso non è necessario utilizzare un modello o di addAsync. Qualcosa di simile lo farà:

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

Questo sta per essere un esempio di alto livello di come un problema simile potrebbe essere risolto utilizzando un oggetto deriso da tutto ciò è che sta facendo la chiamata asincrona. Ovviamente non riesco a vedere il tuo codice in modo che io non posso fare un esempio preciso.

Quindi, come ho detto nel commento, si può prendere in giro fuori una dipendenza in una classe per le chiamate asincrone falsi in modo che diventino sincrona. Prendere la classe seguente

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));
    }
}

Quindi, per default si utilizza la classe concreta che si desidera utilizzare a meno che someAsynchronousObjec viene iniettato nella classe tramite il costruttore. AsycnhronousObject probabilmente ha di essa la propria unit test o è in una classe esterna in modo da non si ha realmente desidera, o hai bisogno di essere testare la sua funzionalità. Quello che ora si può fare è creare un oggetto fittizio che implementa IAsynchronousObject che può essere utilizzato per simulare il suo comportamento. Utilizzando il framework ASMock il test potrebbe essere simile a questa:

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

Questo è solo un esempio di come beffardo può aiutare a test di unità. C'è tutta una ricchezza di informazioni là fuori su scherno anche se è ancora molto nuovo per ActionScript (uscito a dicembre). ASMock si basa su .NET Rhino prende in giro in modo da cercare di Rhino mock dovrebbe gettare un sacco più risultati se hai bisogno di aiuto.

Sicuramente un modo diverso di pensare, ma una volta che si entra in esso si tende a chiedersi come avete ottenuto da in unit testing senza di loro.