¿Cómo pruebas las aplicaciones de Android?

Question

Accepted Answer

Android soporta varios tipos de pruebas — **pruebas unitarias** (lógica, se ejecutan en la JVM), **pruebas instrumentadas** (se ejecutan en un dispositivo/emulador, incluyendo pruebas de UI con Espresso), y más. Una buena estrategia de pruebas mejora la confiabilidad y la confianza.

## Tipos de pruebas

```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
```

## Ejemplo de prueba unitaria

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

## Ejemplo de prueba 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
}
```

## Estrategia de pruebas

```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 qué es importante

Entender cómo probar las aplicaciones de Android es valioso porque **las pruebas mejoran la confiabilidad y la confianza**, permitiendo realizar cambios sin romper nada, por lo que es conocimiento profesional útil.

Android soporta una estrategia de pruebas en múltiples niveles, y entender cada uno es clave. Las **pruebas unitarias** (se ejecutan en la JVM, probando lógica como ViewModels, repositorios y utilidades sin necesidad de un dispositivo, rápidas, usando JUnit y bibliotecas de mocking) verifican la corrección de la lógica de la aplicación de manera eficiente — la base de una suite de pruebas. Las **pruebas instrumentadas** (se ejecutan en un dispositivo o emulador, probando código que necesita el framework de Android, incluyendo **pruebas de UI con Espresso** que interactúan y verifican la UI) detectan problemas que requieren comportamiento real de Android, aunque son más lentas.

Entender ambos tipos y cuándo usar cada uno es necesario para un enfoque de pruebas completo.

Entender la **estrategia de pruebas** — la pirámide de pruebas (muchas pruebas unitarias rápidas para la lógica, menos pruebas instrumentadas/UI lentas), que **importa la arquitectura testeable** (separar la lógica en ViewModels y repositorios con inyección de dependencias hace que el código sea mucho más fácil de probar unitariamente, conectando las pruebas con buena arquitectura), mock de dependencias para pruebas aisladas, y enfocarse en lógica importante y flujos críticos — refleja un enfoque efectivo y equilibrado.

Las pruebas mejoran la confiabilidad (detectando bugs), permiten refactorización confiada (sabiendo que las pruebas detectan regresiones), y son un distintivo del desarrollo profesional.

Ya que las pruebas son importantes para construir aplicaciones confiables y mantenibles, y Android proporciona herramientas en niveles unitarios e instrumentados/UI, y ya que entender los tipos de pruebas, la estrategia y cómo la arquitectura testeable soporta las pruebas es valioso para el desarrollo profesional de Android, entender cómo probar aplicaciones de Android es conocimiento valioso y prácticamente relevante — importante para construir aplicaciones confiables con confianza, reflejando prácticas profesionales, y conectando con los principios arquitectónicos (separación de responsabilidades, DI) que hacen que el código sea testeable, una habilidad útil para desarrollo de Android de calidad.