67

我目前正在使用新的Android Architecture Components开发应用程序。具体来说，我正在实现一个房间数据库，LiveData它在其中一个查询中返回一个对象。插入和查询按预期工作，但是我在使用单元测试测试查询方法时遇到问题。

这是我要测试的 DAO：

NotificationDao.kt

@Dao
interface NotificationDao {

    @Insert
    fun insertNotifications(vararg notifications: Notification): List<Long>

    @Query("SELECT * FROM notifications")
    fun getNotifications(): LiveData<List<Notification>>
}

如您所知，查询函数返回一个LiveData对象，如果我将其更改为List,Cursor或基本上任何内容，那么我会得到预期的结果，即插入数据库中的数据。

问题是以下测试总是会失败，因为对象value的LiveData总是null：

NotificationDaoTest.kt

lateinit var db: SosafeDatabase
lateinit var notificationDao: NotificationDao

@Before
fun setUp() {
    val context = InstrumentationRegistry.getTargetContext()
    db = Room.inMemoryDatabaseBuilder(context, SosafeDatabase::class.java).build()
    notificationDao = db.notificationDao()
}

@After
@Throws(IOException::class)
fun tearDown() {
    db.close()
}

@Test
fun getNotifications_IfNotificationsInserted_ReturnsAListOfNotifications() {
    val NUMBER_OF_NOTIFICATIONS = 5
    val notifications = Array(NUMBER_OF_NOTIFICATIONS, { i -> createTestNotification(i) })
    notificationDao.insertNotifications(*notifications)

    val liveData = notificationDao.getNotifications()
    val queriedNotifications = liveData.value
    if (queriedNotifications != null) {
        assertEquals(queriedNotifications.size, NUMBER_OF_NOTIFICATIONS)
    } else {
        fail()
    }
}

private fun createTestNotification(id: Int): Notification {
    //method omitted for brevity 
}

所以问题是：有谁知道执行涉及 LiveData 对象的单元测试的更好方法？

4

6 回答 6

61

LiveData当有观察者时，Room 会懒惰地计算' 值。

您可以查看示例应用程序。

它使用getValue实用方法添加观察者来获取值：

public static <T> T getOrAwaitValue(final LiveData<T> liveData) throws InterruptedException {
    final Object[] data = new Object[1];
    final CountDownLatch latch = new CountDownLatch(1);
    Observer<T> observer = new Observer<T>() {
        @Override
        public void onChanged(@Nullable T o) {
            data[0] = o;
            latch.countDown();
            liveData.removeObserver(this);
        }
    };
    liveData.observeForever(observer);
    latch.await(2, TimeUnit.SECONDS);
    //noinspection unchecked
    return (T) data[0];
}

使用 kotlin 更好，您可以将其设为扩展功能:)。

于 2017-05-30T20:20:52.597 回答
37

当您LiveData从 Room 中的 a返回时，它会异步Dao进行查询，并且正如@yigit 所说，Room在您通过观察启动查询后会延迟设置. 这种模式是反应式的。LiveData#valueLiveData

对于单元测试，您希望行为是同步的，因此您必须阻塞测试线程并等待将值传递给观察者，然后从那里获取它，然后您可以对其进行断言。

这是一个用于执行此操作的 Kotlin 扩展函数：

private fun <T> LiveData<T>.blockingObserve(): T? {
    var value: T? = null
    val latch = CountDownLatch(1)

    val observer = Observer<T> { t ->
        value = t
        latch.countDown()
    }

    observeForever(observer)

    latch.await(2, TimeUnit.SECONDS)
    return value
}

你可以像这样使用它：

val someValue = someDao.getSomeLiveData().blockingObserve()
于 2017-07-08T23:53:06.240 回答
20

我发现 Mockito 在这种情况下非常有帮助。这是一个例子：

1.依赖关系

testImplementation "org.mockito:mockito-core:2.11.0"
androidTestImplementation "org.mockito:mockito-android:2.11.0"

2.数据库

@Database(
        version = 1,
        exportSchema = false,
        entities = {Todo.class}
)
public abstract class AppDatabase extends RoomDatabase {
    public abstract TodoDao todoDao();
}

3.道

@Dao
public interface TodoDao {
    @Insert(onConflict = REPLACE)
    void insert(Todo todo);

    @Query("SELECT * FROM todo")
    LiveData<List<Todo>> selectAll();
}

4.测试 

@RunWith(AndroidJUnit4.class)
public class TodoDaoTest {
    @Rule
    public TestRule rule = new InstantTaskExecutorRule();

    private AppDatabase database;
    private TodoDao dao;

    @Mock
    private Observer<List<Todo>> observer;

    @Before
    public void setUp() throws Exception {
        MockitoAnnotations.initMocks(this);

        Context context = InstrumentationRegistry.getTargetContext();
        database = Room.inMemoryDatabaseBuilder(context, AppDatabase.class)
                       .allowMainThreadQueries().build();
        dao = database.todoDao();
    }

    @After
    public void tearDown() throws Exception {
        database.close();
    }

    @Test
    public void insert() throws Exception {
        // given
        Todo todo = new Todo("12345", "Mockito", "Time to learn something new");
        dao.selectAll().observeForever(observer);
        // when
        dao.insert(todo);
        // then
        verify(observer).onChanged(Collections.singletonList(todo));
    }
}

希望这有帮助！

于 2017-11-10T18:30:05.960 回答
15

正如@Hemant Kaushik 所说，在这种情况下，您应该使用InstantTaskExecutorRule.

来自 developer.android.com：

一个 JUnit 测试规则，它将架构组件使用的后台执行程序与同步执行每个任务的不同执行程序交换。

真的行！

于 2018-05-02T14:35:13.170 回答
6

与其他答案略有不同的方法可能是使用https://github.com/jraska/livedata-testing。

您避免了模拟，测试可以使用类似于 RxJava 测试的 API，您还可以从 Kotlin 扩展函数中获得优势。

NotificationDaoTest.kt

val liveData = notificationDao.getNotifications()

liveData.test()
    .awaitValue() // for the case where we need to wait for async data
    .assertValue { it.size == NUMBER_OF_NOTIFICATIONS }
于 2019-01-08T19:37:48.113 回答
2

如果您使用的是 JUnit 5，由于规则不适用于它，感谢这篇文章，您可以手动创建扩展：

class InstantExecutorExtension : BeforeEachCallback, AfterEachCallback {

    override fun beforeEach(context: ExtensionContext?) {
        ArchTaskExecutor.getInstance().setDelegate(object : TaskExecutor() {
            override fun executeOnDiskIO(runnable: Runnable) = runnable.run()

            override fun postToMainThread(runnable: Runnable) = runnable.run()

            override fun isMainThread(): Boolean = true
        })
    }

    override fun afterEach(context: ExtensionContext?) {
        ArchTaskExecutor.getInstance().setDelegate(null)
    }
}

然后在你的测试类中像这样使用它：

@ExtendWith(InstantExecutorExtension::class /* , Other extensions */)
class ItemDaoTests {
    ...
}
于 2019-04-30T22:19:57.553 回答