Android RxJava 2 JUnit Test - getMainLooper in Android.os.Looper nicht verspottet RuntimeException

Ich habe gerade hinzugefügt 

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

in @Before annotierte Methode.

Basierend auf der Antwort von @ starkej2, mit einigen Änderungen, wäre die richtige Antwort für Kotlin Entwickler:

1. RxImmediateSchedulerRule.kt-Klasse erstellen: 

.

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()
                }
            }
        }
    }
}

2. Erstellen Sie in Ihrer Testklasse Scheduler ClassRule:

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

Beim Testen von LiveData wurde der gleiche Fehler angezeigt. Beim Testen von LiveData wird diese InstantTaskExecutorRule zusätzlich zu RxImmediateSchedulerRule benötigt, wenn die getestete Klasse sowohl einen Hintergrundthread als auch LiveData hat.

@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)))
    }

}

Referenz: https://pbochenski.pl/blog/07-12-2017-testing_livedata.html

Wie in den Ratschlägen in diesem Medium-Artikel von Peter Tackage können Sie die Scheduler selbst spritzen. 

Wir alle wissen, dass durch das direkte Aufrufen statischer Methoden schwer zu testende Klassen erstellt werden können. Wenn Sie ein Abhängigkeitsinjektions-Framework wie Dagger 2 verwenden, ist das Einfügen der Scheduler besonders einfach. Das Beispiel ist wie folgt:

Definieren Sie eine Schnittstelle in Ihrem Projekt:

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

Definieren Sie eine Implementierung:

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();
    }
}

Statt direkte Verweise auf die Scheduler wie folgt zu verwenden:

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

Sie verwenden Verweise auf Ihre Schnittstelle:

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

Nun könnten Sie für Ihre Tests einen TestSchedulersProvider wie folgt definieren:

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
}

Sie haben jetzt alle Vorteile der Verwendung von TestScheduler , wenn Sie möchten, dass Sie in Ihren Gerätetests arbeiten. Dies ist praktisch für Situationen, in denen Sie eine Verzögerung testen möchten:

@Test
public void testIntegerOneIsEmittedAt20Seconds() {
    //arrange
    TestObserver<Integer> o = delayedRepository.delayedInt()
            .test();

    //act
    testScheduler.advanceTimeTo(20, TimeUnit.SECONDS);

    //assert
    o.assertValue(1);
}

Wenn Sie keine eingespritzten Scheduler verwenden möchten, können die statischen Hooks, die in den anderen Methoden erwähnt werden, auch mit Lambdas ausgeführt werden:

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

Für RxJava 1 können Sie verschiedene Scheduler wie folgt erstellen:

 @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();
}

Unit-Test Android-Anwendung mit Retrofit und Rxjava

Nur um die Antwort von starkej2 zu ergänzen, hat es sehr gut für mich funktioniert, bis ich beim Testen eines Observable.timer () auf stackoverflowerror gestoßen bin. Es gibt keine Hilfe, aber zum Glück habe ich es mit der folgenden Scheduler-Definition gemacht, wobei alle anderen Tests ebenfalls bestanden haben.

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

Ausruhen wie in der Antwort von starkej2. Hoffe das hilft jemandem.

Für diejenigen, die mit Kotlin arbeiten und Rule verwenden, anstatt companion object Sie können @get:Rule.

Anstatt also:

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

Sie können einfach verwenden:

@get:Rule
val schedulers = RxImmediateSchedulerRule()

Ich hatte dieses Problem und kam zu diesem Beitrag, aber ich konnte nichts für RX 1 finden ... Dies ist die Lösung, wenn Sie das gleiche Problem in der ersten Version haben.

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