Jak testujete Android aplikace?

Question

Accepted Answer

Android podporuje několik typů testů — **unit testy** (logika, běží na JVM), **instrumentované testy** (běží na zařízení/emulátoru, včetně UI testů s Espresso) a další. Dobra testovací strategie zvyšuje spolehlivost a důvěru.

## Typy testů

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

## Příklad unit testu

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

## Příklad UI testu (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
}
```

## Testovací strategie

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

## Proč to má значeni

Rozmění, jak testovat Android aplikace, je cenné, protože **testování zvyšuje spolehlivost a důvěru**, což umožňuje provádět změny bez porušení funkcí, takže je to užitečné profesionální znalosti.

Android podporuje testovací strategii na více úrovních a pochopení každé z nich je klíčové. **Unit testy** (běhající na JVM, testující logiku jako ViewModels, repozitáře a utility bez potřeby zařízení, rychlé, používající JUnit a mockování knihovny) ověřují správnost aplikační logiky efektivně — základ testovací sady. **Instrumentované testy** (běhující na zařízení nebo emulátoru, testující kód, který potřebuje Android framework, včetně **UI testů s Espresso**, které interagují s uživatelským rozhraním a ověřují jej) odchytávají problémy vyžadující skutečné chování Android, i když jsou pomalejší.

Pochopení obou typů a kdy použít každý je nezbytné pro kompletní testovací přístup.

Rozmění **testovací strategie** — testovací pyramidy (mnoho rychlých unit testů pro logiku, méně pomalejších instrumentovaných/UI testů), že **architekttura pro testování je důležitá** (oddělování logiky do ViewModels a repozitářů s vkládáním závislostí činí kód mnohem jednodušší na unit testování, propojování testování s dobrou architekturou), mockování závislostí pro izolované testy a zaměření se na důležitou logiku a kritické toky — odráží efektivní, vyvážený přístup.

Testování zvyšuje spolehlivost (odchytávání chyb), umožňuje sebevědomé refaktorování (vědění, že testy odchytávají regrese) a je charakteristikou profesionálního vývoje.

Protože je testování důležité pro vytváření spolehlivých, udržovatelných aplikací a Android poskytuje nástroje na úrovni unit a instrumentovaných/UI testů, a protože pochopení typů testů, strategie a toho, jak testovací architektura podporuje testování, je cenné pro profesionální Android vývoj, pochopení, jak testovat Android aplikace, je cenné, prakticky relevantní znalosti — důležité pro vytváření spolehlivých aplikací s důvěrou, odráží profesionální praktiky a propojuje se s architektonickými principy (oddělení zájmů, DI), které činí kód testovatelným, užitečná dovednost pro kvalitní Android vývoj.