Java TestScheduler.triggerActions方法代码示例

import io.reactivex.schedulers.TestScheduler; //导入方法依赖的package包/类
@Before
public void setUp() throws Exception {
    MockitoAnnotations.initMocks(this);

    testScheduler = new TestScheduler();
    homePresenter = new HomePresenter(contentRepository,
            new TestSchedulerProvider(testScheduler),
            new HomeItemViewModelFactory());

    // mock the Single:
    when(contentRepository.getContentItems()).thenReturn(Single.just(Collections.emptyList()));

    homePresenter.attachView(homeView);

    // trigger the initial load:
    testScheduler.triggerActions();

    // The presenter wont't update the view unless it's active:
    when(homeView.isActive()).thenReturn(true);
}
 

import io.reactivex.schedulers.TestScheduler; //导入方法依赖的package包/类
@Before
public void setUp() throws Exception {
    MockitoAnnotations.initMocks(this);

    int itemId = 2;
    viewModel = new ContentViewModel();
    testScheduler = new TestScheduler();
    contentPresenter = new ContentPresenter(contentRepository,
            new TestSchedulerProvider(testScheduler),
            itemId, viewModel);

    // mock the Single:
    when(contentRepository.getContentItem(itemId)).thenReturn(Single.just(contentItem));

    contentPresenter.attachView(contentView);

    // trigger the initial load:
    testScheduler.triggerActions();

    // The presenter wont't update the view unless it's active:
    when(contentView.isActive()).thenReturn(true);
}
 

import io.reactivex.schedulers.TestScheduler; //导入方法依赖的package包/类
@Test
    public void shouldBeAbleToDisplayMovies() {
//        System.out.println(MainThread);


        TestScheduler testScheduler = new TestScheduler();
        TestObserver<List<Movie>> testObserver = new TestObserver<>();
        Observable<List<Movie>> responseObservable = Observable.just(movies)
                .subscribeOn(testScheduler)
                .observeOn(testScheduler);

        responseObservable.subscribe(testObserver);
        when(interactor.fetchMovies()).thenReturn(responseObservable);

        presenter.setView(view);
        testScheduler.triggerActions();

        testObserver.assertNoErrors();
        testObserver.onComplete();
        verify(view).showMovies(movies);
    }
 

import io.reactivex.schedulers.TestScheduler; //导入方法依赖的package包/类
@Test
public void shouldBeAbleToShowTrailers() {
    //
    TestScheduler testScheduler1 = new TestScheduler();
    Observable<VideoWrapper> response1 = Observable.just(videoWrapper)
            .subscribeOn(testScheduler1)
            .observeOn(AndroidSchedulers.mainThread());
    TestObserver<VideoWrapper> observer = new TestObserver<>();
    response1.subscribe(observer);

    when(movieDetailsInteractor.fetchVideos(anyString())).thenReturn(response1);
    movieDetailsPresenter.displayTrails(movie.getId());
    testScheduler1.triggerActions(); // 为什么在前面
    observer.assertNoErrors();
    observer.assertComplete();
    verify(view).showTrailers(videoWrapper.getVideos());
}
 

import io.reactivex.schedulers.TestScheduler; //导入方法依赖的package包/类
@Test
public void shouldBeAbleToShowReviews() {
    TestScheduler testScheduler = new TestScheduler();
    TestObserver<ReviewWrapper> testObserver = new TestObserver<>();
    Observable<ReviewWrapper> responseObservable = Observable.just(reviewWrapper)
            .subscribeOn(testScheduler)
            .observeOn(AndroidSchedulers.mainThread());

    responseObservable.subscribe(testObserver);

    when(movieDetailsInteractor.fetchReviews(anyString())).thenReturn(responseObservable);

    movieDetailsPresenter.displayReviews(movie.getId());
    testScheduler.triggerActions();

    testObserver.assertNoErrors();
    testObserver.assertComplete();
    verify(view).showReviews(reviewWrapper.getReviews());
}
 

import io.reactivex.schedulers.TestScheduler; //导入方法依赖的package包/类
@Test
public void testBufferingWithNoUpdates() throws InterruptedException
{
    TestScheduler testScheduler = new TestScheduler();
    SimpleFlowableList<Integer> list = new SimpleFlowableList<>();
    FlowableList<Integer> bufferedList = list.buffer(50, TimeUnit.MILLISECONDS, testScheduler);

    TestSubscriber testSubscriber = new TestSubscriber();

    bufferedList.updates().subscribe(testSubscriber);

    testScheduler.advanceTimeBy(50, TimeUnit.MILLISECONDS);
    testScheduler.triggerActions();
    testSubscriber.awaitCount(1);

    testSubscriber.assertNoErrors();
    testSubscriber.assertValueCount(1);

    testScheduler.advanceTimeBy(50, TimeUnit.MILLISECONDS);
    testScheduler.triggerActions();
    testSubscriber.awaitCount(1);

    testSubscriber.dispose();
}
 

import io.reactivex.schedulers.TestScheduler; //导入方法依赖的package包/类
@Test
public void testMaxIdleTime() throws InterruptedException {
    TestScheduler s = new TestScheduler();
    AtomicInteger count = new AtomicInteger();
    AtomicInteger disposed = new AtomicInteger();
    Pool<Integer> pool = NonBlockingPool //
            .factory(() -> count.incrementAndGet()) //
            .healthCheck(n -> true) //
            .maxSize(3) //
            .maxIdleTime(1, TimeUnit.MINUTES) //
            .disposer(n -> disposed.incrementAndGet()) //
            .scheduler(s) //
            .build();
    TestSubscriber<Member<Integer>> ts = new FlowableSingleDeferUntilRequest<>( //
            pool.member()) //
                    .doOnNext(m -> m.checkin()) //
                    .doOnNext(System.out::println) //
                    .doOnRequest(t -> System.out.println("test request=" + t)) //
                    .test(1);
    s.triggerActions();
    ts.assertValueCount(1);
    assertEquals(0, disposed.get());
    s.advanceTimeBy(1, TimeUnit.MINUTES);
    s.triggerActions();
    assertEquals(1, disposed.get());
}
 

import io.reactivex.schedulers.TestScheduler; //导入方法依赖的package包/类
@Test
public void testConnectionPoolRecylesAlternating() {
    TestScheduler s = new TestScheduler();
    AtomicInteger count = new AtomicInteger();
    Pool<Integer> pool = NonBlockingPool //
            .factory(() -> count.incrementAndGet()) //
            .healthCheck(n -> true) //
            .maxSize(2) //
            .maxIdleTime(1, TimeUnit.MINUTES) //
            .scheduler(s) //
            .build();
    TestSubscriber<Integer> ts = new FlowableSingleDeferUntilRequest<>(pool.member()) //
            .repeat() //
            .doOnNext(m -> m.checkin()) //
            .map(m -> m.value()) //
            .test(4); //
    s.triggerActions();
    ts.assertValueCount(4) //
            .assertNotTerminated();
    List<Object> list = ts.getEvents().get(0);
    // all 4 connections released were the same
    assertTrue(list.get(0) == list.get(1));
    assertTrue(list.get(1) == list.get(2));
    assertTrue(list.get(2) == list.get(3));
}
 

import io.reactivex.schedulers.TestScheduler; //导入方法依赖的package包/类
@Test
public void testMemberAvailableAfterCreationScheduledIsUsedImmediately() throws InterruptedException {
    TestScheduler ts = new TestScheduler();
    Scheduler s = createScheduleToDelayCreation(ts);
    AtomicInteger count = new AtomicInteger();
    Pool<Integer> pool = NonBlockingPool //
            .factory(() -> count.incrementAndGet()) //
            .createRetryInterval(10, TimeUnit.MINUTES) //
            .maxSize(2) //
            .maxIdleTime(1, TimeUnit.HOURS) //
            .scheduler(s) //
            .build();
    List<Member<Integer>> list = new ArrayList<Member<Integer>>();
    pool.member().doOnSuccess(m -> list.add(m)).subscribe();
    assertEquals(0, list.size());
    ts.advanceTimeBy(1, TimeUnit.MINUTES);
    ts.triggerActions();
    assertEquals(1, list.size());
    pool.member().doOnSuccess(m -> list.add(m)).subscribe();
    list.get(0).checkin();
    ts.triggerActions();
    assertEquals(2, list.size());
}
 

import io.reactivex.schedulers.TestScheduler; //导入方法依赖的package包/类
@Test
public void onViewCreatedUsersReceived() throws Exception {
    List<User> users = new ArrayList<>();
    TestScheduler scheduler = new TestScheduler();
    PublishSubject<List<User>> subject = PublishSubject.create();
    subject.subscribeOn(scheduler);
    when(mInteractor.getUserList()).thenReturn(subject);
    ListingActivity mock = Mockito.mock(ListingActivity.class, new Answer() {
        @Override
        public Object answer(InvocationOnMock invocation) throws Throwable {
            if (invocation.getMethod().getReturnType().equals(Observable.class))
                return PublishSubject.create();
            else return null;
        }
    });
    mPresenter.attachView(mock);
    mPresenter.detachView(false);
    verify(mInteractor).getUserList();
    subject.onNext(users);
    scheduler.triggerActions();
    verify(mView, never()).setUserList(users);
    verify(mView, never()).showContent();
    verify(mView, never()).showError(any(Throwable.class));
}
 

import io.reactivex.schedulers.TestScheduler; //导入方法依赖的package包/类
@Test
public void onViewCreatedFailed() throws Exception {
    TestScheduler scheduler = new TestScheduler();
    PublishSubject<List<User>> subject = PublishSubject.create();
    subject.subscribeOn(scheduler);
    when(mInteractor.getUserList()).thenReturn(subject);
    ListingActivity mock = Mockito.mock(ListingActivity.class, new Answer() {
        @Override
        public Object answer(InvocationOnMock invocation) throws Throwable {
            if (invocation.getMethod().getReturnType().equals(Observable.class))
                return PublishSubject.create();
            else return null;
        }
    });
    mPresenter.attachView(mock);
    mPresenter.detachView(false);
    verify(mInteractor).getUserList();
    IOException e = new IOException();
    subject.onError(e);
    scheduler.triggerActions();
    verify(mView, never()).setUserList(any(List.class));
    verify(mView, never()).showContent();
    verify(mView, never()).showError(e);
}
 

import io.reactivex.schedulers.TestScheduler; //导入方法依赖的package包/类
@Test
public void onViewCreatedUsersReceived() throws Exception {
    List<User> users = new ArrayList<>();
    TestScheduler scheduler = new TestScheduler();
    PublishSubject<List<User>> subject = PublishSubject.create();
    subject.subscribeOn(scheduler);
    when(mInteractor.getUserList()).thenReturn(subject);
    mPresenter.attachView(mView);
    verify(mView).showLoading();
    verify(mInteractor).getUserList();
    subject.onNext(users);
    scheduler.triggerActions();
    verify(mView).setUserList(users);
    verify(mView).showContent();
    verify(mView, never()).showError(any(Throwable.class));
}
 

import io.reactivex.schedulers.TestScheduler; //导入方法依赖的package包/类
@Test
public void onViewCreatedFailed() throws Exception {
    TestScheduler scheduler = new TestScheduler();
    PublishSubject<List<User>> subject = PublishSubject.create();
    subject.subscribeOn(scheduler);
    when(mInteractor.getUserList()).thenReturn(subject);
    mPresenter.attachView(mView);
    verify(mView).showLoading();
    verify(mInteractor).getUserList();
    IOException e = new IOException();
    subject.onError(e);
    scheduler.triggerActions();
    verify(mView, never()).setUserList(any(List.class));
    verify(mView, never()).showContent();
    verify(mView).showError(e);
}
 

import io.reactivex.schedulers.TestScheduler; //导入方法依赖的package包/类
@Test
public void testPoolFactoryWhenFailsThenRecovers() {
    AtomicReference<Throwable> ex = new AtomicReference<>();
    Consumer<? super Throwable> handler = RxJavaPlugins.getErrorHandler();
    RxJavaPlugins.setErrorHandler(t -> ex.set(t));
    try {
        TestScheduler s = new TestScheduler();
        AtomicInteger c = new AtomicInteger();
        NonBlockingPool<Integer> pool = NonBlockingPool.factory(() -> {
            if (c.getAndIncrement() == 0) {
                throw new TestException();
            } else {
                return c.get();
            }
        }) //
                .maxSize(1) //
                .scheduler(s) //
                .createRetryInterval(10, TimeUnit.SECONDS) //
                .build();
        TestObserver<Integer> ts = pool.member() //
                .map(m -> m.value()) //
                .test() //
                .assertNotTerminated() //
                .assertNoValues();
        s.triggerActions();
        assertTrue(ex.get() instanceof UndeliverableException);
        assertTrue(((UndeliverableException) ex.get()).getCause() instanceof TestException);
        s.advanceTimeBy(10, TimeUnit.SECONDS);
        s.triggerActions();
        ts.assertComplete();
        ts.assertValue(2);
    } finally {
        RxJavaPlugins.setErrorHandler(handler);
    }
}
 

import io.reactivex.schedulers.TestScheduler; //导入方法依赖的package包/类
@Test
public void onViewCreatedUsersReceived() throws Exception {
    List<User> users = new ArrayList<>();
    TestScheduler scheduler = new TestScheduler();
    TestSubject<List<User>> subject = TestSubject.create(scheduler);
    when(mInteractor.getUserList()).thenReturn(subject);
    mPresenter.onViewCreated();
    verify(mView, never()).showLoading();
    verify(mInteractor).getUserList();
    subject.onNext(users);
    scheduler.triggerActions();
    verify(mView, never()).setUserList(users);
    verify(mView, never()).showContent();
    verify(mView, never()).showError(any());
}