Robolectric — qué es, principios de funcionamiento y pruebas unitarias de Android

Qué es Robolectric

Robolectric es un framework de código abierto creado en 2010 para acelerar las pruebas de aplicaciones Android. En lugar de ejecutarse en un emulador o dispositivo, Robolectric proporciona implementaciones shadow de las clases del Android SDK que funcionan directamente en la Máquina Virtual de Java (JVM). Esto permite ejecutar miles de pruebas en segundos.

El problema que resuelve Robolectric

Las pruebas tradicionales de Android requieren ejecutar la aplicación en un emulador, lo que lleva de 3 a 10 minutos para compilar el APK, instalarlo y lanzarlo. Robolectric elimina este paso: las pruebas se compilan como pruebas Java/Kotlin normales y se ejecutan a través de JUnit. Esto proporciona un ciclo de retroalimentación de segundos en lugar de minutos.

Versiones de Android compatibles

Robolectric admite todas las versiones de Android desde API 16 (Android 4.1) hasta la última versión estable. Para cada versión se proporciona un conjunto correspondiente de shadow-objects que emulan el comportamiento de esa versión específica de la plataforma en la que se prueba la aplicación.

Arquitectura y shadow-objects

La arquitectura de Robolectric se basa en la interceptación de llamadas mediante el reemplazo del classloader. Cuando una prueba llama a un método del Android SDK, Robolectric intercepta la llamada y la dirige a un shadow-object. Un shadow-object es una clase Java que imita el comportamiento real de un componente de Android pero funciona sin la plataforma nativa.

Cómo funcionan las shadows

Los shadow-objects implementan los métodos clave de las clases originales de Android. Por ejemplo, ShadowTextView imita métodos como getText(), setText(), getCurrentTextColor() y otros. Cuando se llama a textView.setText("Hola"), el shadow guarda la cadena y la devuelve al invocar getText(). Esto aísla las pruebas del renderizado real y los servicios del sistema.

Jerarquía de shadows

Robolectric admite más de 200 clases shadow que cubren los componentes principales del Android SDK: Activity, Fragment, TextView, Button, RecyclerView, WebView, LocationManager, ConnectivityManager y muchos más. Los shadow-objects siguen la misma jerarquía de herencia que las clases originales de Android.

Instalación y configuración de Robolectric

La instalación de Robolectric en un proyecto Gradle requiere añadir la dependencia testImplementation "org.robolectric:robolectric:4.x". También es necesario especificar la configuración de androidsdk en el archivo build.gradle y añadir la resolución android:testInstrumentationRunner. No se requiere el plugin de pruebas de Android para trabajar con Robolectric.

Configuración básica de Gradle

Después de añadir la dependencia, hay que configurar el directorio para el manifiesto, los recursos y los assets. Robolectric encuentra automáticamente AndroidManifest.xml, pero puede ser necesario indicar la ruta manualmente mediante la anotación @Config o propiedades del sistema. Para proyectos multimódulo, la configuración se establece por separado para cada módulo.

// build.gradle — configuración de 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'
}

La anotación @Config

La anotación @Config permite sobrescribir los parámetros de la prueba: sdk (versión de API), manifest (ruta al manifiesto), qualifiers (configuración de pantalla, idioma). Esto es útil para probar el comportamiento de la aplicación en diferentes versiones de Android, orientaciones de pantalla y configuraciones regionales.

Escribir pruebas con Robolectric

Las pruebas de Robolectric se escriben como pruebas unitarias normales con @RunWith(RobolectricTestRunner.class) para JUnit 4 o mediante RobolectricExtension para JUnit 5. ActivityController gestiona el ciclo de vida de Activity: create(), start(), resume(), pause(), stop(), destroy(). Esto permite probar en detalle cada transición de estado.

Pruebas de Activity

Para probar una Activity se utiliza ActivityController, que pasa secuencialmente por las etapas del ciclo de vida. El acceso a la Activity se realiza mediante controller.get(). Todos los componentes de la vista son accesibles a través de findViewById, como en una aplicación real. Los shadow-objects permiten comprobar textos, visibilidad, colores y otros atributos de las vistas.

@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());
    }
}

Pruebas de intents y navegación

Robolectric intercepta las llamadas a startActivity() y permite comprobar los intents enviados a través de ShadowActivity. Esto posibilita probar la navegación: verificar que al hacer clic en un botón se envía un Intent con el Action, Data y parámetros Extra correctos.

@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 vs. emulador

Robolectric y el emulador resuelven tareas diferentes. Robolectric es ideal para pruebas unitarias rápidas, verificación de lógica de UI, componentes de negocio y repositorios. El emulador es necesario para pruebas de instrumentación, verificación de integración con API, pruebas de cámara, sensores y rendimiento.

Pruebas de ViewModel y Repository

Robolectric es excelente para probar ViewModel, Repository y UseCase — componentes que usan el Android SDK pero no requieren una UI real. ViewModel se prueba mediante una prueba JUnit normal con RobolectricExtension, mientras que los componentes de ciclo de vida (LiveData, StateFlow) funcionan en el entorno shadow sin mocks.

Pruebas de LiveData

Robolectric admite LiveData de serie: puedes suscribirte a LiveData en la prueba, cambiar el estado a través de ViewModel y comprobar el valor emitido. Para operaciones asíncronas se utiliza InstantTaskExecutorRule o runBlocking para corrutinas. Esto elimina la necesidad de simular componentes arquitectónicos.

@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)
    }
}

Shadow-objects personalizados

Si los shadow-objects estándar de Robolectric no cubren una clase del Android SDK necesaria, puedes crear un Shadow personalizado. Para ello, crea una clase con la anotación @Implements(ClassName.class) e implementa los métodos necesarios con @Implementation. Los shadows personalizados se registran mediante @Config(shadows = [CustomShadow::class]).

Pruebas de ContentProvider y Resources

Robolectric admite pruebas de ContentProvider a través de Robolectric.buildContentProvider(). Puedes comprobar operaciones CRUD, consultas con coincidencia de URI y gestión de permisos. Los recursos (cadenas, colores, dimensiones) también son accesibles a través de RuntimeEnvironment.application.resources, lo que permite probar código que depende de recursos.

Migración del emulador a Robolectric

La transición de pruebas de instrumentación a Robolectric requiere un cambio de enfoque. Las pruebas de instrumentación (AndroidJUnit4) verifican el comportamiento real en el emulador, mientras que Robolectric verifica la lógica aislada en un entorno shadow. Se recomienda cubrir la lógica de negocio con pruebas Robolectric y dejar las pruebas de instrumentación para escenarios de integración.

Adaptación de pruebas existentes

Al migrar, hay que: reemplazar AndroidJUnit4 por RobolectricTestRunner, añadir @Config con la versión de SDK objetivo, reemplazar ActivityTestRule por ActivityController, y mover las dependencias de androidTestImplementation a testImplementation. Los mocks (MockK, Mockito) funcionan con Robolectric sin cambios — son independientes de la plataforma.

Limitaciones de la migración

Robolectric no admite: pruebas de cámara (CameraX), NFC, Bluetooth, biometría, trabajo con archivos reales y bibliotecas nativas. Estos escenarios requieren pruebas de instrumentación en el emulador. Robolectric tampoco reproduce el renderizado real — las pruebas de diseño se realizan mejor mediante Compose Test Rule o Espresso. Sin embargo, para verificar la lógica de negocio, la navegación y los estados de ViewModel, Robolectric reemplaza completamente al emulador con una aceleración de 10x.

Compatibilidad con versiones de Java y Kotlin

Robolectric requiere JDK 11 o superior y es compatible con AGP (Android Gradle Plugin) desde 7.0 hasta la última versión estable. El SDK Manager de Robolectric descarga automáticamente las versiones de Android API necesarias en la primera ejecución — es una operación única. Para servidores CI, se recomienda precargar el SDK mediante sdkmanager para evitar retrasos en la primera ejecución de pruebas. La actualización de Robolectric a una nueva versión normalmente no requiere cambios en el código de las pruebas, solo actualizar el número de dependencia en build.gradle.

Integración con MockK y Mockito

Robolectric es compatible con frameworks de mocking populares: MockK para Kotlin y Mockito para Java. Los mocks se utilizan para aislar dependencias: repositorios, clientes API, SharedPreferences. La regla principal es no simular clases del Android SDK — para eso existen los shadow-objects. Simula solo las capas de la aplicación: UseCase, Repository, DataSource y otros componentes de la lógica de negocio. Esta combinación de shadow-objects y mocks proporciona la máxima flexibilidad con un esfuerzo mínimo de escritura de pruebas.