From 70855ac70e413f935d043f56b06572fe7a8eb41e Mon Sep 17 00:00:00 2001 From: Carter Kozak Date: Wed, 2 Oct 2019 15:34:41 -0400 Subject: [PATCH] Refaster assertj migrations support descriptions with format args (#926) Refaster assertj migrations support descriptions with format args --- ...llectionHasSizeExactlyWithDescription.java | 13 ++--- ...tionHasSizeGreaterThanWithDescription.java | 13 ++--- ...sertjCollectionIsEmptyWithDescription.java | 21 ++++---- ...tjCollectionIsNotEmptyWithDescription.java | 41 +++++++------- .../AssertjEqualsWithDescription.java | 21 ++++---- .../AssertjInstanceOfWithDescription.java | 9 ++-- ...sertjMapHasSizeExactlyWithDescription.java | 13 ++--- .../AssertjMapIsEmptyWithDescription.java | 25 ++++----- .../AssertjNotEqualsWithDescription.java | 21 ++++---- ...ionalHasValueRedundantWithDescription.java | 54 +++++++++++++++++++ ...ssertjOptionalHasValueWithDescription.java | 20 +++---- ...tjOptionalIsNotPresentWithDescription.java | 17 +++--- ...sertjOptionalIsPresentWithDescription.java | 9 ++-- .../AssertjStringContainsWithDescription.java | 13 ++--- ...tjStringDoesNotContainWithDescription.java | 13 ++--- .../AssertjCollectionHasSameSizeAsTest.java | 2 + .../refaster/AssertjOptionalHasValueTest.java | 30 +++++++++-- changelog/@unreleased/pr-926.v2.yml | 5 ++ 18 files changed, 215 insertions(+), 125 deletions(-) create mode 100644 baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjOptionalHasValueRedundantWithDescription.java create mode 100644 changelog/@unreleased/pr-926.v2.yml diff --git a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjCollectionHasSizeExactlyWithDescription.java b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjCollectionHasSizeExactlyWithDescription.java index 8eed2b980..d5f6bbc85 100644 --- a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjCollectionHasSizeExactlyWithDescription.java +++ b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjCollectionHasSizeExactlyWithDescription.java @@ -21,24 +21,25 @@ import com.google.errorprone.refaster.ImportPolicy; import com.google.errorprone.refaster.annotation.AfterTemplate; import com.google.errorprone.refaster.annotation.BeforeTemplate; +import com.google.errorprone.refaster.annotation.Repeated; import com.google.errorprone.refaster.annotation.UseImportPolicy; import java.util.Collection; public final class AssertjCollectionHasSizeExactlyWithDescription { @BeforeTemplate - void bad1(Collection things, int size, String description) { - assertThat(things.size() == size).describedAs(description).isTrue(); + void bad1(Collection things, int size, String description, @Repeated Object descriptionArgs) { + assertThat(things.size() == size).describedAs(description, descriptionArgs).isTrue(); } @BeforeTemplate - void bad2(Collection things, int size, String description) { - assertThat(things.size()).describedAs(description).isEqualTo(size); + void bad2(Collection things, int size, String description, @Repeated Object descriptionArgs) { + assertThat(things.size()).describedAs(description, descriptionArgs).isEqualTo(size); } @AfterTemplate @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS) - void after(Collection things, int size, String description) { - assertThat(things).describedAs(description).hasSize(size); + void after(Collection things, int size, String description, @Repeated Object descriptionArgs) { + assertThat(things).describedAs(description, descriptionArgs).hasSize(size); } } diff --git a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjCollectionHasSizeGreaterThanWithDescription.java b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjCollectionHasSizeGreaterThanWithDescription.java index 4ec9419a3..619fcea0b 100644 --- a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjCollectionHasSizeGreaterThanWithDescription.java +++ b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjCollectionHasSizeGreaterThanWithDescription.java @@ -21,24 +21,25 @@ import com.google.errorprone.refaster.ImportPolicy; import com.google.errorprone.refaster.annotation.AfterTemplate; import com.google.errorprone.refaster.annotation.BeforeTemplate; +import com.google.errorprone.refaster.annotation.Repeated; import com.google.errorprone.refaster.annotation.UseImportPolicy; import java.util.Collection; public final class AssertjCollectionHasSizeGreaterThanWithDescription { @BeforeTemplate - void before1(Collection things, int size, String description) { - assertThat(things.size() > size).describedAs(description).isTrue(); + void before1(Collection things, int size, String description, @Repeated Object descriptionArgs) { + assertThat(things.size() > size).describedAs(description, descriptionArgs).isTrue(); } @BeforeTemplate - void before2(Collection things, int size, String description) { - assertThat(things.size()).describedAs(description).isGreaterThan(size); + void before2(Collection things, int size, String description, @Repeated Object descriptionArgs) { + assertThat(things.size()).describedAs(description, descriptionArgs).isGreaterThan(size); } @AfterTemplate @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS) - void after(Collection things, int size, String description) { - assertThat(things).describedAs(description).hasSizeGreaterThan(size); + void after(Collection things, int size, String description, @Repeated Object descriptionArgs) { + assertThat(things).describedAs(description, descriptionArgs).hasSizeGreaterThan(size); } } diff --git a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjCollectionIsEmptyWithDescription.java b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjCollectionIsEmptyWithDescription.java index ee8f0b740..e1b9b5fd1 100644 --- a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjCollectionIsEmptyWithDescription.java +++ b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjCollectionIsEmptyWithDescription.java @@ -21,34 +21,35 @@ import com.google.errorprone.refaster.ImportPolicy; import com.google.errorprone.refaster.annotation.AfterTemplate; import com.google.errorprone.refaster.annotation.BeforeTemplate; +import com.google.errorprone.refaster.annotation.Repeated; import com.google.errorprone.refaster.annotation.UseImportPolicy; import java.util.Collection; public final class AssertjCollectionIsEmptyWithDescription { @BeforeTemplate - void bad1(Collection things, String description) { - assertThat(things.size() == 0).describedAs(description).isTrue(); + void bad1(Collection things, String description, @Repeated Object descriptionArgs) { + assertThat(things.size() == 0).describedAs(description, descriptionArgs).isTrue(); } @BeforeTemplate - void bad2(Collection things, String description) { - assertThat(things.isEmpty()).describedAs(description).isTrue(); + void bad2(Collection things, String description, @Repeated Object descriptionArgs) { + assertThat(things.isEmpty()).describedAs(description, descriptionArgs).isTrue(); } @BeforeTemplate - void bad3(Collection things, String description) { - assertThat(things.size()).describedAs(description).isZero(); + void bad3(Collection things, String description, @Repeated Object descriptionArgs) { + assertThat(things.size()).describedAs(description, descriptionArgs).isZero(); } @BeforeTemplate - void bad4(Collection things, String description) { - assertThat(things.size()).describedAs(description).isEqualTo(0); + void bad4(Collection things, String description, @Repeated Object descriptionArgs) { + assertThat(things.size()).describedAs(description, descriptionArgs).isEqualTo(0); } @AfterTemplate @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS) - void after(Iterable things, String description) { - assertThat(things).describedAs(description).isEmpty(); + void after(Iterable things, String description, @Repeated Object descriptionArgs) { + assertThat(things).describedAs(description, descriptionArgs).isEmpty(); } } diff --git a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjCollectionIsNotEmptyWithDescription.java b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjCollectionIsNotEmptyWithDescription.java index 396c89f46..c64f3166b 100644 --- a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjCollectionIsNotEmptyWithDescription.java +++ b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjCollectionIsNotEmptyWithDescription.java @@ -23,6 +23,7 @@ import com.google.errorprone.refaster.ImportPolicy; import com.google.errorprone.refaster.annotation.AfterTemplate; import com.google.errorprone.refaster.annotation.BeforeTemplate; +import com.google.errorprone.refaster.annotation.Repeated; import com.google.errorprone.refaster.annotation.UseImportPolicy; import java.util.Collection; import java.util.Collections; @@ -30,53 +31,53 @@ public final class AssertjCollectionIsNotEmptyWithDescription { @BeforeTemplate - void bad1(Collection things, String description) { - assertThat(things.size() != 0).describedAs(description).isTrue(); + void bad1(Collection things, String description, @Repeated Object descriptionArgs) { + assertThat(things.size() != 0).describedAs(description, descriptionArgs).isTrue(); } @BeforeTemplate - void bad2(Collection things, String description) { - assertThat(things.size() == 0).describedAs(description).isFalse(); + void bad2(Collection things, String description, @Repeated Object descriptionArgs) { + assertThat(things.size() == 0).describedAs(description, descriptionArgs).isFalse(); } @BeforeTemplate - void bad3(Collection things, String description) { - assertThat(things.size()).describedAs(description).isNotEqualTo(0); + void bad3(Collection things, String description, @Repeated Object descriptionArgs) { + assertThat(things.size()).describedAs(description, descriptionArgs).isNotEqualTo(0); } @BeforeTemplate - void bad4(Collection things, String description) { - assertThat(things.isEmpty()).describedAs(description).isFalse(); + void bad4(Collection things, String description, @Repeated Object descriptionArgs) { + assertThat(things.isEmpty()).describedAs(description, descriptionArgs).isFalse(); } @BeforeTemplate - void bad5(Collection things, String description) { - assertThat(!things.isEmpty()).describedAs(description).isTrue(); + void bad5(Collection things, String description, @Repeated Object descriptionArgs) { + assertThat(!things.isEmpty()).describedAs(description, descriptionArgs).isTrue(); } @BeforeTemplate - void bad6(Collection things, String description) { - assertThat(things).describedAs(description).isNotEqualTo(Collections.emptyList()); + void bad6(Collection things, String description, @Repeated Object descriptionArgs) { + assertThat(things).describedAs(description, descriptionArgs).isNotEqualTo(Collections.emptyList()); } @BeforeTemplate - void bad7(Collection things, String description) { - assertThat(things).describedAs(description).isNotEqualTo(Collections.emptySet()); + void bad7(Collection things, String description, @Repeated Object descriptionArgs) { + assertThat(things).describedAs(description, descriptionArgs).isNotEqualTo(Collections.emptySet()); } @BeforeTemplate - void bad8(Collection things, String description) { - assertThat(things).describedAs(description).isNotEqualTo(ImmutableList.of()); + void bad8(Collection things, String description, @Repeated Object descriptionArgs) { + assertThat(things).describedAs(description, descriptionArgs).isNotEqualTo(ImmutableList.of()); } @BeforeTemplate - void bad9(Collection things, String description) { - assertThat(things).describedAs(description).isNotEqualTo(ImmutableSet.of()); + void bad9(Collection things, String description, @Repeated Object descriptionArgs) { + assertThat(things).describedAs(description, descriptionArgs).isNotEqualTo(ImmutableSet.of()); } @AfterTemplate @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS) - void after(Collection things, String description) { - assertThat(things).describedAs(description).isNotEmpty(); + void after(Collection things, String description, @Repeated Object descriptionArgs) { + assertThat(things).describedAs(description, descriptionArgs).isNotEmpty(); } } diff --git a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjEqualsWithDescription.java b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjEqualsWithDescription.java index 3fe1455cb..a88511822 100644 --- a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjEqualsWithDescription.java +++ b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjEqualsWithDescription.java @@ -21,6 +21,7 @@ import com.google.errorprone.refaster.ImportPolicy; import com.google.errorprone.refaster.annotation.AfterTemplate; import com.google.errorprone.refaster.annotation.BeforeTemplate; +import com.google.errorprone.refaster.annotation.Repeated; import com.google.errorprone.refaster.annotation.UseImportPolicy; import java.util.Objects; @@ -31,28 +32,28 @@ public final class AssertjEqualsWithDescription { @BeforeTemplate - void before1(T expected, T actual, String description) { - assertThat(actual.equals(expected)).describedAs(description).isTrue(); + void before1(T expected, T actual, String description, @Repeated Object descriptionArgs) { + assertThat(actual.equals(expected)).describedAs(description, descriptionArgs).isTrue(); } @BeforeTemplate - void before2(T expected, T actual, String description) { - assertThat(Objects.equals(actual, expected)).describedAs(description).isTrue(); + void before2(T expected, T actual, String description, @Repeated Object descriptionArgs) { + assertThat(Objects.equals(actual, expected)).describedAs(description, descriptionArgs).isTrue(); } @BeforeTemplate - void before3(T expected, T actual, String description) { - assertThat(!actual.equals(expected)).describedAs(description).isFalse(); + void before3(T expected, T actual, String description, @Repeated Object descriptionArgs) { + assertThat(!actual.equals(expected)).describedAs(description, descriptionArgs).isFalse(); } @BeforeTemplate - void before4(T expected, T actual, String description) { - assertThat(!Objects.equals(actual, expected)).describedAs(description).isFalse(); + void before4(T expected, T actual, String description, @Repeated Object descriptionArgs) { + assertThat(!Objects.equals(actual, expected)).describedAs(description, descriptionArgs).isFalse(); } @AfterTemplate @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS) - void after(T expected, T actual, String description) { - assertThat(actual).describedAs(description).isEqualTo(expected); + void after(T expected, T actual, String description, @Repeated Object descriptionArgs) { + assertThat(actual).describedAs(description, descriptionArgs).isEqualTo(expected); } } diff --git a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjInstanceOfWithDescription.java b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjInstanceOfWithDescription.java index d59573465..723b6ef1c 100644 --- a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjInstanceOfWithDescription.java +++ b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjInstanceOfWithDescription.java @@ -22,18 +22,19 @@ import com.google.errorprone.refaster.Refaster; import com.google.errorprone.refaster.annotation.AfterTemplate; import com.google.errorprone.refaster.annotation.BeforeTemplate; +import com.google.errorprone.refaster.annotation.Repeated; import com.google.errorprone.refaster.annotation.UseImportPolicy; public final class AssertjInstanceOfWithDescription { @BeforeTemplate - void before(T input, String description) { - assertThat(Refaster.isInstance(input)).describedAs(description).isTrue(); + void before(T input, String description, @Repeated Object descriptionArgs) { + assertThat(Refaster.isInstance(input)).describedAs(description, descriptionArgs).isTrue(); } @AfterTemplate @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS) - void after(T input, String description) { - assertThat(input).describedAs(description).isInstanceOf(Refaster.clazz()); + void after(T input, String description, @Repeated Object descriptionArgs) { + assertThat(input).describedAs(description, descriptionArgs).isInstanceOf(Refaster.clazz()); } } diff --git a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjMapHasSizeExactlyWithDescription.java b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjMapHasSizeExactlyWithDescription.java index 6e5eac0ed..2e41f72e3 100644 --- a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjMapHasSizeExactlyWithDescription.java +++ b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjMapHasSizeExactlyWithDescription.java @@ -21,24 +21,25 @@ import com.google.errorprone.refaster.ImportPolicy; import com.google.errorprone.refaster.annotation.AfterTemplate; import com.google.errorprone.refaster.annotation.BeforeTemplate; +import com.google.errorprone.refaster.annotation.Repeated; import com.google.errorprone.refaster.annotation.UseImportPolicy; import java.util.Map; public final class AssertjMapHasSizeExactlyWithDescription { @BeforeTemplate - void before1(Map things, int size, String description) { - assertThat(things.size() == size).describedAs(description).isTrue(); + void before1(Map things, int size, String description, @Repeated Object descriptionArgs) { + assertThat(things.size() == size).describedAs(description, descriptionArgs).isTrue(); } @BeforeTemplate - void before2(Map things, int size, String description) { - assertThat(things.size()).describedAs(description).isEqualTo(size); + void before2(Map things, int size, String description, @Repeated Object descriptionArgs) { + assertThat(things.size()).describedAs(description, descriptionArgs).isEqualTo(size); } @AfterTemplate @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS) - void after(Map things, int size, String description) { - assertThat(things).describedAs(description).hasSize(size); + void after(Map things, int size, String description, @Repeated Object descriptionArgs) { + assertThat(things).describedAs(description, descriptionArgs).hasSize(size); } } diff --git a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjMapIsEmptyWithDescription.java b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjMapIsEmptyWithDescription.java index 0a01dbb6b..dcc659950 100644 --- a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjMapIsEmptyWithDescription.java +++ b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjMapIsEmptyWithDescription.java @@ -21,39 +21,40 @@ import com.google.errorprone.refaster.ImportPolicy; import com.google.errorprone.refaster.annotation.AfterTemplate; import com.google.errorprone.refaster.annotation.BeforeTemplate; +import com.google.errorprone.refaster.annotation.Repeated; import com.google.errorprone.refaster.annotation.UseImportPolicy; import java.util.Map; public final class AssertjMapIsEmptyWithDescription { @BeforeTemplate - void before1(Map things, String description) { - assertThat(things.size() == 0).describedAs(description).isTrue(); + void before1(Map things, String description, @Repeated Object descriptionArgs) { + assertThat(things.size() == 0).describedAs(description, descriptionArgs).isTrue(); } @BeforeTemplate - void before2(Map things, String description) { - assertThat(things.isEmpty()).describedAs(description).isTrue(); + void before2(Map things, String description, @Repeated Object descriptionArgs) { + assertThat(things.isEmpty()).describedAs(description, descriptionArgs).isTrue(); } @BeforeTemplate - void before3(Map things, String description) { - assertThat(things.size()).describedAs(description).isZero(); + void before3(Map things, String description, @Repeated Object descriptionArgs) { + assertThat(things.size()).describedAs(description, descriptionArgs).isZero(); } @BeforeTemplate - void before4(Map things, String description) { - assertThat(things.size()).describedAs(description).isEqualTo(0); + void before4(Map things, String description, @Repeated Object descriptionArgs) { + assertThat(things.size()).describedAs(description, descriptionArgs).isEqualTo(0); } @BeforeTemplate - void before5(Map things, String description) { - assertThat(things).describedAs(description).hasSize(0); + void before5(Map things, String description, @Repeated Object descriptionArgs) { + assertThat(things).describedAs(description, descriptionArgs).hasSize(0); } @AfterTemplate @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS) - void after(Map things, String description) { - assertThat(things).describedAs(description).isEmpty(); + void after(Map things, String description, @Repeated Object descriptionArgs) { + assertThat(things).describedAs(description, descriptionArgs).isEmpty(); } } diff --git a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjNotEqualsWithDescription.java b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjNotEqualsWithDescription.java index 206677eae..8417485be 100644 --- a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjNotEqualsWithDescription.java +++ b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjNotEqualsWithDescription.java @@ -21,6 +21,7 @@ import com.google.errorprone.refaster.ImportPolicy; import com.google.errorprone.refaster.annotation.AfterTemplate; import com.google.errorprone.refaster.annotation.BeforeTemplate; +import com.google.errorprone.refaster.annotation.Repeated; import com.google.errorprone.refaster.annotation.UseImportPolicy; import java.util.Objects; @@ -31,28 +32,28 @@ public final class AssertjNotEqualsWithDescription { @BeforeTemplate - void before1(T expected, T actual, String description) { - assertThat(!actual.equals(expected)).describedAs(description).isTrue(); + void before1(T expected, T actual, String description, @Repeated Object descriptionArgs) { + assertThat(!actual.equals(expected)).describedAs(description, descriptionArgs).isTrue(); } @BeforeTemplate - void before2(T expected, T actual, String description) { - assertThat(!Objects.equals(actual, expected)).describedAs(description).isTrue(); + void before2(T expected, T actual, String description, @Repeated Object descriptionArgs) { + assertThat(!Objects.equals(actual, expected)).describedAs(description, descriptionArgs).isTrue(); } @BeforeTemplate - void before3(T expected, T actual, String description) { - assertThat(actual.equals(expected)).describedAs(description).isFalse(); + void before3(T expected, T actual, String description, @Repeated Object descriptionArgs) { + assertThat(actual.equals(expected)).describedAs(description, descriptionArgs).isFalse(); } @BeforeTemplate - void before4(T expected, T actual, String description) { - assertThat(Objects.equals(actual, expected)).describedAs(description).isFalse(); + void before4(T expected, T actual, String description, @Repeated Object descriptionArgs) { + assertThat(Objects.equals(actual, expected)).describedAs(description, descriptionArgs).isFalse(); } @AfterTemplate @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS) - void after(T expected, T actual, String description) { - assertThat(actual).describedAs(description).isNotEqualTo(expected); + void after(T expected, T actual, String description, @Repeated Object descriptionArgs) { + assertThat(actual).describedAs(description, descriptionArgs).isNotEqualTo(expected); } } diff --git a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjOptionalHasValueRedundantWithDescription.java b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjOptionalHasValueRedundantWithDescription.java new file mode 100644 index 000000000..62b2a606b --- /dev/null +++ b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjOptionalHasValueRedundantWithDescription.java @@ -0,0 +1,54 @@ +/* + * (c) Copyright 2019 Palantir Technologies Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.palantir.baseline.refaster; + +import static org.assertj.core.api.Assertions.assertThat; + +import com.google.errorprone.refaster.ImportPolicy; +import com.google.errorprone.refaster.annotation.AfterTemplate; +import com.google.errorprone.refaster.annotation.BeforeTemplate; +import com.google.errorprone.refaster.annotation.Repeated; +import com.google.errorprone.refaster.annotation.UseImportPolicy; +import java.util.Optional; + +public final class AssertjOptionalHasValueRedundantWithDescription { + + @BeforeTemplate + void redundantAssertion( + Optional optional, + T innerValue, + String description1, + @Repeated Object descriptionArgs1, + String description2, + @Repeated Object descriptionArgs2) { + assertThat(optional).describedAs(description1, descriptionArgs1).isPresent(); + assertThat(optional).describedAs(description2, descriptionArgs2).hasValue(innerValue); + } + + @AfterTemplate + @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS) + void after( + Optional optional, + T innerValue, + // The first assertion is unnecessary + String _description1, + @Repeated Object _descriptionArgs1, + String description2, + @Repeated Object descriptionArgs2) { + assertThat(optional).describedAs(description2, descriptionArgs2).hasValue(innerValue); + } +} diff --git a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjOptionalHasValueWithDescription.java b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjOptionalHasValueWithDescription.java index 240bdf4aa..d26ad9898 100644 --- a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjOptionalHasValueWithDescription.java +++ b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjOptionalHasValueWithDescription.java @@ -21,30 +21,26 @@ import com.google.errorprone.refaster.ImportPolicy; import com.google.errorprone.refaster.annotation.AfterTemplate; import com.google.errorprone.refaster.annotation.BeforeTemplate; +import com.google.errorprone.refaster.annotation.Repeated; import com.google.errorprone.refaster.annotation.UseImportPolicy; import java.util.Optional; public final class AssertjOptionalHasValueWithDescription { @BeforeTemplate - void before(Optional optional, T innerValue, String description) { - assertThat(optional.get()).describedAs(description).isEqualTo(innerValue); + void before(Optional optional, T innerValue, String description, @Repeated Object descriptionArgs) { + assertThat(optional.get()).describedAs(description, descriptionArgs).isEqualTo(innerValue); } @BeforeTemplate - void before2(Optional optional, T innerValue, String description) { - assertThat(optional.isPresent() && optional.get().equals(innerValue)).describedAs(description).isTrue(); - } - - @BeforeTemplate - void redundantAssertion(Optional optional, T innerValue, String description) { - assertThat(optional).describedAs(description).isPresent(); - assertThat(optional).describedAs(description).hasValue(innerValue); + void before2(Optional optional, T innerValue, String description, @Repeated Object descriptionArgs) { + assertThat(optional.isPresent() + && optional.get().equals(innerValue)).describedAs(description, descriptionArgs).isTrue(); } @AfterTemplate @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS) - void after(Optional optional, T innerValue, String description) { - assertThat(optional).describedAs(description).hasValue(innerValue); + void after(Optional optional, T innerValue, String description, @Repeated Object descriptionArgs) { + assertThat(optional).describedAs(description, descriptionArgs).hasValue(innerValue); } } diff --git a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjOptionalIsNotPresentWithDescription.java b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjOptionalIsNotPresentWithDescription.java index 14c5ee3ef..fc39c2616 100644 --- a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjOptionalIsNotPresentWithDescription.java +++ b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjOptionalIsNotPresentWithDescription.java @@ -21,29 +21,30 @@ import com.google.errorprone.refaster.ImportPolicy; import com.google.errorprone.refaster.annotation.AfterTemplate; import com.google.errorprone.refaster.annotation.BeforeTemplate; +import com.google.errorprone.refaster.annotation.Repeated; import com.google.errorprone.refaster.annotation.UseImportPolicy; import java.util.Optional; public final class AssertjOptionalIsNotPresentWithDescription { @BeforeTemplate - void before1(Optional thing, String description) { - assertThat(thing.isPresent()).describedAs(description).isFalse(); + void before1(Optional thing, String description, @Repeated Object descriptionArgs) { + assertThat(thing.isPresent()).describedAs(description, descriptionArgs).isFalse(); } @BeforeTemplate - void before2(Optional thing, String description) { - assertThat(!thing.isPresent()).describedAs(description).isTrue(); + void before2(Optional thing, String description, @Repeated Object descriptionArgs) { + assertThat(!thing.isPresent()).describedAs(description, descriptionArgs).isTrue(); } @BeforeTemplate - void before3(Optional thing, String description) { - assertThat(thing).describedAs(description).isEqualTo(Optional.empty()); + void before3(Optional thing, String description, @Repeated Object descriptionArgs) { + assertThat(thing).describedAs(description, descriptionArgs).isEqualTo(Optional.empty()); } @AfterTemplate @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS) - void after(Optional thing, String description) { - assertThat(thing).describedAs(description).isNotPresent(); + void after(Optional thing, String description, @Repeated Object descriptionArgs) { + assertThat(thing).describedAs(description, descriptionArgs).isNotPresent(); } } diff --git a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjOptionalIsPresentWithDescription.java b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjOptionalIsPresentWithDescription.java index 432bfc22a..909bde248 100644 --- a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjOptionalIsPresentWithDescription.java +++ b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjOptionalIsPresentWithDescription.java @@ -21,19 +21,20 @@ import com.google.errorprone.refaster.ImportPolicy; import com.google.errorprone.refaster.annotation.AfterTemplate; import com.google.errorprone.refaster.annotation.BeforeTemplate; +import com.google.errorprone.refaster.annotation.Repeated; import com.google.errorprone.refaster.annotation.UseImportPolicy; import java.util.Optional; public final class AssertjOptionalIsPresentWithDescription { @BeforeTemplate - void before(Optional thing, String description) { - assertThat(thing.isPresent()).describedAs(description).isTrue(); + void before(Optional thing, String description, @Repeated Object descriptionArgs) { + assertThat(thing.isPresent()).describedAs(description, descriptionArgs).isTrue(); } @AfterTemplate @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS) - void after(Optional thing, String description) { - assertThat(thing).describedAs(description).isPresent(); + void after(Optional thing, String description, @Repeated Object descriptionArgs) { + assertThat(thing).describedAs(description, descriptionArgs).isPresent(); } } diff --git a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjStringContainsWithDescription.java b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjStringContainsWithDescription.java index 3a9e8df01..3809c0441 100644 --- a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjStringContainsWithDescription.java +++ b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjStringContainsWithDescription.java @@ -21,23 +21,24 @@ import com.google.errorprone.refaster.ImportPolicy; import com.google.errorprone.refaster.annotation.AfterTemplate; import com.google.errorprone.refaster.annotation.BeforeTemplate; +import com.google.errorprone.refaster.annotation.Repeated; import com.google.errorprone.refaster.annotation.UseImportPolicy; public final class AssertjStringContainsWithDescription { @BeforeTemplate - void before1(String input, CharSequence contains, String description) { - assertThat(input.contains(contains)).describedAs(description).isTrue(); + void before1(String input, CharSequence contains, String description, @Repeated Object descriptionArgs) { + assertThat(input.contains(contains)).describedAs(description, descriptionArgs).isTrue(); } @BeforeTemplate - void before2(String input, CharSequence contains, String description) { - assertThat(!input.contains(contains)).describedAs(description).isFalse(); + void before2(String input, CharSequence contains, String description, @Repeated Object descriptionArgs) { + assertThat(!input.contains(contains)).describedAs(description, descriptionArgs).isFalse(); } @AfterTemplate @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS) - void after(String input, CharSequence contains, String description) { - assertThat(input).describedAs(description).contains(contains); + void after(String input, CharSequence contains, String description, @Repeated Object descriptionArgs) { + assertThat(input).describedAs(description, descriptionArgs).contains(contains); } } diff --git a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjStringDoesNotContainWithDescription.java b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjStringDoesNotContainWithDescription.java index c690932a3..e8c0b22e7 100644 --- a/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjStringDoesNotContainWithDescription.java +++ b/baseline-refaster-rules/src/main/java/com/palantir/baseline/refaster/AssertjStringDoesNotContainWithDescription.java @@ -21,23 +21,24 @@ import com.google.errorprone.refaster.ImportPolicy; import com.google.errorprone.refaster.annotation.AfterTemplate; import com.google.errorprone.refaster.annotation.BeforeTemplate; +import com.google.errorprone.refaster.annotation.Repeated; import com.google.errorprone.refaster.annotation.UseImportPolicy; public final class AssertjStringDoesNotContainWithDescription { @BeforeTemplate - void before1(String input, CharSequence contains, String description) { - assertThat(input.contains(contains)).describedAs(description).isFalse(); + void before1(String input, CharSequence contains, String description, @Repeated Object descriptionArgs) { + assertThat(input.contains(contains)).describedAs(description, descriptionArgs).isFalse(); } @BeforeTemplate - void before2(String input, CharSequence contains, String description) { - assertThat(!input.contains(contains)).describedAs(description).isTrue(); + void before2(String input, CharSequence contains, String description, @Repeated Object descriptionArgs) { + assertThat(!input.contains(contains)).describedAs(description, descriptionArgs).isTrue(); } @AfterTemplate @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS) - void after(String input, CharSequence contains, String description) { - assertThat(input).describedAs(description).doesNotContain(contains); + void after(String input, CharSequence contains, String description, @Repeated Object descriptionArgs) { + assertThat(input).describedAs(description, descriptionArgs).doesNotContain(contains); } } diff --git a/baseline-refaster-rules/src/test/java/com/palantir/baseline/refaster/AssertjCollectionHasSameSizeAsTest.java b/baseline-refaster-rules/src/test/java/com/palantir/baseline/refaster/AssertjCollectionHasSameSizeAsTest.java index aeaadadfd..b4c509c65 100644 --- a/baseline-refaster-rules/src/test/java/com/palantir/baseline/refaster/AssertjCollectionHasSameSizeAsTest.java +++ b/baseline-refaster-rules/src/test/java/com/palantir/baseline/refaster/AssertjCollectionHasSameSizeAsTest.java @@ -80,6 +80,7 @@ public void testArray() { " assertThat(a).describedAs(\"desc\").hasSize(target.length);", " assertThat(b).describedAs(\"desc\").hasSize(target.length);", " assertThat(c).describedAs(\"desc\").hasSize(target.length);", + " assertThat(c).describedAs(\"foo %s\", \"bar\").hasSize(target.length);", " }", "}") .hasOutputLines( @@ -94,6 +95,7 @@ public void testArray() { " assertThat(a).describedAs(\"desc\").hasSameSizeAs(target);", " assertThat(b).describedAs(\"desc\").hasSameSizeAs(target);", " assertThat(c).describedAs(\"desc\").hasSameSizeAs(target);", + " assertThat(c).describedAs(\"foo %s\", \"bar\").hasSameSizeAs(target);", " }", "}"); } diff --git a/baseline-refaster-rules/src/test/java/com/palantir/baseline/refaster/AssertjOptionalHasValueTest.java b/baseline-refaster-rules/src/test/java/com/palantir/baseline/refaster/AssertjOptionalHasValueTest.java index 75cf4558d..9831dd5bd 100644 --- a/baseline-refaster-rules/src/test/java/com/palantir/baseline/refaster/AssertjOptionalHasValueTest.java +++ b/baseline-refaster-rules/src/test/java/com/palantir/baseline/refaster/AssertjOptionalHasValueTest.java @@ -74,10 +74,6 @@ public void testWithDescription() { " assertThat(in.get()).describedAs(\"desc\").isEqualTo(out);", " assertThat(in.isPresent() && in.get().equals(out)).describedAs(\"desc\").isTrue();", " }", - " void g(Optional in, String out) {", - " assertThat(in).describedAs(\"desc\").isPresent();", - " assertThat(in).describedAs(\"desc\").hasValue(out);", - " }", "}") .hasOutputLines( "import static org.assertj.core.api.Assertions.assertThat;", @@ -87,8 +83,32 @@ public void testWithDescription() { " assertThat(in).describedAs(\"desc\").hasValue(out);", " assertThat(in).describedAs(\"desc\").hasValue(out);", " }", + "}"); + } + + @Test + public void testWithDescriptionRedundant() { + assumeThat(System.getProperty("java.specification.version")) + .describedAs("Refaster does not currently support fluent refactors on java 11") + .isEqualTo("1.8"); + RefasterTestHelper + .forRefactoring(AssertjOptionalHasValueRedundantWithDescription.class) + .withInputLines( + "Test", + "import static org.assertj.core.api.Assertions.assertThat;", + "import java.util.Optional;", + "public class Test {", + " void g(Optional in, String out) {", + " assertThat(in).describedAs(\"a\").isPresent();", + " assertThat(in).describedAs(\"b\").hasValue(out);", + " }", + "}") + .hasOutputLines( + "import static org.assertj.core.api.Assertions.assertThat;", + "import java.util.Optional;", + "public class Test {", " void g(Optional in, String out) {", - " assertThat(in).describedAs(\"desc\").hasValue(out);", + " assertThat(in).describedAs(\"b\").hasValue(out);", " ", " }", "}"); diff --git a/changelog/@unreleased/pr-926.v2.yml b/changelog/@unreleased/pr-926.v2.yml new file mode 100644 index 000000000..0336daaa4 --- /dev/null +++ b/changelog/@unreleased/pr-926.v2.yml @@ -0,0 +1,5 @@ +type: improvement +improvement: + description: Refaster assertj migrations support descriptions with format args + links: + - https://github.com/palantir/gradle-baseline/pull/926