Flex, flexunit: Como testar que um evento é despachado duas vezes?

Question

Estou testando algum código de expedição de eventos em um aplicativo Flex, usando o FlexUnit's addAsync Método para testar que os eventos são despachados. Ótimo até agora, posso garantir que pelo menos um evento tenha sido demitido. No entanto, quero ser um pouco mais detalhado; Quero garantir que exatamente o conjunto de eventos que estou esperando sejam despachados. Existe um padrão de teste útil (ou, mesmo, uma estrutura de teste diferente - sou flexível!) Para fazer isso?

Eu tentei este código, mas ele não parece ser invocado pela segunda vez:

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

Em resposta ao comentário ...

E se o evento for despachado diretamente? O ResponseSelected não aciona um evento assíncrono em um objeto composto, ele simplesmente enviou diretamente o próprio evento Response_Changed. Não estou vendo como essa abordagem pode ser ridicularizada usando seu método. Veja bem, estou confuso na prática de testes simulados como está, então provavelmente estou perdendo uma solução simples aqui.

.. nesse caso, você não precisa usar uma simulação ou addasync. Algo assim 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

Este será um exemplo de alto nível de como um problema semelhante pode ser resolvido usando um objeto ridicularizado de tudo o que está fazendo a chamada assíncrona. Obviamente, não consigo ver seu código, então não posso lhe dar um exemplo preciso.

Então, como eu disse no comentário, você pode zombar de uma dependência em uma aula para falsificar chamadas assíncronas, para que elas se tornem síncronas. Pegue a aula abaixo

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

Portanto, por padrão, você está usando a classe de concreto que deseja usar, a menos que o SOMEASHONCHROOUSOBJEC seja injetado na classe através do construtor. O AsyCnHroSObject provavelmente tem seus próprios testes de unidade ou está em uma classe externa, para que você realmente não queira, ou precisa estar testando sua funcionalidade. O que você pode fazer agora é criar um objeto simulado que implementa o IiasSynchroSoBject que pode ser usado para fingir seu comportamento. Usando a estrutura Asmock, o teste pode parecer algo assim:

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

Este é apenas um exemplo de como zombar pode ajudá -lo a testes de unidade. Há uma riqueza de informações por aí em zombaria, embora ainda seja muito novo no ActionScript (lançado em dezembro). A Asmock é baseada na zomba .NET Rhino, portanto, a busca de manchas de rinoceronte deve aumentar muito mais resultados, se você precisar de ajuda.

Definitivamente, uma maneira diferente de pensar, mas uma vez que você entra nele, você tende a se perguntar como você tem nos testes de unidade sem eles.