@Override protected Publisher<Void> handle(Flux<InstanceEvent> publisher) { return publisher.subscribeOn(Schedulers.newSingle("notifications")).flatMap(this::sendNotifications); }
@Override protected Publisher<Void> handle(Flux<InstanceEvent> publisher) { return publisher.subscribeOn(Schedulers.newSingle("info-updater")) .filter(event -> event instanceof InstanceEndpointsDetectedEvent || event instanceof InstanceStatusChangedEvent || event instanceof InstanceRegistrationUpdatedEvent) .flatMap(this::updateInfo); }
@Override protected Publisher<Void> handle(Flux<InstanceEvent> publisher) { return publisher.subscribeOn(Schedulers.newSingle("endpoint-detector")) .filter(event -> event instanceof InstanceStatusChangedEvent || event instanceof InstanceRegistrationUpdatedEvent) .flatMap(this::detectEndpoints); }
@Override public void start() { super.start(); intervalSubscription = Flux.interval(updateInterval) .doOnSubscribe(s -> log.debug("Scheduled status update every {}", updateInterval)) .log(log.getName(), Level.FINEST) .subscribeOn(Schedulers.newSingle("status-monitor")) .concatMap(i -> this.updateStatusForAllInstances()) .onErrorContinue((ex, value) -> log.warn("Unexpected error while updating statuses", ex )) .subscribe(); }
@Override protected Publisher<Void> handle(Flux<InstanceEvent> publisher) { return publisher.subscribeOn(Schedulers.newSingle("status-updater")) .filter(event -> event instanceof InstanceRegisteredEvent || event instanceof InstanceRegistrationUpdatedEvent) .flatMap(event -> updateStatus(event.getInstance())); }
@Test(expected = RuntimeException.class) public void blockingLastError2() { Flux.defer(() -> Mono.error(new RuntimeException("test"))) .subscribeOn(scheduler) .blockLast(Duration.ofSeconds(1)); }
@Test public void callableThrows() { StepVerifier.create(Mono.fromCallable(() -> { throw new IOException("forced failure"); }) .flux() .subscribeOn(Schedulers.single())) .expectErrorMatches(e -> e instanceof IOException && e.getMessage().equals("forced failure")) .verify(); }
@Test public void callableReturnsNull() { StepVerifier.create(Mono.empty() .flux() .subscribeOn(Schedulers.single())) .verifyComplete(); }
@Test public void callableReturnsNullFused() { StepVerifier.create(Mono.empty() .flux() .subscribeOn(Schedulers.single())) .expectFusion(Fuseable.ASYNC) .verifyComplete(); }
@Test public void scanOperator() { final Flux<Integer> test = Flux.just(1).subscribeOn(Schedulers.immediate()); assertThat(test).isInstanceOf(Scannable.class) .isInstanceOf(FluxSubscribeOnValue.class); assertThat(((Scannable) test).scan(Scannable.Attr.RUN_ON)).isSameAs(Schedulers.immediate()); }
@Test public void assertNextWithSubscribeOnJust() { assertThatExceptionOfType(AssertionError.class) .isThrownBy( StepVerifier.create(Flux.just(1) .subscribeOn(Schedulers.newSingle("test"))) .then(() -> System.out.println("foo")) .assertNext(v -> assertThat(v).isNull()) .thenCancel() ::verify); }
@Test public void callableReturnsNull3() { StepVerifier.create(Mono.fromCallable(() -> null) .flux() .subscribeOn(Schedulers.single()), 1) .verifyComplete(); }
@Test public void callableReturnsNull2() { StepVerifier.create(Mono.fromCallable(() -> null) .flux() .subscribeOn(Schedulers.single()), 0) .verifyComplete(); }
@Test public void callableReturnsNullFused2() { StepVerifier.create(Mono.fromCallable(() -> null) .flux() .subscribeOn(Schedulers.single()) .doOnNext(v -> System.out.println(v)), 1) .expectFusion(Fuseable.ASYNC) .thenRequest(1) .verifyComplete(); }
@Test public void classic() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); Flux.range(1, 1000).subscribeOn(Schedulers.fromExecutorService(ForkJoinPool.commonPool())).subscribe(ts); ts.await(Duration.ofSeconds(5)); ts.assertValueCount(1000) .assertNoError() .assertComplete(); }
@Test public void classicEmptyBackpressured() throws Exception { AssertSubscriber<Integer> ts = AssertSubscriber.create(0); Flux.<Integer>empty().subscribeOn(Schedulers.fromExecutorService(ForkJoinPool.commonPool())).subscribe(ts); ts.await(Duration.ofSeconds(5)); ts.assertNoValues() .assertNoError() .assertComplete(); }
@Test public void callableReturnsNullFused3() { StepVerifier.create(Mono.fromCallable(() -> null) .flux() .subscribeOn(Schedulers.single()), 0) .expectFusion(Fuseable.ASYNC) .verifyComplete(); }
@Test public void normal() { StepVerifier.create(Mono.fromCallable(() -> 1) .flux() .subscribeOn(Schedulers.single())) .expectNext(1) .expectComplete() .verify(); }
@Test public void normalFused() { StepVerifier.create(Mono.fromCallable(() -> 1) .flux() .subscribeOn(Schedulers.single())) .expectFusion(Fuseable.ASYNC) .expectNext(1) .expectComplete() .verify(); }
@Test public void normalBackpressuredFusedCancelled() { StepVerifier.withVirtualTime(() -> Mono.fromCallable(() -> 1) .flux() .subscribeOn( Schedulers.single()), 0) .expectFusion(Fuseable.ASYNC) .thenAwait() .thenCancel() .verify(); }