@Test public void getError_returns_null_when_component_is_created() { assertThat(underTest.getError()).isNull(); }
void assertAfterOnSubscribeState(InnerOperator s) { assertThat(s.scan(Scannable.Attr.ERROR)).isNull(); assertThat(s.scan(Scannable.Attr.REQUESTED_FROM_DOWNSTREAM)).isEqualTo(1L); assertThat(s.scan(Scannable.Attr.TERMINATED)).isFalse(); assertThat(s.scanOrDefault(Scannable.Attr.CANCELLED, false)).isFalse(); }
@Test public void deserializeBadCredentialsExceptionMixinTest() throws IOException { BadCredentialsException exception = mapper.readValue(EXCEPTION_JSON, BadCredentialsException.class); assertThat(exception).isNotNull(); assertThat(exception.getCause()).isNull(); assertThat(exception.getMessage()).isEqualTo("message"); assertThat(exception.getLocalizedMessage()).isEqualTo("message"); } }
@Test public void cause() { IOException ioexception = new IOException("my exception"); IllegalStateException illegalStateException = new IllegalStateException(ioexception); RuntimeException runtimeException = new RuntimeException(illegalStateException); assertThat(ExceptionUtil.isCausedBy(runtimeException, IOException.class)).isTrue(); assertThat(ExceptionUtil.isCausedBy(runtimeException, IllegalStateException.class, IOException.class)).isTrue(); assertThat(ExceptionUtil.isCausedBy(runtimeException, Exception.class)).isTrue(); assertThat(ExceptionUtil.isCausedBy(runtimeException, IllegalAccessException.class)).isFalse(); assertThat(ExceptionUtil.findCause(runtimeException, IllegalStateException.class)).isSameAs(illegalStateException); assertThat(ExceptionUtil.findCause(runtimeException, IOException.class)).isSameAs(ioexception); assertThat(ExceptionUtil.findCause(runtimeException, UncheckedException.class)).isNull(); }
@Test public void immediateCancel() { AtomicReference<String> value = new AtomicReference<>(); AtomicReference<Throwable> error = new AtomicReference<>(); Disposable s = Flux.just("foo", "bar") .delayUntil(v -> Mono.just(1)) .subscribe(value::set, error::set, () -> {}, Subscription::cancel); assertThat(value.get()).isNull(); assertThat(error.get()).isNull(); //would be a NPE if trigger array wasn't pre-initialized }
@Test public void only_label() { ContextException e = ContextException.of(LABEL); assertThat(e.getMessage()).isEqualTo(LABEL); assertThat(e.getRawMessage()).isEqualTo(LABEL); assertThat(e.getCause()).isNull(); }
@Test public void scanProcessor() { FluxProcessor<String, String> test = DirectProcessor.<String>create().serialize(); assertThat(test.scan(Scannable.Attr.CAPACITY)).isEqualTo(16); assertThat(test.scan(Scannable.Attr.TERMINATED)).isFalse(); assertThat(test.scan(Scannable.Attr.ERROR)).isNull(); test.onError(new IllegalStateException("boom")); assertThat(test.scan(Scannable.Attr.ERROR)).hasMessage("boom"); assertThat(test.scan(Scannable.Attr.TERMINATED)).isTrue(); } }
@Test public void status_is_SUCCEEDED_and_failure_is_null_when_trigger_runs_without_an_exception() { underTest.startIt(); assertThat(migrationState.getStatus()).isEqualTo(DatabaseMigrationState.Status.SUCCEEDED); assertThat(migrationState.getError()).isNull(); assertThat(migrationState.getStartedAt()).isNotNull(); }
@Test public void scanProcessor() { WorkQueueProcessor<String> test = WorkQueueProcessor.create("name", 16); Subscription subscription = Operators.emptySubscription(); test.onSubscribe(subscription); Assertions.assertThat(test.scan(Scannable.Attr.PARENT)).isEqualTo(subscription); Assertions.assertThat(test.scan(Scannable.Attr.CAPACITY)).isEqualTo(16); Assertions.assertThat(test.scan(Scannable.Attr.TERMINATED)).isFalse(); Assertions.assertThat(test.scan(Scannable.Attr.ERROR)).isNull(); test.onError(new IllegalStateException("boom")); Assertions.assertThat(test.scan(Scannable.Attr.ERROR)).hasMessage("boom"); Assertions.assertThat(test.scan(Scannable.Attr.TERMINATED)).isTrue(); }
@Test public void onMonoRejectedDoOnErrorClazzNot() { Mono<String> mp = Mono.error(new TestException()); AtomicReference<Throwable> ref = new AtomicReference<>(); MonoProcessor<String> processor = mp.doOnError(RuntimeException.class, ref::set) .toProcessor(); processor.subscribe(); assertThat(processor.getError()).isInstanceOf(TestException.class); assertThat(ref.get()).isNull(); }
@Test public void scanSubscriptionError() { CoreSubscriber<Integer> subscriber = new LambdaSubscriber<>(null, e -> {}, null, null); FluxGenerate.GenerateSubscription<Integer, Integer> test = new FluxGenerate.GenerateSubscription<>(subscriber, 1, (s, o) -> null, s -> {}); test.error(new IllegalStateException("boom")); assertThat(test.scan(Scannable.Attr.TERMINATED)).isTrue(); assertThat(test.scan(Scannable.Attr.ERROR)).isNull(); }
@Test public void scanMainSubscriberError() { CoreSubscriber<? super Integer> subscriber = new LambdaSubscriber<>(null, e -> { }, null, sub -> sub.request(2)); MergeReduceMain<Integer> test = new MergeReduceMain<>(subscriber, 2, (a, b) -> a + b); subscriber.onSubscribe(test); assertThat(test.scan(Scannable.Attr.ERROR)).isNull(); test.innerError(new IllegalStateException("boom")); assertThat(test.scan(Scannable.Attr.ERROR)).hasMessage("boom"); }
@Test public void scanSubscription() { CoreSubscriber<Integer> subscriber = new LambdaSubscriber<>(null, e -> {}, null, null); FluxGenerate.GenerateSubscription<Integer, Integer> test = new FluxGenerate.GenerateSubscription<>(subscriber, 1, (s, o) -> null, s -> {}); assertThat(test.scan(Scannable.Attr.TERMINATED)).isFalse(); assertThat(test.scan(Scannable.Attr.CANCELLED)).isFalse(); assertThat(test.scan(Scannable.Attr.ACTUAL)).isSameAs(subscriber); test.request(5); assertThat(test.scan(Scannable.Attr.REQUESTED_FROM_DOWNSTREAM)).isEqualTo(5L); assertThat(test.scan(Scannable.Attr.ERROR)).isNull(); }
@Test public void scanSubscriberError() { CoreSubscriber<String> actual = new LambdaMonoSubscriber<>(null, e -> {}, null, null); MonoPublishOn.PublishOnSubscriber<String> test = new MonoPublishOn.PublishOnSubscriber<>( actual, Schedulers.single()); Assertions.assertThat(test.scan(Scannable.Attr.ERROR)).isNull(); test.onError(new IllegalStateException("boom")); Assertions.assertThat(test.scan(Scannable.Attr.ERROR)).hasMessage("boom"); }
@Test public void loadConfigWhenUserDetailsServiceHasCircularReferenceThenStillLoads() throws Exception { this.spring.register(RequiresUserDetailsServiceConfig.class, UserDetailsServiceConfig.class).autowire(); MyFilter myFilter = this.spring.getContext().getBean(MyFilter.class); Throwable thrown = catchThrowable(() -> myFilter.userDetailsService.loadUserByUsername("user") ); assertThat(thrown).isNull(); thrown = catchThrowable(() -> myFilter.userDetailsService.loadUserByUsername("admin") ); assertThat(thrown).isInstanceOf(UsernameNotFoundException.class); }
@Test public void scanSubscriberError() { BlockingIterable.SubscriberIterator<String> test = new BlockingIterable.SubscriberIterator<>( Queues.<String>one().get(), 123); IllegalStateException error = new IllegalStateException("boom"); assertThat(test.scan(Scannable.Attr.ERROR)).describedAs("before ERROR") .isNull(); test.onError(error); assertThat(test.scan(Scannable.Attr.ERROR)).describedAs("after ERROR") .isSameAs(error); assertThat(test.scan(Scannable.Attr.TERMINATED)).isTrue(); }
@Test public void successive_calls_to_startIt_reset_status_startedAt_and_failureError() { mockMigrationThrowsError(); underTest.startIt(); assertThat(migrationState.getStatus()).isEqualTo(DatabaseMigrationState.Status.FAILED); assertThat(migrationState.getError()).isSameAs(AN_ERROR); Date firstStartDate = migrationState.getStartedAt(); assertThat(firstStartDate).isNotNull(); mockMigrationDoesNothing(); underTest.startIt(); assertThat(migrationState.getStatus()).isEqualTo(DatabaseMigrationState.Status.SUCCEEDED); assertThat(migrationState.getError()).isNull(); assertThat(migrationState.getStartedAt()).isNotSameAs(firstStartDate); }
@Test public void scanMain() { Subscription s = Operators.emptySubscription(); test.onSubscribe(s); assertThat(test.scan(Scannable.Attr.PARENT)).describedAs("PARENT").isSameAs(s); assertThat(test.scan(Scannable.Attr.TERMINATED)).describedAs("TERMINATED").isFalse(); assertThat(test.scan(Scannable.Attr.CANCELLED)).describedAs("CANCELLED").isFalse(); assertThat(test.scan(Scannable.Attr.ERROR)).describedAs("ERROR").isNull(); assertThat(test.scan(Scannable.Attr.PREFETCH)).describedAs("PREFETCH").isEqualTo(Integer.MAX_VALUE); }
@Test public void doOnErrorPredicateNot() { AtomicReference<Throwable> ref = new AtomicReference<>(); StepVerifier.create(Flux.error(new TestException()) .doOnError(RuntimeException.class::isInstance, ref::set)) .thenAwait() .then(() -> assertThat(ref.get()) .isNull()) .verifyError(TestException.class); }
@Test public void scanBufferAsyncSink() { CoreSubscriber<String> actual = new LambdaSubscriber<>(null, e -> {}, null, null); BufferAsyncSink<String> test = new BufferAsyncSink<>(actual, 123); test.queue.offer("foo"); assertThat(test.scan(Scannable.Attr.BUFFERED)).isEqualTo(1); assertThat(test.scan(Scannable.Attr.TERMINATED)).isFalse(); assertThat(test.scan(Scannable.Attr.ERROR)).isNull(); test.error(new IllegalStateException("boom")); assertThat(test.scan(Scannable.Attr.TERMINATED)).isTrue(); assertThat(test.scan(Scannable.Attr.ERROR)).hasMessage("boom"); }