Android RxJava 2 JUnit test-getMainLooper dans android.OS.Looper Non moqué RuntimeException

je viens d'ajouter

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

in @Before annotated method.

j'ai eu la même erreur quand J'ai testé LiveData. Lors de L'essai de LiveData, ce InstantTaskExecutorRule est nécessaire en plus de Rximmediateschedulerrulle si la classe à l'essai a à la fois le fil de fond et LiveData.

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

}

référence: https://pbochenski.pl/blog/07-12-2017-testing_livedata.html

comme dans le conseil dans cet article médium de Peter Tackage vous pouvez injecter les programmeurs vous-même.

nous savons tous que l'appel direct de méthodes statiques peut rendre pour les classes qui sont difficiles à tester et si vous utilisez un cadre d'injection de dépendance comme Dagger 2 injecter les ordonnanceurs peut être particulièrement facile. L'exemple est le suivant:

définissez une interface dans votre projet:

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

definit an implementation:

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

maintenant au lieu d'utiliser des références directes aux ordonnanceurs comme ceci:

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

vous utilisez des références à votre interface:

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

maintenant pour vos tests, vous pouvez définir un TestSchedulersProvider comme ceci:

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
}

vous avez maintenant tous les avantages d'utiliser TestScheduler quand vous voulez dans votre unité fait des tests. Cela est pratique pour les situations où vous pourriez vouloir tester un délai:

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

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

    //assert
    o.assertValue(1);
}

Sinon, si vous ne voulez pas utiliser des programmateurs injectés les crochets statiques mentionnés dans les autres méthodes peuvent être faites en utilisant lambdas:

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

pour RxJava 1 vous pouvez créer différents ordonnanceurs comme ceci:

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

"151940920 de tests Unitaires de l'application android, avec de rénovation et de rxjava

juste pour ajouter à la réponse de starkej2, ça a très bien fonctionné pour moi jusqu'à ce que je tombe sur stackoverflowerror en testant un Observable.minuterie.)( Il n'y a pas d'aide sur cela, mais heureusement je l'ai obtenu travailler avec la définition de planificateur ci-dessous, avec tous les autres tests également passer.

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

reste comme dans la réponse de starkej2. Espérons que cela aide quelqu'un.

j'ai eu ce problème et je suis venu à ce poste, mais je ne pouvais rien trouver pour RX 1. C'est donc la solution si vous avez le même problème sur la première version.

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