private void startScheduler(SchedulerTestConfiguration configuration) throws Exception {
if (!scheduler.isStartedWithSameConfiguration(configuration)) {
log("Starting Scheduler");
scheduler.start(configuration);
}
currentTestConfiguration = configuration;
}
@Test
public void testJustWithScheduler() {
TestScheduler scheduler = new TestScheduler();
Observable<Integer> observable = Observable.fromArray(1, 2).subscribeOn(scheduler);
Subscriber<Integer> observer = TestHelper.mockSubscriber();
observable.subscribe(observer);
scheduler.advanceTimeBy(1, TimeUnit.MILLISECONDS);
InOrder inOrder = inOrder(observer);
inOrder.verify(observer, times(1)).onNext(1);
inOrder.verify(observer, times(1)).onNext(2);
inOrder.verify(observer, times(1)).onComplete();
inOrder.verifyNoMoreInteractions();
}
public ResourceManager getResourceManager(TestUsers user) throws Exception {
startScheduler(currentTestConfiguration);
if (!connectedRMUser.is(user)) { // changing user on the fly
if (connectedRMUser != null) {
connectedRMUser.disconnect();
}
connectedRMUser = new RMTestUser(user);
connectedRMUser.connect(scheduler.getRMAuth());
}
if (!connectedRMUser.isConnected()) {
connectedRMUser.connect(scheduler.getRMAuth());
}
return connectedRMUser.getResourceManager();
}
/**
* Return Scheduler's interface. Start Scheduler if needed, connect as administrator if needed (if
* not yet connected as user).
*
* <p>WARNING : if there was a previous connection as User, this connection is shut down. And so
* some event can be missed by event receiver, between disconnection and reconnection (only one
* connection to Scheduler per body is possible).
*
* @param user Type of user
* @return scheduler interface
* @throws Exception if an error occurs.
*/
public Scheduler getSchedulerInterface(TestUsers user) throws Exception {
startScheduler(currentTestConfiguration);
if (!connectedSchedulerUser.is(user)) { // changing user on the fly
if (connectedSchedulerUser != null) {
connectedSchedulerUser.disconnect();
}
connectedSchedulerUser = new SchedulerTestUser(user);
connectedSchedulerUser.connect(scheduler.getAuth());
}
if (!connectedSchedulerUser.isConnected()) {
connectedSchedulerUser.connect(scheduler.getAuth());
}
return connectedSchedulerUser.getScheduler();
}
@Test
public void timestampWithScheduler2() {
TestScheduler scheduler = new TestScheduler();
PublishSubject<Integer> source = PublishSubject.create();
Observable<Timed<Integer>> m = source.timestamp(scheduler);
m.subscribe(observer);
source.onNext(1);
source.onNext(2);
scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
source.onNext(3);
InOrder inOrder = inOrder(observer);
inOrder.verify(observer, times(1)).onNext(new Timed<>(1, 0, TimeUnit.MILLISECONDS));
inOrder.verify(observer, times(1)).onNext(new Timed<>(2, 0, TimeUnit.MILLISECONDS));
inOrder.verify(observer, times(1)).onNext(new Timed<>(3, 200, TimeUnit.MILLISECONDS));
verify(observer, never()).onError(any(Throwable.class));
verify(observer, never()).onComplete();
}
public static String getLocalUrl() {
return scheduler.getUrl();
}
/**
* Return Scheduler authentication interface. Start Scheduler with test configuration file, if
* scheduler is not yet started.
*
* @throws Exception
*/
public SchedulerAuthenticationInterface getSchedulerAuth() throws Exception {
startScheduler(currentTestConfiguration);
return scheduler.getAuth();
}
/** Kill the forked Scheduler if exists. */
public void killScheduler() throws Exception {
connectedRMUser.disconnect();
connectedSchedulerUser.disconnect();
scheduler.kill();
}
