/** * Creates a QBit callback based on promise created. * * @param promiseConsumer promise consumer * @param <T> T * @return QBit callback */ public <T> Callback<T> callback(final Consumer<Promise<T>> promiseConsumer) { Promise<T> promise = reactor.promise(); promiseConsumer.accept(promise); return Reakt.convertPromise(promise); }
@Test public void utilityMethod() { Promise promise; promise = reactor.promiseNotify(); assertTrue(promise instanceof ReplayPromise); promise = reactor.promise(Employee.class); assertTrue(promise instanceof ReplayPromise); promise = reactor.promiseString(); assertTrue(promise instanceof ReplayPromise); promise = reactor.promiseBoolean(); assertTrue(promise instanceof ReplayPromise); promise = reactor.promiseLong(); assertTrue(promise instanceof ReplayPromise); promise = reactor.promiseInt(); assertTrue(promise instanceof ReplayPromise); promise = reactor.promiseFloat(); assertTrue(promise instanceof ReplayPromise); promise = reactor.promiseDouble(); assertTrue(promise instanceof ReplayPromise); promise = reactor.promiseList(Employee.class); assertTrue(promise instanceof ReplayPromise); promise = reactor.promiseSet(Employee.class); assertTrue(promise instanceof ReplayPromise); promise = reactor.promiseCollection(Employee.class); assertTrue(promise instanceof ReplayPromise); promise = reactor.promiseMap(String.class, Employee.class); assertTrue(promise instanceof ReplayPromise); }
@Override public PromiseHandler<T> invokeWithReactor(final Reactor reactor, Duration timeout) { final BasePromise<T> reactorPromise = (BasePromise<T>) reactor.promise(timeout); copyPromiseFieldsToReactorPromise(reactorPromise); return this; }
@Override public PromiseHandler<T> invokeWithReactor(final Reactor reactor) { final BasePromise<T> reactorPromise = (BasePromise<T>) reactor.promise(); copyPromiseFieldsToReactorPromise(reactorPromise); return this; }
@Override public PromiseHandler<T> invokeWithReactor(final Reactor reactor, Duration timeout) { final BasePromise<T> reactorPromise = (BasePromise<T>) reactor.promise(timeout); copyPromiseFieldsToReactorPromise(reactorPromise); return this; }
@Override public PromiseHandler<T> invokeWithReactor(final Reactor reactor) { final BasePromise<T> reactorPromise = (BasePromise<T>) reactor.promise(); copyPromiseFieldsToReactorPromise(reactorPromise); return this; }
@Test public void normalNullCall() { final AtomicBoolean errorFound = new AtomicBoolean(); final AtomicBoolean thenCalled = new AtomicBoolean(); final Promise<Object> promise = reactor.promise(Duration.ofSeconds(1)) .catchError(error -> errorFound.set(true)) .then(object -> thenCalled.set(true)); reactor.process(); assertTrue(!errorFound.get()); //No errors. assertTrue(!thenCalled.get()); //Then should still not be called promise.asHandler().resolve(null); reactor.process(); assertTrue(!errorFound.get()); //No errors. assertTrue(thenCalled.get()); //Then should be called }
@Test public void testTimeout() { final AtomicBoolean errorFound = new AtomicBoolean(); final AtomicBoolean thenCalled = new AtomicBoolean(); final Promise<Object> promise = reactor.promise(Duration.ofSeconds(1)) .catchError(error -> errorFound.set(true)) .then(object -> thenCalled.set(true)); reactor.process(); //Force a timeout. assertTrue(!errorFound.get()); //No errors yet. testTimer.setTime(System.currentTimeMillis() + Duration.ofSeconds(30).toMillis()); reactor.process(); assertTrue(errorFound.get()); //Now we should have an error assertTrue(!thenCalled.get()); //Then should not be called promise.asHandler().resolve(new Object()); reactor.process(); assertTrue(!thenCalled.get()); //Then should still not be called }
@Test public void normalCall() { final AtomicBoolean errorFound = new AtomicBoolean(); final AtomicBoolean thenCalled = new AtomicBoolean(); final Promise<Object> promise = reactor.promise(Duration.ofSeconds(1)) .catchError(error -> errorFound.set(true)) .then(object -> thenCalled.set(true)); reactor.process(); assertTrue(!errorFound.get()); //No errors. assertTrue(!thenCalled.get()); //Then should still not be called promise.asHandler().resolve(new Object()); reactor.process(); assertTrue(!errorFound.get()); //No errors. assertTrue(thenCalled.get()); //Then should be called }
@Test public void testAllList() { AtomicBoolean thenCalled = new AtomicBoolean(); Promise<String> promise1 = reactor.promise(); Promise<String> promise2 = reactor.promise(); final Promise<Void> promise = reactor.all(Arrays.asList(promise1, promise2)); promise.then(s -> thenCalled.set(true)); assertFalse(promise.asHandler().complete()); reactor.process(); assertFalse(promise.asHandler().complete()); /** Invoke the callback. */ promise1.asHandler().resolve("DONE"); promise2.asHandler().resolve("DONE"); reactor.process(); //play it /** You can see the results but the events wont fire until reactor plays the replay promises. */ assertTrue(promise.asHandler().complete()); assertTrue(promise.asHandler().success()); /** Now we see the event. */ assertTrue(thenCalled.get()); }
@Test public void testAnyList() { AtomicBoolean thenCalled = new AtomicBoolean(); Promise<String> promise1 = reactor.promise(); Promise<String> promise2 = reactor.promise(); final Promise<Void> promise = reactor.any(Arrays.asList(promise1, promise2)); promise.then(s -> thenCalled.set(true)); assertFalse(promise.asHandler().complete()); reactor.process(); assertFalse(promise.asHandler().complete()); /** Invoke the callback. */ promise1.asHandler().resolve("DONE"); promise2.asHandler().resolve("DONE"); reactor.process(); //play it /** You can see the results but the events wont fire until reactor plays the replay promises. */ assertTrue(promise.asHandler().complete()); assertTrue(promise.asHandler().success()); /** Now we see the event. */ assertTrue(thenCalled.get()); }
@Test public void testAll() { AtomicInteger thenCalled = new AtomicInteger(); Promise<String> promise1 = reactor.promise(); Promise<String> promise2 = reactor.promise(); final Promise<Void> promise = reactor.all(promise1, promise2); promise.then(s -> thenCalled.incrementAndGet()); assertFalse(promise.asHandler().complete()); reactor.process(); assertFalse(promise.asHandler().complete()); /** Invoke the callback. */ promise1.asHandler().resolve("DONE"); promise2.asHandler().resolve("DONE"); reactor.process(); //play it /** You can see the results but the events wont fire until reactor plays the replay promises. */ assertTrue(promise.asHandler().complete()); assertTrue(promise.asHandler().success()); /** Now we see the event. */ assertEquals(1, thenCalled.get()); }
@Test public void testAny() { AtomicBoolean thenCalled = new AtomicBoolean(); Promise<String> promise1 = reactor.promise(); Promise<String> promise2 = reactor.promise(); final Promise<Void> promise = reactor.any(promise1, promise2); promise.then(s -> thenCalled.set(true)); assertFalse(promise.asHandler().complete()); reactor.process(); assertFalse(promise.asHandler().complete()); /** Invoke the callback. */ promise1.asHandler().resolve("DONE"); promise2.asHandler().resolve("DONE"); reactor.process(); //play it /** You can see the results but the events wont fire until reactor plays the replay promises. */ assertTrue(promise.asHandler().complete()); assertTrue(promise.asHandler().success()); /** Now we see the event. */ assertTrue(thenCalled.get()); }
@Test public void testOnePromise() { AtomicBoolean thenCalled = new AtomicBoolean(); Promise<String> promise = reactor.promise(); promise.then(s -> thenCalled.set(true)); assertFalse(promise.asHandler().complete()); reactor.process(); assertFalse(promise.asHandler().complete()); /** Invoke the callback. */ promise.asHandler().resolve("DONE"); /** You can see the results but the events wont fire until reactor plays the replay promises. */ assertTrue(promise.asHandler().complete()); assertTrue(promise.asHandler().success()); assertEquals("DONE", promise.asHandler().get()); /* We don't see the then(..) event yet because it won't fire until we play it. */ assertFalse(thenCalled.get()); reactor.process(); //play it /** Now we see the event. */ assertTrue(thenCalled.get()); }