Como você testa aplicações Android?

Question

Accepted Answer

Android suporta vários tipos de testes — **testes unitários** (lógica, executados na JVM), **testes instrumentados** (executados em um dispositivo/emulador, incluindo testes de UI com Espresso), e mais. Uma boa estratégia de testes melhora a confiabilidade e a confiança.

## Tipos de testes

```text
UNIT TESTS (local, on the JVM) → test logic (ViewModels, repositories, utilities):
  → fast (no device); use JUnit, Mockito/MockK (mocking), no Android framework needed
  → for business logic, data processing, ViewModels
INSTRUMENTED TESTS (on a device/emulator) → test code needing the Android framework:
  → UI tests (ESPRESSO — interact with and verify the UI), integration tests
  → slower (real device/emulator) but test real Android behavior
```

## Exemplo de teste unitário

```kotlin
@Test
fun `calculates total correctly`() {
  val cart = Cart()
  cart.add(Item(price = 10))
  assertEquals(10, cart.total)        // test pure logic, fast, no device
}
```

## Exemplo de teste de UI (Espresso)

```kotlin
// Espresso interacts with the UI and verifies behavior
@Test fun clickButton_updatesText() {
  onView(withId(R.id.myButton)).perform(click())     // tap
  onView(withId(R.id.result)).check(matches(withText("Clicked")))  // verify
}
```

## Estratégia de testes

```text
→ Test PYRAMID: many fast UNIT tests (logic), fewer instrumented/UI tests (slower)
→ Architecture matters — testable code (ViewModels, repositories with DI) is easier to
  unit-test (separate logic from the framework)
→ Mock dependencies (network, database) for isolated unit tests
→ Test important logic and critical user flows
```

## Por que isso importa

Entender como testar aplicações Android é valioso porque **testes melhoram a confiabilidade e a confiança**, permitindo mudanças sem quebrar as coisas, portanto é um conhecimento profissional útil.

Android suporta uma estratégia de testes em vários níveis, e entender cada um é fundamental. **Testes unitários** (executando na JVM, testando lógica como ViewModels, repositórios e utilitários sem precisar de um dispositivo, rápidos, usando JUnit e bibliotecas de mock) verificam a correção da lógica de um aplicativo de forma eficiente — a base de um conjunto de testes. **Testes instrumentados** (executando em um dispositivo ou emulador, testando código que precisa do framework Android, incluindo **testes de UI com Espresso** que interagem e verificam a UI) capturam problemas que exigem comportamento Android real, embora sejam mais lentos.

Entender os dois tipos e quando usar cada um é necessário para uma abordagem completa de testes.

Entender a **estratégia de testes** — a pirâmide de testes (muitos testes unitários rápidos para lógica, menos testes instrumentados/UI mais lentos), que **arquitetura testável importa** (separar lógica em ViewModels e repositórios com injeção de dependência torna o código muito mais fácil de testar, conectando testes com uma boa arquitetura), simular dependências para testes isolados, e focar na lógica importante e fluxos críticos — reflete uma abordagem eficaz e balanceada.

Testes melhoram a confiabilidade (encontrando bugs), permitem refatoração confiante (sabendo que os testes capturam regressões), e são uma marca do desenvolvimento profissional.

Já que testes são importantes para construir aplicações confiáveis e mantíveis, e Android fornece ferramentas em níveis unitários e instrumentados/UI, e já que entender os tipos de testes, a estratégia e como a arquitetura testável suporta testes é valioso para desenvolvimento Android profissional, entender como testar aplicações Android é conhecimento valioso e praticamente relevante — importante para construir aplicações confiáveis com confiança, refletindo práticas profissionais, e conectando aos princípios arquiteturais (separação de responsabilidades, DI) que tornam o código testável, uma habilidade útil para desenvolvimento Android de qualidade.