Testar o layout do Compose

Teste a interface do app para verificar se o comportamento do código do Compose está correto. Isso permite que você detecte erros no início e melhore a qualidade do app.

O Compose fornece um conjunto de APIs de teste para encontrar elementos, verificar atributos e executar 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 de Compose, consulte a seção geral Testar apps no Android.

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

Conceitos principais

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

• Semântica: a semântica dá significado à sua interface, permitindo que os testes interajam com elementos específicos.
• APIs de teste: com elas, é possível encontrar elementos, verificar atributos e realizar ações do usuário.
• Sincronização: a sincronização verifica se os testes aguardam a inatividade da interface antes de realizar ações ou fazer declarações.
• Interoperabilidade: a interoperabilidade permite que os testes funcionem com elementos baseados em Compose e View no mesmo app.

Folha de referência de testes

Consulte a folha de referência de testes para uma visão geral de todos os principais tópicos que você precisa aprender sobre testes no Compose.

Configurar

Configure seu app para permitir que você teste 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 uma ComposeTestRule e uma implementação para Android chamada AndroidComposeTestRule. Com essa regra, é possível definir o conteúdo do Compose ou acessar a atividade. Você cria as regras usando funções de fábrica, createComposeRule ou, se precisar acessar uma atividade, createAndroidComposeRule. Um teste de UI típico do Compose tem esta aparência:

// 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 fundamentos e técnicas de teste.
• Conceitos básicos de testes:saiba mais sobre os principais conceitos 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:é uma boa prática executar também testes de instrumentação. Ou seja, testes executados diretamente no dispositivo.
• Integração contínua:permite 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 do teste do Compose.

Codelab

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

Amostras