@Test(timeout = 1000L)
public void testSynchronousError() {
final Observable<Observable<String>> o1 = Observable.error(new RuntimeException("unit test"));
final CountDownLatch latch = new CountDownLatch(1);
Observable.mergeDelayError(o1)
.subscribe(
new Observer<String>() {
@Override
public void onComplete() {
fail("Expected onError path");
}
@Override
public void onError(Throwable e) {
latch.countDown();
}
@Override
public void onNext(String s) {
fail("Expected onError path");
}
});
try {
latch.await();
} catch (InterruptedException ex) {
fail("interrupted");
}
}
@Test(description = "OPENDJ-1197")
public void testClientSideConnectTimeout() throws Exception {
// Use an non-local unreachable network address.
final ConnectionFactory factory =
new LDAPConnectionFactory(
"10.20.30.40", 1389, new LDAPOptions().setConnectTimeout(1, TimeUnit.MILLISECONDS));
try {
for (int i = 0; i < ITERATIONS; i++) {
final PromiseImpl<LdapException, NeverThrowsException> promise = PromiseImpl.create();
final Promise<? extends Connection, LdapException> connectionPromise =
factory.getConnectionAsync();
connectionPromise.onFailure(getFailureHandler(promise));
ConnectionException e =
(ConnectionException) promise.getOrThrow(TEST_TIMEOUT, TimeUnit.SECONDS);
assertThat(e.getResult().getResultCode()).isEqualTo(ResultCode.CLIENT_SIDE_CONNECT_ERROR);
// Wait for the connect to timeout.
try {
connectionPromise.getOrThrow(TEST_TIMEOUT, TimeUnit.SECONDS);
fail("The connect request succeeded unexpectedly");
} catch (ConnectionException ce) {
assertThat(ce.getResult().getResultCode())
.isEqualTo(ResultCode.CLIENT_SIDE_CONNECT_ERROR);
}
}
} finally {
factory.close();
}
}
@Test
public void testTakeWithErrorInObserver() {
final AtomicInteger count = new AtomicInteger();
final AtomicReference<Throwable> error = new AtomicReference<>();
Observable.just("1", "2", "three", "4")
.take(3)
.safeSubscribe(
new Observer<String>() {
@Override
public void onComplete() {
System.out.println("completed");
}
@Override
public void onError(Throwable e) {
error.set(e);
System.out.println("error");
e.printStackTrace();
}
@Override
public void onNext(String v) {
int num = Integer.parseInt(v);
System.out.println(num);
// doSomething(num);
count.incrementAndGet();
}
});
assertEquals(2, count.get());
assertNotNull(error.get());
if (!(error.get() instanceof NumberFormatException)) {
fail("It should be a NumberFormatException");
}
}
@SuppressWarnings("deprecation")
@Test
public void shouldStubStringVarargs() {
when(mock.withStringVarargsReturningString(1)).thenReturn("1");
when(mock.withStringVarargsReturningString(2, "1", "2", "3")).thenReturn("2");
RuntimeException expected = new RuntimeException();
stubVoid(mock).toThrow(expected).on().withStringVarargs(3, "1", "2", "3", "4");
assertEquals("1", mock.withStringVarargsReturningString(1));
assertEquals(null, mock.withStringVarargsReturningString(2));
assertEquals("2", mock.withStringVarargsReturningString(2, "1", "2", "3"));
assertEquals(null, mock.withStringVarargsReturningString(2, "1", "2"));
assertEquals(null, mock.withStringVarargsReturningString(2, "1", "2", "3", "4"));
assertEquals(null, mock.withStringVarargsReturningString(2, "1", "2", "9999"));
mock.withStringVarargs(3, "1", "2", "3", "9999");
mock.withStringVarargs(9999, "1", "2", "3", "4");
try {
mock.withStringVarargs(3, "1", "2", "3", "4");
fail();
} catch (Exception e) {
assertEquals(expected, e);
}
}
@Test
public void testUnsubscribeAfterTake() {
Subscription s = mock(Subscription.class);
TestObservable w = new TestObservable(s, "one", "two", "three");
@SuppressWarnings("unchecked")
Observer<String> aObserver = mock(Observer.class);
Observable<String> take = Observable.create(take(w, 1));
take.subscribe(aObserver);
// wait for the Observable to complete
try {
w.t.join();
} catch (Throwable e) {
e.printStackTrace();
fail(e.getMessage());
}
System.out.println("TestObservable thread finished");
verify(aObserver, times(1)).onNext("one");
verify(aObserver, never()).onNext("two");
verify(aObserver, never()).onNext("three");
verify(aObserver, times(1)).onCompleted();
verify(s, times(1)).unsubscribe();
verifyNoMoreInteractions(aObserver);
}
/**
* Set up the {@link ClientSession} to throw an exception when {@link
* ClientSession#createProducer(String)} is called. Make sure, we throw up our hands saying "I am
* not dealing with this".
*
* @throws Exception
*/
@Test(expected = RuntimeException.class)
public void eventSinkShouldThrowExceptionWhenProducerCreationFailsInConstructor()
throws Exception {
doThrow(new HornetQException()).when(mockClientSession.createProducer(anyString()));
createEventSink(mockSessionFactory);
fail("Runtime exception should have been thrown.");
}
@Test
public void testResumeNext() {
Subscription s = mock(Subscription.class);
// Trigger failure on second element
TestObservable f = new TestObservable(s, "one", "fail", "two", "three");
Observable<String> w = Observable.create(f);
Observable<String> resume = Observable.from("twoResume", "threeResume");
Observable<String> observable = Observable.create(onErrorResumeNextViaObservable(w, resume));
@SuppressWarnings("unchecked")
Observer<String> observer = mock(Observer.class);
observable.subscribe(observer);
try {
f.t.join();
} catch (InterruptedException e) {
fail(e.getMessage());
}
verify(observer, Mockito.never()).onError(any(Throwable.class));
verify(observer, times(1)).onCompleted();
verify(observer, times(1)).onNext("one");
verify(observer, Mockito.never()).onNext("two");
verify(observer, Mockito.never()).onNext("three");
verify(observer, times(1)).onNext("twoResume");
verify(observer, times(1)).onNext("threeResume");
}
/**
* The error from the user provided Observable is handled by the subscribe try/catch because this
* is synchronous
*
* <p>Result: Passes
*/
@Test
public void testCustomObservableWithErrorInObservableSynchronous() {
final AtomicInteger count = new AtomicInteger();
final AtomicReference<Throwable> error = new AtomicReference<>();
// FIXME custom built???
Observable.just("1", "2")
.concatWith(Observable.error(() -> new NumberFormatException()))
.subscribe(
new Observer<String>() {
@Override
public void onComplete() {
System.out.println("completed");
}
@Override
public void onError(Throwable e) {
error.set(e);
System.out.println("error");
e.printStackTrace();
}
@Override
public void onNext(String v) {
System.out.println(v);
count.incrementAndGet();
}
});
assertEquals(2, count.get());
assertNotNull(error.get());
if (!(error.get() instanceof NumberFormatException)) {
fail("It should be a NumberFormatException");
}
}
/**
* Set up the {@link ClientSessionFactory} to throw an exception when {@link
* ClientSessionFactory#createSession()} is called. Make sure, we throw up our hands saying "I am
* not dealing with this".
*
* @throws Exception
*/
@Test(expected = RuntimeException.class)
public void eventSinkShouldThrowExceptionWhenSessionCreationFailsInConstructor()
throws Exception {
final ClientSessionFactory csFactory = mock(ClientSessionFactory.class);
doThrow(new HornetQException()).when(csFactory.createSession());
createEventSink(csFactory);
fail("Runtime exception should have been thrown.");
}
@Test
public void shouldSayUnfinishedVerificationButNotInvalidUseOfMatchers() {
verify(withFinal).finalMethod(anyObject());
try {
verify(withFinal);
fail();
} catch (UnfinishedVerificationException e) {
}
}
/**
* https://github.com/ReactiveX/RxJava/issues/198
*
* <p>Rx Design Guidelines 5.2
*
* <p>"when calling the Subscribe method that only has an onNext argument, the OnError behavior
* will be to rethrow the exception on the thread that the message comes out from the Observable.
* The OnCompleted behavior in this case is to do nothing."
*/
@Test
@Ignore("Subscribers can't throw")
public void testErrorThrownWithoutErrorHandlerSynchronous() {
try {
Observable.error(new RuntimeException("failure")).subscribe();
fail("expected exception");
} catch (Throwable e) {
assertEquals("failure", e.getMessage());
}
}
@Test
public void shouldFailFastWhenArgumentMatchersAbused() {
misplacedArgumentMatcher();
try {
mock(IMethods.class);
fail();
} catch (InvalidUseOfMatchersException e) {
assertContains("Misplaced argument matcher", e.getMessage());
}
}
@Test
public void physicalOnly() throws Exception {
String expected = "Pool is restricted to physical systems: 'pool10'.";
try {
bindByPoolErrorTest("rulefailed.physical.only");
fail();
} catch (ForbiddenException e) {
assertEquals(expected, e.getMessage());
}
}
@Test
public void virtOnly() {
String expected = "Pool is restricted to virtual guests: 'pool10'.";
try {
bindByPoolErrorTest("rulefailed.virt.only");
fail();
} catch (ForbiddenException e) {
assertEquals(expected, e.getMessage());
}
}
@Test
public void consumerDoesntSupportDerived() {
String expected = "Unit does not support derived products " + "data required by pool 'pool10'";
try {
bindByPoolErrorTest("rulefailed.derivedproduct.unsupported.by.consumer");
fail();
} catch (ForbiddenException e) {
assertEquals(expected, e.getMessage());
}
}
@Test
public void consumerDoesntSupportRam() {
String expected = "Unit does not support RAM " + "calculation required by pool 'pool10'";
try {
bindByPoolErrorTest("rulefailed.ram.unsupported.by.consumer");
fail();
} catch (ForbiddenException e) {
assertEquals(expected, e.getMessage());
}
}
@Test
public void shouldValidateStateWhenResetting() {
// invalid verify:
verify(mock);
try {
reset(mockTwo);
fail();
} catch (UnfinishedVerificationException e) {
}
}
@Test
public void shouldResetOngoingStubbingSoThatMoreMeaningfulExceptionsAreRaised() {
mock(IMethods.class);
mock.booleanReturningMethod();
reset(mock);
try {
when(null).thenReturn("anything");
fail();
} catch (MissingMethodInvocationException e) {
}
}
@Test
public void testValidateSingleInvalid() {
when(config.getBoolean(eq(ConfigProperties.STANDALONE))).thenReturn(false);
ContentOverride override = new ContentOverride("label", "baseurl", "value");
try {
validator.validate(override);
fail("Expected exception was \"BadRequestException\" not thrown.");
} catch (BadRequestException bre) {
assertEquals("Not allowed to override values for: baseurl", bre.getMessage());
}
}
private void bindByProductErrorTest(String msg) throws Exception {
try {
String[] pids = {"prod1", "prod2", "prod3"};
Map<String, ValidationResult> fakeResult = new HashMap<String, ValidationResult>();
fakeResult.put("blah", fakeOutResult(msg));
EntitlementRefusedException ere = new EntitlementRefusedException(fakeResult);
AutobindData data = AutobindData.create(consumer).forProducts(pids);
when(pm.entitleByProducts(data)).thenThrow(ere);
entitler.bindByProducts(data);
} catch (EntitlementRefusedException e) {
fail(msg + ": threw unexpected error");
}
}
/** A reduce should fail with an NoSuchElementException if done on an empty Observable. */
@Test(expected = NoSuchElementException.class)
public void testReduceWithEmptyObservable() {
Observable<Integer> observable = Observable.range(1, 0);
observable
.reduce((t1, t2) -> t1 + t2)
.toBlocking()
.forEach(
t1 -> {
// do nothing ... we expect an exception instead
});
fail("Expected an exception to be thrown");
}
@Test
public void shouldVerifyBooleanVarargs() {
mock.withBooleanVarargs(1);
mock.withBooleanVarargs(2, true, false, true);
mock.withBooleanVarargs(3, true, true, true);
verify(mock).withBooleanVarargs(1);
verify(mock).withBooleanVarargs(2, true, false, true);
try {
verify(mock).withBooleanVarargs(3, true, true, true, true);
fail();
} catch (ArgumentsAreDifferent e) {
}
}
@Test
public void shouldVerifyStringVarargs() {
mock.withStringVarargs(1);
mock.withStringVarargs(2, "1", "2", "3");
mock.withStringVarargs(3, "1", "2", "3", "4");
verify(mock).withStringVarargs(1);
verify(mock).withStringVarargs(2, "1", "2", "3");
try {
verify(mock).withStringVarargs(2, "1", "2", "79", "4");
fail();
} catch (ArgumentsAreDifferent e) {
}
}
@Test
public void shouldVerifyObjectVarargs() {
mock.withObjectVarargs(1);
mock.withObjectVarargs(2, "1", new ArrayList<Object>(), new Integer(1));
mock.withObjectVarargs(3, new Integer(1));
verify(mock).withObjectVarargs(1);
verify(mock).withObjectVarargs(2, "1", new ArrayList<Object>(), new Integer(1));
try {
verifyNoMoreInteractions(mock);
fail();
} catch (NoInteractionsWanted e) {
}
}
@Test
public void testReplay() throws InterruptedException {
final AtomicInteger counter = new AtomicInteger();
ConnectableObservable<String> o =
Observable.<String>create(
observer -> {
observer.onSubscribe(EmptySubscription.INSTANCE);
new Thread(
new Runnable() {
@Override
public void run() {
counter.incrementAndGet();
observer.onNext("one");
observer.onComplete();
}
})
.start();
})
.replay();
// we connect immediately and it will emit the value
Disposable s = o.connect();
try {
// we then expect the following 2 subscriptions to get that same value
final CountDownLatch latch = new CountDownLatch(2);
// subscribe once
o.subscribe(
v -> {
assertEquals("one", v);
latch.countDown();
});
// subscribe again
o.subscribe(
v -> {
assertEquals("one", v);
latch.countDown();
});
if (!latch.await(1000, TimeUnit.MILLISECONDS)) {
fail("subscriptions did not receive values");
}
assertEquals(1, counter.get());
} finally {
s.dispose();
}
}
@Test
public void testValidateCollectionBothInvalid() {
when(config.getBoolean(eq(ConfigProperties.STANDALONE))).thenReturn(false);
List<ContentOverride> overrides = new LinkedList<ContentOverride>();
overrides.add(new ContentOverride("label", "baseurl", "value"));
overrides.add(new ContentOverride("other label", "name", "other value"));
try {
validator.validate(overrides);
fail("Expected exception \"BadRequestException\" was not thrown.");
} catch (BadRequestException bre) {
assertTrue(
bre.getMessage()
.matches("^Not allowed to override values for: (?:baseurl, name|name, baseurl)"));
}
}
@Test
@SuppressWarnings("unchecked")
public void testSimple() throws InterruptedException {
final ExecutorService exec = Executors.newCachedThreadPool();
try {
final CountDownLatch ready = new CountDownLatch(1);
Func0<Future<Observable<Integer>>> func =
new Func0<Future<Observable<Integer>>>() {
@Override
public Future<Observable<Integer>> call() {
return exec.submit(
new Callable<Observable<Integer>>() {
@Override
public Observable<Integer> call() throws Exception {
if (!ready.await(1000, TimeUnit.MILLISECONDS)) {
throw new IllegalStateException("Not started in time");
}
return Observable.from(1);
}
});
}
};
Observable<Integer> result = Async.deferFuture(func, Schedulers.threadPoolForComputation());
final Observer<Integer> observer = mock(Observer.class);
final CountDownLatch done = new CountDownLatch(1);
result.subscribe(new OperationStartFutureTest.MockHelper<Integer>(observer, done));
ready.countDown();
if (!done.await(1000, TimeUnit.MILLISECONDS)) {
fail("Not completed in time!");
}
InOrder inOrder = inOrder(observer);
inOrder.verify(observer).onNext(1);
inOrder.verify(observer).onCompleted();
verify(observer, never()).onError(any(Throwable.class));
} finally {
exec.shutdown();
}
}
/**
* Unit test for OPENDJ-1247: as per previous test, except this time verify that the connection
* failure removes the connection from a connection pool.
*/
@Test
public void testClientSideTimeoutForBindRequestInConnectionPool() throws Exception {
resetState();
registerBindEvent();
registerCloseEvent();
for (int i = 0; i < ITERATIONS; i++) {
final Connection connection = pool.getConnection();
try {
waitForConnect();
final MockConnectionEventListener listener = new MockConnectionEventListener();
connection.addConnectionEventListener(listener);
// Now bind with timeout.
final PromiseImpl<LdapException, NeverThrowsException> promise = PromiseImpl.create();
final LdapPromise<BindResult> bindPromise = connection.bindAsync(newSimpleBindRequest());
bindPromise.onFailure(getFailureHandler(promise));
waitForBind();
// Wait for the request to timeout and check the handler was invoked.
TimeoutResultException e = (TimeoutResultException) promise.getOrThrow(5, TimeUnit.SECONDS);
verifyResultCodeIsClientSideTimeout(e);
// Now check the promise was completed as expected.
try {
bindPromise.getOrThrow(5, TimeUnit.SECONDS);
fail("The bind request succeeded unexpectedly");
} catch (TimeoutResultException te) {
verifyResultCodeIsClientSideTimeout(te);
}
/*
* The connection should no longer be valid, the event listener
* should have been notified, but no abandon should have been
* sent.
*/
listener.awaitError(TEST_TIMEOUT, TimeUnit.SECONDS);
assertThat(connection.isValid()).isFalse();
verifyResultCodeIsClientSideTimeout(listener.getError());
connection.close();
waitForClose();
verifyNoAbandonSent();
} finally {
connection.close();
}
}
}
@Test
public void testNoDryBindWhenAutobindDisabledForOwner() throws Exception {
Consumer consumer = createConsumer();
consumer.getOwner().setAutobindDisabled(true);
when(mockedConsumerCurator.verifyAndLookupConsumer(eq(consumer.getUuid())))
.thenReturn(consumer);
ManifestManager manifestManager = mock(ManifestManager.class);
ConsumerResource consumerResource =
new ConsumerResource(
mockedConsumerCurator,
null,
null,
null,
null,
null,
null,
i18n,
null,
null,
null,
null,
null,
null,
null,
mockedOwnerCurator,
null,
null,
null,
null,
null,
null,
new CandlepinCommonTestConfig(),
null,
null,
null,
null,
productCurator,
manifestManager);
try {
consumerResource.dryBind(consumer.getUuid(), "some-sla");
fail("Should have thrown a BadRequestException.");
} catch (BadRequestException e) {
assertEquals("Owner has autobind disabled.", e.getMessage());
}
}
private void bindByPoolErrorTest(String msg) {
try {
String poolid = "pool10";
Pool pool = mock(Pool.class);
Map<String, ValidationResult> fakeResult = new HashMap<String, ValidationResult>();
fakeResult.put(poolid, fakeOutResult(msg));
EntitlementRefusedException ere = new EntitlementRefusedException(fakeResult);
when(pool.getId()).thenReturn(poolid);
when(poolCurator.find(eq(poolid))).thenReturn(pool);
Map<String, Integer> pQs = new HashMap<String, Integer>();
pQs.put(poolid, 1);
when(pm.entitleByPools(eq(consumer), eq(pQs))).thenThrow(ere);
entitler.bindByPoolQuantity(consumer, poolid, 1);
} catch (EntitlementRefusedException e) {
fail(msg + ": threw unexpected error");
}
}