Testarea în dezvoltarea mobilă: ce este, ce tipuri și cum să organizați

Niveluri de testare: Unit, Integration, E2E

Testarea unitară

Testele unitare sunt fundamentul testării aplicațiilor mobile. Ele verifică cea mai mică unitate de cod — o singură funcție, metodă sau clasă izolată de restul sistemului. În dezvoltarea mobilă, testele unitare sunt scrise în JUnit (Android) și XCTest (iOS). Un test unitar bun trebuie să fie rapid, independent și repetabil — nu trebuie să depindă de rețea, bază de date sau componente UI. Pentru izolare se folosesc test doubles: mock-uri, stub-uri și fake-uri.

Mockito (Java/Kotlin) și MockK (Kotlin-first) sunt biblioteci populare pentru crearea de obiecte mock pe Android. Pe iOS se folosesc OCMock, Cuckoo sau protocoale manuale. Regulă: testele unitare trebuie să acopere logica de afaceri și modelele de date. Testele UI nu trebuie să dubleze testele unitare — ele verifică interacțiunea utilizatorului cu interfața.

Testarea de integrare

Testele de integrare verifică interacțiunea dintre componente: depozit cu bază de date, ViewModel cu serviciu API, navigare între ecrane. Spre deosebire de testele unitare, testele de integrare folosesc dependențe reale sau apropiate de realitate (de exemplu, bază de date în memorie sau server mock). Robolectric este un framework pentru rularea testelor Android pe JVM fără emulator, accelerând testele de integrare de 10 ori.

Testele snapshot (Golden Tests) sunt un tip special de test de integrare care compară o componentă UI randată cu o imagine de referință (snapshot). Dacă aspectul se schimbă, testul eșuează — dezvoltatorul vede ce s-a schimbat. Facebook SnapshotTestCase (iOS) și Shot (Android) sunt instrumente populare pentru testarea snapshot.

Testarea E2E și UI

Testele E2E (end-to-end) verifică scenariul complet al utilizatorului de la început până la sfârșit: lansarea aplicației, autentificare, efectuarea unei acțiuni, verificarea rezultatului. Testele UI sunt un subset al E2E axat pe interfață. Instrumente: Espresso (Android), XCUITest (iOS), Detox (React Native). Testele E2E sunt cele mai lente, deci sunt rulate separat pe CI — de obicei în compilări nocturne.

Instrumente iOS: XCTest și XCUITest

XCTest

XCTest este framework-ul integrat Apple pentru testarea unitară a aplicațiilor mobile. XCTestRunner rulează teste pe simulator sau pe un dispozitiv real. Testele moștenesc din XCTestCase, conțin setUp și tearDown pentru pregătire și curățare. XCTest include XCTAssert pentru aserțiuni (XCTAssertEqual, XCTAssertNil, XCTAssertTrue) și XCTWaiter pentru așteptarea operațiilor asincrone.

Exemplu de test XCTest simplu: crearea unui model User, verificarea corectitudinii inițializării, formatării numelui și calculului vârstei. Code Coverage în Xcode arată care linii de cod sunt acoperite de teste — obiectivul pentru proiecte comerciale: cel puțin 70–80% acoperire a logicii de afaceri. XCTest este integrat cu Xcode Server și sistemele CI prin xcodebuild test.

XCUITest

XCUITest este framework-ul Apple pentru testarea UI. Funcționează prin identificatori de accesibilitate: XCUIElementQuery găsește butoane, câmpuri de intrare, tabele după etichetă, identificator sau tip. XCUITest înregistrează o secvență de acțiuni (record/playback) și generează cod de test. Important: toate elementele UI trebuie să aibă un accessibilityIdentifier pentru funcționarea stabilă a testelor.

Instrumente Android: JUnit, Espresso, Robolectric

JUnit și Mockito

JUnit este framework-ul de bază pentru testarea unitară a aplicațiilor mobile în Java/Kotlin. Pe Android se folosesc JUnit 4 (ultima versiune stabilă 4.13.2) și JUnit 5 pentru proiecte noi. Mockito este o bibliotecă pentru crearea de obiecte mock: when(mock.method()).thenReturn(value) — un model standard pentru izolarea clasei testate de dependențe.

Exemplu de test JUnit pentru Android:

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;

import static org.junit.Assert.*;
import static org.mockito.Mockito.*;

@RunWith(MockitoJUnitRunner.class)
public class LoginViewModelTest {

    @Mock
    AuthRepository authRepository;

    @Test
    public void login_emptyEmail_returnsError() {
        LoginViewModel vm = new LoginViewModel(authRepository);
        String result = vm.login("", "password123");
        assertEquals("Email cannot be empty", result);
        verify(authRepository, never()).authenticate(any());
    }
}

Espresso și UI Automator

Espresso este framework-ul Google pentru testele UI Android. Espresso se sincronizează automat cu firul UI: onView(withId(R.id.button)).perform(click()).check(matches(isDisplayed())). Espresso este ușor de scris și stabil datorită așteptării încorporate a stării de inactivitate. UI Automator este un framework pentru teste inter-aplicații care poate interacționa cu elemente de sistem (dialoguri de permisiuni, umbra de notificări).

Instrumente cross-platform: Detox, Appium

Detox pentru React Native

Detox este un framework E2E cu cutie gri pentru testarea aplicațiilor mobile React Native de la Wix. Detox funcționează pe ambele platforme dintr-o singură bază de cod de test, folosind intern Espresso (Android) și XCUITest (iOS). Detox așteaptă automat ca aplicația să devină inactivă (fără animații, cereri de rețea, temporizatoare) și abia apoi execută următoarea acțiune.

Appium

Appium este un framework cross-platform universal care suportă Android, iOS, Web și aplicații hibride. Appium folosește protocolul WebDriver și suportă orice limbaj de programare (Java, Python, JS, Ruby). Serverul Appium funcționează ca un server HTTP care traduce comenzi în comenzi native UI Automator / XCUITest. Principalul dezavantaj al Appium este viteza: testele rulează mai lent decât Espresso sau XCUITest native.

TDD și BDD: metodologii de testare

TDD: Test-Driven Development

TDD este o metodologie de testare a aplicațiilor mobile în care testul este scris înaintea codului de implementare. Ciclul Red-Green-Refactor: (1) scrieți un test care eșuează (Red), (2) scrieți codul minim pentru a trece testul (Green), (3) refactorizați codul păstrând testul trecut. TDD oferă 100% acoperire de test pentru funcționalitatea nouă și o arhitectură curată, deoarece testul este prima specificație a cerinței.

BDD: Behaviour-Driven Development

BDD este o extensie a TDD în care testele sunt scrise în limbaj natural în format Given-When-Then. Given (context) — When (acțiune) — Then (rezultat așteptat). Testele BDD sunt înțelese de toți membrii echipei: dezvoltatori, testeri, analiști și clienți. Mock vs Stub vs Fake: Mock verifică interacțiunea (dacă metoda a fost apelată), Stub returnează date fixe, Fake este o implementare simplificată funcțională (de exemplu, DB în memorie). La IT Sectr, folosim TDD pentru logica de afaceri critică și BDD pentru scenarii de acceptare.

Test Doubles este numele general pentru obiectele care înlocuiesc dependențele reale în teste. Există patru tipuri: Dummy (obiect pentru umplerea parametrilor, neutilizat), Stub (returnează valori date), Spy (înregistrează apeluri pentru verificare), Mock (predefinește apelurile așteptate). Înțelegerea diferenței este esențială pentru proiectarea corectă a testelor.

CI/CD și Device Farm

Automatizarea testelor în CI/CD

CI/CD — Integrare Continuă și Livrare Continuă: practica de a construi și testa automat aplicații mobile la fiecare modificare de cod. În dezvoltarea mobilă, pipeline-ul CI/CD include: linting, teste unitare, teste de integrare, construire APK/IPA și teste UI. GitHub Actions și Bitrise sunt platforme populare pentru CI/CD mobil. Testele ar trebui să ruleze rapid: teste unitare în 1–2 minute, de integrare în 5–10, UI în 15–30 minute.

Device Farm

Device Farm este o fermă de dispozitive reale pentru testare. Firebase Test Lab (Android) și Xcode Cloud (iOS) oferă acces cloud la sute de modele de dispozitive. Device Farm relevă probleme invizibile pe emulatoare: diferite dimensiuni de ecran, performanță pe dispozitive vechi, probleme de compatibilitate. La IT Sectr, folosim regulat Firebase Test Lab pentru Android și Xcode Cloud pentru iOS.