A
Android 单元测试专家
作者：鹿Sir开发工具v1
Android 测试专家，支持 JUnit 5、Mockito、MockK 和 Kotlin 协程测试。当用户需要编写 Android 单元测试、ViewModel 测试、Repository 测试、Flow 测试、Espresso UI 测试时触发。触发词：Android 测试、JUnit、Mockito、单元测试、Espresso、ViewModel 测试。
下载量
256
点赞
64
价格
免费
技能文档
---
name: diegosouzapw-android-unit-test
title: Android 单元测试专家
category: 开发工具
description: Android 测试专家，支持 JUnit 5、Mockito、MockK 和 Kotlin 协程测试。当用户需要编写 Android 单元测试、ViewModel 测试、Repository 测试、Flow 测试、Espresso UI 测试时触发。触发词：Android 测试、JUnit、Mockito、单元测试、Espresso、ViewModel 测试。
---
# Android 单元测试专家
使用 JUnit 5、Mockito 和 Kotlin 进行 Android 应用测试的专家指南。
## 技能工作流
### 步骤1：配置依赖
```groovy
// build.gradle (app)
dependencies {
// 单元测试
testImplementation 'junit:junit:4.13.2'
testImplementation 'org.junit.jupiter:junit-jupiter:5.9.3'
testImplementation 'org.mockito:mockito-core:5.3.1'
testImplementation 'org.mockito.kotlin:mockito-kotlin:5.0.0'
testImplementation 'io.mockk:mockk:1.13.5'
testImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.7.1'
testImplementation 'app.cash.turbine:turbine:1.0.0'
// 仪器化测试
androidTestImplementation 'androidx.test.ext:junit:1.1.5'
androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'
androidTestImplementation 'androidx.test:runner:1.5.2'
androidTestImplementation 'androidx.test:rules:1.5.0'
}
```
### 步骤2：使用 AAA 模式（Arrange, Act, Assert）
```kotlin
class UserRepositoryTest {
@Test
fun `getUser returns user when found`() {
// Arrange
val userId = "user_123"
val expectedUser = User(userId, "John Doe", "john@example.com")
val mockDataSource = mock<UserDataSource> {
on { getUser(userId) } doReturn expectedUser
}
val repository = UserRepository(mockDataSource)
// Act
val result = repository.getUser(userId)
// Assert
assertEquals(expectedUser, result)
verify(mockDataSource).getUser(userId)
}
}
```
### 步骤3：ViewModel 测试
```kotlin
@OptIn(ExperimentalCoroutinesApi::class)
class UserViewModelTest {
@get:Rule
val mainDispatcherRule = MainDispatcherRule()
private lateinit var viewModel: UserViewModel
private lateinit var repository: UserRepository
@Before
fun setup() {
repository = mock()
viewModel = UserViewModel(repository)
}
@Test
fun `loadUser updates state to success when repository returns user`() = runTest {
// Arrange
val user = User("1", "John", "john@example.com")
whenever(repository.getUser("1")).thenReturn(Result.success(user))
// Act
viewModel.loadUser("1")
// Assert
val state = viewModel.uiState.value
assertTrue(state is UserUiState.Success)
assertEquals(user, (state as UserUiState.Success).user)
}
@Test
fun `loadUser updates state to error when repository fails`() = runTest {
// Arrange
val exception = IOException("Network error")
whenever(repository.getUser("1")).thenReturn(Result.failure(exception))
// Act
viewModel.loadUser("1")
// Assert
val state = viewModel.uiState.value
assertTrue(state is UserUiState.Error)
assertEquals("Network error", (state as UserUiState.Error).message)
}
}
```
### 步骤4：配置 MainDispatcherRule
```kotlin
@OptIn(ExperimentalCoroutinesApi::class)
class MainDispatcherRule(
private val testDispatcher: TestDispatcher = UnconfinedTestDispatcher()
) : TestWatcher() {
override fun starting(description: Description) {
Dispatchers.setMain(testDispatcher)
}
override fun finished(description: Description) {
Dispatchers.resetMain()
}
}
```
### 步骤5：Repository 测试
```kotlin
class UserRepositoryTest {
private lateinit var repository: UserRepository
private lateinit var remoteDataSource: UserRemoteDataSource
private lateinit var localDataSource: UserLocalDataSource
@Before
fun setup() {
remoteDataSource = mock()
localDataSource = mock()
repository = UserRepository(remoteDataSource, localDataSource)
}
@Test
fun `getUsers returns cached data when available`() = runTest {
// Arrange
val cachedUsers = listOf(User("1", "John", "john@example.com"))
whenever(localDataSource.getUsers()).thenReturn(cachedUsers)
// Act
val result = repository.getUsers()
// Assert
assertEquals(cachedUsers, result)
verify(localDataSource).getUsers()
verifyNoInteractions(remoteDataSource)
}
@Test
fun `getUsers fetches from remote when cache is empty`() = runTest {
// Arrange
val remoteUsers = listOf(User("1", "John", "john@example.com"))
whenever(localDataSource.getUsers()).thenReturn(emptyList())
whenever(remoteDataSource.getUsers()).thenReturn(remoteUsers)
// Act
val result = repository.getUsers()
// Assert
assertEquals(remoteUsers, result)
verify(localDataSource).saveUsers(remoteUsers)
}
}
```
### 步骤6：使用 Turbine 进行 Flow 测试
```kotlin
@OptIn(ExperimentalCoroutinesApi::class)
class FlowTestExample {
@Test
fun `userFlow emits expected values`() = runTest {
val repository = UserRepository()
repository.userFlow.test {
// 初始状态
assertEquals(UserState.Loading, awaitItem())
// 加载完成后
assertEquals(UserState.Success(user), awaitItem())
// 取消并忽略后续发射
cancelAndIgnoreRemainingEvents()
}
}
@Test
fun `searchFlow debounces and emits results`() = runTest {
val viewModel = SearchViewModel()
viewModel.searchResults.test {
viewModel.onSearchQueryChanged("test")
advanceTimeBy(300) // 防抖时间
val result = awaitItem()
assertTrue(result.isNotEmpty())
cancelAndIgnoreRemainingEvents()
}
}
}
```
### 步骤7：参数化测试
```kotlin
class CalculatorTest {
@ParameterizedTest
@CsvSource(
"1, 1, 2",
"2, 3, 5",
"10, -5, 5",
"0, 0, 0"
)
fun `add returns correct sum`(a: Int, b: Int, expected: Int) {
val calculator = Calculator()
assertEquals(expected, calculator.add(a, b))
}
@ParameterizedTest
@MethodSource("divisionTestData")
fun `divide handles edge cases`(a: Int, b: Int, expected: Result<Int>) {
val calculator = Calculator()
assertEquals(expected, calculator.divide(a, b))
}
companion object {
@JvmStatic
fun divisionTestData() = listOf(
Arguments.of(10, 2, Result.success(5)),
Arguments.of(9, 3, Result.success(3)),
Arguments.of(5, 0, Result.failure<Int>(ArithmeticException()))
)
}
}
```
### 步骤8：使用 MockK 进行 Kotlin 测试
```kotlin
class UserServiceTest {
@MockK
private lateinit var api: UserApi
@MockK
private lateinit var cache: UserCache
private lateinit var service: UserService
@Before
fun setup() {
MockKAnnotations.init(this)
service = UserService(api, cache)
}
@Test
fun `getUser uses coEvery for suspend functions`() = runTest {
// Arrange
val user = User("1", "John", "john@example.com")
coEvery { api.getUser("1") } returns user
coEvery { cache.save(any()) } just Runs
// Act
val result = service.getUser("1")
// Assert
assertEquals(user, result)
coVerify { cache.save(user) }
}
@Test
fun `verify call order`() = runTest {
val user = User("1", "John", "john@example.com")
coEvery { api.getUser("1") } returns user
coEvery { cache.save(any()) } just Runs
service.getUser("1")
coVerifyOrder {
api.getUser("1")
cache.save(user)
}
}
}
```
### 步骤9：测试数据工厂
```kotlin
object UserFactory {
fun create(
id: String = "user_${UUID.randomUUID()}",
name: String = "Test User",
email: String = "test@example.com",
isActive: Boolean = true
) = User(id, name, email, isActive)
fun createList(count: Int = 5) = (1..count).map {
create(id = "user_$it", name = "User $it")
}
}
// 在测试中使用
@Test
fun `test with factory`() {
val user = UserFactory.create(name = "Custom Name")
val users = UserFactory.createList(10)
}
```
### 步骤10：自定义断言
```kotlin
fun <T> Result<T>.shouldBeSuccess(): T {
assertTrue(this.isSuccess, "Expected success but was failure: ${this.exceptionOrNull()}")
return this.getOrThrow()
}
fun <T> Result<T>.shouldBeFailure(): Throwable {
assertTrue(this.isFailure, "Expected failure but was success: ${this.getOrNull()}")
return this.exceptionOrNull()!!
}
// 使用示例
@Test
fun `repository returns success`() {
val result = repository.getUser("1")
val user = result.shouldBeSuccess()
assertEquals("John", user.name)
}
```
### 步骤11：Espresso UI 测试
```kotlin
@RunWith(AndroidJUnit4::class)
class LoginActivityTest {
@get:Rule
val activityRule = ActivityScenarioRule(LoginActivity::class.java)
@Test
fun loginButton_isDisabled_whenEmailIsEmpty() {
onView(withId(R.id.emailInput)).perform(clearText())
onView(withId(R.id.passwordInput)).perform(typeText("password123"))
onView(withId(R.id.loginButton)).check(matches(not(isEnabled())))
}
@Test
fun successfulLogin_navigatesToHome() {
onView(withId(R.id.emailInput)).perform(typeText("test@example.com"))
onView(withId(R.id.passwordInput)).perform(typeText("password123"))
onView(withId(R.id.loginButton)).perform(click())
onView(withId(R.id.homeScreen)).check(matches(isDisplayed()))
}
}
```
## 最佳实践
1. **一个测试 = 一个行为** - 每个测试只验证一件事
2. **描述性命名** - 使用反引号创建可读的测试名称
3. **AAA 模式** - 每个测试都遵循 Arrange、Act、Assert
4. **隔离性** - 测试之间互不依赖
5. **快速执行** - 单元测试应瞬间完成
6. **测试边界情况** - null、空列表、错误场景使用说明
# Android 单元测试专家 Android 应用单元测试专家指南，涵盖 JUnit 5、Mockito、MockK 和 Kotlin 协程测试。 ## 核心能力 - **依赖配置**：JUnit 5、Mockito、MockK、Turbine 等测试框架配置 - **AAA 模式**：Arrange-Act-Assert 标准测试模式 - **ViewModel 测试**：协程调度器配置与状态验证 - **Repository 测试**：数据源 Mock 与缓存逻辑测试 - **Flow 测试**：使用 Turbine 测试 Kotlin Flow - **参数化测试**：使用 @ParameterizedTest 进行多组数据测试 - **MockK**：Kotlin 专用 Mock 框架，支持协程函数 - **测试数据工厂**：可复用的测试数据生成 - **自定义断言**：Result 类型的便捷断言 - **Espresso UI 测试**：界面交互测试 ## 触发方式 当用户提到以下内容时自动触发： - Android 测试、JUnit、Mockito - 单元测试、ViewModel 测试 - Espresso、UI 测试 - Flow 测试、协程测试 ## 依赖 - Android 项目 - JUnit 5 - Mockito / MockK - Kotlin Coroutines Test - Turbine（Flow 测试） - Espresso（UI 测试）
支持平台：Qoder · QoderWork · Claude · Codex 等 AI 编程助手