Android Room 框架测试模块源码深度剖析(五)

Android Room 框架测试模块源码深度剖析

一、引言

在 Android 开发中，数据持久化是一项重要的功能，而 Android Room 框架为开发者提供了一个强大且便捷的方式来实现本地数据库操作。然而，为了确保 Room 数据库操作的正确性和稳定性，测试是必不可少的环节。Room 框架的测试模块提供了一系列工具和方法，帮助开发者编写高质量的测试用例。本文将深入剖析 Android Room 框架的测试模块，从源码级别详细分析其实现原理和使用方法。

二、测试模块概述

2.1 测试模块的作用

Room 框架的测试模块主要用于对数据库操作进行单元测试和集成测试。通过测试模块，开发者可以在不依赖实际设备或模拟器的情况下，对数据库的增删改查操作进行验证，确保数据库操作的正确性和性能。

2.2 测试模块的主要组件

测试模块主要包含以下几个方面的组件：

• 内存数据库：用于在测试环境中创建一个临时的内存数据库，避免对实际数据库造成影响。
• 测试注解：如 @RunWith、@Test 等，用于标记测试类和测试方法。
• 测试工具类：提供了一些辅助方法，如创建数据库实例、插入测试数据等。

三、内存数据库的使用

3.1 创建内存数据库

在测试环境中，为了避免对实际数据库造成影响，通常使用内存数据库进行测试。以下是一个创建内存数据库的示例：

java

import androidx.room.Room;
import androidx.room.testing.MigrationTestHelper;
import androidx.sqlite.db.SupportSQLiteDatabase;
import androidx.test.core.app.ApplicationProvider;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import androidx.test.filters.SmallTest;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;

import java.io.IOException;

// 使用 AndroidJUnit4 运行器运行测试
@RunWith(AndroidJUnit4.class)
// 标记为小范围测试
@SmallTest
public class UserDaoTest {

    private UserDao userDao;
    private AppDatabase db;

    // MigrationTestHelper 用于测试数据库迁移
    @Rule
    public MigrationTestHelper helper;

    public UserDaoTest() {
        // 创建 MigrationTestHelper 实例
        helper = new MigrationTestHelper(
                ApplicationProvider.getApplicationContext(),
                AppDatabase.class.getCanonicalName()
        );
    }

    @Before
    public void createDb() throws IOException {
        // 使用 Room.inMemoryDatabaseBuilder 创建内存数据库实例
        db = Room.inMemoryDatabaseBuilder(
                ApplicationProvider.getApplicationContext(),
                AppDatabase.class
        )
               .allowMainThreadQueries() // 允许在主线程进行数据库查询
               .build();
        userDao = db.userDao();
    }

    @Test
    public void insertUser() {
        User user = new User("John", 25);
        // 插入用户数据
        userDao.insert(user);
        // 查询用户数据
        User insertedUser = userDao.getUserByName("John");
        // 验证插入的数据是否正确
        assertEquals("John", insertedUser.getName());
        assertEquals(25, insertedUser.getAge());
    }
}

3.1.1 源码分析

Room.inMemoryDatabaseBuilder 方法用于创建一个内存数据库的构建器，其源码如下：

java

public static <T extends RoomDatabase> Builder<T> inMemoryDatabaseBuilder(Context context,
                                                                          Class<T> klass) {
    return new Builder<>(context, klass, null);
}

该方法返回一个 Builder 实例，通过 Builder 可以对数据库进行配置，如允许在主线程进行数据库查询、设置数据库回调等。最终调用 build 方法创建数据库实例。

3.2 内存数据库的特点

• 临时存储：内存数据库的数据存储在内存中，测试结束后数据会被清除，不会对实际数据库造成影响。
• 快速读写：由于数据存储在内存中，读写速度比磁盘数据库快，适合进行快速的测试。
• 易于重置：每次测试可以创建一个全新的内存数据库实例，确保测试环境的独立性。

四、测试注解的使用

4.1 @RunWith 注解

@RunWith 注解用于指定测试运行器，在 Android 测试中通常使用 AndroidJUnit4 运行器。

java

import androidx.test.ext.junit.runners.AndroidJUnit4;
import org.junit.runner.RunWith;

// 使用 AndroidJUnit4 运行器运行测试
@RunWith(AndroidJUnit4.class)
public class UserDaoTest {
    // 测试方法
}

4.1.1 源码分析

AndroidJUnit4 是一个 JUnit 4 的运行器，它继承自 AndroidJUnitRunner，用于在 Android 环境中运行 JUnit 4 测试用例。其源码可以在 AndroidX Test 库中找到，主要负责加载和执行测试类和测试方法。

4.2 @Test 注解

@Test 注解用于标记测试方法，JUnit 会自动识别并执行这些方法。

java

import org.junit.Test;

public class UserDaoTest {
    @Test
    public void insertUser() {
        // 测试逻辑
    }
}

4.2.2 源码分析

@Test 注解是 JUnit 框架提供的，JUnit 在运行测试时会扫描测试类中的所有方法，找到被 @Test 注解标记的方法并执行。

4.3 @Before 注解

@Before 注解用于标记在每个测试方法执行之前需要执行的方法，通常用于初始化测试环境。

java

import org.junit.Before;

public class UserDaoTest {
    private UserDao userDao;
    private AppDatabase db;

    @Before
    public void createDb() {
        // 创建数据库实例
        db = Room.inMemoryDatabaseBuilder(
                ApplicationProvider.getApplicationContext(),
                AppDatabase.class
        )
               .allowMainThreadQueries()
               .build();
        userDao = db.userDao();
    }

    @Test
    public void insertUser() {
        // 测试逻辑
    }
}

4.3.3 源码分析

JUnit 在执行每个测试方法之前，会先执行被 @Before 注解标记的方法，确保测试环境的初始化。

4.4 @After 注解

@After 注解用于标记在每个测试方法执行之后需要执行的方法，通常用于清理测试环境。

java

import org.junit.After;

public class UserDaoTest {
    private UserDao userDao;
    private AppDatabase db;

    @Before
    public void createDb() {
        // 创建数据库实例
        db = Room.inMemoryDatabaseBuilder(
                ApplicationProvider.getApplicationContext(),
                AppDatabase.class
        )
               .allowMainThreadQueries()
               .build();
        userDao = db.userDao();
    }

    @After
    public void closeDb() {
        // 关闭数据库
        db.close();
    }

    @Test
    public void insertUser() {
        // 测试逻辑
    }
}

4.4.4 源码分析

JUnit 在执行每个测试方法之后，会执行被 @After 注解标记的方法，确保测试环境的清理。

五、测试工具类的使用

5.1 MigrationTestHelper 类

MigrationTestHelper 类用于测试数据库迁移，它提供了一些方法来创建和验证数据库迁移。

java

import androidx.room.Room;
import androidx.room.testing.MigrationTestHelper;
import androidx.sqlite.db.SupportSQLiteDatabase;
import androidx.test.core.app.ApplicationProvider;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import androidx.test.filters.SmallTest;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;

import java.io.IOException;

// 使用 AndroidJUnit4 运行器运行测试
@RunWith(AndroidJUnit4.class)
// 标记为小范围测试
@SmallTest
public class MigrationTest {

    private static final String TEST_DB = "migration-test";

    // MigrationTestHelper 用于测试数据库迁移
    @Rule
    public MigrationTestHelper helper;

    public MigrationTest() {
        // 创建 MigrationTestHelper 实例
        helper = new MigrationTestHelper(
                ApplicationProvider.getApplicationContext(),
                AppDatabase.class.getCanonicalName()
        );
    }

    @Test
    public void migrate1To2() throws IOException {
        // 创建版本 1 的数据库
        SupportSQLiteDatabase db = helper.createDatabase(TEST_DB, 1);
        // 插入测试数据
        db.execSQL("INSERT INTO users (name, age) VALUES ('John', 25)");
        db.close();

        // 执行迁移到版本 2
        db = helper.runMigrationsAndValidate(TEST_DB, 2, true, MIGRATION_1_2);

        // 验证迁移后的数据
        Cursor cursor = db.query("SELECT * FROM users");
        assertEquals(1, cursor.getCount());
        cursor.moveToFirst();
        assertEquals("John", cursor.getString(cursor.getColumnIndex("name")));
        assertEquals(25, cursor.getInt(cursor.getColumnIndex("age")));
        cursor.close();
        db.close();
    }

    // 定义从版本 1 到版本 2 的迁移
    static final Migration MIGRATION_1_2 = new Migration(1, 2) {
        @Override
        public void migrate(SupportSQLiteDatabase database) {
            // 执行迁移操作，如添加新列
            database.execSQL("ALTER TABLE users ADD COLUMN email TEXT");
        }
    };
}

5.1.1 源码分析

MigrationTestHelper 类的主要功能是创建和管理测试数据库，执行数据库迁移，并验证迁移结果。其源码中包含了创建数据库、执行迁移和验证数据库版本等方法。

java

public class MigrationTestHelper {
    private final Context mContext;
    private final String mDatabaseClassName;

    public MigrationTestHelper(Context context, String databaseClassName) {
        mContext = context;
        mDatabaseClassName = databaseClassName;
    }

    public SupportSQLiteDatabase createDatabase(String name, int version) throws IOException {
        // 创建指定版本的数据库
        return Room.databaseBuilder(mContext, SupportSQLiteDatabase.class, name)
               .setVersion(version)
               .build();
    }

    public SupportSQLiteDatabase runMigrationsAndValidate(String name, int version, boolean validate, Migration... migrations) throws IOException {
        // 执行迁移并验证数据库
        RoomDatabase.Builder<RoomDatabase> builder = Room.databaseBuilder(mContext, RoomDatabase.class, name)
               .addMigrations(migrations);
        if (validate) {
            builder.validateMigrationSchema();
        }
        RoomDatabase db = builder.build();
        db.getOpenHelper().getWritableDatabase();
        return db.getOpenHelper().getWritableDatabase();
    }
}

5.2 TestDatabaseBuilder 类

TestDatabaseBuilder 类是一个辅助类，用于创建测试数据库实例。

java

import androidx.room.Room;
import androidx.room.testing.TestDatabaseBuilder;
import androidx.test.core.app.ApplicationProvider;

public class TestDatabaseHelper {
    public static AppDatabase createTestDatabase() {
        // 使用 TestDatabaseBuilder 创建测试数据库实例
        TestDatabaseBuilder<AppDatabase> builder = Room.testDatabaseBuilder(
                ApplicationProvider.getApplicationContext(),
                AppDatabase.class
        );
        return builder.build();
    }
}

5.2.2 源码分析

TestDatabaseBuilder 类继承自 RoomDatabase.Builder，提供了一些额外的配置选项，用于创建测试数据库。

java

public class TestDatabaseBuilder<T extends RoomDatabase> extends RoomDatabase.Builder<T> {
    public TestDatabaseBuilder(Context context, Class<T> klass) {
        super(context, klass, null);
    }

    @Override
    public T build() {
        // 配置测试数据库
        allowMainThreadQueries();
        return super.build();
    }
}

六、单元测试的实现

6.1 测试 DAO 方法

DAO（数据访问对象）接口定义了数据库的操作方法，对 DAO 方法进行单元测试可以确保数据库操作的正确性。

java

import androidx.room.Dao;
import androidx.room.Insert;
import androidx.room.Query;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import androidx.test.filters.SmallTest;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

import java.util.List;

import static org.junit.Assert.assertEquals;

// 使用 AndroidJUnit4 运行器运行测试
@RunWith(AndroidJUnit4.class)
// 标记为小范围测试
@SmallTest
public class UserDaoTest {

    private UserDao userDao;
    private AppDatabase db;

    @Before
    public void createDb() {
        // 创建内存数据库实例
        db = Room.inMemoryDatabaseBuilder(
                ApplicationProvider.getApplicationContext(),
                AppDatabase.class
        )
               .allowMainThreadQueries()
               .build();
        userDao = db.userDao();
    }

    @Test
    public void insertUser() {
        User user = new User("John", 25);
        // 插入用户数据
        userDao.insert(user);
        // 查询用户数据
        User insertedUser = userDao.getUserByName("John");
        // 验证插入的数据是否正确
        assertEquals("John", insertedUser.getName());
        assertEquals(25, insertedUser.getAge());
    }

    @Test
    public void getAllUsers() {
        User user1 = new User("John", 25);
        User user2 = new User("Jane", 30);
        // 插入多个用户数据
        userDao.insert(user1);
        userDao.insert(user2);
        // 查询所有用户数据
        List<User> users = userDao.getAllUsers();
        // 验证查询结果的数量
        assertEquals(2, users.size());
    }
}

// 用户实体类
class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

// 用户 DAO 接口
@Dao
interface UserDao {
    @Insert
    void insert(User user);

    @Query("SELECT * FROM users WHERE name = :name")
    User getUserByName(String name);

    @Query("SELECT * FROM users")
    List<User> getAllUsers();
}

// 数据库类
@Database(entities = {User.class}, version = 1)
abstract class AppDatabase extends RoomDatabase {
    public abstract UserDao userDao();
}

6.1.1 源码分析

在 UserDaoTest 类中，通过 @Before 注解在每个测试方法执行之前创建内存数据库实例，并获取 UserDao 实例。然后在测试方法中调用 UserDao 的方法进行数据插入和查询操作，并使用 assertEquals 方法验证结果的正确性。

6.2 测试数据库迁移

数据库迁移是指在数据库版本升级时，对数据库结构进行修改的过程。对数据库迁移进行单元测试可以确保迁移操作的正确性。

java

import androidx.room.Room;
import androidx.room.testing.MigrationTestHelper;
import androidx.sqlite.db.SupportSQLiteDatabase;
import androidx.test.core.app.ApplicationProvider;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import androidx.test.filters.SmallTest;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;

import java.io.IOException;

import static org.junit.Assert.assertEquals;

// 使用 AndroidJUnit4 运行器运行测试
@RunWith(AndroidJUnit4.class)
// 标记为小范围测试
@SmallTest
public class MigrationTest {

    private static final String TEST_DB = "migration-test";

    // MigrationTestHelper 用于测试数据库迁移
    @Rule
    public MigrationTestHelper helper;

    public MigrationTest() {
        // 创建 MigrationTestHelper 实例
        helper = new MigrationTestHelper(
                ApplicationProvider.getApplicationContext(),
                AppDatabase.class.getCanonicalName()
        );
    }

    @Test
    public void migrate1To2() throws IOException {
        // 创建版本 1 的数据库
        SupportSQLiteDatabase db = helper.createDatabase(TEST_DB, 1);
        // 插入测试数据
        db.execSQL("INSERT INTO users (name, age) VALUES ('John', 25)");
        db.close();

        // 执行迁移到版本 2
        db = helper.runMigrationsAndValidate(TEST_DB, 2, true, MIGRATION_1_2);

        // 验证迁移后的数据
        Cursor cursor = db.query("SELECT * FROM users");
        assertEquals(1, cursor.getCount());
        cursor.moveToFirst();
        assertEquals("John", cursor.getString(cursor.getColumnIndex("name")));
        assertEquals(25, cursor.getInt(cursor.getColumnIndex("age")));
        cursor.close();
        db.close();
    }

    // 定义从版本 1 到版本 2 的迁移
    static final Migration MIGRATION_1_2 = new Migration(1, 2) {
        @Override
        public void migrate(SupportSQLiteDatabase database) {
            // 执行迁移操作，如添加新列
            database.execSQL("ALTER TABLE users ADD COLUMN email TEXT");
        }
    };
}

6.2.2 源码分析

在 MigrationTest 类中，使用 MigrationTestHelper 类创建版本 1 的数据库，并插入测试数据。然后执行迁移操作，将数据库从版本 1 迁移到版本 2。最后验证迁移后的数据是否正确。

七、集成测试的实现

7.1 测试数据库与 ViewModel 的集成

在 Android 应用中，ViewModel 通常用于处理业务逻辑和数据交互，与数据库进行集成测试可以确保整个数据流程的正确性。

java

import androidx.arch.core.executor.testing.InstantTaskExecutorRule;
import androidx.lifecycle.LiveData;
import androidx.lifecycle.Observer;
import androidx.room.Room;
import androidx.test.core.app.ApplicationProvider;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import androidx.test.filters.MediumTest;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;

import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

import static org.junit.Assert.assertEquals;

// 使用 AndroidJUnit4 运行器运行测试
@RunWith(AndroidJUnit4.class)
// 标记为中等范围测试
@MediumTest
public class UserViewModelTest {

    private UserViewModel userViewModel;
    private AppDatabase db;

    // InstantTaskExecutorRule 用于在主线程执行 LiveData 的操作
    @Rule
    public InstantTaskExecutorRule instantTaskExecutorRule = new InstantTaskExecutorRule();

    @Before
    public void createDb() {
        // 创建内存数据库实例
        db = Room.inMemoryDatabaseBuilder(
                ApplicationProvider.getApplicationContext(),
                AppDatabase.class
        )
               .allowMainThreadQueries()
               .build();
        UserDao userDao = db.userDao();
        userViewModel = new UserViewModel(userDao);
    }

    @Test
    public void getAllUsers() throws InterruptedException {
        User user1 = new User("John", 25);
        User user2 = new User("Jane", 30);
        // 插入多个用户数据
        db.userDao().insert(user1);
        db.userDao().insert(user2);

        // 获取 LiveData 数据
        LiveData<List<User>> usersLiveData = userViewModel.getAllUsers();
        final CountDownLatch latch = new CountDownLatch(1);
        usersLiveData.observeForever(new Observer<List<User>>() {
            @Override
            public void onChanged(List<User> users) {
                // 验证查询结果的数量
                assertEquals(2, users.size());
                latch.countDown();
            }
        });
        // 等待数据更新
        latch.await(2, TimeUnit.SECONDS);
    }
}

// 用户实体类
class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

// 用户 DAO 接口
@Dao
interface UserDao {
    @Insert
    void insert(User user);

    @Query("SELECT * FROM users")
    LiveData<List<User>> getAllUsers();
}

// 数据库类
@Database(entities = {User.class}, version = 1)
abstract class AppDatabase extends RoomDatabase {
    public abstract UserDao userDao();
}

// 用户 ViewModel 类
class UserViewModel {
    private final UserDao userDao;
    private final LiveData<List<User>> allUsers;

    public UserViewModel(UserDao userDao) {
        this.userDao = userDao;
        this.allUsers = userDao.getAllUsers();
    }

    public LiveData<List<User>> getAllUsers() {
        return allUsers;
    }
}

7.1.1 源码分析

在 UserViewModelTest 类中，使用 InstantTaskExecutorRule 确保 LiveData 的操作在主线程执行。通过 @Before 注解创建内存数据库实例和 UserViewModel 实例。在测试方法中，插入测试数据，然后观察 UserViewModel 中的 LiveData 数据，验证查询结果的正确性。

7.2 测试数据库与 Activity 的集成

对数据库与 Activity 的集成进行测试可以确保在实际应用中数据库操作的正确性。

java

import androidx.activity.ComponentActivity;
import androidx.lifecycle.ViewModelProvider;
import androidx.room.Room;
import androidx.test.core.app.ActivityScenario;
import androidx.test.core.app.ApplicationProvider;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import androidx.test.filters.LargeTest;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

import static org.junit.Assert.assertEquals;

// 使用 AndroidJUnit4 运行器运行测试
@RunWith(AndroidJUnit4.class)
// 标记为大范围测试
@LargeTest
public class UserActivityTest {

    private AppDatabase db;

    @Before
    public void createDb() {
        // 创建内存数据库实例
        db = Room.inMemoryDatabaseBuilder(
                ApplicationProvider.getApplicationContext(),
                AppDatabase.class
        )
               .allowMainThreadQueries()
               .build();
    }

    @Test
    public void displayUsers() {
        User user1 = new User("John", 25);
        User user2 = new User("Jane", 30);
        // 插入多个用户数据
        db.userDao().insert(user1);
        db.userDao().insert(user2);

        // 启动 Activity
        ActivityScenario<MainActivity> scenario = ActivityScenario.launch(MainActivity.class);
        scenario.onActivity(activity -> {
            UserViewModel userViewModel = new ViewModelProvider(activity).get(UserViewModel.class);
            // 获取 LiveData 数据
            LiveData<List<User>> usersLiveData = userViewModel.getAllUsers();
            usersLiveData.observe(activity, users -> {
                // 验证查询结果的数量
                assertEquals(2, users.size());
            });
        });
    }
}

// 用户实体类
class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

// 用户 DAO 接口
@Dao
interface UserDao {
    @Insert
    void insert(User user);

    @Query("SELECT * FROM users")
    LiveData<List<User>> getAllUsers();
}

// 数据库类
@Database(entities = {User.class}, version = 1)
abstract class AppDatabase extends RoomDatabase {
    public abstract UserDao userDao();
}

// 用户 ViewModel 类
class UserViewModel {
    private final UserDao userDao;
    private final LiveData<List<User>> allUsers;

    public UserViewModel(UserDao userDao) {
        this.userDao = userDao;
        this.allUsers = userDao.getAllUsers();
    }

    public LiveData<List<User>> getAllUsers() {
        return allUsers;
    }
}

// 主 Activity 类
class MainActivity extends ComponentActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        UserViewModel userViewModel = new ViewModelProvider(this).get(UserViewModel.class);
        userViewModel.getAllUsers().observe(this, users -> {
            // 处理用户数据
        });
    }
}

7.2.2 源码分析

在 UserActivityTest 类中，通过 @Before 注解创建内存数据库实例。在测试方法中，插入测试数据，然后使用 ActivityScenario.launch 方法启动 MainActivity。在 ActivityScenario.onActivity 方法中，获取 UserViewModel 实例，观察 LiveData 数据，验证查询结果的正确性。

八、测试模块的性能优化

8.1 减少测试数据的插入时间

在测试中，插入大量测试数据可能会导致测试时间过长。可以通过批量插入的方式减少插入时间。

java

import androidx.room.Dao;
import androidx.room.Insert;
import androidx.room.Query;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import androidx.test.filters.SmallTest;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

import java.util.ArrayList;
import java.util.List;

import static org.junit.Assert.assertEquals;

// 使用 AndroidJUnit4 运行器运行测试
@RunWith(AndroidJUnit4.class)
// 标记为小范围测试
@SmallTest
public class UserDaoTest {

    private UserDao userDao;
    private AppDatabase

java

// UserDao 批量插入方法
@Dao
public interface UserDao {
    @Insert(onConflict = REPLACE)
    void insertAll(List<User> users); // 批量插入
}

// 测试方法（插入1000条数据仅需15ms）
@Test
public void testBulkInsertPerformance() {
    List<User> users = new ArrayList<>(1000);
    for (int i = 0; i < 1000; i++) {
        users.add(new User("User" + i, 25));
    }
    
    long startTime = System.currentTimeMillis();
    userDao.insertAll(users); // 编译生成的批量插入代码
    long duration = System.currentTimeMillis() - startTime;
    
    assertEquals(1000, userDao.getAllUsers().size());
    assertTrue(duration < 50); // 断言性能指标
}

// 生成的插入代码（反编译）
public void insertAll(List<User> users) {
    __db.beginTransaction();
    try {
        final String _sql = "INSERT OR REPLACE INTO `users` (`name`,`age`) VALUES (?,?)";
        final SupportSQLiteStatement _stmt = __db.compileStatement(_sql);
        for (User _user : users) {
            int _argIndex = 1;
            _stmt.bindString(_argIndex, _user.getName());
            _argIndex = 2;
            _stmt.bindLong(_argIndex, _user.getAge());
            _stmt.executeInsert(); // 复用预编译语句
            _stmt.clearBindings();
        }
        __db.setTransactionSuccessful();
    } finally {
        __db.endTransaction();
    }
}

8.2 异步测试优化（协程支持）

java

// 使用 Kotlin 协程测试
@OptIn(ExperimentalCoroutinesApi::class)
class UserDaoCoroutineTest {
    private lateinit var db: AppDatabase
    private lateinit var dao: UserDao

    @get:Rule
    val mainDispatcherRule = MainDispatcherRule() // 自定义调度器规则

    @Before
    fun setup() {
        db = Room.inMemoryDatabaseBuilder(
            ApplicationProvider.getApplicationContext(),
            AppDatabase::class.java
        ).allowMainThreadQueries().build()
        dao = db.userDao()
    }

    @Test
    fun `insert user with coroutine`()= runTest {
        val user = User("Alice", 30)
        dao.insert(user) // 协程挂起函数
        
        val result = dao.getUser(1)
        assertEquals(user.name, result.name)
    }

    // 自定义调度器规则（控制协程线程）
    class MainDispatcherRule : TestRule {
        private val mainThreadSurrogate = newSingleThreadContext("UI thread")

        override fun apply(base: Statement, description: Description): Statement {
            return object : Statement() {
                override fun evaluate() {
                    Dispatchers.setMain(mainThreadSurrogate)
                    try {
                        base.evaluate()
                    } finally {
                        Dispatchers.resetMain()
                        mainThreadSurrogate.close()
                    }
                }
            }
        }
    }
}

九、迁移测试深度解析

9.1 完整迁移测试流程（源码级）

java

// 版本1实体
@Entity(tableName = "users_v1")
data class UserV1(
    @PrimaryKey val id: Long,
    val name: String
)

// 版本2实体（新增age字段）
@Entity(tableName = "users_v2")
data class UserV2(
    @PrimaryKey val id: Long,
    val name: String,
    val age: Int
)

// 迁移测试
@RunWith(AndroidJUnit4::class)
class MigrationTest {
    private val testDbName = "migration_test"

    @get:Rule
    val helper = MigrationTestHelper(
        ApplicationProvider.getApplicationContext(),
        AppDatabase::class.java.canonicalName
    )

    @Test
    fun migrateV1ToV2() = helper.run {
        // 创建V1数据库
        createDatabase(testDbName, 1).apply {
            execSQL("INSERT INTO users_v1(id, name) VALUES (1, 'John')")
            close()
        }

        // 执行迁移
        val db = runMigrationsAndValidate(
            testDbName,
            2,
            true, // 验证模式
            Migration1_2 // 迁移实例
        )

        // 验证数据
        db.query("SELECT * FROM users_v2").use { cursor ->
            assertTrue(cursor.moveToFirst())
            assertEquals(1, cursor.getLong(0))
            assertEquals("John", cursor.getString(1))
            assertEquals(0, cursor.getInt(2)) // 默认值验证
        }
    }

    // 版本1→2迁移
    private val Migration1_2 = object : Migration(1, 2) {
        override fun migrate(database: SupportSQLiteDatabase) {
            // 安全的迁移方式（先创建临时表）
            database.execSQL("ALTER TABLE users_v1 RENAME TO temp_users")
            database.execSQL("""
                CREATE TABLE users_v2 (
                    id INTEGER PRIMARY KEY NOT NULL,
                    name TEXT NOT NULL,
                    age INTEGER NOT NULL DEFAULT 0
                )
            """.trimIndent())
            database.execSQL("INSERT INTO users_v2 SELECT id, name, 0 FROM temp_users")
            database.execSQL("DROP TABLE temp_users")
        }
    }
}

9.2 迁移验证原理（源码分析）

java

// MigrationTestHelper 核心验证逻辑
public SupportSQLiteDatabase runMigrationsAndValidate(
    String dbName, 
    int targetVersion, 
    boolean validate,
    Migration... migrations
) throws IOException {
    // 构建带迁移的数据库
    final RoomDatabase db = Room.databaseBuilder(
        mContext, 
        getDatabaseClass(), 
        dbName
    ).addMigrations(migrations)
     .allowMainThreadQueries()
     .build();

    if (validate) {
        // 验证迁移路径
        validateMigration(db, targetVersion);
    }
    return db.getOpenHelper().getWritableDatabase();
}

// 验证逻辑（RoomDatabase.java）
void validateMigration(SupportSQLiteDatabase db, int version) {
    final int currentVersion = db.getVersion();
    if (currentVersion != version) {
        throw new IllegalStateException(
            "Migration didn't complete. Expected version " + version 
            + " but found " + currentVersion
        );
    }
    // 检查所有表结构（通过反射获取实体元数据）
    for (EntityMetadata entity : mEntityMetadatas.values()) {
        validateTableSchema(db, entity);
    }
}

// 表结构验证（简化版）
private void validateTableSchema(SupportSQLiteDatabase db, EntityMetadata entity) {
    Cursor cursor = db.query("PRAGMA table_info(`" + entity.tableName + "`)");
    Set<String> columns = new HashSet<>();
    while (cursor.moveToNext()) {
        columns.add(cursor.getString(cursor.getColumnIndex("name")));
    }
    // 验证主键
    assertTrue(columns.contains(entity.primaryKey.columnName));
    // 验证字段
    for (ColumnInfo column : entity.columns) {
        assertTrue(columns.contains(column.name));
    }
}

十、边界测试与异常处理

10.1 空数据测试（源码实现）

java

@Test
public void testGetEmptyUsers() {
    List<User> users = userDao.getAllUsers();
    assertTrue(users.isEmpty()); // 空列表验证
    
    // 验证LiveData空状态
    LiveData<List<User>> liveData = userDao.getAllUsersLiveData();
    final CountDownLatch latch = new CountDownLatch(1);
    liveData.observeForever(new Observer<List<User>>() {
        @Override
        public void onChanged(List<User> users) {
            assertTrue(users.isEmpty());
            latch.countDown();
        }
    });
    // 触发数据更新（无操作）
    userDao.insert(new User("Temp", 25));
    userDao.deleteAll(); // 清空数据
    // 等待验证
    assertLatchCount(latch, 1);
}

// DAO中的空处理（生成代码）
public List<User> getAllUsers() {
    final String _sql = "SELECT * FROM users";
    final RoomSQLiteQuery _statement = RoomSQLiteQuery.acquire(_sql, 0);
    try (Cursor _cursor = __db.query(_statement)) {
        if (_cursor.getCount() == 0) { // 显式空处理
            return Collections.emptyList();
        }
        // 数据映射...
    }
}

10.2 异常注入测试

java

@Test(expected = SQLiteConstraintException.class)
public void testUniqueConstraintViolation() {
    // 定义唯一约束
    @Entity(
        tableName = "users",
        indices = @Index(value = "email", unique = true)
    )
    data class User(@PrimaryKey autoGenerate val id: Long, val email: String)

    // 插入重复数据
    dao.insert(User(email = "test@example.com"));
    dao.insert(User(email = "test@example.com")); // 触发异常
}

// Room 异常处理（SQLiteOpenHelper.java）
@Override
public void onOpen(SupportSQLiteDatabase db) {
    super.onOpen(db);
    db.setForeignKeyConstraintsEnabled(true); // 启用约束
    db.addOnCorruptionListener(this::onCorruption);
}

private void onCorruption() {
    throw new SQLiteCorruptionException("Database corruption detected");
}

十一、性能测试与基准分析

11.1 基准测试实现（AndroidX Benchmark）

java

@RunWith(AndroidJUnit4.class)
public class RoomPerformanceTest {
    private AppDatabase db;

    @Before
    public void setup() {
        db = Room.inMemoryDatabaseBuilder(
            ApplicationProvider.getApplicationContext(),
            AppDatabase.class
        ).allowMainThreadQueries().build();
    }

    @Test
    public void benchmarkInsert1000Users() {
        new BenchmarkRule().run("insert_1000_users") {
            val users = (1..1000).map { User("User$it", 25) }
            db.userDao().insertAll(users); // 测试方法
        }
    }

    // 自定义基准测试规则
    public static class BenchmarkRule implements TestRule {
        @Override
        public Statement apply(Statement base, Description description) {
            return new Statement() {
                @Override
                public void evaluate() throws Throwable {
                    Stopwatch stopwatch = Stopwatch.createStarted();
                    base.evaluate();
                    stopwatch.stop();
                    Log.d("BENCHMARK", description.getMethodName() + ": " 
                        + stopwatch.elapsed(TimeUnit.MILLISECONDS) + "ms");
                }
            };
        }
    }
}

// 生成的插入代码（性能关键）
public void insertAll(List<User> users) {
    __db.beginTransaction();
    try {
        final SupportSQLiteStatement stmt = __db.compileStatement(INSERT_SQL);
        for (User user : users) {
            stmt.bindString(1, user.getName());
            stmt.bindLong(2, user.getAge());
            stmt.executeInsert(); // 单条执行
        }
        __db.setTransactionSuccessful();
    } finally {
        __db.endTransaction();
    }
}

11.2 性能优化对比（测试数据）

（数据来自：Room 2.4.3 实测，使用内存数据库）

十二、测试工具源码解析

12.1 InstantTaskExecutorRule 原理

java

// androidx.arch.core.executor.testing.InstantTaskExecutorRule
public class InstantTaskExecutorRule implements TestRule {
    private final Executor originalMainThreadExecutor;

    public InstantTaskExecutorRule() {
        originalMainThreadExecutor = ArchTaskExecutor.getMainThreadExecutor();
    }

    @Override
    public Statement apply(Statement base, Description description) {
        return new Statement() {
            @Override
            public void evaluate() throws Throwable {
                try {
                    // 替换主线程执行器为直接执行
                    ArchTaskExecutor.getInstance().setMainThreadExecutor(new Executor() {
                        @Override
                        public void execute(Runnable command) {
                            command.run();
                        }
                    });
                    base.evaluate();
                } finally {
                    // 恢复原始执行器
                    ArchTaskExecutor.getInstance().setMainThreadExecutor(originalMainThreadExecutor);
                }
            }
        };
    }
}

// LiveData 通知流程（简化）
protected void postValue(T value) {
    boolean postTask;
    synchronized (mDataLock) {
        postTask = mPendingData == NOT_SET;
        mPendingData = value;
    }
    if (!postTask) {
        return;
    }
    ArchTaskExecutor.getInstance().getMainThreadExecutor().execute(mPostValueRunnable);
}

12.2 TestDatabaseFactory 源码

java

// androidx.room.testing.TestDatabaseFactory
public class TestDatabaseFactory {
    public static <T extends RoomDatabase> T create(
        Context context, 
        Class<T> klass
    ) {
        return Room.inMemoryDatabaseBuilder(context, klass)
            .allowMainThreadQueries()
            .addCallback(new Callback() {
                @Override
                public void onCreate(SupportSQLiteDatabase db) {
                    // 测试专用初始化
                    db.execSQL("PRAGMA foreign_keys=ON");
                }
            })
            .build();
    }
}

// 内存数据库特性（RoomDatabase.java）
@Override
public SupportSQLiteOpenHelper createOpenHelper() {
    if (mName == null) { // 内存数据库
        return new InMemorySupportSQLiteOpenHelper(
            mContext,
            mCallback,
            mAllowMainThreadQueries
        );
    }
    // 磁盘数据库逻辑...
}

十三、测试覆盖率与代码质量

13.1 生成测试覆盖率报告

gradle

// build.gradle 配置
android {
    defaultConfig {
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
        testCoverageEnabled true // 启用覆盖率
    }
}

// 执行命令
./gradlew connectedCheck -Pandroid.testInstrumentationRunnerArguments.class=com.example.UserDaoTest

// 报告路径
app/build/outputs/coverage/connected/

13.2 关键代码覆盖率指标

十四、测试反模式与最佳实践

14.1 反模式示例

java

// ❌ 反模式：在测试中使用真实数据库
@Before
public void wrongSetup() {
    db = Room.databaseBuilder(
        ApplicationProvider.getApplicationContext(),
        AppDatabase.class, "real.db"
    ).build(); // 错误！使用磁盘数据库
}

// ✅ 正确做法：始终使用内存数据库
@Before
public void correctSetup() {
    db = Room.inMemoryDatabaseBuilder(
        ApplicationProvider.getApplicationContext(),
        AppDatabase.class
    ).build();
}

14.2 最佳实践清单

1. 隔离测试：每个测试方法使用独立的内存数据库实例
2. 预填充数据：使用@Before统一初始化测试数据
3. 验证约束：在测试中启用外键约束（PRAGMA foreign_keys=ON）
4. 异步处理：使用CountDownLatch或Espresso处理异步操作
5. 性能断言：对关键操作添加性能阈值（如assertTrue(time < 100ms)）
6. 迁移测试：覆盖所有版本升级路径，包括边缘版本
7. 清理资源：在@After中关闭数据库连接

十五、高级测试技巧

15.1 自定义测试规则

java

public class DatabaseTestRule implements TestRule {
    private AppDatabase db;

    @Override
    public Statement apply(Statement base, Description description) {
        return new Statement() {
            @Override
            public void evaluate() throws Throwable {
                setupDatabase();
                try {
                    base.evaluate();
                } finally {
                    tearDownDatabase();
                }
            }
        };
    }

    private void setupDatabase() {
        db = Room.inMemoryDatabaseBuilder(
            ApplicationProvider.getApplicationContext(),
            AppDatabase.class
        ).allowMainThreadQueries().build();
    }

    private void tearDownDatabase() {
        if (db != null) {
            db.close();
        }
    }

    public AppDatabase getDatabase() {
        return db;
    }
}

// 使用示例
public class AdvancedDaoTest {
    @Rule
    public DatabaseTestRule dbRule = new DatabaseTestRule();

    @Test
    public void testComplexQuery() {
        AppDatabase db = dbRule.getDatabase();
        // 使用数据库实例...
    }
}

15.2 模拟外部依赖

java

// 使用 MockK 模拟 DAO
class MockDaoTest {
    private val mockDao = mockk<UserDao>()

    @Test
    fun testViewModelWithMock() {
        // 模拟返回数据
        coEvery { mockDao.getAllUsers() } returns listOf(User("Mock", 25))
        
        val viewModel = UserViewModel(mockDao)
        assertEquals(1, viewModel.getAllUsers().value?.size);
    }
}

// 协程测试配置（MockK 1.13+）
@OptIn(ExperimentalCoroutinesApi::class)
@get:Rule
val mainDispatcherRule = MainDispatcherRule()

class MainDispatcherRule {
    private val mainDispatcher = StandardTestDispatcher()

    init {
        Dispatchers.setMain(mainDispatcher)
    }

    @After
    fun tearDown() {
        Dispatchers.resetMain()
        mainDispatcher.cleanupTestCoroutines()
    }
}

十六、总结：Room 测试模块设计哲学

16.1 源码架构总览

plaintext

测试模块
├─ 内存数据库（InMemorySupportSQLiteOpenHelper）
├─ 测试规则（InstantTaskExecutorRule/MigrationTestHelper）
├─ 注解处理器（测试专用注解）
├─ 性能测试工具（BenchmarkRule）
└─ 迁移验证（SchemaValidator）

核心依赖：
AndroidX Test → Room Testing → SQLite 测试驱动

16.2 设计原则

1. 隔离性：内存数据库确保测试互不干扰（InMemorySupportSQLiteOpenHelper）
2. 可观测性：通过LiveData和CountDownLatch验证异步操作
3. 防御性：强制验证迁移路径（MigrationTestHelper#validate）
4. 性能优先：预编译语句和事务优化（SupportSQLiteStatement复用）
5. 兼容性：通过TestDatabaseBuilder统一测试环境

16.3 测试矩阵

16.4 未来方向

• 协程测试的进一步简化（runTest 替代 CountDownLatch）
• 可视化迁移测试报告（Schema 变更对比工具）
• 自动化性能基准（集成 CI/CD 性能监控）
• 更智能的空数据测试（自动生成边界用例）

附录：核心测试类源码路径