@Override public final void onComplete() { onNext(null); }
private void handleOnComplete() { if (!this.content.isTerminated()) { byte[] bytes = new byte[this.buffer.readableByteCount()]; this.buffer.read(bytes); this.content.onNext(bytes); } } }
@Test public void testMono() throws Exception { MonoProcessor<String> promise = MonoProcessor.create(); promise.onNext("test"); final CountDownLatch successCountDownLatch = new CountDownLatch(1); promise.subscribe(v -> successCountDownLatch.countDown()); assertThat("Failed", successCountDownLatch.await(10, TimeUnit.SECONDS)); }
@Test public void MonoProcessorSuccessDoOnTerminate() { MonoProcessor<String> mp = MonoProcessor.create(); AtomicInteger invoked = new AtomicInteger(); mp.doOnTerminate(invoked::incrementAndGet).subscribe(); mp.onNext("test"); assertThat(invoked.get()).isEqualTo(1); assertThat(mp.isSuccess()).isTrue(); assertThat(mp.isError()).isFalse(); }
@Test public void resolveWithMono() { BindingResult bindingResult = createBindingResult(new Foo(), "foo"); MonoProcessor<BindingResult> monoProcessor = MonoProcessor.create(); monoProcessor.onNext(bindingResult); this.bindingContext.getModel().asMap().put(BindingResult.MODEL_KEY_PREFIX + "foo", monoProcessor); MethodParameter parameter = this.testMethod.arg(Errors.class); Object actual = this.resolver.resolveArgument(parameter, this.bindingContext, this.exchange) .block(Duration.ofMillis(5000)); assertSame(bindingResult, actual); }
@Test public void MonoProcessorSuccessSubscribeCallback() { MonoProcessor<String> mp = MonoProcessor.create(); AtomicReference<String> ref = new AtomicReference<>(); mp.subscribe(ref::set); mp.onNext("test"); assertThat(ref.get()).isEqualToIgnoringCase("test"); assertThat(mp.isSuccess()).isTrue(); assertThat(mp.isError()).isFalse(); }
model.put(BindingResult.MODEL_KEY_PREFIX + name, errors); model.put(name, value); bindingResultMono.onNext(errors); }) .then(Mono.fromCallable(() -> {
@Test public void MonoProcessorSuccessDoOnSuccess() { MonoProcessor<String> mp = MonoProcessor.create(); AtomicReference<String> ref = new AtomicReference<>(); mp.doOnSuccess(ref::set).subscribe(); mp.onNext("test"); assertThat(ref.get()).isEqualToIgnoringCase("test"); assertThat(mp.isSuccess()).isTrue(); assertThat(mp.isError()).isFalse(); }
@Test(expected = Exception.class) public void MonoProcessorDoubleSignal() { MonoProcessor<String> mp = MonoProcessor.create(); mp.onNext("test"); mp.onError(new Exception("test")); }
@Test public void MonoProcessorNullFulfill() { MonoProcessor<String> mp = MonoProcessor.create(); mp.onNext(null); assertThat(mp.isTerminated()).isTrue(); assertThat(mp.isSuccess()).isTrue(); assertThat(mp.peek()).isNull(); }
@Test public void MonoProcessorThenFulfill() { MonoProcessor<Integer> mp = MonoProcessor.create(); mp.onNext(1); MonoProcessor<Integer> mp2 = mp.flatMap(s -> Mono.just(s * 2)) .toProcessor(); mp2.subscribe(); assertThat(mp2.isTerminated()).isTrue(); assertThat(mp2.isSuccess()).isTrue(); assertThat(mp2.peek()).isEqualTo(2); }
@Override public Mono<ClientHttpResponse> connect(HttpMethod httpMethod, URI uri, Function<? super ClientHttpRequest, Mono<Void>> requestCallback) { MonoProcessor<ClientHttpResponse> result = MonoProcessor.create(); MockClientHttpRequest mockClientRequest = new MockClientHttpRequest(httpMethod, uri); MockServerHttpResponse mockServerResponse = new MockServerHttpResponse(); mockClientRequest.setWriteHandler(requestBody -> { log("Invoking HttpHandler for ", httpMethod, uri); ServerHttpRequest mockServerRequest = adaptRequest(mockClientRequest, requestBody); ServerHttpResponse responseToUse = prepareResponse(mockServerResponse, mockServerRequest); this.handler.handle(mockServerRequest, responseToUse).subscribe(aVoid -> {}, result::onError); return Mono.empty(); }); mockServerResponse.setWriteHandler(responseBody -> Mono.fromRunnable(() -> { log("Creating client response for ", httpMethod, uri); result.onNext(adaptResponse(mockServerResponse, responseBody)); })); log("Writing client request for ", httpMethod, uri); requestCallback.apply(mockClientRequest).subscribe(aVoid -> {}, result::onError); return result; }
@Test public void MonoProcessorMapFulfill() { MonoProcessor<Integer> mp = MonoProcessor.create(); mp.onNext(1); MonoProcessor<Integer> mp2 = mp.map(s -> s * 2) .toProcessor(); mp2.subscribe(); assertThat(mp2.isTerminated()).isTrue(); assertThat(mp2.isSuccess()).isTrue(); assertThat(mp2.peek()).isEqualTo(2); }
@Test public void MonoProcessorSuccessChainTogether() { MonoProcessor<String> mp = MonoProcessor.create(); MonoProcessor<String> mp2 = MonoProcessor.create(); mp.subscribe(mp2); mp.onNext("test"); assertThat(mp2.peek()).isEqualToIgnoringCase("test"); assertThat(mp.isSuccess()).isTrue(); assertThat(mp.isError()).isFalse(); }
@Test public void deferredResultSubscriberWithOneValue() throws Exception { // Mono MonoProcessor<String> mono = MonoProcessor.create(); testDeferredResultSubscriber(mono, Mono.class, forClass(String.class), () -> mono.onNext("foo"), "foo"); // Mono empty MonoProcessor<String> monoEmpty = MonoProcessor.create(); testDeferredResultSubscriber(monoEmpty, Mono.class, forClass(String.class), monoEmpty::onComplete, null); // RxJava 1 Single AtomicReference<SingleEmitter<String>> ref = new AtomicReference<>(); Single<String> single = Single.fromEmitter(ref::set); testDeferredResultSubscriber(single, Single.class, forClass(String.class), () -> ref.get().onSuccess("foo"), "foo"); // RxJava 2 Single AtomicReference<io.reactivex.SingleEmitter<String>> ref2 = new AtomicReference<>(); io.reactivex.Single<String> single2 = io.reactivex.Single.create(ref2::set); testDeferredResultSubscriber(single2, io.reactivex.Single.class, forClass(String.class), () -> ref2.get().onSuccess("foo"), "foo"); }
@Test public void filterMonoProcessorNot() { MonoProcessor<Integer> mp = MonoProcessor.create(); MonoProcessor<Integer> mp2 = MonoProcessor.create(); StepVerifier.create(mp.filter(s -> s % 2 == 0).subscribeWith(mp2)) .then(() -> mp.onNext(1)) .then(() -> assertThat(mp2.isError()).isFalse()) .then(() -> assertThat(mp2.isSuccess()).isTrue()) .then(() -> assertThat(mp2.peek()).isNull()) .then(() -> assertThat(mp2.isTerminated()).isTrue()) .verifyComplete(); }
@Test public void wrapToFlux(){ MonoProcessor<String> mp = MonoProcessor.create(); mp.onNext("test"); StepVerifier.create(Flux.from(mp)) .expectNext("test") .verifyComplete(); }
@Test @SuppressWarnings({ "unchecked", "rawtypes" }) public void monoSuccess() { Message emptyMessage = MessageBuilder.withPayload(new byte[0]).build(); given(this.channel.send(any(Message.class))).willReturn(true); given(this.converter.toMessage(any(), any(MessageHeaders.class))).willReturn(emptyMessage); ReactiveController controller = new ReactiveController(); this.messageHandler.registerHandler(controller); this.messageHandler.setDestinationPrefixes(Arrays.asList("/app1", "/app2/")); Message<?> message = createMessage("/app1/mono"); this.messageHandler.handleMessage(message); assertNotNull(controller.mono); controller.mono.onNext("foo"); verify(this.converter).toMessage(this.payloadCaptor.capture(), any(MessageHeaders.class)); assertEquals("foo", this.payloadCaptor.getValue()); }
@Test public void asyncFusion() { AssertSubscriber<Object> ts = AssertSubscriber.create(); MonoProcessor<Integer> up = MonoProcessor.create(); up.filter(v -> (v & 1) == 0) .subscribe(ts); up.onNext(2); up.onComplete(); ts.assertValues(2) .assertNoError() .assertComplete(); }