Android Testing Strategies: A Comprehensive Guide for Modern Architecture#

Testing is the cornerstone of maintainable Android applications. This comprehensive guide explores testing strategies for modern Android architecture, covering unit testing, integration testing, and UI testing with real-world examples from Google’s Architecture Samples.

Testing Pyramid for Android#

The Three-Layer Testing Approach#

1
// Small Tests (70%) - Unit Tests
2
class TasksViewModelTest {
3
    @Test
4
    fun loadTasks_loading_showsLoading() {
5
        // Arrange
6
        val viewModel = TasksViewModel(fakeRepository)
7

8
        // Act
9
        viewModel.loadTasks()
10

11
        // Assert
12
        assertTrue(viewModel.uiState.value.isLoading)
13
    }
14
}
15

16
// Medium Tests (20%) - Integration Tests
17
@MediumTest
18
class TasksRepositoryTest {
19
    @Test
20
    fun saveTask_retrievesTask() = runTest {
21
        // Test repository with real database
22
        val repository = DefaultTasksRepository(
23
            tasksDao = database.taskDao(),
24
            dispatcher = TestCoroutineDispatcher()
25
        )
26

27
        repository.saveTask(Task(id = "1", title = "Test Task"))
28
        val result = repository.getTask("1")
29

30
        assertEquals("Test Task", result.title)
31
    }
32
}
33

34
// Large Tests (10%) - UI Tests
35
@LargeTest
36
class TasksScreenTest {
37
    @get:Rule
38
    val composeTestRule = createComposeRule()
39

40
    @Test
41
    fun tasksScreen_showsTasksList() {
42
        composeTestRule.setContent {
43
            TasksScreen(/*...*/)
44
        }
45

46
        composeTestRule.onNodeWithText("Test Task")
47
            .assertIsDisplayed()
48
    }
49
}

Unit Testing ViewModels#

ViewModel Testing with Coroutines#

1
@ExtendWith(MockitoExtension::class)
2
class TaskDetailViewModelTest {
3

4
    @Mock
5
    lateinit var tasksRepository: TasksRepository
6

7
    @get:Rule
8
    val mainDispatcherRule = MainDispatcherRule()
9

10
    private lateinit var viewModel: TaskDetailViewModel
11

12
    @BeforeEach
13
    fun setupViewModel() {
14
        viewModel = TaskDetailViewModel(
15
            taskId = "1",
16
            tasksRepository = tasksRepository
17
        )
18
    }
19

20
    @Test
21
    fun loadTask_success_showsTask() = runTest {
22
        // Arrange
23
        val task = Task(id = "1", title = "Test Task", description = "Description")
24
        whenever(tasksRepository.getTask("1")).thenReturn(task)
25

26
        // Act
27
        viewModel.loadTask()
28

29
        // Assert
30
        val uiState = viewModel.uiState.value
31
        assertFalse(uiState.isLoading)
32
        assertEquals(task, uiState.task)
33
        assertNull(uiState.userMessage)
34
    }
35

36
    @Test
37
    fun loadTask_failure_showsError() = runTest {
38
        // Arrange
39
        whenever(tasksRepository.getTask("1"))
40
            .thenThrow(RuntimeException("Network error"))
41

42
        // Act
43
        viewModel.loadTask()
44

45
        // Assert
46
        val uiState = viewModel.uiState.value
47
        assertFalse(uiState.isLoading)
48
        assertNull(uiState.task)
49
        assertNotNull(uiState.userMessage)
50
    }
51

52
    @Test
53
    fun deleteTask_success_navigatesUp() = runTest {
54
        // Arrange
55
        val task = Task(id = "1", title = "Test Task")
56
        viewModel.uiState.value = TaskDetailUiState(task = task)
57

58
        // Act
59
        viewModel.deleteTask()
60

61
        // Assert
62
        verify(tasksRepository).deleteTask("1")
63
        assertTrue(viewModel.isTaskDeleted.value)
64
    }
65
}

Testing State Management#

1
class TasksViewModelTest {
2

3
    @Test
4
    fun filterTasks_activeFilter_showsActiveTasks() = runTest {
5
        // Arrange
6
        val tasks = listOf(
7
            Task(id = "1", title = "Active Task", isCompleted = false),
8
            Task(id = "2", title = "Completed Task", isCompleted = true)
9
        )
10
        whenever(tasksRepository.getTasks()).thenReturn(tasks)
11

12
        // Act
13
        viewModel.setFiltering(TasksFilterType.ACTIVE_TASKS)
14

15
        // Assert
16
        val uiState = viewModel.uiState.value
17
        assertEquals(1, uiState.items.size)
18
        assertEquals("Active Task", uiState.items[0].title)
19
    }
20

21
    @Test
22
    fun completeTask_updatesTaskAndRefreshes() = runTest {
23
        // Arrange
24
        val taskId = "1"
25

26
        // Act
27
        viewModel.completeTask(taskId, true)
28

29
        // Assert
30
        verify(tasksRepository).completeTask(taskId)
31
        verify(tasksRepository).getTasks() // Refreshed after completion
32
    }
33
}

Testing Repository Layer#

Repository Integration Testing#

1
@HiltAndroidTest
2
class DefaultTasksRepositoryTest {
3

4
    @get:Rule
5
    var hiltRule = HiltAndroidRule(this)
6

7
    @Inject
8
    @ApplicationContext
9
    lateinit var context: Context
10

11
    private lateinit var database: ToDoDatabase
12
    private lateinit var repository: TasksRepository
13

14
    @Before
15
    fun setup() {
16
        hiltRule.inject()
17

18
        database = Room.inMemoryDatabaseBuilder(
19
            context,
20
            ToDoDatabase::class.java
21
        )
22
        .allowMainThreadQueries()
23
        .build()
24

25
        repository = DefaultTasksRepository(
26
            tasksDao = database.taskDao(),
27
            dispatcher = Dispatchers.IO
28
        )
29
    }
30

31
    @After
32
    fun tearDown() {
33
        database.close()
34
    }
35

36
    @Test
37
    fun saveTask_retrievesTask() = runTest {
38
        // Arrange
39
        val task = Task(
40
            id = "1",
41
            title = "Test Task",
42
            description = "Test Description"
43
        )
44

45
        // Act
46
        repository.saveTask(task)
47
        val result = repository.getTask("1")
48

49
        // Assert
50
        assertEquals(task.title, result.title)
51
        assertEquals(task.description, result.description)
52
    }
53

54
    @Test
55
    fun deleteTask_removesTask() = runTest {
56
        // Arrange
57
        val task = Task(id = "1", title = "Test Task")
58
        repository.saveTask(task)
59

60
        // Act
61
        repository.deleteTask("1")
62

63
        // Assert
64
        assertThrows<Exception> {
65
            runBlocking { repository.getTask("1") }
66
        }
67
    }
68

69
    @Test
70
    fun getTasks_withFilter_returnsFilteredTasks() = runTest {
71
        // Arrange
72
        val activeTasks = listOf(
73
            Task(id = "1", title = "Active 1", isCompleted = false),
74
            Task(id = "2", title = "Active 2", isCompleted = false)
75
        )
76
        val completedTasks = listOf(
77
            Task(id = "3", title = "Completed 1", isCompleted = true)
78
        )
79

80
        activeTasks.plus(completedTasks).forEach {
81
            repository.saveTask(it)
82
        }
83

84
        // Act
85
        val activeTasks = repository.getTasks(false)
86
        val completedTasks = repository.getTasks(true)
87

88
        // Assert
89
        assertEquals(2, activeTasks.size)
90
        assertEquals(1, completedTasks.size)
91
    }
92
}

Testing Jetpack Compose UI#

Compose Testing Fundamentals#

1
@RunWith(AndroidJUnit4::class)
2
class TasksScreenTest {
3

4
    @get:Rule
5
    val composeTestRule = createComposeRule()
6

7
    @Test
8
    fun tasksScreen_displaysTasksList() {
9
        // Arrange
10
        val tasks = listOf(
11
            Task(id = "1", title = "Task 1", isCompleted = false),
12
            Task(id = "2", title = "Task 2", isCompleted = true)
13
        )
14

15
        // Act
16
        composeTestRule.setContent {
17
            TasksScreen(
18
                uiState = TasksUiState(items = tasks),
19
                onAddTask = {},
20
                onTaskClick = {},
21
                onTaskCheckedChange = { _, _ -> }
22
            )
23
        }
24

25
        // Assert
26
        composeTestRule.onNodeWithText("Task 1").assertIsDisplayed()
27
        composeTestRule.onNodeWithText("Task 2").assertIsDisplayed()
28
    }
29

30
    @Test
31
    fun tasksScreen_clickAddTask_callsCallback() {
32
        // Arrange
33
        var addTaskCalled = false
34

35
        // Act
36
        composeTestRule.setContent {
37
            TasksScreen(
38
                uiState = TasksUiState(),
39
                onAddTask = { addTaskCalled = true },
40
                onTaskClick = {},
41
                onTaskCheckedChange = { _, _ -> }
42
            )
43
        }
44

45
        composeTestRule.onNodeWithContentDescription("Add task")
46
            .performClick()
47

48
        // Assert
49
        assertTrue(addTaskCalled)
50
    }
51

52
    @Test
53
    fun tasksScreen_toggleTaskCompletion_updatesState() {
54
        // Arrange
55
        val tasks = listOf(
56
            Task(id = "1", title = "Task 1", isCompleted = false)
57
        )
58
        var toggledTaskId = ""
59
        var toggledCompleted = false
60

61
        // Act
62
        composeTestRule.setContent {
63
            TasksScreen(
64
                uiState = TasksUiState(items = tasks),
65
                onAddTask = {},
66
                onTaskClick = {},
67
                onTaskCheckedChange = { taskId, completed ->
68
                    toggledTaskId = taskId
69
                    toggledCompleted = completed
70
                }
71
            )
72
        }
73

74
        composeTestRule.onNodeWithText("Task 1")
75
            .performClick()
76

77
        // Assert
78
        assertEquals("1", toggledTaskId)
79
        assertTrue(toggledCompleted)
80
    }
81
}

Testing Complex Compose Components#

1
class TaskItemTest {
2

3
    @get:Rule
4
    val composeTestRule = createComposeRule()
5

6
    @Test
7
    fun taskItem_completedTask_showsStrikethrough() {
8
        // Arrange
9
        val completedTask = Task(
10
            id = "1",
11
            title = "Completed Task",
12
            isCompleted = true
13
        )
14

15
        // Act
16
        composeTestRule.setContent {
17
            TaskItem(
18
                task = completedTask,
19
                onTaskClick = {},
20
                onCheckedChange = {}
21
            )
22
        }
23

24
        // Assert
25
        composeTestRule.onNodeWithText("Completed Task")
26
            .assertHasStrikethroughText()
27
    }
28

29
    @Test
30
    fun taskItem_longPress_showsContextMenu() {
31
        // Arrange
32
        val task = Task(id = "1", title = "Task")
33

34
        // Act
35
        composeTestRule.setContent {
36
            TaskItem(
37
                task = task,
38
                onTaskClick = {},
39
                onCheckedChange = {},
40
                onLongClick = { /* Show context menu */ }
41
            )
42
        }
43

44
        composeTestRule.onNodeWithText("Task")
45
            .performTouchInput { longClick() }
46

47
        // Assert context menu appears
48
        composeTestRule.onNodeWithText("Delete")
49
            .assertIsDisplayed()
50
    }
51
}

1
@HiltAndroidTest
2
class NavigationTest {
3

4
    @get:Rule
5
    var hiltRule = HiltAndroidRule(this)
6

7
    @get:Rule
8
    val composeTestRule = createComposeRule()
9

10
    private lateinit var navController: TestNavHostController
11

12
    @Before
13
    fun setupNavHost() {
14
        hiltRule.inject()
15

16
        composeTestRule.setContent {
17
            navController = TestNavHostController(LocalContext.current)
18
            navController.navigatorProvider.addNavigator(ComposeNavigator())
19

20
            TodoNavHost(navController = navController)
21
        }
22
    }
23

24
    @Test
25
    fun navHost_startDestination_isTasksScreen() {
26
        assertEquals(TodoDestinations.TASKS_ROUTE, navController.currentDestination?.route)
27
    }
28

29
    @Test
30
    fun navHost_clickAddTask_navigatesToAddTask() {
31
        // Click add task button
32
        composeTestRule.onNodeWithContentDescription("Add task")
33
            .performClick()
34

35
        // Verify navigation to add/edit screen
36
        assertEquals(
37
            TodoDestinations.ADD_EDIT_TASK_ROUTE,
38
            navController.currentDestination?.route
39
        )
40
    }
41

42
    @Test
43
    fun navHost_editTask_navigatesWithTaskId() {
44
        // Navigate to task detail first
45
        navController.navigate("${TodoDestinations.TASK_DETAIL_ROUTE}/1")
46

47
        // Click edit button
48
        composeTestRule.onNodeWithContentDescription("Edit task")
49
            .performClick()
50

51
        // Verify navigation to edit screen with task ID
52
        assertTrue(
53
            navController.currentDestination?.route?.contains("1") == true
54
        )
55
    }
56
}

Database Testing#

Room Database Testing#

1
@RunWith(AndroidJUnit4::class)
2
@SmallTest
3
class TasksDaoTest {
4

5
    private lateinit var database: ToDoDatabase
6
    private lateinit var tasksDao: TasksDao
7

8
    @Before
9
    fun setup() {
10
        database = Room.inMemoryDatabaseBuilder(
11
            ApplicationProvider.getApplicationContext(),
12
            ToDoDatabase::class.java
13
        )
14
        .allowMainThreadQueries()
15
        .build()
16

17
        tasksDao = database.taskDao()
18
    }
19

20
    @After
21
    fun tearDown() {
22
        database.close()
23
    }
24

25
    @Test
26
    fun insertTask_retrievesSameTask() = runTest {
27
        // Arrange
28
        val task = Task(
29
            id = "1",
30
            title = "Test Task",
31
            description = "Test Description",
32
            isCompleted = false
33
        )
34

35
        // Act
36
        tasksDao.insertTask(task)
37
        val retrieved = tasksDao.getTaskById("1")
38

39
        // Assert
40
        assertEquals(task.title, retrieved.title)
41
        assertEquals(task.description, retrieved.description)
42
        assertEquals(task.isCompleted, retrieved.isCompleted)
43
    }
44

45
    @Test
46
    fun updateTask_modifiesExistingTask() = runTest {
47
        // Arrange
48
        val originalTask = Task(id = "1", title = "Original")
49
        tasksDao.insertTask(originalTask)
50

51
        // Act
52
        val updatedTask = originalTask.copy(title = "Updated")
53
        tasksDao.updateTask(updatedTask)
54

55
        // Assert
56
        val retrieved = tasksDao.getTaskById("1")
57
        assertEquals("Updated", retrieved.title)
58
    }
59

60
    @Test
61
    fun deleteCompletedTasks_onlyDeletesCompleted() = runTest {
62
        // Arrange
63
        val activeTasks = listOf(
64
            Task(id = "1", title = "Active 1", isCompleted = false),
65
            Task(id = "2", title = "Active 2", isCompleted = false)
66
        )
67
        val completedTasks = listOf(
68
            Task(id = "3", title = "Completed 1", isCompleted = true),
69
            Task(id = "4", title = "Completed 2", isCompleted = true)
70
        )
71

72
        activeTasks.plus(completedTasks).forEach {
73
            tasksDao.insertTask(it)
74
        }
75

76
        // Act
77
        tasksDao.deleteCompletedTasks()
78

79
        // Assert
80
        val remainingTasks = tasksDao.getTasks()
81
        assertEquals(2, remainingTasks.size)
82
        assertTrue(remainingTasks.all { !it.isCompleted })
83
    }
84
}

Testing with Hilt Dependency Injection#

Test Doubles and Fake Repositories#

1
class FakeTasksRepository : TasksRepository {
2

3
    private val tasks = mutableListOf<Task>()
4
    private var shouldReturnError = false
5

6
    fun setShouldReturnError(value: Boolean) {
7
        shouldReturnError = value
8
    }
9

10
    override suspend fun getTasks(forceUpdate: Boolean): List<Task> {
11
        if (shouldReturnError) {
12
            throw Exception("Test exception")
13
        }
14
        return tasks.toList()
15
    }
16

17
    override suspend fun getTask(taskId: String): Task {
18
        if (shouldReturnError) {
19
            throw Exception("Test exception")
20
        }
21
        return tasks.find { it.id == taskId }
22
            ?: throw Exception("Task not found")
23
    }
24

25
    override suspend fun saveTask(task: Task) {
26
        if (shouldReturnError) {
27
            throw Exception("Test exception")
28
        }
29
        tasks.removeIf { it.id == task.id }
30
        tasks.add(task)
31
    }
32

33
    override suspend fun deleteTask(taskId: String) {
34
        if (shouldReturnError) {
35
            throw Exception("Test exception")
36
        }
37
        tasks.removeIf { it.id == taskId }
38
    }
39

40
    override suspend fun completeTask(taskId: String) {
41
        tasks.find { it.id == taskId }?.let { task ->
42
            val index = tasks.indexOf(task)
43
            tasks[index] = task.copy(isCompleted = true)
44
        }
45
    }
46
}
47

48
@Module
49
@TestInstallIn(
50
    components = [SingletonComponent::class],
51
    replaces = [RepositoryModule::class]
52
)
53
object FakeRepositoryModule {
54

55
    @Provides
56
    @Singleton
57
    fun provideTasksRepository(): TasksRepository = FakeTasksRepository()
58
}

End-to-End Testing with Hilt#

1
@HiltAndroidTest
2
@LargeTest
3
class TasksActivityTest {
4

5
    @get:Rule(order = 0)
6
    val hiltRule = HiltAndroidRule(this)
7

8
    @get:Rule(order = 1)
9
    val activityRule = ActivityScenarioRule(TasksActivity::class.java)
10

11
    @Inject
12
    lateinit var repository: TasksRepository
13

14
    @Before
15
    fun init() {
16
        hiltRule.inject()
17
    }
18

19
    @Test
20
    fun createTask_savesAndDisplaysTask() = runTest {
21
        // Navigate to add task
22
        onView(withId(R.id.add_task_fab)).perform(click())
23

24
        // Fill task details
25
        onView(withId(R.id.add_task_title_edit_text))
26
            .perform(typeText("New Task"))
27
        onView(withId(R.id.add_task_description_edit_text))
28
            .perform(typeText("Task Description"))
29

30
        // Save task
31
        onView(withId(R.id.save_task_fab)).perform(click())
32

33
        // Verify task appears in list
34
        onView(withText("New Task")).check(matches(isDisplayed()))
35

36
        // Verify task is saved in repository
37
        val tasks = repository.getTasks()
38
        assertTrue(tasks.any { it.title == "New Task" })
39
    }
40
}

Performance Testing#

Testing Performance Characteristics#

1
class TasksPerformanceTest {
2

3
    @get:Rule
4
    val benchmarkRule = BenchmarkRule()
5

6
    @Test
7
    fun measureTaskListScrolling() {
8
        benchmarkRule.measureRepeated {
9
            // Generate large dataset
10
            val tasks = (1..1000).map {
11
                Task(id = it.toString(), title = "Task $it")
12
            }
13

14
            // Measure scrolling performance
15
            composeTestRule.setContent {
16
                TasksList(tasks = tasks)
17
            }
18

19
            composeTestRule.onNodeWithTag("TasksList")
20
                .performScrollToIndex(500)
21
        }
22
    }
23

24
    @Test
25
    fun measureDatabaseOperations() = runTest {
26
        benchmarkRule.measureRepeated {
27
            runBlocking {
28
                // Measure database insert performance
29
                val tasks = (1..100).map {
30
                    Task(id = it.toString(), title = "Task $it")
31
                }
32

33
                tasks.forEach { repository.saveTask(it) }
34

35
                // Measure query performance
36
                repository.getTasks()
37
            }
38
        }
39
    }
40
}

Testing Best Practices#

Test Organization#

1
class TasksViewModelTest {
2

3
    // Test class setup
4
    companion object {
5
        private const val TASK_ID = "1"
6
        private val TEST_TASK = Task(
7
            id = TASK_ID,
8
            title = "Test Task",
9
            description = "Description"
10
        )
11
    }
12

13
    // Group related tests
14
    @Nested
15
    @DisplayName("Loading Tasks")
16
    inner class LoadingTasks {
17

18
        @Test
19
        fun `loading tasks shows loading state`() { /* ... */ }
20

21
        @Test
22
        fun `successful load shows tasks`() { /* ... */ }
23

24
        @Test
25
        fun `failed load shows error`() { /* ... */ }
26
    }
27

28
    @Nested
29
    @DisplayName("Task Operations")
30
    inner class TaskOperations {
31

32
        @Test
33
        fun `complete task updates repository`() { /* ... */ }
34

35
        @Test
36
        fun `delete task removes from list`() { /* ... */ }
37
    }
38
}

Custom Test Rules and Extensions#

1
@ExperimentalCoroutinesApi
2
class MainDispatcherRule(
3
    private val testDispatcher: TestDispatcher = UnconfinedTestDispatcher()
4
) : TestWatcher() {
5

6
    override fun starting(description: Description) {
7
        Dispatchers.setMain(testDispatcher)
8
    }
9

10
    override fun finished(description: Description) {
11
        Dispatchers.resetMain()
12
    }
13
}
14

15
// Custom assertion extensions
16
fun ComposeTestRule.assertTaskIsDisplayed(taskTitle: String) {
17
    onNodeWithText(taskTitle).assertIsDisplayed()
18
}
19

20
fun ComposeTestRule.assertTaskIsCompleted(taskTitle: String) {
21
    onNodeWithText(taskTitle)
22
        .assert(hasStrikethroughText())
23
}
24

25
// Test data builders
26
object TestTaskBuilder {
27
    fun createTask(
28
        id: String = "default-id",
29
        title: String = "Default Task",
30
        description: String = "Default Description",
31
        isCompleted: Boolean = false
32
    ) = Task(
33
        id = id,
34
        title = title,
35
        description = description,
36
        isCompleted = isCompleted
37
    )
38

39
    fun createTasks(count: Int) = (1..count).map {
40
        createTask(
41
            id = it.toString(),
42
            title = "Task $it"
43
        )
44
    }
45
}

Conclusion#

Comprehensive testing is essential for building robust Android applications. This guide covered:

Testing Pyramid: Balancing unit, integration, and UI tests
ViewModel Testing: Testing state management and coroutines
Repository Testing: Integration testing with Room database
Compose UI Testing: Testing declarative UI components
Navigation Testing: Verifying navigation flows
Dependency Injection: Using Hilt for testable architecture
Performance Testing: Measuring and optimizing performance

By implementing these testing strategies, you’ll build more reliable, maintainable Android applications that scale with confidence. Remember to write tests that are fast, reliable, and provide clear feedback when they fail.

The key is to start with a solid foundation of unit tests, add integration tests for critical paths, and use UI tests sparingly for end-to-end scenarios. This approach ensures comprehensive coverage while maintaining fast feedback loops during development.