Testing is a fundamental part of Android app development. In this article, we'll explore the different testing strategies and tools available on Android.
Types of Testing
1. Unit Testing
class UserRepositoryTest {
@Test
fun `test user creation`() {
// Arrange
val user = User("1", "Test User")
// Act
val result = userRepository.createUser(user)
// Assert
assertTrue(result.isSuccess)
assertEquals(user, result.getOrNull())
}
}
2. Integration Testing
@HiltAndroidTest
class UserFlowTest {
@get:Rule
val hiltRule = HiltAndroidRule(this)
@Inject
lateinit var userRepository: UserRepository
@Test
fun testUserFlow() {
// Arrange
val user = User("1", "Test User")
// Act
userRepository.createUser(user)
val savedUser = userRepository.getUser("1")
// Assert
assertEquals(user, savedUser)
}
}
UI Testing
1. Compose Testing
@Test
fun testUserScreen() {
composeTestRule.setContent {
UserScreen(viewModel = viewModel)
}
composeTestRule
.onNodeWithText("Test User")
.assertIsDisplayed()
composeTestRule
.onNodeWithContentDescription("Edit")
.performClick()
composeTestRule
.onNodeWithText("Edit User")
.assertIsDisplayed()
}
2. Espresso Testing
@Test
fun testUserList() {
// Arrange
val users = listOf(User("1", "Test User"))
userRepository.setUsers(users)
// Act
activityRule.launchActivity(null)
// Assert
onView(withId(R.id.user_list))
.check(matches(isDisplayed()))
onView(withText("Test User"))
.check(matches(isDisplayed()))
}
Testing ViewModels
1. ViewModel Testing
class UserViewModelTest {
@Test
fun `test user loading`() = runTest {
// Arrange
val users = listOf(User("1", "Test User"))
val repository = mock<UserRepository>()
whenever(repository.getUsers()).thenReturn(users)
val viewModel = UserViewModel(repository)
// Act
viewModel.loadUsers()
// Assert
assertEquals(users, viewModel.users.value)
}
}
2. State Testing
@Test
fun `test loading state`() = runTest {
// Arrange
val viewModel = UserViewModel(repository)
// Act
viewModel.loadUsers()
// Assert
assertTrue(viewModel.isLoading.value)
// Simulate loading completed
advanceUntilIdle()
assertFalse(viewModel.isLoading.value)
}
Testing Coroutines
1. Coroutine Testing
@Test
fun `test coroutine flow`() = runTest {
// Arrange
val flow = flow {
emit(1)
delay(100)
emit(2)
}
// Act & Assert
flow.test {
assertEquals(1, awaitItem())
assertEquals(2, awaitItem())
awaitComplete()
}
}
2. Error Handling
@Test
fun `test error handling`() = runTest {
// Arrange
val error = RuntimeException("Test error")
val flow = flow { throw error }
// Act & Assert
flow.test {
assertTrue(awaitError() is RuntimeException)
}
}
Best Practices
Test structure
- Follow the AAA pattern (Arrange-Act-Assert)
- Keep tests independent
- Use descriptive names
Mocks and fakes
- Use mocks for external dependencies
- Implement fakes for integration testing
- Avoid excessive mocking
Code coverage
- Aim for meaningful coverage
- Focus on critical use cases
- Don't obsess over 100%
Testing Tools
JUnit
- Base testing framework
- Annotations for setup
- Assertions for validation
Mockito
- Creating mocks
- Verifying interactions
- Stubbing behavior
Espresso
- UI testing
- Interacting with views
- State validation
Compose Testing
- Declarative UI testing
- Interacting with composables
- State validation
Benefits of Good Testing
- Early bug detection
- Safe refactoring
- Living documentation
- Better code design
- Confidence in your code
Conclusion
Testing is an essential part of Android app development. A good testing strategy helps maintain code quality and makes long-term maintenance easier.