Robolectric — wat is het, werkingsprincipes en unit testing van Android

Wat is Robolectric

Robolectric is een open-source framework, opgericht in 2010 om het testen van Android-applicaties te versnellen. In plaats van te draaien op een emulator of apparaat, biedt Robolectric shadow-implementaties van Android SDK-klassen die direct op de Java Virtual Machine (JVM) werken. Dit maakt het mogelijk duizenden tests in seconden uit te voeren.

Het probleem dat Robolectric oplost

Traditioneel Android-testen vereist het opstarten van de applicatie op een emulator, wat 3–10 minuten duurt voor het bouwen van APK, installeren en opstarten. Robolectric elimineert deze stap: tests worden gecompileerd als gewone Java/Kotlin-tests en uitgevoerd via JUnit. Dit geeft een feedbackcyclus van enkele seconden in plaats van minuten.

Ondersteunde Android-versies

Robolectric ondersteunt alle Android-versies vanaf API 16 (Android 4.1) tot de laatste stabiele versie. Voor elke versie wordt een overeenkomstige set shadow-objecten geleverd die het gedrag van die specifieke platformversie emuleren waarop de applicatie wordt getest.

Architectuur en shadow-objecten

De architectuur van Robolectric is gebaseerd op een mechanisme van het onderscheppen van aanroepen door vervanging van de classloader. Wanneer een test een methode van de Android SDK aanroept, onderschept Robolectric de aanroep en stuurt deze naar het shadow-object. Shadow-object is een Java-klasse die het werkelijke gedrag van een Android-component nabootst, maar werkt zonder native platform.

Hoe shadows werken

Shadow-objecten implementeren de belangrijkste methoden van de originele Android-klassen. ShadowTextView imiteert bijvoorbeeld de methoden getText(), setText(), getCurrentTextColor() en andere. Bij aanroep van textView.setText(„Hello“) slaat het shadow-object de string op en retourneert deze bij aanroep van getText(). Dit isoleert tests van echte weergave en systeemdiensten.

Shadow-hiërarchie

Robolectric ondersteunt meer dan 200 shadow-klassen die de belangrijkste componenten van de Android SDK dekken: Activity, Fragment, TextView, Button, RecyclerView, WebView, LocationManager, ConnectivityManager en vele andere. Shadow-objecten volgen dezelfde overervingshiërarchie als de originele Android-klassen.

Installatie en configuratie van Robolectric

Installatie van Robolectric in een Gradle-project vereist het toevoegen van de afhankelijkheid testImplementation „org.robolectric:robolectric:4.x“. Ook moet de android:sdk-configuratie in het build.gradle-bestand worden opgegeven en android:testInstrumentationRunner worden toegevoegd. Voor het werken met Robolectric is geen android-test-plugin nodig.

Basis Gradle-configuratie

Na het toevoegen van de afhankelijkheid moet de directory voor manifest, resources en assets worden geconfigureerd. Robolectric vindt AndroidManifest.xml automatisch, maar het kan nodig zijn het pad handmatig op te geven via de @Config-annotatie of systeemeigenschappen. Voor multi-module projecten wordt de configuratie voor elke module afzonderlijk ingesteld.

// build.gradle — configuratie van Robolectric
android {
    testOptions {
        unitTests.includeAndroidResources = true
        unitTests.all {
            systemProperty 'robolectric.dependency.dir',
                project.rootDir.absolutePath + '/build/intermediates'
        }
    }
}

dependencies {
    testImplementation 'org.robolectric:robolectric:4.13'
    testImplementation 'org.junit.jupiter:junit-jupiter:5.10.0'
}

@Config-annotatie

De @Config-annotatie maakt het mogelijk testparameters te overschrijven: sdk (API-versie), manifest (pad naar manifest), qualifiers (schermconfiguratie, taal). Dit is nuttig voor het testen van applicatiegedrag op verschillende Android-versies, schermoriëntaties en lokalisaties.

Tests schrijven met Robolectric

Robolectric-tests worden geschreven als gewone unittesten met @RunWith(RobolectricTestRunner.class) voor JUnit 4 of via RobolectricExtension voor JUnit 5. ActivityController beheert de levenscyclus van Activity: create(), start(), resume(), pause(), stop(), destroy(). Dit maakt gedetailleerd testen van elke toestandsovergang mogelijk.

Activity testen

Voor het testen van Activity wordt ActivityController gebruikt die sequentieel door de fasen van de levenscyclus gaat. Toegang tot de Activity gebeurt via controller.get(). Alle weergavecomponenten zijn toegankelijk via findViewById, zoals in een echte applicatie. Shadow-objecten maken het mogelijk teksten, zichtbaarheid, kleuren en andere attributen van de weergave te controleren.

@RunWith(RobolectricTestRunner.class)
@Config(sdk = BuildConfig.SDK_INT)
public class MainActivityTest {

    @Test
    public void testActivityDisplaysGreeting() {
        ActivityController<MainActivity> controller =
            Robolectric.buildActivity(MainActivity.class);
        controller.create().start().resume();

        MainActivity activity = controller.get();
        TextView greeting = activity.findViewById(R.id.greeting);
        ShadowTextView shadow = Shadows.shadowOf(greeting);

        assertEquals("Welcome!", shadow.getText());
    }
}

Intents en navigatie testen

Robolectric onderschept startActivity()-aanroepen en maakt het mogelijk verzonden intents te controleren via ShadowActivity. Dit biedt de mogelijkheid navigatie te testen: controleren dat bij het klikken op een knop een Intent met de juiste Action, Data en Extra-parameters wordt verzonden.

@Test
public void testNavigationToDetails() {
    controller.create().start().resume();
    MainActivity activity = controller.get();

    activity.findViewById(R.id.detailsButton).performClick();

    ShadowActivity shadowActivity = Shadows.shadowOf(activity);
    Intent intent = shadowActivity.getNextStartedActivity();
    assertEquals(
        DetailsActivity.class.getName(),
        intent.getComponent().getClassName()
    );
}

Robolectric versus emulator

Robolectric en de emulator lossen verschillende taken op. Robolectric is ideaal voor snelle unittesten, controle van UI-logica, bedrijfscomponenten en repositories. De emulator is noodzakelijk voor instrumentatietests, controle van integratie met API, testen van camera, sensoren en prestaties.

ViewModel en Repository testen

Robolectric is uitstekend geschikt voor het testen van ViewModel, Repository en UseCase — componenten die de Android SDK gebruiken maar geen echte UI vereisen. ViewModel wordt getest via een gewone JUnit-test met RobolectricExtension, waarbij levenscycluscomponenten (LiveData, StateFlow) werken in de shadow-omgeving zonder mocks.

LiveData testen

Robolectric ondersteunt LiveData uit de doos: men kan zich abonneren op LiveData in de test, de status wijzigen via ViewModel en de geëmitteerde waarde controleren. Voor asynchrone bewerkingen wordt InstantTaskExecutorRule of runBlocking voor coroutines gebruikt. Dit elimineert de noodzaak om architectuurcomponenten te mocken.

@RunWith(RobolectricTestRunner::class)
@Config(sdk = [BuildConfig.SDK_INT])
class ProfileViewModelTest {

    private val repository = FakeUserRepository()
    private val viewModel = ProfileViewModel(repository)

    @Test
    fun `loading profile sets state to success`() = runBlocking {
        viewModel.loadProfile("user123")
        val state = viewModel.profileState.getOrAwaitValue()
        Assertions.assertTrue(state is UiState.Success)
    }
}

Aangepaste shadow-objecten

Als de standaard shadow-objecten van Robolectric de benodigde Android SDK-klasse niet dekken, kan een aangepaste Shadow worden gemaakt. Hiervoor wordt een klasse gemaakt met de @Implements(ClassName.class)-annotatie en worden de benodigde methoden geïmplementeerd met @Implementation. Aangepaste shadows worden geregistreerd via @Config(shadows = [CustomShadow::class]).

ContentProvider en Resources testen

Robolectric ondersteunt het testen van ContentProvider via Robolectric.buildContentProvider(). CRUD-bewerkingen, query met URI-matching en afhandeling van toegangsrechten kunnen worden gecontroleerd. Resources (strings, kleuren, afmetingen) zijn ook toegankelijk via RuntimeEnvironment.application.resources, wat het testen van resource-afhankelijke code mogelijk maakt.

Migratie van emulator naar Robolectric

Overstappen van instrumentatietests naar Robolectric vereist een verandering van aanpak. Instrumentatietests (AndroidJUnit4) controleren het werkelijke gedrag op de emulator, Robolectric — geïsoleerde logica in de shadow-omgeving. Het wordt aanbevolen bedrijfslogica te dekken met Robolectric-tests en instrumentatietests te bewaren voor integratiescenario’s.

Aanpassen van bestaande tests

Bij migratie moet men: AndroidJUnit4 vervangen door RobolectricTestRunner, @Config toevoegen met de doel-SDK-versie, ActivityTestRule vervangen door ActivityController, en afhankelijkheden verplaatsen van androidTestImplementation naar testImplementation. Mocks (MockK, Mockito) werken met Robolectric zonder wijzigingen — ze zijn niet afhankelijk van het platform.

Beperkingen bij migratie

Robolectric ondersteunt niet: testen van camera (CameraX), NFC, Bluetooth, biometrie, werken met echte bestanden en native bibliotheken. Voor deze scenario’s zijn instrumentatietests op de emulator nodig. Robolectric reproduceert ook geen echte weergave — lay-outtests kunnen beter worden uitgevoerd via Compose Test Rule of Espresso. Voor het controleren van bedrijfslogica, navigatie en ViewModel-toestanden vervangt Robolectric de emulator echter volledig met een 10-voudige versnelling.

Compatibiliteit met Java- en Kotlin-versies

Robolectric vereist JDK 11 of hoger en is compatibel met AGP (Android Gradle Plugin) van 7.0 tot de laatste stabiele versie. De SDK-manager van Robolectric downloadt automatisch de benodigde Android API-versies bij de eerste start — dit is een eenmalige bewerking. Voor CI-servers wordt aanbevolen de SDK vooraf te downloaden via sdkmanager om vertragingen bij de eerste testrun te voorkomen. Het updaten van Robolectric naar een nieuwe versie vereist meestal geen wijzigingen in de testcode, alleen het bijwerken van het afhankelijkheidsnummer in build.gradle.

Integratie met MockK en Mockito

Robolectric is compatibel met populaire mocking-frameworks: MockK voor Kotlin en Mockito voor Java. Mocks worden gebruikt voor het isoleren van afhankelijkheden: repositories, API-cliënten, SharedPreferences. De hoofdregel — mock geen Android SDK-klassen, daarvoor zijn shadow-objecten. Mock alleen de lagen van de applicatie: UseCase, Repository, DataSource en andere componenten van de bedrijfslogica. Deze combinatie van shadow-objecten en mocks geeft maximale flexibiliteit met minimale kosten voor het schrijven van tests.