Android 测试全景：从单元测试到 UI 自动化的完整实践

Android 测试全景：从单元测试到 UI 自动化的完整实践

在 Android 开发中，测试不是可选项，而是保证代码质量、减少线上事故的必备工程实践。本文将带你从零开始搭建一套完整的测试体系，涵盖单元测试、Android 特有测试场景以及 UI 自动化测试的全链路实践。

单元测试基础：JUnit、Mockito 与 Truth

单元测试的核心是隔离验证——针对单个类或方法，屏蔽外部依赖，快速验证逻辑正确性。

JUnit 5 快速上手

JUnit 是 Java 生态的测试基石。在 build.gradle 中引入依赖：

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter:5.9.3'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.9.3'
}

tasks.withType(Test) { useJUnitPlatform() }

一个典型的单元测试示例：

import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Assertions.*
import org.junit.jupiter.api.BeforeEach

class UserValidatorTest { private lateinit var validator: UserValidator

@BeforeEach fun setup() { validator = UserValidator() }

@Test fun valid email should pass validation() { val result = validator.validateEmail("user@example.com") assertTrue(result.isValid) }

@Test fun invalid email should return error message() { val result = validator.validateEmail("not-an-email") assertFalse(result.isValid) assertEquals("Invalid email format", result.errorMessage) } }

Mockito：模拟外部依赖

当测试对象依赖数据库、网络或其他组件时，Mockito 可以创建轻量级替身：

testImplementation 'org.mockito:mockito-core:5.3.1'
testImplementation 'org.mockito.kotlin:mockito-kotlin:5.0.0'

实战示例——测试一个依赖网络 API 的 Repository：

import org.mockito.kotlin.*
import kotlinx.coroutines.test.runTest

class UserRepositoryTest { private val api: UserApi = mock() private val repository = UserRepository(api)

@Test fun fetchUser should return user when API succeeds() = runTest { // Given val userId = "123" val expectedUser = User(userId, "Alice", "alice@test.com") whenever(api.getUser(userId)).thenReturn(expectedUser)

// When val result = repository.fetchUser(userId)

// Then assertEquals(expectedUser, result) verify(api, times(1)).getUser(userId) }

@Test fun fetchUser should throw exception when API fails() = runTest { // Given whenever(api.getUser(any())).thenThrow(NetworkException("Connection timeout"))

// When & Then assertThrows<NetworkException> { repository.fetchUser("123") } } }

Truth：让断言更易读

Google 的 Truth 库提供流畅的断言 API：

testImplementation 'com.google.truth:truth:1.1.5'

对比传统 JUnit 断言：

import com.google.common.truth.Truth.assertThat

@Test fun truth makes assertions readable() { val numbers = listOf(1, 2, 3, 4, 5) // JUnit 风格 assertTrue(numbers.contains(3)) assertEquals(5, numbers.size) // Truth 风格（更自然） assertThat(numbers).contains(3) assertThat(numbers).hasSize(5) assertThat(numbers).containsExactly(1, 2, 3, 4, 5).inOrder() }

Android 单元测试：本地测试 vs 仪器测试

Android 的测试分为两类：本地测试（运行在 JVM）和仪器测试（运行在设备/模拟器）。

Robolectric：在 JVM 上模拟 Android 框架

Robolectric 让你无需启动模拟器即可测试 Android 组件：

testImplementation 'org.robolectric:robolectric:4.10.3'

测试一个带 Context 依赖的工具类：

import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.RuntimeEnvironment
import com.google.common.truth.Truth.assertThat

@RunWith(RobolectricTestRunner::class) class SharedPrefsManagerTest { private val context = RuntimeEnvironment.getApplication() private val manager = SharedPrefsManager(context)

@Test fun saveToken should persist token correctly() { manager.saveToken("abc123") val token = manager.getToken() assertThat(token).isEqualTo("abc123") }

@Test fun clearToken should remove stored token() { manager.saveToken("xyz") manager.clearToken() assertThat(manager.getToken()).isNull() } }

本地测试 vs 仪器测试的选择

| 场景 | 推荐方式 | 原因 | |------|---------|------| | 纯业务逻辑（ViewModel、UseCase） | 本地测试 | 速度快，无需设备 | | 轻量 Android API（SharedPreferences、Intent） | Robolectric | 接近真实环境，仍在 JVM 运行 | | 复杂 UI 交互、动画、传感器 | 仪器测试 | 必须在真实环境验证 | | 数据库（Room）、文件 I/O | 两者皆可 | Robolectric 快，仪器测试更准确 |

UI 自动化测试：Espresso 与 UI Automator

Espresso：应用内 UI 测试

Espresso 是 Google 官方的 UI 测试框架，适合测试单个应用的界面交互：

androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'
androidTestImplementation 'androidx.test.ext:junit:1.1.5'
androidTestImplementation 'androidx.test:runner:1.5.2'
androidTestImplementation 'androidx.test:rules:1.5.0'

完整登录流程测试示例：

import androidx.test.espresso.Espresso.onView
import androidx.test.espresso.action.ViewActions.*
import androidx.test.espresso.assertion.ViewAssertions.matches
import androidx.test.espresso.matcher.ViewMatchers.*
import androidx.test.ext.junit.rules.ActivityScenarioRule
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith

@RunWith(AndroidJUnit4::class) class LoginActivityTest { @get:Rule val activityRule = ActivityScenarioRule(LoginActivity::class.java)

@Test fun loginWithValidCredentials_shouldNavigateToHome() { // 输入用户名和密码 onView(withId(R.id.edit_username)) .perform(typeText("testuser"), closeSoftKeyboard()) onView(withId(R.id.edit_password)) .perform(typeText("password123"), closeSoftKeyboard())

// 点击登录按钮 onView(withId(R.id.btn_login)) .perform(click())

// 验证跳转到主页 onView(withId(R.id.text_welcome)) .check(matches(isDisplayed())) .check(matches(withText("Welcome, testuser!"))) }

@Test fun loginWithEmptyFields_shouldShowError() { onView(withId(R.id.btn_login)) .perform(click())

onView(withId(R.id.text_error)) .check(matches(withText("Please enter username and password"))) } }

UI Automator：跨应用测试

当需要测试跨应用场景（如分享到系统应用、权限弹窗），使用 UI Automator：

androidTestImplementation 'androidx.test.uiautomator:uiautomator:2.3.0'

测试权限请求流程：

import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.uiautomator.UiDevice
import androidx.test.uiautomator.UiSelector
import androidx.test.uiautomator.Until

@Test fun requestCameraPermission_shouldGrantAccess() { val device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())

// 触发权限请求 onView(withId(R.id.btn_open_camera)).perform(click())

// 等待系统权限弹窗 device.wait(Until.hasObject(By.text("Allow")), 3000)

// 点击"允许"按钮 val allowButton = device.findObject(UiSelector().text("Allow")) if (allowButton.exists()) { allowButton.click() }

// 验证相机已打开 onView(withId(R.id.camera_preview)) .check(matches(isDisplayed())) }

测试覆盖率与持续集成

生成测试覆盖率报告

在 build.gradle 中启用 JaCoCo：

android {
    buildTypes {
        debug {
            testCoverageEnabled true
        }
    }
}

tasks.register('jacocoTestReport', JacocoReport) { dependsOn 'testDebugUnitTest', 'createDebugCoverageReport'

reports { xml.required = true html.required = true }

def fileFilter = [ '**/R.class', '**/BuildConfig.*', '**/Manifest*.*', '**/*_Factory.*' ]

def kotlinTree = fileTree(dir: "$buildDir/tmp/kotlin-classes/debug", excludes: fileFilter) def javaTree = fileTree(dir: "$buildDir/intermediates/javac/debug", excludes: fileFilter)

classDirectories.setFrom(files([kotlinTree, javaTree])) sourceDirectories.setFrom(files(['src/main/java', 'src/main/kotlin'])) executionData.setFrom(fileTree(dir: buildDir, includes: [ 'jacoco/testDebugUnitTest.exec', 'outputs/code_coverage/debugAndroidTest/connected/**/*.ec' ])) }

运行命令生成报告：

./gradlew jacocoTestReport

报告输出在 build/reports/jacoco/jacocoTestReport/html/index.html。

在 CI 中集成测试

GitHub Actions 配置示例（.github/workflows/test.yml）：

name: Android CI

on: push: branches: [ main, develop ] pull_request: branches: [ main ]

jobs: test: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - name: Set up JDK 17 uses: actions/setup-java@v3 with: java-version: '17' distribution: 'temurin' - name: Grant execute permission for gradlew run: chmod +x gradlew - name: Run unit tests run: ./gradlew testDebugUnitTest - name: Run instrumented tests uses: reactivecircus/android-emulator-runner@v2 with: api-level: 33 target: google_apis arch: x86_64 script: ./gradlew connectedDebugAndroidTest - name: Generate coverage report run: ./gradlew jacocoTestReport - name: Upload coverage to Codecov uses: codecov/codecov-action@v3 with: files: ./app/build/reports/jacoco/jacocoTestReport/jacocoTestReport.xml

实战案例：从零搭建测试体系

假设我们有一个新闻应用，从零搭建测试体系的步骤：

第一步：项目依赖配置

在 app/build.gradle 中统一配置测试依赖：

dependencies {
    // 单元测试
    testImplementation 'junit:junit:4.13.2'
    testImplementation 'org.mockito:mockito-core:5.3.1'
    testImplementation 'org.mockito.kotlin:mockito-kotlin:5.0.0'
    testImplementation 'com.google.truth:truth:1.1.5'
    testImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.7.3'
    testImplementation 'androidx.arch.core:core-testing:2.2.0'
    testImplementation 'org.robolectric:robolectric:4.10.3'
    
    // UI 测试
    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'
    androidTestImplementation 'androidx.test.uiautomator:uiautomator:2.3.0'
}

第二步：ViewModel 单元测试

class NewsViewModelTest {
    @get:Rule
    val instantExecutorRule = InstantTaskExecutorRule()
    
    private val repository: NewsRepository = mock()
    private lateinit var viewModel: NewsViewModel

@Before fun setup() { viewModel = NewsViewModel(repository) }

@Test fun loadNews should update LiveData when repository returns data() = runTest { // Given val articles = listOf( Article("1", "Title 1", "Content 1"), Article("2", "Title 2", "Content 2") ) whenever(repository.fetchLatestNews()).thenReturn(Result.success(articles))

// When viewModel.loadNews()

// Then assertThat(viewModel.newsLiveData.value).isEqualTo(articles) assertThat(viewModel.isLoadingLiveData.value).isFalse() } }

第三步：Repository 测试（含数据库和网络）

@RunWith(RobolectricTestRunner::class)
class NewsRepositoryTest {
    private lateinit var database: NewsDatabase
    private val api: NewsApi = mock()
    private lateinit var repository: NewsRepository

@Before fun setup() { val context = RuntimeEnvironment.getApplication() database = Room.inMemoryDatabaseBuilder(context, NewsDatabase::class.java) .allowMainThreadQueries() .build() repository = NewsRepository(api, database.newsDao()) }

@Test fun fetchLatestNews should cache results in database() = runTest { // Given val remoteArticles = listOf(Article("1", "Remote Title", "Content")) whenever(api.getLatestNews()).thenReturn(remoteArticles)

// When repository.fetchLatestNews()

// Then val cachedArticles = database.newsDao().getAllArticles() assertThat(cachedArticles).hasSize(1) assertThat(cachedArticles[0].title).isEqualTo("Remote Title") } }

第四步：完整 UI 流程测试

@RunWith(AndroidJUnit4::class)
@LargeTest
class NewsFlowTest {
    @get:Rule
    val activityRule = ActivityScenarioRule(MainActivity::class.java)

@Test fun userCanBrowseAndReadArticle() { // 等待列表加载 onView(withId(R.id.recycler_news)) .check(matches(isDisplayed()))

// 点击第一篇文章 onView(withId(R.id.recycler_news)) .perform(RecyclerViewActions.actionOnItemAtPosition<RecyclerView.ViewHolder>(0, click()))

// 验证详情页显示 onView(withId(R.id.text_article_title)) .check(matches(isDisplayed()))

// 点击分享按钮 onView(withId(R.id.btn_share)) .perform(click())

// 使用 UI Automator 验证系统分享面板 val device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation()) val sharePanel = device.findObject(UiSelector().textContains("Share")) assertThat(sharePanel.exists()).isTrue() } }

测试金字塔与最佳实践

遵循测试金字塔原则：

- 70% 单元测试：快速、稳定、低成本 - 20% 集成测试：验证模块间协作 - 10% UI 测试：覆盖核心用户流程

关键建议：

1. 测试要快：单元测试应在毫秒级完成，整个测试套件不超过 5 分钟 2. 测试要独立：每个测试可以独立运行，不依赖执行顺序 3. 测试要清晰：使用 Given-When-Then 结构，测试名称描述预期行为 4. Mock 要克制：只 mock 外部依赖，不要 mock 被测对象本身 5. 持续演进：新功能必须有测试，老代码逐步补测试

总结

测试不是负担，而是重构的信心来源和质量的最后防线。从单元测试的快速反馈，到 UI 自动化测试的端到端验证，完整的测试体系能让你在迭代时更从容、在上线时更放心。

现在就为你的项目配置第一个测试用例吧——从最核心的业务逻辑开始，逐步建立覆盖网，你会发现代码质量和开发体验都会有质的提升。