Android 在单元测试中，如何在断言结果之前等待RxJava2可观察对象完成

我正在尝试测试我的代码中订阅冷可观测的部分。我的问题是，单元测试没有在断言结果之前等待内部可观察调用结束，因此我的测试失败

下面是我要测试的代码：

public class UserManager {

    private UserRepository userRepository;
    private PublishSubject<List<User>> usersSubject = PublishSubject.create();

    public UserManager(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public Observable<List<User>> users() {
        return usersSubject;
    }

    public void onUserIdsReceived(List<String> userIds) {
        userRepository.getUsersInfo(userIds)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new SingleObserver<List<User>>() {
                @Override
                    public void onSubscribe(@NonNull Disposable d) {}

                    @Override
                    public void onSuccess(@NonNull List<User> users) {
                        usersSubject.onNext(users);
                    }

                    @Override
                    public void onError(Throwable e) {}
                }
    }
}

公共类用户管理器{
私有用户存储库用户存储库；
private PublishSubject UsersObject=PublishSubject.create（）；
公共用户管理器（用户存储库用户存储库）{
this.userRepository=userRepository；
}
公共可观察用户（）{
返回usersObject；
}
已接收公共无效OnUserId（列出用户ID）{
userRepository.getUsersInfo（userid）
.observeOn（AndroidSchedulers.mainThread（））
.subscribe（新的SingleObserver（）{
@凌驾
订阅上的公共无效（@NonNull Disposable d）{}
@凌驾
成功时公共无效（@NonNull列表用户）{
UsersObject.onNext（用户）；
}
@凌驾
公共无效者（可抛弃者）{}
}
}
}

这是我的测试：

@RunWith(MockitoJUnitRunner::class)
class UserManagerTest {

private val userRepository = mock(UserRepository::class.java)

companion object {
    @BeforeClass
    @JvmStatic
    fun setup() {
        RxJavaPlugins.setIoSchedulerHandler({ _ -> TestScheduler() })
        RxJavaPlugins.setSingleSchedulerHandler({ _ -> TestScheduler() })
        RxJavaPlugins.setNewThreadSchedulerHandler({ _ -> TestScheduler() })
        RxJavaPlugins.setComputationSchedulerHandler({ _ -> TestScheduler() })
        RxAndroidPlugins.setInitMainThreadSchedulerHandler({ _ -> TestScheduler() })
        RxAndroidPlugins.setMainThreadSchedulerHandler({ _ -> TestScheduler() })
    }
}

@Test
fun testReceivedUserIdResultsInPushedUser() {
    // Given
    val usersIds = mutableListOf<String>()
    usersIds.add("id1")
    val usersDetails = mutableListOf<User>()
    usersDetails.add(User.testUser())
    given(userRepository.getUsersInfo(usersIds)).willReturn(Single.just(usersDetails))

    val userManager = UserManager(userRepository)
    val testObserver = TestObserver<List<User>>()
    userManager.users().subscribeWith(testObserver)

    // When
    userManager.onUsersIdsReceived(usersIds)

    // Then
    testObserver.assertNoErrors()
    testObserver.assertNotComplete()
    testObserver.assertValueCount(1)
    testObserver.assertValue( { detectedUsers: List<DetectedUser> ->
        // My test
    })
}

@RunWith（MockitoJUnitRunner:：class）
类UserManagerTest{
private val userRepository=mock（userRepository:：class.java）
伴星{
@课前
@JvmStatic
趣味设置（）{
RxJavaPlugins.setIoSchedulerHandler（{->TestScheduler（）}）
RxJavaPlugins.setSingleSchedulerHandler（{->TestScheduler（）}）
RxJavaPlugins.setNewThreadSchedulerHandler（{->TestScheduler（）}）
RxJavaPlugins.setComputationSchedulerHandler（{->TestScheduler（）}）
RxAndroidPlugins.setInitMainThreadSchedulerHandler（{->TestScheduler（）}）
RxAndroidPlugins.setMainThreadSchedulerHandler（{->TestScheduler（）}）
}
}
@试验
趣味测试ReceivedUserResultsInPushedUser（）{
//给定
val usersIds=mutableListOf（）
usersIds.add（“id1”）
val usersDetails=mutableListOf（）
usersDetails.add（User.testUser（））
给定（userRepository.getUsersInfo（usersIds））.willReturn（Single.just（usersDetails））
val userManager=userManager（userRepository）
val testObserver=testObserver（）
userManager.users（）.subscribowith（testObserver）
//什么时候
userManager.onUsersIdsReceived（usersIds）
//然后
testObserver.assertNoErrors（）
testObserver.assertNotComplete（）
testObserver.assertValueCount（1）
assertValue（{detectedUsers:List->
//我的测试
})
}

我的测试失败是因为我的testObserver没有收到任何事件，最合乎逻辑的原因是测试没有等待userRepository.getUsersInfo（UserId）调用结束，即使我模拟了userRepository并使用了TestScheduler。

---

有没有一种方法可以等待内部可观察调用结束，从而使我的代码可测试？

我使用

trampoline

而不是像这样的TestScheduler，它会同步执行

// override Schedulers.io()
RxJavaPlugins.setIoSchedulerHandler(schedulerCallable -> Schedulers.trampoline());
// override AndroidSchedulers.mainThread()
RxAndroidPlugins.setInitMainThreadSchedulerHandler(schedulerCallable -> Schedulers.trampoline());

也考虑去除

RxAndroidPlugins.setMainThreadSchedulerHandler（{->TestScheduler（）}）

---

我想我遇到了一些问题。

你可以考虑使用<代码> TestObjistServayAuthIt（）/<代码>