From af259ce97ee3f4bbaa8cb78d25d1c14b7fed89df Mon Sep 17 00:00:00 2001 From: Rick Ossendrijver Date: Tue, 21 Sep 2021 09:33:12 +0200 Subject: [PATCH] Add AssertValue for 4 types --- .../RxJavaFlowableToReactorTemplates.java | 15 +++++ .../RxJavaMaybeToReactorTemplates.java | 15 +++++ .../RxJavaObservableToReactorTemplates.java | 64 +++++++++++++------ .../RxJavaSingleToReactorTemplates.java | 15 +++++ ...vaFlowableToReactorTemplatesTestInput.java | 4 ++ ...aFlowableToReactorTemplatesTestOutput.java | 7 ++ ...xJavaMaybeToReactorTemplatesTestInput.java | 4 ++ ...JavaMaybeToReactorTemplatesTestOutput.java | 7 ++ ...ObservableToReactorTemplatesTestInput.java | 4 ++ ...bservableToReactorTemplatesTestOutput.java | 7 ++ ...JavaSingleToReactorTemplatesTestInput.java | 4 ++ ...avaSingleToReactorTemplatesTestOutput.java | 7 ++ 12 files changed, 133 insertions(+), 20 deletions(-) diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaFlowableToReactorTemplates.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaFlowableToReactorTemplates.java index b8a70c16..168a2250 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaFlowableToReactorTemplates.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaFlowableToReactorTemplates.java @@ -1164,6 +1164,21 @@ final class RxJavaFlowableToReactorTemplates { } } + static final class FlowableTestAssertValue { + @BeforeTemplate + void before(Flowable flowable, Predicate predicate) throws InterruptedException { + flowable.test().await().assertValue(predicate); + } + + @AfterTemplate + void after(Flowable flowable, Predicate predicate) { + RxJava2Adapter.flowableToFlux(flowable) + .as(StepVerifier::create) + .expectNextMatches(RxJavaReactorMigrationUtil.toJdkPredicate(predicate)) + .verifyComplete(); + } + } + static final class FlowableTestAssertResultValues { @BeforeTemplate void before(Flowable flowable, @Repeated T item) throws InterruptedException { diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaMaybeToReactorTemplates.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaMaybeToReactorTemplates.java index ef07051d..3230fa5d 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaMaybeToReactorTemplates.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaMaybeToReactorTemplates.java @@ -627,6 +627,21 @@ final class RxJavaMaybeToReactorTemplates { } } + static final class MaybeTestAssertValue { + @BeforeTemplate + void before(Maybe maybe, Predicate predicate) throws InterruptedException { + maybe.test().await().assertValue(predicate); + } + + @AfterTemplate + void after(Maybe maybe, Predicate predicate) { + RxJava2Adapter.maybeToMono(maybe) + .as(StepVerifier::create) + .expectNextMatches(RxJavaReactorMigrationUtil.toJdkPredicate(predicate)) + .verifyComplete(); + } + } + static final class MaybeTestAssertComplete { @BeforeTemplate void before(Maybe maybe) throws InterruptedException { diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaObservableToReactorTemplates.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaObservableToReactorTemplates.java index 2240cf07..6268dd2d 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaObservableToReactorTemplates.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaObservableToReactorTemplates.java @@ -614,15 +614,16 @@ final class RxJavaObservableToReactorTemplates { @BeforeTemplate void before(Observable observable, T item) throws InterruptedException { Refaster.anyOf( - observable.test().await().assertResult(item), observable.test().await().assertValue(item)); + observable.test().await().assertResult(item), + observable.test().await().assertValue(item)); } @AfterTemplate void after(Observable observable, T item) { RxJava2Adapter.observableToFlux(observable, BackpressureStrategy.BUFFER) - .as(StepVerifier::create) - .expectNext(item) - .verifyComplete(); + .as(StepVerifier::create) + .expectNext(item) + .verifyComplete(); } } @@ -635,7 +636,25 @@ final class RxJavaObservableToReactorTemplates { @AfterTemplate void after(Observable observable) { - RxJava2Adapter.observableToFlux(observable, BackpressureStrategy.BUFFER).as(StepVerifier::create).verifyComplete(); + RxJava2Adapter.observableToFlux(observable, BackpressureStrategy.BUFFER) + .as(StepVerifier::create) + .verifyComplete(); + } + } + + // XXX: Default BackpressureStrategy.BUFFER + static final class ObservableTestAssertValue { + @BeforeTemplate + void before(Observable observable, Predicate predicate) throws InterruptedException { + observable.test().await().assertValue(predicate); + } + + @AfterTemplate + void after(Observable observable, Predicate predicate) { + RxJava2Adapter.observableToFlux(observable, BackpressureStrategy.BUFFER) + .as(StepVerifier::create) + .expectNextMatches(RxJavaReactorMigrationUtil.toJdkPredicate(predicate)) + .verifyComplete(); } } @@ -644,16 +663,16 @@ final class RxJavaObservableToReactorTemplates { @BeforeTemplate void before(Observable observable, @Repeated T item) throws InterruptedException { Refaster.anyOf( - observable.test().await().assertResult(Refaster.asVarargs(item)), - observable.test().await().assertValues(Refaster.asVarargs(item))); + observable.test().await().assertResult(Refaster.asVarargs(item)), + observable.test().await().assertValues(Refaster.asVarargs(item))); } @AfterTemplate void after(Observable observable, @Repeated T item) { RxJava2Adapter.observableToFlux(observable, BackpressureStrategy.BUFFER) - .as(StepVerifier::create) - .expectNext(item) - .verifyComplete(); + .as(StepVerifier::create) + .expectNext(item) + .verifyComplete(); } } @@ -667,7 +686,9 @@ final class RxJavaObservableToReactorTemplates { @AfterTemplate void after(Observable observable) { - RxJava2Adapter.observableToFlux(observable, BackpressureStrategy.BUFFER).as(StepVerifier::create).verifyComplete(); + RxJava2Adapter.observableToFlux(observable, BackpressureStrategy.BUFFER) + .as(StepVerifier::create) + .verifyComplete(); } } @@ -675,16 +696,16 @@ final class RxJavaObservableToReactorTemplates { static final class ObservableTestAssertErrorClass { @BeforeTemplate void before(Observable observable, Class errorClass) - throws InterruptedException { + throws InterruptedException { observable.test().await().assertError(errorClass); } @AfterTemplate void after(Observable observable, Class errorClass) { RxJava2Adapter.observableToFlux(observable, BackpressureStrategy.BUFFER) - .as(StepVerifier::create) - .expectError(errorClass) - .verify(); + .as(StepVerifier::create) + .expectError(errorClass) + .verify(); } } @@ -699,7 +720,9 @@ final class RxJavaObservableToReactorTemplates { @AfterTemplate void after(Observable observable) { - RxJava2Adapter.observableToFlux(observable, BackpressureStrategy.BUFFER).as(StepVerifier::create).verifyComplete(); + RxJava2Adapter.observableToFlux(observable, BackpressureStrategy.BUFFER) + .as(StepVerifier::create) + .verifyComplete(); } } @@ -714,7 +737,8 @@ final class RxJavaObservableToReactorTemplates { // // @AfterTemplate // void after(Observable observable, Collection expected) { - // RxJava2Adapter.observableToMono(observable).as(StepVerifier::create).expectNextMatches(t -> + // RxJava2Adapter.observableToMono(observable).as(StepVerifier::create).expectNextMatches(t + // -> // ).verifyComplete(); // } // } @@ -729,9 +753,9 @@ final class RxJavaObservableToReactorTemplates { @AfterTemplate void after(Observable observable, int count) { RxJava2Adapter.observableToFlux(observable, BackpressureStrategy.BUFFER) - .as(StepVerifier::create) - .expectNextCount(count) - .verifyComplete(); + .as(StepVerifier::create) + .expectNextCount(count) + .verifyComplete(); } } diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaSingleToReactorTemplates.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaSingleToReactorTemplates.java index 2e1e5064..4e8aab94 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaSingleToReactorTemplates.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaSingleToReactorTemplates.java @@ -448,6 +448,21 @@ final class RxJavaSingleToReactorTemplates { } } + static final class SingleTestAssertValue { + @BeforeTemplate + void before(Single single, Predicate predicate) throws InterruptedException { + single.test().await().assertValue(predicate); + } + + @AfterTemplate + void after(Single single, Predicate predicate) { + RxJava2Adapter.singleToMono(single) + .as(StepVerifier::create) + .expectNextMatches(RxJavaReactorMigrationUtil.toJdkPredicate(predicate)) + .verifyComplete(); + } + } + static final class SingleTestAssertComplete { @BeforeTemplate void before(Single single) throws InterruptedException { diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaFlowableToReactorTemplatesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaFlowableToReactorTemplatesTestInput.java index 6c6f183e..dc4a87ab 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaFlowableToReactorTemplatesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaFlowableToReactorTemplatesTestInput.java @@ -180,6 +180,10 @@ final class RxJavaFlowableToReactorTemplatesTest implements RefasterTemplateTest Flowable.just(1).test().await().assertResult(); } + void testFlowableTestAssertValue() throws InterruptedException { + Flowable.just(1).test().await().assertValue(i -> i > 1); + } + void testFlowableTestAssertResultValues() throws InterruptedException { Flowable.just(1, 2, 3).test().await().assertResult(1, 2, 3); Flowable.just(4, 5, 6).test().await().assertValues(4, 5, 6); diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaFlowableToReactorTemplatesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaFlowableToReactorTemplatesTestOutput.java index e01f54f9..6b03c474 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaFlowableToReactorTemplatesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaFlowableToReactorTemplatesTestOutput.java @@ -257,6 +257,13 @@ final class RxJavaFlowableToReactorTemplatesTest implements RefasterTemplateTest RxJava2Adapter.flowableToFlux(Flowable.just(1)).as(StepVerifier::create).verifyComplete(); } + void testFlowableTestAssertValue() throws InterruptedException { + RxJava2Adapter.flowableToFlux(Flowable.just(1)) + .as(StepVerifier::create) + .expectNextMatches(RxJavaReactorMigrationUtil.toJdkPredicate(i -> i > 1)) + .verifyComplete(); + } + void testFlowableTestAssertResultValues() throws InterruptedException { RxJava2Adapter.flowableToFlux(Flowable.just(1, 2, 3)) .as(StepVerifier::create) diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaMaybeToReactorTemplatesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaMaybeToReactorTemplatesTestInput.java index 40ea3898..7d6f4daf 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaMaybeToReactorTemplatesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaMaybeToReactorTemplatesTestInput.java @@ -168,6 +168,10 @@ final class RxJavaMaybeToReactorTemplatesTest implements RefasterTemplateTestCas Maybe.just(1).test().await().assertResult(); } + void MaybeTestAssertValue() throws InterruptedException { + Maybe.just(1).test().await().assertValue(i -> i > 1); + } + void testMaybeTestAssertComplete() throws InterruptedException { Maybe.just(1).test().await().assertComplete(); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaMaybeToReactorTemplatesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaMaybeToReactorTemplatesTestOutput.java index f755e059..b4a19755 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaMaybeToReactorTemplatesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaMaybeToReactorTemplatesTestOutput.java @@ -240,6 +240,13 @@ final class RxJavaMaybeToReactorTemplatesTest implements RefasterTemplateTestCas RxJava2Adapter.maybeToMono(Maybe.just(1)).as(StepVerifier::create).verifyComplete(); } + void MaybeTestAssertValue() throws InterruptedException { + RxJava2Adapter.maybeToMono(Maybe.just(1)) + .as(StepVerifier::create) + .expectNextMatches(RxJavaReactorMigrationUtil.toJdkPredicate(i -> i > 1)) + .verifyComplete(); + } + void testMaybeTestAssertComplete() throws InterruptedException { RxJava2Adapter.maybeToMono(Maybe.just(1)).as(StepVerifier::create).verifyComplete(); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaObservableToReactorTemplatesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaObservableToReactorTemplatesTestInput.java index f2a5e13a..3fb96d48 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaObservableToReactorTemplatesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaObservableToReactorTemplatesTestInput.java @@ -46,6 +46,10 @@ final class RxJavaObservableToReactorTemplatesTest implements RefasterTemplateTe Observable.just(1).test().await().assertResult(); } + void testObservableTestAssertValue() throws InterruptedException { + Observable.just(1).test().await().assertValue(i -> i > 2); + } + void testObservableTestAssertResultValues() throws InterruptedException { Observable.just(1, 2, 3).test().await().assertResult(1, 2, 3); Observable.just(4, 5, 6).test().await().assertValues(4, 5, 6); diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaObservableToReactorTemplatesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaObservableToReactorTemplatesTestOutput.java index a0ea7c5b..4c8212dc 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaObservableToReactorTemplatesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaObservableToReactorTemplatesTestOutput.java @@ -71,6 +71,13 @@ final class RxJavaObservableToReactorTemplatesTest implements RefasterTemplateTe .verifyComplete(); } + void testObservableTestAssertValue() throws InterruptedException { + RxJava2Adapter.observableToFlux(Observable.just(1), BackpressureStrategy.BUFFER) + .as(StepVerifier::create) + .expectNextMatches(RxJavaReactorMigrationUtil.toJdkPredicate(i -> i > 2)) + .verifyComplete(); + } + void testObservableTestAssertResultValues() throws InterruptedException { RxJava2Adapter.observableToFlux(Observable.just(1, 2, 3), BackpressureStrategy.BUFFER) .as(StepVerifier::create) diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaSingleToReactorTemplatesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaSingleToReactorTemplatesTestInput.java index fbd1ccef..df713d5a 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaSingleToReactorTemplatesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaSingleToReactorTemplatesTestInput.java @@ -69,6 +69,10 @@ final class RxJavaSingleToReactorTemplatesTest implements RefasterTemplateTestCa Single.just(1).test().await().assertResult(); } + void testSingleTestAssertValue() throws InterruptedException { + Single.just(1).test().await().assertValue(i -> i > 1); + } + void testSingleTestAssertComplete() throws InterruptedException { Single.just(1).test().await().assertComplete(); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaSingleToReactorTemplatesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaSingleToReactorTemplatesTestOutput.java index 76a02e5d..ab8662c7 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaSingleToReactorTemplatesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaSingleToReactorTemplatesTestOutput.java @@ -103,6 +103,13 @@ final class RxJavaSingleToReactorTemplatesTest implements RefasterTemplateTestCa RxJava2Adapter.singleToMono(Single.just(1)).as(StepVerifier::create).verifyComplete(); } + void testSingleTestAssertValue() throws InterruptedException { + RxJava2Adapter.singleToMono(Single.just(1)) + .as(StepVerifier::create) + .expectNextMatches(RxJavaReactorMigrationUtil.toJdkPredicate(i -> i > 1)) + .verifyComplete(); + } + void testSingleTestAssertComplete() throws InterruptedException { RxJava2Adapter.singleToMono(Single.just(1)).as(StepVerifier::create).verifyComplete(); }