RxMapperTest.java

package org.jooby.rx;

import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.isA;
import static org.junit.Assert.assertEquals;

import java.util.function.Function;

import org.jooby.Deferred;
import org.jooby.rx.Rx.DeferredSubscriber;
import org.jooby.test.MockUnit;
import org.jooby.test.MockUnit.Block;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

import rx.Completable;
import rx.Observable;
import rx.Scheduler;
import rx.Single;
import rx.Subscription;

@RunWith(PowerMockRunner.class)
@PrepareForTest({Rx.class, Observable.class, Single.class, Completable.class,
    DeferredSubscriber.class })
@SuppressWarnings({"rawtypes", "unchecked" })
public class RxMapperTest {

  private Block obsSubscribeInit = unit -> {
    Observable value = unit.powerMock(Observable.class);
    unit.registerMock(Observable.class, value);
  };

  private Block sSubscribeInit = unit -> {
    Single single = unit.powerMock(Single.class);

    unit.registerMock(Single.class, single);
  };

  private Block cSubscribeInit = unit -> {
    Completable single = unit.powerMock(Completable.class);
    unit.registerMock(Completable.class, single);
  };

  private Block deferredSubscriber = unit -> {
    DeferredSubscriber subscriber = unit.constructor(DeferredSubscriber.class)
        .args(Deferred.class)
        .build(isA(Deferred.class));
    unit.registerMock(DeferredSubscriber.class, subscriber);
  };

  private Block obsSubscribe = unit -> {
    Observable value = unit.get(Observable.class);

    DeferredSubscriber subscriber = unit.get(DeferredSubscriber.class);

    expect(value.subscribe(subscriber)).andReturn(null);
  };

  private Block sSubscribe = unit -> {
    Single value = unit.get(Single.class);

    DeferredSubscriber subscriber = unit.get(DeferredSubscriber.class);

    expect(value.subscribe(subscriber)).andReturn(null);
  };

  private Block cSubscribe = unit -> {
    Completable value = unit.get(Completable.class);

    DeferredSubscriber subscriber = unit.get(DeferredSubscriber.class);

    value.subscribe(subscriber);
  };

  private Block scheduler = unit -> {
    Scheduler scheduler = unit.mock(Scheduler.class);
    unit.registerMock(Scheduler.class, scheduler);
  };

  @Test
  public void rxObservable() throws Exception {
    new MockUnit(Observable.class, Subscription.class)
        .expect(obsSubscribeInit)
        .expect(deferredSubscriber)
        .expect(obsSubscribe)
        .run(unit -> {
          Deferred deferred = (Deferred) Rx.rx().map(unit.get(Observable.class));
          deferred.handler(null, (r, x) -> {
          });
        });
  }

  @Test
  public void rxObservableWithScheduler() throws Exception {
    new MockUnit(Observable.class, Subscription.class)
        .expect(obsSubscribeInit)
        .expect(deferredSubscriber)
        .expect(scheduler)
        .expect(obsSubscribe)
        .expect(unit -> {
          Observable single = unit.get(Observable.class);

          expect(single.observeOn(unit.get(Scheduler.class))).andReturn(single);
        })
        .run(unit -> {
          Deferred deferred = (Deferred) Rx
              .rx(o -> o.observeOn(unit.get(Scheduler.class)), Function.identity())
              .map(unit.get(Observable.class));
          deferred.handler(null, (r, x) -> {
          });
        });
  }

  @Test
  public void rxSingle() throws Exception {
    new MockUnit()
        .expect(sSubscribeInit)
        .expect(deferredSubscriber)
        .expect(sSubscribe)
        .run(unit -> {
          Deferred deferred = (Deferred) Rx.rx().map(unit.get(Single.class));
          deferred.handler(null, (r, x) -> {
          });
        });
  }

  @Test
  public void rxComplete() throws Exception {
    new MockUnit()
        .expect(cSubscribeInit)
        .expect(deferredSubscriber)
        .expect(cSubscribe)
        .run(unit -> {
          Deferred deferred = (Deferred) Rx.rx().map(unit.get(Completable.class));
          deferred.handler(null, (r, x) -> {
          });
        });
  }

  @Test
  public void rxNone() throws Exception {
    new MockUnit()
        .run(unit -> {
          Object value = new Object();
          assertEquals(value, Rx.rx().map(value));
        });
  }

}