Testing Support Library

A Android Testing Support Library fornece uma estrutura extensa para testar aplicativos Android. Essa biblioteca fornece um conjunto de APIs que permitem compilar e executar código de teste para seus aplicativos, inclusive testes de JUnit 4 e de interface do usuário (IU) funcionais. Para executar testes criados com essas APIs, use o Android Studio IDE ou a linha de comando.

A Android Testing Support Library está disponível no Android SDK Manager. Para obter mais informações, consulte Configuração da Testing Support Library

Esta página fornece informações sobre as ferramentas fornecidas na Android Testing Support Library, como usá-las no ambiente de teste e informações sobre versões da biblioteca.

Recursos da Testing Support Library

A Android Testing Support Library contém as seguintes ferramentas de automação de testes:

  • AndroidJUnitRunner: Executor de teste compatível com JUnit 4 para Android
  • Espresso: Estrutura de teste de IU; adequado para teste funcional da IU dentro de um aplicativo
  • UI Automator: Estrutura de teste de IU; adequado para teste funcional de IU de vários aplicativos entre sistemas e aplicativos instalados

AndroidJUnitRunner

A classe AndroidJUnitRunner é um executor de testes JUnit que permite executar classes de teste no estilo do JUnit 3 ou do JUnit 4 em dispositivos Android, inclusive aquelas que usam as estruturas de teste Espresso e UI Automator. O executor de teste trata o carregamento do pacote de teste e do aplicativo sob teste em um dispositivo, a execução dos testes e o relatório de resultados do teste. Essa classe substitui a classe InstrumentationTestRunner, que só tem suporte para testes JUnit 3.

Os principais recursos desse executor de testes são:

Exige o Android 2.2 (API de nível 8) ou posterior.

Compatibilidade com JUnit

O melhor executor é compatível com os testes JUnit 3 e JUnit 4 (até o JUnit 4.10). No entanto, deve-se evitar misturar código de teste JUnit 3 e JUnit 4 no mesmo pacote, pois isso pode causar resultados inesperados. Se você está criando uma classe de teste JUnit 4 instrumentada para executar em um dispositivo ou emulador, a classe de teste deve ter a anotação @RunWith(AndroidJUnit4.class) como prefixo.

O fragmento de código a seguir mostra como você pode escrever um teste JUnit 4 instrumentado para validar que a operação add na classe CalculatorActivity funcione corretamente.

import android.support.test.runner.AndroidJUnit4;
import android.support.test.runner.AndroidJUnitRunner;
import android.test.ActivityInstrumentationTestCase2;

@RunWith(AndroidJUnit4.class)
public class CalculatorInstrumentationTest
        extends ActivityInstrumentationTestCase2<CalculatorActivity> {

    @Before
    public void setUp() throws Exception {
        super.setUp();

        // Injecting the Instrumentation instance is required
        // for your test to run with AndroidJUnitRunner.
        injectInstrumentation(InstrumentationRegistry.getInstrumentation());
        mActivity = getActivity();
    }

    @Test
    public void typeOperandsAndPerformAddOperation() {
        // Call the CalculatorActivity add() method and pass in some operand values, then
        // check that the expected value is returned.
    }

    @After
    public void tearDown() throws Exception {
        super.tearDown();
    }
}

Acesso a informações de instrumentação

Você pode usar a classe InstrumentationRegistry para acessar informações relacionadas à execução do teste. Essa classe contém o objeto Instrumentation, o objeto Context do aplicativo-alvo, o objeto Context do teste-alvo e os argumentos da linha de comando passados para o teste. Esses dados são úteis ao escrever testes usando a estrutura do UI Automator ou que tenham dependências nos objetos Instrumentation ou Context.

Filtragem de testes

Nos testes JUnit 4.x, é possível usar anotações para configurar a execução dos testes. Esse recurso minimiza a necessidade de adicionar texto clichê e código condicional nos testes. Além das anotações padrão compatíveis com JUnit 4, o executor de testes também suporta anotações específicas do Android, dentre elas:

  • @RequiresDevice: Especifica que o teste deve ser executado apenas em dispositivos físicos, não em emuladores.
  • @SdkSupress: Impede a exibição do teste em um nível da Android API inferior ao nível fornecido. Por exemplo, para suprimir a execução dos testes em todos os níveis de API inferiores a 18, use a anotação @SDKSupress(minSdkVersion=18).
  • @SmallTest, @MediumTest e @LargeTest: Classifica o tempo de execução e, consequentemente, a frequência de um teste.

Fragmentação de testes

O executor de testes suporta a divisão de um único conjunto de testes em vários fragmentos para que seja possível executar testes facilmente que pertencem ao mesmo fragmento como um grupo sob a mesma instância Instrumentation. Cada fragmento é identificado por um número de índice. Ao executar testes, use a opção -e numShards para especificar o número de fragmentos separados a criar e a opção -e shardIndex para especificar o fragmento a ser executado.

Por exemplo, para dividir o conjunto de testes em 10 fragmentos e executar apenas os testes agrupados no segundo fragmento, use o seguinte comando:

adb shell am instrument -w -e numShards 10 -e shardIndex 2

Para saber mais sobre como usar esse executor de testes, consulte a referência da API.

Espresso

A estrutura de testes Espresso fornece um conjunto de APIs para desenvolver testes de IU e testar os fluxos do usuário dentro de um aplicativo. Essas APIs permitem escrever testes de IU automatizados que sejam concisos e executem de forma confiável. O Espresso é adequado para escrever testes automatizados no estilo caixa branca, em que o código de teste usa detalhes de código de implementação do aplicativo sendo testado.

Os principais recursos da estrutura de teste Espresso são:

  • APIs flexíveis para ver e adaptar correspondências em aplicativos-alvo. Para obter mais informações, consulte Ver correspondências.
  • Um conjunto extenso de APIs de ação para automatizar interações da IU. Para obter mais informações, consulte APIs de ação.
  • Sincronização de encadeamento de UI para melhorar a confiabilidade dos testes. Para obter mais informações, consulte Sincronização de encadeamento de UI.

Exige o Android 2.2 (API de nível 8) ou posterior.

Ver correspondências

O método Espresso.onView() permite acessar um componente da IU no aplicativo-alvo e interagir com ele. O método aceita um argumento Matcher e busca a hierarquia da visualização para localizar uma instância View correspondente que atende a certos critérios definidos. Você pode refinar as buscas especificando critérios como:

  • O nome da classe da visualização
  • A descrição do conteúdo da visualização
  • O R.id da visualização
  • O texto exibido na visualização

Por exemplo, para buscar um botão que tenha o valor de ID my_button, é possível especificar uma correspondência como esta:

onView(withId(R.id.my_button));

Se a busca for bem-sucedida, o método onView() retorna uma referência que permite executar ações de usuário e assertivas de teste em relação à visualização-alvo.

Correspondência de adaptador

Em um layout AdapterView, o layout é dinamicamente preenchido com visualizações de nível inferior em tempo de execução. Se a visualização-alvo está dentro de um layout de subclasse da AdapterView (como uma ListView ou GridView), o método onView() pode não funcionar porque apenas um subconjunto das visualizações do layout podem estar carregadas na hierarquia de visualizações atual.

Em vez disso, use o método Espresso.onData() para acessar um elemento da visualização-alvo. O método Espresso.onData() retorna uma referência que permite executar ações de usuário e assertivas de teste em relação aos elementos em uma AdapterView.

APIs de ação

Normalmente, você testa um aplicativo realizando algumas interações de usuário com relação à interface do usuário do aplicativo. É possível automatizar essas ações com facilidade no teste usando a API ViewActions. Você pode realizar interações de IU como:

  • Cliques na visualização
  • Deslizar
  • Pressionar de teclas e botões
  • Digitação de texto
  • Abrir um link

Por exemplo, para simular a entrada de um valor de string e o pressionar de um botão para enviar o valor, você pode escrever um script de teste automatizado como abaixo. Os métodos ViewInteraction.perform() e DataInteraction.perform() recebem um ou mais argumentos ViewAction e executam as ações na ordem fornecida.

// Type text into an EditText view, then close the soft keyboard
onView(withId(R.id.editTextUserInput))
    .perform(typeText(STRING_TO_BE_TYPED), closeSoftKeyboard());

// Press the button to submit the text change
onView(withId(R.id.changeTextBt)).perform(click());

Sincronização de encadeamento de UI

Os testes nos dispositivos Android podem falhar aleatoriamente por problemas de tempo. Esse problema dos testes é chamado de inconsistência dos testes. Antes do Espresso, a alternativa era inserir um período de suspensão ou limite suficientemente longo em um teste ou adicionar código para continuar tentando a operação com falha. A estrutura de teste Espresso trata a sincronização entre a Instrumentation e o encadeamento de UI. Isso remove a necessidade de alternativas de tempo anteriores e garante que as ações e assertivas de testes funcionem de forma mais confiável.

Para saber mais sobre o uso do Espresso, consulte a referência da API e o treinamento Teste de IU para um aplicativo.

UI Automator

A estrutura de teste UI Automator fornece um conjunto de APIs para criar testes de IU que executem interações em aplicativos de usuário e de sistema. As UI Automator APIs permitem realizar operações como abrir o menu Configurações ou executar o aplicativo em um dispositivo de teste. A estrutura de teste UI Automator é adequada para escrever testes automatizados no estilo caixa preta, em que o código dos testes não se baseia em detalhes de implementação internos do aplicativo-alvo.

Os principais recursos da estrutura de teste UI Automator incluem:

  • Um visualizador para inspecionar a hierarquia de layouts. Para obter mais informações, consulte Visualizador do UI Automator.
  • Uma API para recuperar informações de estado e realizar operações no dispositivo-alvo. Para obter mais informações, consulte Acesso ao estado do dispositivo.
  • APIs que suportam testes de IU entre aplicativos. Para obter mais informações, consulte UI Automator APIs.

Exige o Android 4.3 (API de nível 18) ou posterior.

Visualizador do UI Automator

A ferramenta uiautomatorviewer fornece uma GUI conveniente para varrer e analisar os componentes de IU atualmente exibidos em um dispositivo Android. Você pode usar essa ferramenta para inspecionar a hierarquia de layouts e ver as propriedades dos componentes da IU que estejam visíveis no primeiro plano do dispositivo. Essas informações permitem criar testes mais detalhados usando o UI Automator, por exemplo, criando um seletor de IU que corresponda a uma propriedade visível específica.

A ferramenta uiautomatorviewer fica localizada no diretório <android-sdk>/tools/.

Acesso ao estado do dispositivo

A estrutura de teste UI Automator fornece uma classe UiDevice para acessar e realizar operações no dispositivo no qual o aplicativo-alvo está sendo executado. Você pode chamar seus métodos para acessar propriedades do dispositivo, como orientação atual ou tamanho da tela. A classe UiDevice também permite realizar ações como:

  • Mudar a rotação do dispositivo
  • Pressionar um botão no controle direcional
  • Pressionar os botões Voltar, Página inicial ou Menu
  • Abrir a aba de notificações
  • Obter uma captura de tela da janela atual

Por exemplo: para simular o pressionar do botão da Página inicial, chame o método UiDevice.pressHome().

UI Automator APIs

As UI Automator APIs permitem escrever testes robustos sem precisar conhecer os detalhes de implementação do aplicativo-alvo. Você pode usar essas APIs para capturar e manipular componentes da IU em vários aplicativos:

  • UiCollection: Enumera os elementos da IU de um recipiente para a finalidade de contagem ou direcionar a subelementos pelo texto visível ou pela propriedade content-description.
  • UiObject: Representa um elemento da IU que está visível no dispositivo.
  • UiScrollable: Permite procurar itens em um recipiente de IU rolável.
  • UiSelector: Representa uma consulta para um ou mais elementos da IU alvo em um dispositivo.
  • Configurator: Permite definir parâmetros principais para executar testes do UI Automator.

Por exemplo, o código a seguir mostra como escrever um script de teste que abre o inicializador do aplicativo padrão no dispositivo:

// Initialize UiDevice instance
mDevice = UiDevice.getInstance(getInstrumentation());

// Perform a short press on the HOME button
mDevice.pressHome();

// Bring up the default launcher by searching for
// a UI component that matches the content-description for the launcher button
UiObject allAppsButton = mDevice
        .findObject(new UiSelector().description("Apps"));

// Perform a click on the button to bring up the launcher
allAppsButton.clickAndWaitForNewWindow();

Para saber mais sobre o uso do UI Automator, consulte a referência da API e o treinamento Teste de IU para vários aplicativos.

Configuração da Testing Support Library

O pacote da Android Testing Support Library está incluso na versão mais recente do Android Support Repository, que você pode obter como download suplementar no Android SDK Manager.

Para baixar o Android Support Repository pelo SDK Manager:

  1. Inicie o Android SDK Manager.
  2. Na janela do SDK Manager, role até o final da lista Packages, encontre a pasta Extras e, se necessário, expanda-a para mostrar o conteúdo.
  3. Selecione o item Android Support Repository.
  4. Clique no botão Install packages....

Depois de baixar, a ferramenta instala os arquivos do Support Repository no diretório existente do Android SDK. Os arquivos de biblioteca ficam localizados no seguinte subdiretório do diretório do SDK: <sdk>/extras/android/m2repository.

As classes da Android Testing Support Library se localizam no pacote android.support.test.

Para usar a Android Testing Support Library no projeto Gradle, adicione estas dependências no arquivo build.gradle:

dependencies {
  androidTestCompile 'com.android.support.test:runner:0.4'
  // Set this dependency to use JUnit 4 rules
  androidTestCompile 'com.android.support.test:rules:0.4'
  // Set this dependency to build and run Espresso tests
  androidTestCompile 'com.android.support.test.espresso:espresso-core:2.2.1'
  // Set this dependency to build and run UI Automator tests
  androidTestCompile 'com.android.support.test.uiautomator:uiautomator-v18:2.1.2'
}

Para definir AndroidJUnitRunner como o executor padrão de instrumentação de teste no projeto Gradle, especifique esta dependência no arquivo build.gradle:

android {
    defaultConfig {
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
}

Recomenda-se usar a Android Testing Support Library em conjunto com o Android Studio IDE. O Android Studio oferece capacidades que permitem o desenvolvimento de testes, como:

  • Sistema flexível de programação baseado em Gradle que permite um gerenciamento de dependências para o código de teste
  • Estrutura de projeto única pra conter a unidade e o código de teste instrumentado junto com o código-fonte do aplicativo
  • Compatibilidade para implantar e executar testes em dispositivos virtuais ou físicos usando uma linha de comandos ou interface gráfica do usuário

Para obter mais informações e baixar o Android Studio, consulte Download do Android Studio e das SDK Tools.