Testar o layout do Compose

Teste a IU do app para verificar se o comportamento do código do Compose está correto. Isso permite que você detecte erros com antecedência e melhore a qualidade do app.

O Compose oferece um conjunto de APIs de teste para encontrar elementos, verificar os atributos deles e realizar ações do usuário. As APIs também incluem recursos avançados, como manipulação de tempo. Use essas APIs para criar testes robustos que verificam o comportamento do app.

Visualizações

Se você estiver trabalhando com visualizações em vez do Compose, consulte a seção geral Testar apps no Android.

Um bom ponto de partida é o guia Automatizar testes de IU. Ele explica como automatizar testes executados no dispositivo, inclusive ao usar visualizações.

Principais conceitos

Confira alguns conceitos importantes para testar seu código do Compose:

  • Semântica: a semântica dá significado à IU, permitindo que os testes interajam com elementos específicos.
  • APIs de teste: as APIs de teste permitem encontrar elementos, verificar os atributos deles e realizar ações do usuário.
  • Sincronização: verifica se os testes aguardam a IU ficar inativa antes de realizar ações ou fazer declarações.
  • Interoperabilidade: permite que os testes funcionem com elementos do Compose e baseados em visualização no mesmo app.

Folha de referência de testes

Consulte a página de referência de testes para uma visão geral de todos os tópicos importantes que você precisa Aprenda Mais sobre testes no Compose.

Configuração

Configurar o app para testar o código do Compose.

Primeiro, adicione as seguintes dependências ao arquivo build.gradle do módulo que contém seus testes de IU:

// Test rules and transitive dependencies:
androidTestImplementation("androidx.compose.ui:ui-test-junit4:$compose_version")
// Needed for createComposeRule(), but not for createAndroidComposeRule<YourActivity>():
debugImplementation("androidx.compose.ui:ui-test-manifest:$compose_version")

Esse módulo inclui um ComposeTestRule e uma implementação para Android chamada AndroidComposeTestRule. Com essa regra, é possível definir o conteúdo do Compose ou acessar a atividade. As regras são criadas usando funções de fábrica, createComposeRule ou, se você precisar de acesso a uma atividade, createAndroidComposeRule. Um teste de interface típico do Compose é assim:

// file: app/src/androidTest/java/com/package/MyComposeTest.kt

class MyComposeTest {

    @get:Rule val composeTestRule = createComposeRule()
    // use createAndroidComposeRule<YourActivity>() if you need access to
    // an activity

    @Test
    fun myTest() {
        // Start the app
        composeTestRule.setContent {
            MyAppTheme {
                MainScreen(uiState = fakeUiState, /*...*/)
            }
        }

        composeTestRule.onNodeWithText("Continue").performClick()

        composeTestRule.onNodeWithText("Welcome").assertIsDisplayed()
    }
}

Outros recursos

  • Testar apps no Android: a página de destino principal de testes do Android oferece uma visão mais ampla dos conceitos básicos e das técnicas de teste.
  • Conceitos básicos de testes:saiba mais sobre os conceitos básicos por trás do teste de um app Android.
  • Testes locais:é possível executar alguns testes localmente, na sua própria estação de trabalho.
  • Testes de instrumentação:também é uma boa prática executar testes de instrumentação. Ou seja, testes que são executados diretamente no dispositivo.
  • Integração contínua:com a integração contínua, é possível integrar seus testes ao pipeline de implantação.
  • Teste diferentes tamanhos de tela:com tantos dispositivos disponíveis para os usuários, é importante testar diferentes tamanhos de tela.
  • Espresso: embora seja destinado a interfaces baseadas em visualizações, o conhecimento do Espresso ainda pode ser útil para alguns aspectos dos testes do Compose.

Codelab

Para saber mais, consulte o codelab sobre como testar no Jetpack Compose.

Amostras