Android test全景：从单元 test到 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 测试：覆盖核心用户流程

关键建议：

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

总结

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

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

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

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

JUnit 5 快速上手

Mockito：模拟外部依赖

Truth：让断言更易读

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

Robolectric：在 JVM 上模拟 Android 框架

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

UI 自动化测试：Espresso 与 UI Automator

Espresso：应用内 UI 测试

UI Automator：跨应用测试

测试覆盖率与持续集成

生成测试覆盖率报告

在 CI 中集成测试

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

第一步：项目依赖配置

第二步：ViewModel 单元测试

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

第四步：完整 UI 流程测试

测试金字塔与最佳实践

总结

热门文章

最新文章

相关电子书

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

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

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

JUnit 5 快速上手

Mockito：模拟外部依赖

Truth：让断言更易读

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

Robolectric：在 JVM 上模拟 Android 框架

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

UI 自动化测试：Espresso 与 UI Automator

Espresso：应用内 UI 测试

UI Automator：跨应用测试

测试覆盖率与持续集成

生成测试覆盖率报告

在 CI 中集成测试

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

第一步：项目依赖配置

第二步：ViewModel 单元测试

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

第四步：完整 UI 流程测试

测试金字塔与最佳实践

总结

热门文章

最新文章

相关电子书