Android RxJava 2 JUnit test - getMainLooper in android.os.Lo - Android RxJava 2 JUnit test - getMainLooper in android.os.Looper not mocked RuntimeException 小贝子编程网

我在尝试为使用observeOn(AndroidSchedulers.mainThread())的演示者运行 JUnit 测试时遇到运行时异常。

由于它们是纯 JUnit 测试而不是 Android 仪器测试，因此它们无法访问 Android 依赖项，导致我在执行测试时遇到以下错误：

java.lang.ExceptionInInitializerError
at io.reactivex.android.schedulers.AndroidSchedulers$1.call(AndroidSchedulers.java:35)
at io.reactivex.android.schedulers.AndroidSchedulers$1.call(AndroidSchedulers.java:33)
at io.reactivex.android.plugins.RxAndroidPlugins.callRequireNonNull(RxAndroidPlugins.java:70)
at io.reactivex.android.plugins.RxAndroidPlugins.initMainThreadScheduler(RxAndroidPlugins.java:40)
at io.reactivex.android.schedulers.AndroidSchedulers.<clinit>(AndroidSchedulers.java:32)
…
Caused by: java.lang.RuntimeException: Method getMainLooper in android.os.Looper not mocked. See http://g.co/androidstudio/not-mocked for details.
at android.os.Looper.getMainLooper(Looper.java)
at io.reactivex.android.schedulers.AndroidSchedulers$MainHolder.<clinit>(AndroidSchedulers.java:29)
...

java.lang.NoClassDefFoundError: Could not initialize class io.reactivex.android.schedulers.AndroidSchedulers
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
…

发生此错误是因为AndroidSchedulers.mainThread()返回的默认调度程序是LooperScheduler的实例，并且依赖于 JUnit 测试中不可用的 Android 依赖项。

我们可以通过在运行测试之前使用不同的调度程序初始化RxAndroidPlugins来避免此问题。您可以在@BeforeClass方法中执行此操作，如下所示：

@BeforeClass
public static void setUpRxSchedulers() {
Scheduler immediate = new Scheduler() {
@Override
public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
// this prevents StackOverflowErrors when scheduling with a delay
return super.scheduleDirect(run, 0, unit);
}
@Override
public Worker createWorker() {
return new ExecutorScheduler.ExecutorWorker(Runnable::run);
}
};
RxJavaPlugins.setInitIoSchedulerHandler(scheduler -> immediate);
RxJavaPlugins.setInitComputationSchedulerHandler(scheduler -> immediate);
RxJavaPlugins.setInitNewThreadSchedulerHandler(scheduler -> immediate);
RxJavaPlugins.setInitSingleSchedulerHandler(scheduler -> immediate);
RxAndroidPlugins.setInitMainThreadSchedulerHandler(scheduler -> immediate);
}

或者，您可以创建自定义TestRule，以便跨多个测试类重用初始化逻辑。

public class RxImmediateSchedulerRule implements TestRule {
private Scheduler immediate = new Scheduler() {
@Override
public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
// this prevents StackOverflowErrors when scheduling with a delay
return super.scheduleDirect(run, 0, unit);
}
@Override
public Worker createWorker() {
return new ExecutorScheduler.ExecutorWorker(Runnable::run);
}
};
@Override
public Statement apply(final Statement base, Description description) {
return new Statement() {
@Override
public void evaluate() throws Throwable {
RxJavaPlugins.setInitIoSchedulerHandler(scheduler -> immediate);
RxJavaPlugins.setInitComputationSchedulerHandler(scheduler -> immediate);
RxJavaPlugins.setInitNewThreadSchedulerHandler(scheduler -> immediate);
RxJavaPlugins.setInitSingleSchedulerHandler(scheduler -> immediate);
RxAndroidPlugins.setInitMainThreadSchedulerHandler(scheduler -> immediate);
try {
base.evaluate();
} finally {
RxJavaPlugins.reset();
RxAndroidPlugins.reset();
}
}
};
}
}

然后，您可以将其应用于您的测试类

public class TestClass {
@ClassRule public static final RxImmediateSchedulerRule schedulers = new RxImmediateSchedulerRule();
@Test
public void testStuff_stuffHappens() {
...
}
}

这两种方法都将确保在任何测试执行之前和访问AndroidSchedulers之前覆盖默认调度程序。

使用用于单元测试的即时调度程序覆盖 RxJava 调度程序还将确保正在测试的代码中的 RxJava 用法同步运行，这将使编写单元测试变得更加容易。

来源：
https://www.infoq.com/articles/Testing-RxJava2 https://medium.com/@peter.tackage/overriding-rxandroid-schedulers-in-rxjava-2-5561b3d14212

我刚刚添加了

RxAndroidPlugins.setInitMainThreadSchedulerHandler(scheduler -> Schedulers.trampoline());

在@Before注释的方法中。

我在测试LiveData时遇到了同样的错误。在测试 LiveData 时，如果被测试的类同时具有后台线程和 LiveData，则除了 RxImmediateSchedulerRule 之外，还需要此 InstantTaskExecutorRule。

@RunWith(MockitoJUnitRunner::class)
class MainViewModelTest {
companion object {
@ClassRule @JvmField
val schedulers = RxImmediateSchedulerRule()
}
@Rule
@JvmField
val rule = InstantTaskExecutorRule()
@Mock
lateinit var dataRepository: DataRepository
lateinit var model: MainViewModel
@Before
fun setUp() {
model = MainViewModel(dataRepository)
}
@Test
fun fetchData() {
//given    
val returnedItem = createDummyItem()    
val observer = mock<Observer<List<Post>>>()    
model.getPosts().observeForever(observer)    
//when    
liveData.value = listOf(returnedItem)    
//than    
verify(observer).onChanged(listOf(Post(returnedItem.id, returnedItem.title, returnedItem.url)))
}
}

参考： https://pbochenski.pl/blog/07-12-2017-testing_livedata.html

根据@starkej2答案，经过一些更改，Kotlin开发人员的正确答案是：

创建RxImmediateSchedulerRule.kt类：

，

import io.reactivex.Scheduler
import io.reactivex.android.plugins.RxAndroidPlugins
import io.reactivex.internal.schedulers.ExecutorScheduler
import io.reactivex.plugins.RxJavaPlugins
import org.junit.rules.TestRule
import org.junit.runner.Description
import org.junit.runners.model.Statement
import java.util.concurrent.Executor
class RxImmediateSchedulerRule : TestRule {
private val immediate = object : Scheduler() {
override fun createWorker(): Worker {
return ExecutorScheduler.ExecutorWorker(Executor { it.run() })
}
}
override fun apply(base: Statement, description: Description): Statement {
return object : Statement() {
@Throws(Throwable::class)
override fun evaluate() {
RxJavaPlugins.setInitIoSchedulerHandler { immediate }
RxJavaPlugins.setInitComputationSchedulerHandler { immediate }
RxJavaPlugins.setInitNewThreadSchedulerHandler { immediate }
RxJavaPlugins.setInitSingleSchedulerHandler { immediate }
RxAndroidPlugins.setInitMainThreadSchedulerHandler { immediate }
try {
base.evaluate()
} finally {
RxJavaPlugins.reset()
RxAndroidPlugins.reset()
}
}
}
}
}

在您的测试类上，创建调度程序类规则：

class TestViewModelTest {
companion object {
@ClassRule
@JvmField
val schedulers = RxImmediateSchedulerRule()
}
@Before
fun setUp() {
//your setup code here
}
@Test
fun yourTestMethodHere{}
}

正如Peter Tackage在这篇Medium文章中的建议一样，您可以自己注入调度程序。

我们都知道，直接调用静态方法可以使类难以测试，如果您使用像 Dagger 2 这样的依赖注入框架，注入调度程序会特别容易。示例如下：

在项目中定义接口：

public interface SchedulerProvider {
Scheduler ui();
Scheduler computation();
Scheduler io();
Scheduler special();
// Other schedulers as required…
}

定义实现：

final class AppSchedulerProvider implements SchedulerProvider {
@Override 
public Scheduler ui() {
return AndroidSchedulers.mainThread();
}
@Override 
public Scheduler computation() {
return Schedulers.computation();
}
@Override 
public Scheduler io() {
return Schedulers.io();
}
@Override 
public Scheduler special() {
return MyOwnSchedulers.special();
}
}

现在，不要像这样使用对调度程序的直接引用：

bookstoreModel.getFavoriteBook()
.map(Book::getTitle)
.delay(5, TimeUnit.SECONDS)
.observeOn(AndroidSchedulers.mainThread())
.subscribe(view::setBookTitle));

您可以使用对接口的引用：

bookstoreModel.getFavoriteBook()
.map(Book::getTitle)
.delay(5, TimeUnit.SECONDS, 
this.schedulerProvider.computation())
.observeOn(this.schedulerProvider.ui())
.subscribe(view::setBookTitle));

现在对于您的测试，您可以像这样定义一个 TestSchedulersProvider：

public final class TestSchedulersProvider implements SchedulerProvider {
@Override
public Scheduler ui() {
return new TestScheduler();
}
@Override
public Scheduler io() {
return Schedulers.trampoline(); //or test scheduler if you want
}
//etc
}

现在，当您需要在单元测试中使用TestScheduler时，您拥有了使用的所有优势。这在您可能想要测试延迟的情况下会派上用场：

@Test
public void testIntegerOneIsEmittedAt20Seconds() {
//arrange
TestObserver<Integer> o = delayedRepository.delayedInt()
.test();
//act
testScheduler.advanceTimeTo(20, TimeUnit.SECONDS);
//assert
o.assertValue(1);
}

否则，如果您不想使用注入的调度程序，可以使用 lambda 完成其他方法中提到的静态钩子：

@Before
public void setUp() {
RxAndroidPlugins.setInitMainThreadSchedulerHandler(h -> Schedulers.trampoline());
RxJavaPlugins.setIoSchedulerHandler(h -> Schedulers.trampoline());
//etc
}

对于那些使用Kotlin并使用Rule而不是创建companion object的人，您可以使用@get:Rule。

因此，而不是使用：

companion object {
@ClassRule
@JvmField
val schedulers = RxImmediateSchedulerRule()
}

您可以简单地使用：

@get:Rule
val schedulers = RxImmediateSchedulerRule()

如果您仍然遇到问题并且上述代码都无法帮助您，除此之外，将这一行添加到您的 app.gradle 文件中并不是一个坏主意：

testOptions {
animationsDisabled = true
unitTests {
includeAndroidResources = true
returnDefaultValues = true
}
}

只是为了补充starkej2的答案，它对我来说效果很好，直到我在测试Observable.timer()时遇到stackoverflowerror。对此没有任何帮助，但幸运的是，我让它与下面的调度程序定义一起工作，所有其他测试也都通过了。

new Scheduler() {
@Override
public Worker createWorker() {
return new ExecutorScheduler.ExecutorWorker(new ScheduledThreadPoolExecutor(1) {
@Override
public void execute(@NonNull Runnable runnable) {
runnable.run();
}
});
}
};

其余的就像 starkej2 的答案一样。希望这对某人有所帮助。

我遇到了这个问题并来到了这篇文章，但我找不到 RX 1 的任何内容。因此，如果您在第一个版本上遇到相同的问题，这就是解决方案。

@BeforeClass
public static void setupClass() {
RxAndroidPlugins.getInstance().registerSchedulersHook(new RxAndroidSchedulersHook() {
@Override
public Scheduler getMainThreadScheduler() {
return Schedulers.trampoline();
}
});
}

对于 RxJava 1，您可以创建不同的调度程序，如下所示：

@Before
public void setUp() throws Exception {
// Override RxJava schedulers
RxJavaHooks.setOnIOScheduler(new Func1<Scheduler, Scheduler>() {
@Override
public Scheduler call(Scheduler scheduler) {
return Schedulers.immediate();
}
});
RxJavaHooks.setOnComputationScheduler(new Func1<Scheduler, Scheduler>() {
@Override
public Scheduler call(Scheduler scheduler) {
return Schedulers.immediate();
}
});
RxJavaHooks.setOnNewThreadScheduler(new Func1<Scheduler, Scheduler>() {
@Override
public Scheduler call(Scheduler scheduler) {
return Schedulers.immediate();
}
});
// Override RxAndroid schedulers
final RxAndroidPlugins rxAndroidPlugins = RxAndroidPlugins.getInstance();
rxAndroidPlugins.registerSchedulersHook(new RxAndroidSchedulersHook() {
@Override
public Scheduler getMainThreadScheduler() {
return Schedulers.immediate();
}
});
} 
@After
public void tearDown() throws Exception {
RxJavaHooks.reset();
RxAndroidPlugins.getInstance().reset();
}

使用改造和 rxjava 对安卓应用程序进行单元测试

Android RxJava 2 JUnit test - getMainLooper in android.os.Lo

相关内容

最新更新

热门标签：