Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Use Named.of to describe parameterized tests input #2801

Merged
merged 1 commit into from
Oct 4, 2021
Merged

Use Named.of to describe parameterized tests input #2801

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
79 changes: 40 additions & 39 deletions reactor-core/src/test/java/reactor/core/publisher/FluxDoOnEachTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -24,8 +24,10 @@
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.LongAdder;
import java.util.function.Function;
import java.util.stream.Stream;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import org.reactivestreams.Subscription;

Expand All @@ -45,6 +47,8 @@
import reactor.util.context.Context;

import static org.assertj.core.api.Assertions.*;
import static org.junit.jupiter.api.Named.named;
import static org.junit.jupiter.params.provider.Arguments.arguments;

public class FluxDoOnEachTest {

Expand All @@ -57,48 +61,45 @@ public void nullSource() {

private static final String sourceErrorMessage = "boomSource";

private static Object[] sourcesError() {
return new Object[] {
new Object[] { Flux.<Integer>error(new IllegalStateException(sourceErrorMessage))
.hide() },
new Object[] { Flux.<Integer>error(new IllegalStateException(sourceErrorMessage))
.hide().filter(i -> true) },
new Object[] { Flux.<Integer>error(new IllegalStateException(sourceErrorMessage)) },
new Object[] { Flux.<Integer>error(new IllegalStateException(sourceErrorMessage))
.filter(i -> true) }
};
private static Stream<Arguments> sourcesError() {
return Stream.of(
arguments(named("error", Flux.<Integer>error(new IllegalStateException(sourceErrorMessage)).hide())),
arguments(named("error (fusion)", Flux.<Integer>error(new IllegalStateException(sourceErrorMessage)))),
arguments(named("error (conditional)", Flux.<Integer>error(new IllegalStateException(sourceErrorMessage)).hide().filter(i -> true))),
arguments(named("error (fusion+conditional)", Flux.<Integer>error(new IllegalStateException(sourceErrorMessage)).filter(i -> true)))
);
}

private static Object[] sources12Complete() {
return new Object[] {
new Object[] { Flux.just(1,2).hide() },
new Object[] { Flux.just(1,2).hide().filter(i -> true) },
new Object[] { Flux.just(1,2) },
new Object[] { Flux.just(1,2).filter(i -> true) }
};
private static Stream<Arguments> sources12Complete() {
return Stream.of(
arguments(named("just(1,2)", Flux.just(1,2).hide())),
arguments(named("just(1,2) (conditional)", Flux.just(1,2).hide().filter(i -> true))),
arguments(named("just(1,2) (fusion)", Flux.just(1,2))),
arguments(named("just(1,2) (fusion+conditional)", Flux.just(1,2).filter(i -> true)))
);
}

private static Object[] sourcesEmpty() {
return new Object[] {
new Object[] { Flux.<Integer>empty().hide() },
new Object[] { Flux.<Integer>empty().hide().filter(i -> true) },
new Object[] { Flux.<Integer>empty() },
new Object[] { Flux.<Integer>empty().filter(i -> true) }
};
private static Stream<Arguments> sourcesEmpty() {
return Stream.of(
arguments(named("empty", Flux.<Integer>empty().hide())),
arguments(named("empty (conditional)", Flux.<Integer>empty().hide().filter(i -> true))),
arguments(named("empty (fusion)", Flux.<Integer>empty())),
arguments(named("empty (fusion+conditional)", Flux.<Integer>empty().filter(i -> true)))
);
}

private static Object[] sourcesNever() {
return new Object[] {
new Object[] { Flux.<Integer>never().hide() },
new Object[] { Flux.<Integer>never().hide().filter(i -> true) },
new Object[] { Flux.<Integer>never() },
new Object[] { Flux.<Integer>never().filter(i -> true) }
};
private static Stream<Arguments> sourcesNever() {
return Stream.of(
arguments(named("never", Flux.<Integer>never().hide())),
arguments(named("never (conditional)", Flux.<Integer>never().hide().filter(i -> true))),
arguments(named("never (fusion)", Flux.<Integer>never())),
arguments(named("never (fusion+conditional)", Flux.<Integer>never().filter(i -> true)))
);
}

@ParameterizedTestWithName
@MethodSource("sources12Complete")
public void normal(Flux<Integer> source) {
void normal(Flux<Integer> source) {
AssertSubscriber<Integer> ts = AssertSubscriber.create();

AtomicReference<Integer> onNext = new AtomicReference<>();
Expand Down Expand Up @@ -296,7 +297,7 @@ public void fusedAsyncCallbackErrorsOnTerminal() {

@ParameterizedTestWithName
@MethodSource("sourcesError")
public void error(Flux<Integer> source) {
void error(Flux<Integer> source) {
AssertSubscriber<Integer> ts = AssertSubscriber.create();

AtomicReference<Integer> onNext = new AtomicReference<>();
Expand Down Expand Up @@ -329,7 +330,7 @@ else if (s.isOnComplete()) {

@ParameterizedTestWithName
@MethodSource("sourcesEmpty")
public void empty(Flux<Integer> source) {
void empty(Flux<Integer> source) {
AssertSubscriber<Integer> ts = AssertSubscriber.create();

AtomicReference<Integer> onNext = new AtomicReference<>();
Expand Down Expand Up @@ -361,7 +362,7 @@ else if (s.isOnComplete()) {

@ParameterizedTestWithName
@MethodSource("sourcesNever")
public void never(Flux<Integer> source) {
void never(Flux<Integer> source) {
AssertSubscriber<Integer> ts = AssertSubscriber.create();

AtomicReference<Integer> onNext = new AtomicReference<>();
Expand Down Expand Up @@ -393,7 +394,7 @@ else if (s.isOnComplete()) {

@ParameterizedTestWithName
@MethodSource("sources12Complete")
public void nextCallbackError(Flux<Integer> source) {
void nextCallbackError(Flux<Integer> source) {
AssertSubscriber<Integer> ts = AssertSubscriber.create();
LongAdder state = new LongAdder();

Expand All @@ -416,7 +417,7 @@ public void nextCallbackError(Flux<Integer> source) {

@ParameterizedTestWithName
@MethodSource("sources12Complete")
public void nextCallbackBubbleError(Flux<Integer> source) {
void nextCallbackBubbleError(Flux<Integer> source) {
AssertSubscriber<Integer> ts = AssertSubscriber.create();
LongAdder state = new LongAdder();

Expand All @@ -443,7 +444,7 @@ public void nextCallbackBubbleError(Flux<Integer> source) {

@ParameterizedTestWithName
@MethodSource("sources12Complete")
public void completeCallbackError(Flux<Integer> source) {
void completeCallbackError(Flux<Integer> source) {
AssertSubscriber<Integer> ts = AssertSubscriber.create();
AtomicBoolean completeHandled = new AtomicBoolean();
AtomicBoolean errorHandled = new AtomicBoolean();
Expand Down Expand Up @@ -472,7 +473,7 @@ public void completeCallbackError(Flux<Integer> source) {

@ParameterizedTestWithName
@MethodSource("sourcesError")
public void errorCallbackError(Flux<Integer> source) {
void errorCallbackError(Flux<Integer> source) {
AssertSubscriber<Integer> ts = AssertSubscriber.create();
LongAdder state = new LongAdder();

Expand Down
86 changes: 46 additions & 40 deletions reactor-core/src/test/java/reactor/core/publisher/FluxUsingWhenTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -24,9 +24,11 @@
import java.util.concurrent.atomic.LongAdder;
import java.util.function.Function;
import java.util.logging.Level;
import java.util.stream.Stream;

import org.awaitility.Awaitility;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import org.mockito.Mockito;
import org.reactivestreams.Publisher;
Expand All @@ -50,6 +52,8 @@

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatNullPointerException;
import static org.junit.jupiter.api.Named.named;
import static org.junit.jupiter.params.provider.Arguments.arguments;

public class FluxUsingWhenTest {

Expand Down Expand Up @@ -695,12 +699,12 @@ public void apiRollbackGeneratingNull(Flux<String> transactionWithError) {

@ParameterizedTestWithName
@MethodSource("sourcesFullTransaction")
public void apiCancel(Flux<String> transactionWithError) {
public void apiCancel(Flux<String> transactionToCancel) {
final AtomicReference<TestResource> ref = new AtomicReference<>();
Flux<String> flux = Flux.usingWhen(Mono.fromCallable(TestResource::new),
d -> {
ref.set(d);
return transactionWithError;
return transactionToCancel;
},
TestResource::commit,
TestResource::rollback,
Expand Down Expand Up @@ -758,15 +762,15 @@ public void apiCancelFailure(Flux<String> transaction) {

@ParameterizedTestWithName
@MethodSource("sourcesFullTransaction")
public void apiCancelGeneratingNullLogs(Flux<String> transactionWithError) {
public void apiCancelGeneratingNullLogs(Flux<String> transactionToCancel) {
TestLogger testLogger = new TestLogger();
Loggers.useCustomLoggers(s -> testLogger);
try {
final AtomicReference<TestResource> ref = new AtomicReference<>();
Flux<String> flux = Flux.usingWhen(Mono.fromCallable(TestResource::new),
d -> {
ref.set(d);
return transactionWithError;
return transactionToCancel;
},
TestResource::commit,
TestResource::rollback,
Expand Down Expand Up @@ -1418,50 +1422,52 @@ public Flux<Integer> cancelNull() {

//unit test parameter providers

private static Object[] sources01() {
return new Object[] {
new Object[] { Flux.interval(Duration.ofMillis(100)).map(String::valueOf) },
new Object[] { Flux.range(0, 2).map(String::valueOf) }
};
private static Stream<Arguments> sources01() {
return Stream.of(
arguments(named("interval(100ms).map(toString)", Flux.interval(Duration.ofMillis(100)).map(String::valueOf))),
arguments(named("range(0,2).map(toString)", Flux.range(0, 2).map(String::valueOf)))
);
}

private static Object[] sourcesFullTransaction() {
return new Object[] {
new Object[] { Flux.just("Transaction started", "work in transaction", "more work in transaction").hide() },
new Object[] { Flux.just("Transaction started", "work in transaction", "more work in transaction") }
};
private static Stream<Arguments> sourcesFullTransaction() {
return Stream.of(
arguments(named("(start,wip1,wip2)", Flux.just("Transaction started", "work in transaction", "more work in transaction").hide())),
arguments(named("(start,wip1,wip2) (fusion)", Flux.just("Transaction started", "work in transaction", "more work in transaction")))
);
}

private static Object[] sourcesTransactionError() {
return new Object[] {
new Object[] { Flux.just("Transaction started", "work in transaction")
.concatWith(Mono.error(new IllegalStateException("boom"))) },
new Object[] { Flux.just("Transaction started", "work in transaction", "boom")
.map(v -> { if (v.length() > 4) return v; else throw new IllegalStateException("boom"); } ) }
};
private static Stream<Arguments> sourcesTransactionError() {
return Stream.of(
arguments(named("(start,wip,ERROR)",
Flux.just("Transaction started", "work in transaction")
.concatWith(Mono.error(new IllegalStateException("boom")))
)),
arguments(named("(start,wip,ERROR) (fusion)",
Flux.just("Transaction started", "work in transaction", "boom")
.map(v -> { if (v.length() > 4) return v; else throw new IllegalStateException("boom"); })
))
);
}

private static Object[] sourcesContext() {
return new Object[] {
new Object[] { Mono.deferContextual(Mono::just).map(it -> it.get(String.class)).hide() },
new Object[] { Mono.deferContextual(Mono::just).map(it -> it.get(String.class)) }
};
private static Stream<Arguments> sourcesContext() {
return Stream.of(
arguments(named("deferContextual", Mono.deferContextual(Mono::just).map(it -> it.get(String.class)).hide())),
arguments(named("deferContextual (fusion)", Mono.deferContextual(Mono::just).map(it -> it.get(String.class))))
);
}

private static Object[] sourcesContextError() {
return new Object[] {
new Object[] { Mono
.deferContextual(Mono::just)
.map(it -> it.get(String.class))
.hide()
.map(it -> { throw new IllegalStateException("boom"); })
},
new Object[] { Mono
.deferContextual(Mono::just)
.map(it -> it.get(String.class))
.map(it -> { throw new IllegalStateException("boom"); })
}
};
private static Stream<Arguments> sourcesContextError() {
return Stream.of(
arguments(named("deferContextual+error",
Mono.deferContextual(Mono::just)
.map(it -> it.get(String.class))
.hide()
.map(it -> { throw new IllegalStateException("boom"); }))),
arguments(named("deferContextual+error (fusion)",
Mono.deferContextual(Mono::just)
.map(it -> it.get(String.class))
.map(it -> { throw new IllegalStateException("boom"); })))
);
}

}
35 changes: 19 additions & 16 deletions reactor-core/src/test/java/reactor/core/publisher/MonoCacheTimeTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -24,16 +24,17 @@
import java.util.function.Function;
import java.util.stream.Stream;

import org.assertj.core.api.ThrowableAssert;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import org.reactivestreams.Subscription;

import reactor.core.CoreSubscriber;
import reactor.core.Disposable;
import reactor.core.Scannable;
import reactor.core.scheduler.Schedulers;
import reactor.test.ParameterizedTestWithName;
import reactor.test.StepVerifier;
import reactor.test.publisher.MonoOperatorTest;
import reactor.test.publisher.TestPublisher;
Expand All @@ -43,6 +44,8 @@

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.jupiter.api.Named.named;
import static org.junit.jupiter.params.provider.Arguments.arguments;

public class MonoCacheTimeTest extends MonoOperatorTest<String, String> {

Expand Down Expand Up @@ -937,24 +940,24 @@ private void assertCacheTtl(Mono<Integer> mono, Duration ttl, AtomicInteger subC
assertThat(subCount.get()).isEqualTo(2);
}

@ParameterizedTest(name = "{displayName} [for null case #{index}]")
@ParameterizedTestWithName
@MethodSource("nullInvocations")
public void nullArgumentsToCacheOperatorsAreImmediatelyRejected(ThrowableAssert.ThrowingCallable nullInvocation) { //TODO replace with Named.of in JUnit 5.8+
assertThatExceptionOfType(NullPointerException.class).isThrownBy(nullInvocation);
void nullArgumentsToCacheOperatorsAreImmediatelyRejected(ThrowingCallable type) {
assertThatExceptionOfType(NullPointerException.class).isThrownBy(type);
}

private static Stream<ThrowableAssert.ThrowingCallable> nullInvocations() {
private static Stream<Arguments> nullInvocations() {
return Stream.of(
() -> Mono.empty().cache(null),
() -> Mono.empty().cache(null, Schedulers.parallel()),
() -> Mono.empty().cache(Duration.ZERO, null),
() -> Mono.empty().cache(null, e -> Duration.ZERO, () -> Duration.ZERO),
() -> Mono.empty().cache(v -> Duration.ZERO, null, () -> Duration.ZERO),
() -> Mono.empty().cache(v -> Duration.ZERO, e -> Duration.ZERO, null),
() -> Mono.empty().cache(null, e -> Duration.ZERO, () -> Duration.ZERO, Schedulers.parallel()),
() -> Mono.empty().cache(v -> Duration.ZERO, null, () -> Duration.ZERO, Schedulers.parallel()),
() -> Mono.empty().cache(v -> Duration.ZERO, e -> Duration.ZERO, null, Schedulers.parallel()),
() -> Mono.empty().cache(v -> Duration.ZERO, e -> Duration.ZERO, () -> Duration.ZERO, null)
arguments(named("cache(null)", (ThrowingCallable) () -> Mono.empty().cache(null))),
arguments(named("cache(null,parallel)", (ThrowingCallable) () -> Mono.empty().cache(null, Schedulers.parallel()))),
arguments(named("cache(ZERO,null)", (ThrowingCallable) () -> Mono.empty().cache(Duration.ZERO, null))),
arguments(named("cache(null,e->ZERO,()->ZERO)", (ThrowingCallable) () -> Mono.empty().cache(null, e -> Duration.ZERO, () -> Duration.ZERO))),
arguments(named("cache(v->ZERO,null,()->ZERO)", (ThrowingCallable) () -> Mono.empty().cache(v -> Duration.ZERO, null, () -> Duration.ZERO))),
arguments(named("cache(v->ZERO,e->ZERO,null)", (ThrowingCallable) () -> Mono.empty().cache(v -> Duration.ZERO, e -> Duration.ZERO, null))),
arguments(named("cache(null,e->ZERO,()->ZERO,parallel)", (ThrowingCallable) () -> Mono.empty().cache(null, e -> Duration.ZERO, () -> Duration.ZERO, Schedulers.parallel()))),
arguments(named("cache(v->ZERO,null,()->ZERO,parallel)", (ThrowingCallable) () -> Mono.empty().cache(v -> Duration.ZERO, null, () -> Duration.ZERO, Schedulers.parallel()))),
arguments(named("cache(v->ZERO,e->ZERO,null,parallel)", (ThrowingCallable) () -> Mono.empty().cache(v -> Duration.ZERO, e -> Duration.ZERO, null, Schedulers.parallel()))),
arguments(named("cache(v->ZERO,e->ZERO,()->ZERO,null)", (ThrowingCallable) () -> Mono.empty().cache(v -> Duration.ZERO, e -> Duration.ZERO, () -> Duration.ZERO, null)))
);
}
}