Hogyan tesztelsz Android alkalmazásokat?

Question

Accepted Answer

Az Android több tesztelési típust támogat — **unit tesztek** (logika, a JVM-en futnak), **instrumentált tesztek** (eszközön/emulátoron futnak, beleértve az Espresso-val végzett UI teszteket), és még sok más. A jó tesztelési stratégia javítja a megbízhatóságot és a bizalmat.

## Teszttípusok

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

## Unit teszt példa

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

## UI teszt példa (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
}
```

## Tesztelési stratégia

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

## Miért fontos

Annak megértése, hogyan kell tesztelni Android alkalmazásokat, értékes, mivel **a tesztelés javítja a megbízhatóságot és a bizalmat**, lehetővé teszi a módosításokat anélkül, hogy dolgok elromlanának, ezért hasznos szakszemélyzeti tudás.

Az Android több szinten támogat egy tesztelési stratégiát, és az egyes szintek megértése kulcsfontosságú. Az **unit tesztek** (a JVM-en futnak, logikát tesztelnek, mint ViewModelek,Repositóryk és segédprogramok, nincs szükség eszközre, gyorsak, JUnit és mock könyvtárakat használnak) hatékonyan igazolják az alkalmazás logikájának helyességét — a tesztelési csomag alapja. Az **instrumentált tesztek** (eszközön vagy emulátoron futnak, az Android keretrendszert igénylő kódot tesztelnek, beleértve az **Espresso-val végzett UI teszteket**, amelyek interakcióba lépnek az UI-val és azt ellenőrzik) olyan problémákat fognak fel, amelyekhez valódi Android viselkedés szükséges, bár lassabbak.

Annak megértése, hogy mindkét típus mely típus és mikor kell használni, szükséges a teljes tesztelési megközelítéshez.

A **tesztelési stratégia** megértése — a tesztpiramis (sok gyors unit teszt a logikához, kevesebb lassabb instrumentált/UI teszt), hogy **a tesztelhető architektúra fontos** (a logika ViewModelekbe és repositóryokba való szétválasztása dependency injectionnel nagymértékben megkönnyíti a kódot az unit teszthez, összeköti a tesztelést a jó architektúrával), a függőségek meghamisítása az izolált tesztekhez, és a fontos logikára és kritikus folyamatokra való összpontosítás — egy hatékony, kiegyensúlyozott megközelítést tükröz.

A tesztelés javítja a megbízhatóságot (hibák elkapása), lehetővé teszi az önös refaktorálást (tudva, hogy a tesztek regressziókat fognak), és a szakmai fejlesztés jellemzője.

Mivel a tesztelés fontos a megbízható, karbantartható alkalmazások létrehozásához, az Android pedig az unit és instrumentált/UI szinteken keresztül biztosít eszközöket, valamint mivel a teszttípusok, a stratégia megértése, és a tesztelhető architektúra tesztelést támogatja, értékes a szakszemélyzeti Android fejlesztésben, a tesztelési alkalmazások tesztelésének megértése értékes, gyakorlatilag releváns tudás — fontos a megbízható alkalmazások felépítéséhez bizalommal, amely a szakszemélyzeti gyakorlatokat tükrözi, és az építészeti elvekhez kapcsolódik (a problémák elválasztása, DI), amely teszi a kódot tesztelhetővé, hasznos készség a minőségi Android fejlesztéshez.