Examples with ParameterizedTestWithName reactor.test.ParameterizedTestWithName used on opensource projects

Example 16 with ParameterizedTestWithName

use of reactor.test.ParameterizedTestWithName in project reactor-core by reactor.

the class FluxCreateTest method secondOnCancelHandlerIsDisposedImmediately.

@ParameterizedTestWithName
@EnumSource(OverflowStrategy.class)
void secondOnCancelHandlerIsDisposedImmediately(OverflowStrategy overflowStrategy) {
    AtomicInteger firstDisposed = new AtomicInteger();
    AtomicInteger secondDisposed = new AtomicInteger();
    Flux.create(sink -> sink.onCancel(firstDisposed::incrementAndGet).onCancel(secondDisposed::incrementAndGet), overflowStrategy).subscribe();
    assertThat(firstDisposed).as("first handler for %s", overflowStrategy).hasValue(0);
    assertThat(secondDisposed).as("second handler for %s", overflowStrategy).hasValue(1);
}

Example 17 with ParameterizedTestWithName

use of reactor.test.ParameterizedTestWithName in project reactor-core by reactor.

the class FluxUsingWhenTest method cancelDefaultHandlerFailure.

@ParameterizedTestWithName
@MethodSource("sources01")
@Deprecated
public void cancelDefaultHandlerFailure(Flux<String> source) {
    TestResource testResource = new TestResource();
    final TestLogger tl = new TestLogger();
    Loggers.useCustomLoggers(name -> tl);
    try {
        Function<TestResource, Publisher<?>> completeOrCancel = r -> {
            return r.commit().concatWith(Mono.error(new IllegalStateException("commit error")));
        };
        Flux<String> test = Flux.usingWhen(Mono.just(testResource), tr -> source, completeOrCancel, (r, e) -> r.rollback(new RuntimeException("placeholder ignored rollback exception")), completeOrCancel).take(2);
        StepVerifier.create(test).expectNext("0", "1").verifyComplete();
        testResource.commitProbe.assertWasSubscribed();
        testResource.cancelProbe.assertWasNotSubscribed();
        testResource.rollbackProbe.assertWasNotSubscribed();
    } finally {
        Loggers.resetLoggerFactory();
    }
    assertThat(tl.getErrContent()).contains("Async resource cleanup failed after cancel").contains("java.lang.IllegalStateException: commit error");
}

Example 18 with ParameterizedTestWithName

use of reactor.test.ParameterizedTestWithName in project reactor-core by reactor.

the class FluxUsingWhenTest method cancelWithHandlerGenerationFailureLogs.

@ParameterizedTestWithName
@MethodSource("sources01")
public void cancelWithHandlerGenerationFailureLogs(Flux<String> source) throws InterruptedException {
    TestLogger tl = new TestLogger();
    Loggers.useCustomLoggers(name -> tl);
    TestResource testResource = new TestResource();
    try {
        Flux<String> test = Flux.usingWhen(Mono.just(testResource), tr -> source, TestResource::commit, TestResource::rollback, r -> null).take(2);
        StepVerifier.create(test).expectNext("0", "1").verifyComplete();
        testResource.commitProbe.assertWasNotSubscribed();
        testResource.cancelProbe.assertWasNotSubscribed();
        testResource.rollbackProbe.assertWasNotSubscribed();
    } finally {
        Loggers.resetLoggerFactory();
    }
    assertThat(tl.getErrContent()).contains("Error generating async resource cleanup during onCancel").contains("java.lang.NullPointerException");
}

Example 19 with ParameterizedTestWithName

use of reactor.test.ParameterizedTestWithName in project reactor-core by reactor.

the class InternalOneSinkTest method shouldDelegateToHandler.

@ParameterizedTestWithName
@EnumSource(value = Sinks.EmitResult.class)
void shouldDelegateToHandler(EmitResult emitResult) {
    assumeThat(emitResult.isFailure()).isTrue();
    Sinks.One<Object> sink = new InternalOneSinkAdapter<Object>() {

        @Override
        public Sinks.EmitResult tryEmitValue(Object value) {
            return emitResult;
        }

        @Override
        public Sinks.EmitResult tryEmitError(Throwable error) {
            return emitResult;
        }

        @Override
        public Sinks.EmitResult tryEmitEmpty() {
            return emitResult;
        }
    };
    for (SignalType signalType : new SignalType[] { SignalType.ON_NEXT, SignalType.ON_ERROR, SignalType.ON_COMPLETE }) {
        AtomicReference<Sinks.EmitResult> emissionRef = new AtomicReference<>();
        try {
            EmitFailureHandler handler = (failedSignalType, failedEmission) -> {
                emissionRef.set(failedEmission);
                return false;
            };
            switch(signalType) {
                case ON_NEXT:
                    sink.emitValue("Hello", handler);
                    break;
                case ON_ERROR:
                    sink.emitError(new Exception("boom"), handler);
                    break;
                case ON_COMPLETE:
                    sink.emitEmpty(handler);
                    break;
                default:
                    throw new IllegalStateException();
            }
        } catch (EmissionException e) {
            assertThat(e.getReason()).isEqualTo(Sinks.EmitResult.FAIL_NON_SERIALIZED);
        }
        assertThat(emissionRef).as("emitResult").hasValue(emitResult);
    }
}

Example 20 with ParameterizedTestWithName

use of reactor.test.ParameterizedTestWithName in project reactor-core by reactor.

the class InternalManySinkTest method shouldDelegateToHandler.

@ParameterizedTestWithName
@EnumSource(value = Sinks.EmitResult.class)
void shouldDelegateToHandler(Sinks.EmitResult emitResult) {
    assumeThat(emitResult.isFailure()).isTrue();
    Sinks.Many<Object> sink = new InternalManySinkAdapter<Object>() {

        @Override
        public EmitResult tryEmitNext(Object o) {
            return emitResult;
        }

        @Override
        public Sinks.EmitResult tryEmitError(Throwable error) {
            return emitResult;
        }

        @Override
        public EmitResult tryEmitComplete() {
            return emitResult;
        }
    };
    for (SignalType signalType : new SignalType[] { SignalType.ON_NEXT, SignalType.ON_ERROR, SignalType.ON_COMPLETE }) {
        AtomicReference<EmitResult> emissionRef = new AtomicReference<>();
        try {
            EmitFailureHandler handler = (failedSignalType, failedEmission) -> {
                emissionRef.set(failedEmission);
                return false;
            };
            switch(signalType) {
                case ON_NEXT:
                    sink.emitNext("Hello", handler);
                    break;
                case ON_ERROR:
                    sink.emitError(new Exception("boom"), handler);
                    break;
                case ON_COMPLETE:
                    sink.emitComplete(handler);
                    break;
                default:
                    throw new IllegalStateException();
            }
        } catch (EmissionException e) {
            assertThat(e.getReason()).isEqualTo(EmitResult.FAIL_NON_SERIALIZED);
        }
        assertThat(emissionRef).as("emitResult").hasValue(emitResult);
    }
}