Recursos de inatividade do Espresso

Um recurso de inatividade representa uma operação assíncrona com resultados que afetam as operações subsequentes em um teste de interface. Ao registrar recursos de inatividade com o Espresso, você pode validar essas operações assíncronas de forma mais confiável ao testar o app.

Identificar quando os recursos de inatividade são necessários

O Espresso oferece um conjunto sofisticado de recursos de sincronização. No entanto, essa característica do framework se aplica apenas a operações que postam mensagens no MessageQueue, como uma subclasse de View que está desenhando o conteúdo na tela.

Como o Espresso não tem conhecimento de outras operações assíncronas, incluindo as que estão em execução em uma linha de execução em segundo plano, ele não pode fornecer garantias de sincronização nessas situações. Para que o Espresso reconheça as operações de longa duração do seu app, é preciso registrar cada uma delas como um recurso de inatividade.

Se você não usar recursos de inatividade ao testar os resultados do trabalho assíncrono do app, talvez seja necessário usar uma das seguintes soluções alternativas para melhorar a confiabilidade dos testes:

  • Adicionar chamadas de anúncio a Thread.sleep(). Quando você adiciona atrasos artificiais aos testes, o pacote de testes leva mais tempo para concluir a execução, e os testes ainda podem falhar às vezes quando executados em dispositivos mais lentos. Além disso, esses atrasos não são bem dimensionados, já que o app pode precisar realizar um trabalho assíncrono mais demorado em uma versão futura.
  • Implementar wrappers de nova tentativa, que usam um loop para verificar repetidamente se o app ainda está realizando trabalho assíncrono até que ocorra um tempo limite. Mesmo que você especifique um número máximo de novas tentativas nos testes, cada nova execução consome recursos do sistema, principalmente a CPU.
  • Usar instâncias de CountDownLatch, que permitem que uma ou mais linhas de execução aguardem até que um número específico de operações em execução em outra linha de execução seja concluído. Esses objetos exigem que você especifique um tempo limite. Caso contrário, o app pode ser bloqueado indefinidamente. As travas também adicionam complexidade desnecessária ao código, dificultando a manutenção.

O Espresso permite remover essas soluções alternativas não confiáveis dos testes e, em vez disso, registrar o trabalho assíncrono do app como recursos de inatividade.

Casos de uso comuns

Ao realizar operações semelhantes aos exemplos a seguir nos seus testes, considere usar um recurso de inatividade:

  • Carregar dados da Internet ou de uma fonte de dados local.
  • Estabelecer conexões com bancos de dados e callbacks.
  • Gerenciar serviços gerenciados usando um serviço do sistema ou uma instância de IntentService.
  • Executar lógica de negócios complexa, como transformações de bitmap.

É especialmente importante registrar recursos de inatividade quando essas operações atualizam uma interface que seus testes validam.

Exemplo de implementação de recursos de inatividade

A lista a seguir descreve vários exemplos de implementações de recursos de inatividade que podem ser integrados ao seu app:

CountingIdlingResource
Mantém um contador de tarefas ativas. Quando o contador é zero, o recurso associado é considerado inativo. Essa funcionalidade é muito parecida com a de um Semaphore. Na maioria dos casos, essa implementação é suficiente para gerenciar o trabalho assíncrono do app durante os testes.
UriIdlingResource
Semelhante a CountingIdlingResource, mas o contador precisa ser zero por um período específico antes que o recurso seja considerado inativo. Esse período de espera adicional considera solicitações de rede consecutivas, em que um app na sua linha de execução pode fazer uma nova solicitação imediatamente após receber uma resposta a uma solicitação anterior.
IdlingThreadPoolExecutor
Uma implementação personalizada de ThreadPoolExecutor que monitora o número total de tarefas em execução nos pools de linhas de execução criados. Essa classe usa um CountingIdlingResource para manter o contador de tarefas ativas.
IdlingScheduledThreadPoolExecutor
Uma implementação personalizada de ScheduledThreadPoolExecutor. Ele oferece as mesmas funcionalidades e recursos da classe IdlingThreadPoolExecutor, mas também pode acompanhar tarefas programadas para o futuro ou para serem executadas periodicamente.

Criar o próprio recurso de inatividade

Ao usar recursos de inatividade nos testes do app, talvez seja necessário fornecer gerenciamento de recursos ou geração de registros personalizados. Nesses casos, as implementações listadas na seção anterior podem não ser suficientes. Se esse for o caso, você pode estender uma dessas implementações de recurso de inatividade ou criar uma própria.

Se você implementar sua própria funcionalidade de recurso de inatividade, lembre-se das seguintes práticas recomendadas, principalmente a primeira:

Invocar transições para o estado inativo fora das verificações de inatividade
Depois que o app ficar inativo, chame onTransitionToIdle() fora de qualquer implementação de isIdleNow(). Dessa forma, o Espresso não faz uma segunda verificação desnecessária para determinar se um determinado recurso de inatividade está inativo.

O snippet de código a seguir ilustra essa recomendação:

fun isIdle() {
    // DON'T call callback.onTransitionToIdle() here!
}

fun backgroundWorkDone() {
    // Background work finished.
    callback.onTransitionToIdle() // Good. Tells Espresso that the app is idle.

    // Don't do any post-processing work beyond this point. Espresso now
    // considers your app to be idle and moves on to the next test action.
}

Registrar recursos de inatividade antes que eles se tornem necessários

Os benefícios de sincronização associados aos recursos de inatividade só entram em vigor após a primeira invocação do Espresso do método isIdleNow() desse recurso.

A lista a seguir mostra vários exemplos dessa propriedade:

  • Se você registrar um recurso de inatividade em um método anotado com @Before, ele vai entrar em vigor na primeira linha de cada teste.
  • Se você registrar um recurso de inatividade em um teste, ele vai entrar em vigor durante a próxima ação baseada no Espresso. Esse comportamento ainda ocorre mesmo que a próxima ação esteja no mesmo teste que a instrução que registra o recurso de inatividade.
Cancelar o registro de recursos de inatividade depois de usá-los

Para conservar os recursos do sistema, cancele o registro dos recursos de inatividade assim que não precisar mais deles. Por exemplo, se você registrar um recurso de inatividade em um método anotado com @Before, é melhor cancelar o registro desse recurso em um método correspondente anotado com @After.

Usar um registro de inatividade para registrar e cancelar o registro de recursos de inatividade

Ao usar esse contêiner para os recursos de inatividade do app, é possível registrar e cancelar o registro deles repetidamente, conforme necessário, e ainda observar um comportamento consistente.

Manter apenas o estado simples do app nos recursos de inatividade

Por exemplo, os recursos de inatividade que você implementa e registra não podem conter referências a objetos View.

Registrar recursos de inatividade

O Espresso oferece uma classe de contêiner em que você pode colocar os recursos de inatividade do app. Essa classe, chamada IdlingRegistry, é um artefato independente que introduz uma sobrecarga mínima ao app. A classe também permite que você siga as etapas abaixo para melhorar a capacidade de manutenção do app:

  • Crie uma referência ao IdlingRegistry, em vez dos recursos de inatividade que ele contém, nos testes do app.
  • Manter diferenças na coleção de recursos de inatividade que você usa para cada variante de build.
  • Defina recursos de inatividade nos serviços do app, em vez de nos componentes de interface que fazem referência a esses serviços.

Integrar recursos de inatividade ao app

Embora seja possível adicionar recursos de inatividade a um app de várias maneiras, uma abordagem em particular mantém o encapsulamento do app e ainda permite especificar uma operação específica que um determinado recurso de inatividade representa.

Ao adicionar recursos de inatividade ao app, recomendamos fortemente colocar a lógica do recurso de inatividade no próprio app e realizar apenas as operações de registro e cancelamento de registro nos testes.

Embora você crie a situação incomum de usar uma interface somente para testes no código de produção ao seguir essa abordagem, é possível unir recursos de inatividade ao código que você já tem, mantendo o tamanho do APK e a contagem de métodos do app.

Abordagens alternativas

Se você preferir não ter a lógica de recursos de inatividade no código de produção do app, há várias outras estratégias de integração viáveis:

  • Crie variantes de build, como as variações de produto do Gradle, e use recursos de inatividade apenas no build de depuração do app.
  • Use um framework de injeção de dependência, como o Dagger, para injetar o gráfico de dependência de recursos de inatividade do app nos testes. Se você estiver usando o Dagger 2, a injeção precisa se originar de um subcomponente.
  • Implemente um recurso de inatividade nos testes do app e exponha a parte da implementação do app que precisa ser sincronizada nesses testes.

    Atenção: embora essa decisão de design pareça criar uma referência independente para recursos de inatividade, ela também quebra o encapsulamento em todos os apps, exceto nos mais simples.

Outros recursos

Para mais informações sobre o uso do Espresso em testes do Android, consulte os recursos abaixo.

Amostras