Testar as atividades do app

As atividades servem como contêineres para cada interação do usuário no seu app. é importante testar como as atividades do seu aplicativo se comportam durante eventos, como os seguintes:

  • Outro app, como o de telefone, interrompe a atividade.
  • O sistema destrói e recria sua atividade.
  • O usuário coloca a atividade em um novo ambiente de janelamento, como picture-in-picture (PIP) ou várias janelas.

Particularmente, é importante garantir que a sua atividade se comporte corretamente em resposta aos eventos descritos na seção A atividade de desenvolvimento de software.

Este guia descreve como avaliar a capacidade do app de manter dados integridade e uma boa experiência do usuário à medida que as atividades do app passam passam por diferentes estados do ciclo de vida.

Direcionar o estado de uma atividade

Um aspecto importante do teste das atividades do seu aplicativo envolve o posicionamento do elemento atividades em estados específicos. Para definir esse "dado" parte dos seus testes, use instâncias de ActivityScenario, parte do Biblioteca do AndroidX Test. Nessa classe, é possível: colocar sua atividade em estados que simulam eventos no nível do dispositivo.

A ActivityScenario é uma API multiplataforma que pode ser usada em testes de unidade locais. e testes de integração no dispositivo. Em um dispositivo real ou virtual, O ActivityScenario oferece segurança de linha de execução, sincronizando eventos entre seus linha de execução de instrumentação do teste e a linha de execução que executa a atividade em teste.

A API é particularmente adequada para avaliar como uma atividade em se comporta quando é destruído ou criado. Esta seção apresenta os tipos mais comuns casos de uso associados a esta API.

Criar uma atividade

Para criar a atividade em teste, adicione o código mostrado no snippet a seguir:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEvent() {
       launchActivity<MyActivity>().use {
       }
    }
}

Depois de criar a atividade, o ActivityScenario faz a transição dela para o RESUMED. Este estado indica que a atividade está em execução ficam visíveis para os usuários. Nesse estado, você tem liberdade para interagir com o Elementos View usando testes de interface do Espresso.

O Google recomenda que você chame close na atividade quando o teste é concluída. Isso limpa os recursos associados e melhora a a estabilidade dos seus testes. ActivityScenario implementa Closeable, para que você possa aplique a extensão use, ou try-with-resources, ao modelo para que a atividade seja fechada automaticamente.

Como alternativa, é possível usar ActivityScenarioRule para chamar automaticamente ActivityScenario.launch antes de cada teste e ActivityScenario.close na desmontagem do teste. O exemplo a seguir mostra como definir uma regra e receber uma uma instância de um cenário:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @get:Rule var activityScenarioRule = activityScenarioRule<MyActivity>()

    @Test fun testEvent() {
        val scenario = activityScenarioRule.scenario
    }
}

Direcionar a atividade para um novo estado

Para orientar a atividade para um estado diferente, como CREATED ou STARTED, chame moveToState() Esta ação simula uma situação em que sua atividade está parado ou pausado, respectivamente, porque foi interrompido por outro aplicativo ou por um ação do sistema.

Um exemplo de uso de moveToState() aparece no snippet de código a seguir.

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEvent() {
        launchActivity<MyActivity>().use { scenario ->
            scenario.moveToState(State.CREATED)
        }
    }
}

Determinar o estado atual da atividade

Para determinar o estado atual de uma atividade em teste, acesse o valor do atributo state no objeto ActivityScenario. É especialmente útil para verificar o estado de uma atividade em teste se ela redirecionar para outra atividade ou se encerra, conforme demonstrado no código a seguir snippet:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEvent() {
        launchActivity<MyActivity>().use { scenario ->
            scenario.onActivity { activity ->
              startActivity(Intent(activity, MyOtherActivity::class.java))
            }

            val originalActivityState = scenario.state
        }
    }
}

Recriar a atividade

Quando um dispositivo está com poucos recursos, o sistema pode destruir uma atividade, exigir que o app recrie essa atividade quando o usuário retornar. Para simular essas condições, chame recreate():

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEvent() {
        launchActivity<MyActivity>().use { scenario ->
            scenario.recreate()
        }
    }
}

A classe ActivityScenario mantém o estado da instância salva da atividade e quaisquer objetos anotados usando @NonConfigurationInstance. Esses objetos carregam na nova instância da atividade em teste.

Recuperar resultados de atividades

Para obter o código de resultado ou os dados associados a uma atividade concluída, acesse o do campo result no objeto ActivityScenario, conforme mostrado no o seguinte snippet de código:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testResult() {
        launchActivity<MyActivity>().use {
            onView(withId(R.id.finish_button)).perform(click())

            // Activity under test is now finished.

            val resultCode = scenario.result.resultCode
            val resultData = scenario.result.resultData
        }
    }
}

Acionar ações na atividade

Todos os métodos em ActivityScenario estão bloqueando chamadas, por isso a API exige que você os execute na linha de execução de instrumentação.

Para acionar ações na atividade em teste, use os correspondentes de visualização do Espresso para interagir com elementos em sua visualização:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEvent() {
        launchActivity<MyActivity>().use {
            onView(withId(R.id.refresh)).perform(click())
        }
    }
}

No entanto, se você precisar chamar um método na própria atividade, poderá fazê-lo com segurança implementando ActivityAction:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEvent() {
        launchActivity<MyActivity>().use { scenario ->
            scenario.onActivity { activity ->
              activity.handleSwipeToRefresh()
            }
        }
    }
}