0

设置：

在我们的项目中（在工作中 - 我无法发布真实代码），我们已经实现了干净的 MVVM。视图通过 LiveData 与 ViewModel 通信。ViewModel 承载两种用例：做某事的“动作用例”和“状态更新用例”。反向通信是异步的（就动作反应而言）。它不像 API 调用，您可以从调用中获取结果。是BLE，所以写完特性后会有一个我们监听的通知特性。所以我们使用了大量的 Rx 来更新状态。它在科特林。

视图模型：

@PerFragment
class SomeViewModel @Inject constructor(private val someActionUseCase: SomeActionUseCase,
                                        someUpdateStateUseCase: SomeUpdateStateUseCase) : ViewModel() {

    private val someState = MutableLiveData<SomeState>()

    private val stateSubscription: Disposable

    // region Lifecycle
    init {
        stateSubscription = someUpdateStateUseCase.state()
                .subscribeIoObserveMain() // extension function
                .subscribe { newState ->
                    someState.value = newState
                })
    }

    override fun onCleared() {
        stateSubscription.dispose()

        super.onCleared()
    }
    // endregion

    // region Public Functions
    fun someState() = someState

    fun someAction(someValue: Boolean) {
        val someNewValue = if (someValue) "This" else "That"

        someActionUseCase.someAction(someNewValue)
    }
    // endregion
}

更新状态用例：

@Singleton
class UpdateSomeStateUseCase @Inject constructor(
            private var state: SomeState = initialState) {

    private val statePublisher: PublishProcessor<SomeState> = 
            PublishProcessor.create()

    fun update(state: SomeState) {
        this.state = state

        statePublisher.onNext(state)
    }

    fun state(): Observable<SomeState> = statePublisher.toObservable()
                                                       .startWith(state)
}

我们使用 Spek 进行单元测试。

@RunWith(JUnitPlatform::class)
class SomeViewModelTest : SubjectSpek<SomeViewModel>({

    setRxSchedulersTrampolineOnMain()

    var mockSomeActionUseCase = mock<SomeActionUseCase>()
    var mockSomeUpdateStateUseCase = mock<SomeUpdateStateUseCase>()

    var liveState = MutableLiveData<SomeState>()

    val initialState = SomeState(initialValue)
    val newState = SomeState(newValue)

    val behaviorSubject = BehaviorSubject.createDefault(initialState)

    subject {
        mockSomeActionUseCase = mock()
        mockSomeUpdateStateUseCase = mock()

        whenever(mockSomeUpdateStateUseCase.state()).thenReturn(behaviorSubject)

        SomeViewModel(mockSomeActionUseCase, mockSomeUpdateStateUseCase).apply {
            liveState = state() as MutableLiveData<SomeState>
        }
    }

    beforeGroup { setTestRxAndLiveData() }
    afterGroup { resetTestRxAndLiveData() }

    context("some screen") {
        given("the action to open the screen") {
            on("screen opened") {
                subject
                behaviorSubject.startWith(initialState)

                it("displays the initial state") {
                    assertEquals(liveState.value, initialState)
                }
            }
        }

        given("some setup") {
            on("some action") {
                it("does something") {
                    subject.doSomething(someValue)

                    verify(mockSomeUpdateStateUseCase).someAction(someOtherValue)
                }
            }

            on("action updating the state") {
                it("displays new state") {
                    behaviorSubject.onNext(newState)

                    assertEquals(liveState.value, newState)
                }
            }
        }
    }
}

起初我们使用的是 Observable 而不是 BehaviorSubject：

var observable = Observable.just(initialState)
...
whenever(mockSomeUpdateStateUseCase.state()).thenReturn(observable)
...
observable = Observable.just(newState)
assertEquals(liveState.value, newState)

而不是：

val behaviorSubject = BehaviorSubject.createDefault(initialState)
...
whenever(mockSomeUpdateStateUseCase.state()).thenReturn(behaviorSubject)
...
behaviorSubject.onNext(newState)
assertEquals(liveState.value, newState)

但是单元测试很不稳定。大多数情况下它们会通过（总是在孤立运行时），但有时它们会在运行整个套装时失败。考虑到它与 Rx 的异步特性有关，我们移至 BehaviourSubject 以便能够控制 onNext() 何时发生。当我们在本地机器上从 AndroidStudio 运行它们时，测试现在通过了，但它们在构建机器上仍然不稳定。重新启动构建通常会使它们通过。

失败的测试总是我们断言 LiveData 值的测试。所以嫌疑人是 LiveData、Rx、Spek 或它们的组合。

问题：有没有人有过使用 LiveData、Spek 或 Rx 编写单元测试的类似经历，你是否找到了解决这些脆弱问题的编写方法？

.....................

使用的辅助函数和扩展函数：

fun instantTaskExecutorRuleStart() =
        ArchTaskExecutor.getInstance().setDelegate(object : TaskExecutor() {
            override fun executeOnDiskIO(runnable: Runnable) {
                runnable.run()
            }

            override fun isMainThread(): Boolean {
                return true
            }

            override fun postToMainThread(runnable: Runnable) {
                runnable.run()
            }
        })

fun instantTaskExecutorRuleFinish() = ArchTaskExecutor.getInstance().setDelegate(null)

fun setRxSchedulersTrampolineOnMain() = RxAndroidPlugins.setInitMainThreadSchedulerHandler { Schedulers.trampoline() }

fun setTestRxAndLiveData() {
    setRxSchedulersTrampolineOnMain()
    instantTaskExecutorRuleStart()
}

fun resetTestRxAndLiveData() {
    RxAndroidPlugins.reset()
    instantTaskExecutorRuleFinish()
}

fun <T> Observable<T>.subscribeIoObserveMain(): Observable<T> =
        subscribeOnIoThread().observeOnMainThread()

fun <T> Observable<T>.subscribeOnIoThread(): Observable<T> = subscribeOn(Schedulers.io())

fun <T> Observable<T>.observeOnMainThread(): Observable<T> =
        observeOn(AndroidSchedulers.mainThread())
4

2 回答 2

0

我没有使用 Speck 进行单元测试。我使用了 java 单元测试平台，它与 Rx 和 LiveData 完美配合，但你必须记住一件事。Rx 和 LiveData 是异步的，你不能做这样的事情someObserver.subscribe{}, someObserver.doSmth{}, assert{}有时会起作用，但这不是正确的方法。

对于 Rx，TestObservers用于观察 Rx 事件。就像是：

@Test
public void testMethod() {
   TestObserver<SomeObject> observer = new TestObserver()
   someClass.doSomethingThatReturnsObserver().subscribe(observer)
   observer.assertError(...)
   // or
   observer.awaitTerminalEvent(1, TimeUnit.SECONDS)
   observer.assertValue(somethingReturnedForOnNext)
}

对于 LiveData，您也必须使用 CountDownLatch 来等待 LiveData 执行。像这样的东西：

@Test
public void someLiveDataTest() {
   CountDownLatch latch = new CountDownLatch(1); // if you want to check one time exec
   somethingTahtReturnsLiveData.observeForever(params -> {
      /// you can take the params value here
      latch.countDown();
   }
   //trigger live data here
   ....
   latch.await(1, TimeUnit.SECONDS)
   assert(...)
}

使用这种方法，您的测试应该可以在任何机器上以任何顺序运行。此外，闩锁和终端事件的等待时间应尽可能短，测试应快速运行。

注意 1：代码是 JAVA，但您可以在 kotlin 中轻松更改它。

注2：单例是单元测试的最大敌人；）。（在他们身边有静态方法）。

于 2018-10-12T10:05:51.163 回答
0

问题不在于LiveData; 这是更常见的问题 - 单身人士。这里Update...StateUseCases必须是单身人士；否则，如果观察者获得不同的实例，他们将拥有不同的 PublishProcessor 并且不会获得已发布的内容。

每个Update...StateUseCases都有一个测试，每个注入的 ViewModel 都有一个测试Update...StateUseCases（间接通过...StateObserver）。

状态存在于 中Update...StateUseCases，因为它是一个单例，所以它在两个测试中都会发生变化，并且它们使用相同的实例变得相互依赖。

首先尽可能避免使用单例。

如果不是，则在每个测试组之后重置状态。

于 2018-11-19T09:14:14.570 回答