0Pricing
Android Academy · Aula

Testes de interface com Espresso

Escreva testes automatizados de interface com Espresso. Encontre views com onView(), interaja com perform(), valide o estado com check() e teste interações com RecyclerView.

Testes de interface com Espresso é uma aula grátis de Android Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Android Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Android Academy inclui 4 aulas no total.

O que é o Espresso?

Espresso é a estrutura oficial do Android para testes de interface. Ela permite escrever testes que interagem com a interface do seu aplicativo — tocam em botões, digitam texto, percorrem listas — e verificam o que é exibido na tela.

O Espresso é executado em um dispositivo ou emulador (teste instrumentado) e sincroniza automaticamente com a thread da interface — não são necessárias chamadas instáveis de sleep().

Configuração

O Espresso faz parte do conjunto de ferramentas de teste do Android. Adicione estas dependências a app/build.gradle:

// app/build.gradle:
android {
    defaultConfig {
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }
}

dependencies {
    androidTestImplementation 'androidx.test.ext:junit:1.1.5'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'
    androidTestImplementation 'androidx.test.espresso:espresso-contrib:3.5.1'  // RecyclerView
}

ActivityScenarioRule

Use ActivityScenarioRule para iniciar uma Activity antes de cada teste e fechá-la depois:

@RunWith(AndroidJUnit4::class)
class LoginActivityTest {

    @get:Rule
    val activityRule = ActivityScenarioRule(LoginActivity::class.java)

    @Test
    fun `login button is displayed`() {
        onView(withId(R.id.btnLogin))
            .check(matches(isDisplayed()))
    }
}

onView() e ViewMatchers

onView(matcher) encontra uma view na hierarquia atual. Combine matchers para obter mais precisão:

// Match by ID:
onView(withId(R.id.tvTitle))

// Match by text:
onView(withText("Submit"))

// Match by content description (for accessibility):
onView(withContentDescription("Close dialog"))

// Combine matchers:
onView(allOf(withId(R.id.btnSave), isEnabled()))

// Inside a specific parent:
onView(withId(R.id.btnSave)).inRoot(isDialog())

ViewActions — interagindo com views

Depois de encontrar uma view, execute uma ação com .perform():

// Tap a button:
onView(withId(R.id.btnLogin)).perform(click())

// Type into an EditText:
onView(withId(R.id.etEmail))
    .perform(typeText("alice@example.com"), closeSoftKeyboard())

// Clear text and retype:
onView(withId(R.id.etPassword))
    .perform(clearText(), typeText("secret123"), closeSoftKeyboard())

// Scroll to a view:
onView(withId(R.id.btnSubmit)).perform(scrollTo(), click())

// Long press:
onView(withId(R.id.ivImage)).perform(longClick())

ViewAssertions — verificando o estado

Verifique o que é exibido na tela com .check():

// View is displayed:
onView(withId(R.id.tvError)).check(matches(isDisplayed()))

// View has specific text:
onView(withId(R.id.tvTitle)).check(matches(withText("Welcome!")))

// View is not displayed (GONE or INVISIBLE):
onView(withId(R.id.progressBar)).check(matches(not(isDisplayed())))

// View is enabled:
onView(withId(R.id.btnSave)).check(matches(isEnabled()))

// View does not exist:
onView(withId(R.id.tvError)).check(doesNotExist())

Teste completo de login

Um teste completo que digita as credenciais e toca em fazer login:

@Test
fun `successful login shows home screen`() {
    // Type email
    onView(withId(R.id.etEmail))
        .perform(typeText("alice@example.com"), closeSoftKeyboard())

    // Type password
    onView(withId(R.id.etPassword))
        .perform(typeText("password123"), closeSoftKeyboard())

    // Tap login button
    onView(withId(R.id.btnLogin)).perform(click())

    // Assert welcome message is shown
    onView(withId(R.id.tvWelcome))
        .check(matches(withText("Welcome, Alice!")))
}

Testando RecyclerView

Use RecyclerViewActions de espresso-contrib para interagir com itens da lista:

import androidx.test.espresso.contrib.RecyclerViewActions

@Test
fun `clicking item opens detail screen`() {
    // Scroll to position 5 and click:
    onView(withId(R.id.recyclerView))
        .perform(RecyclerViewActions.actionOnItemAtPosition<RecyclerView.ViewHolder>(
            5, click()
        ))

    // Assert detail screen is shown:
    onView(withId(R.id.tvDetailTitle)).check(matches(isDisplayed()))
}

Testando a validação de entrada

Verifique se as mensagens de erro aparecem quando a entrada é inválida:

@Test
fun `empty email shows error message`() {
    // Leave email blank, tap login
    onView(withId(R.id.btnLogin)).perform(click())

    // Assert error is shown
    onView(withId(R.id.tilEmail))
        .check(matches(hasDescendant(withText("Email is required"))))
}

@Test
fun `short password shows error`() {
    onView(withId(R.id.etPassword))
        .perform(typeText("123"), closeSoftKeyboard())
    onView(withId(R.id.btnLogin)).perform(click())
    onView(withId(R.id.tilPassword))
        .check(matches(hasDescendant(withText("Minimum 6 characters"))))
}

Recursos de inatividade

O Espresso espera automaticamente a inatividade da thread da interface, mas não espera chamadas de rede nem corrotinas. Use IdlingResource para informar ao Espresso que ele deve aguardar o seu trabalho assíncrono:

// CountingIdlingResource: increment before async work, decrement when done
val idlingResource = CountingIdlingResource("NetworkCall")

// In your ViewModel/Repository:
idlingResource.increment()
viewModelScope.launch {
    loadData()
    idlingResource.decrement()
}

// In test setUp:
@Before
fun setUp() {
    IdlingRegistry.getInstance().register(idlingResource)
}

@After
fun tearDown() {
    IdlingRegistry.getInstance().unregister(idlingResource)
}

Executando testes do Espresso

Execute testes instrumentados em um dispositivo conectado ou em um emulador:

  • No Android Studio: clique com o botão direito em uma classe de teste → Executar
  • Pelo terminal: ./gradlew connectedAndroidTest
  • Os resultados aparecem em app/build/reports/androidTests/

Use o Android Emulator API 28 ou posterior para execuções de testes estáveis e rápidas. Desative as animações nas configurações do desenvolvedor para evitar instabilidade.

Verificação rápida

Qual é o padrão correto do Espresso para encontrar uma view e verificar o texto dela?

Recapitulação: testes de interface com Espresso

Os testes automatizados de interface detectam regressões antes que os usuários as encontrem:

  • onView(matcher) — encontra uma view
  • .perform(action) — toca, digita e percorre
  • .check(matches(...)) — verifica visibilidade, texto e estado
  • RecyclerViewActions para interações com listas
  • IdlingResource para operações assíncronas
  • Desative as animações do sistema para evitar testes instáveis

A seguir: depure e analise o desempenho do seu aplicativo como um profissional.

Perguntas Frequentes

A aula “Testes de interface com Espresso” é grátis?

Sim — o texto completo de “Testes de interface com Espresso” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Android Academy, atualize para CoddyKit PRO. O curso de Android Academy inclui 4 aulas no total.

O que vou aprender em “Testes de interface com Espresso”?

Escreva testes automatizados de interface com Espresso. Encontre views com onView(), interaja com perform(), valide o estado com check() e teste interações com RecyclerView. Você pratica Android Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Android Academy?

Nenhuma experiência prévia é necessária. Android Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Testes de interface com Espresso”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Android Academy?

Sim. Cada aula de Android Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Testes unitários com JUnit
  2. Simulação com Mockito
  3. Testes de interface com Espresso
  4. Depuração e criação de perfis
← Voltar para Android Academy