@Override protected Scheduler scheduler() { return Schedulers.newSingle("TimedSchedulerTest"); }
@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); }
public void start() { this.subscription = Flux.interval(this.checkReminderInverval, Schedulers.newSingle("reminders")) .log(log.getName(), Level.FINEST) .doOnSubscribe(s -> log.debug("Started reminders")) .flatMap(i -> this.sendReminders()) .onErrorContinue((ex, value) -> log.warn( "Unexpected error while sending reminders", ex )) .subscribe(); }
@Override protected Scheduler scheduler() { return Schedulers.single(Schedulers.newSingle("singleWorkerTimer")); }
@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 public void testDispatch() throws Exception { Scheduler service = Schedulers.newSingle(r -> { Thread t = new Thread(r, "dispatcher"); t.setUncaughtExceptionHandler((t1, e) -> exceptionThrown.set(e)); return t; }); service.dispose(); }
@BeforeClass public static void before() { scheduler = Schedulers.fromExecutorService(Executors.newSingleThreadExecutor()); nonBlockingScheduler = Schedulers.newSingle("nonBlockingScheduler"); }
@Test public void testRejectingSingleScheduler() { assertRejectingScheduler(Schedulers.newSingle("test")); }
@Test public void schedulerDecoratorEmptyDecorators() { assertThat(Schedulers.DECORATORS).isEmpty(); assertThatCode(() -> Schedulers.newSingle("foo").dispose()) .doesNotThrowAnyException(); }
@Test public void rejectedOnNextLeadsToOnError() { Scheduler scheduler = Schedulers.newSingle("rejectedOnNextLeadsToOnError"); scheduler.dispose(); StepVerifier.create(Flux.just(1, 2, 3) .bufferTimeout(4, Duration.ofMillis(500), scheduler)) .expectError(RejectedExecutionException.class) .verify(Duration.ofSeconds(1)); }
@Test public void discardOnTimerRejected() { Scheduler scheduler = Schedulers.newSingle("discardOnTimerRejected"); StepVerifier.create(Flux.just(1, 2, 3) .doOnNext(n -> scheduler.dispose()) .bufferTimeout(10, Duration.ofMillis(100), scheduler)) .expectErrorSatisfies(e -> assertThat(e).isInstanceOf(RejectedExecutionException.class)) .verifyThenAssertThat() .hasDiscardedExactly(1); }
@Test public void testOverride() throws InterruptedException { TestSchedulers ts = new TestSchedulers(true); Schedulers.setFactory(ts); Assert.assertEquals(ts.single, Schedulers.newSingle("unused")); Assert.assertEquals(ts.elastic, Schedulers.newElastic("unused")); Assert.assertEquals(ts.parallel, Schedulers.newParallel("unused")); Schedulers.resetFactory(); Scheduler s = Schedulers.newSingle("unused"); s.dispose(); Assert.assertNotSame(ts.single, s); }
@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 discardPollAsyncPredicateFail() { StepVerifier.create(Flux.just(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) //range uses tryOnNext, so let's use just instead .publishOn(Schedulers.newSingle("discardPollAsync"), 1) .filter(i -> { throw new IllegalStateException("boom"); }) ) .expectFusion(Fuseable.ASYNC) .expectErrorMessage("boom") .verifyThenAssertThat() .hasDiscarded(1); //publishOn also might discard the rest }
@Test public void discardConditionalPollAsyncPredicateFail() { StepVerifier.create(Flux.range(1, 10) //range uses tryOnNext, so let's use just instead .publishOn(Schedulers.newSingle("discardPollAsync")) .filter(i -> { throw new IllegalStateException("boom"); }) .filter(i -> true) ) .expectFusion(Fuseable.ASYNC) .expectErrorMessage("boom") .verifyThenAssertThat() .hasDiscarded(1); //publishOn also discards the rest }
@Test public void discardPollAsyncPredicateMiss() { StepVerifier.create(Flux.just(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) //range uses tryOnNext, so let's use just instead .publishOn(Schedulers.newSingle("discardPollAsync")) .filter(i -> i % 2 == 0) ) .expectFusion(Fuseable.ASYNC) .expectNextCount(5) .expectComplete() .verifyThenAssertThat() .hasDiscardedExactly(1, 3, 5, 7, 9); }
@Test public void discardConditionalPollAsyncPredicateMiss() { StepVerifier.create(Flux.just(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) //range uses tryOnNext, so let's use just instead .publishOn(Schedulers.newSingle("discardPollAsync")) .filter(i -> i % 2 == 0) .filter(i -> true) ) .expectFusion(Fuseable.ASYNC) .expectNextCount(5) .expectComplete() .verifyThenAssertThat() .hasDiscardedExactly(1, 3, 5, 7, 9); }