diff --git a/.baseline/checkstyle/checkstyle.xml b/.baseline/checkstyle/checkstyle.xml index 7e155ea5d..212e115e8 100644 --- a/.baseline/checkstyle/checkstyle.xml +++ b/.baseline/checkstyle/checkstyle.xml @@ -75,7 +75,7 @@ - + diff --git a/README.md b/README.md index 756ac3a66..71b499b94 100644 --- a/README.md +++ b/README.md @@ -150,7 +150,7 @@ Safe Logging can be found at [github.com/palantir/safe-logging](https://github.c - `PreferSafeLoggingPreconditions`: Users should use the safe-logging versions of Precondition checks for standardization when there is equivalent functionality ```diff -com.google.common.base.Preconditions.checkNotNull(variable, "message"); - +com.palantir.logsafe.Preconditions.checkNotNull(variable, "message"); // equivalent functionality is available in the safe-logging variant + +com.palantir.logsafe.preconditions.Preconditions.checkNotNull(variable, "message"); // equivalent functionality is available in the safe-logging variant ``` - `ShutdownHook`: Applications should not use `Runtime#addShutdownHook`. - `GradleCacheableTaskAction`: Gradle plugins should not call `Task.doFirst` or `Task.doLast` with a lambda, as that is not cacheable. See [gradle/gradle#5510](https://github.com/gradle/gradle/issues/5510) for more details. @@ -202,6 +202,7 @@ Safe Logging can be found at [github.com/palantir/safe-logging](https://github.c - `IncubatingMethod`: Prevents calling Conjure incubating APIs unless you explicitly opt-out of the check on a per-use or per-project basis. - `CompileTimeConstantViolatesLiskovSubstitution`: Requires consistent application of the `@CompileTimeConstant` annotation to resolve inconsistent validation based on the reference type on which the met is invoked. - `ClassInitializationDeadlock`: Detect type structures which can cause deadlocks initializing classes. +- `SafeLoggingPreconditionsMigration`: Migrate safe-logging preconditions references to the new non-deprecated package. ### Programmatic Application diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/LogSafePreconditionsMessageFormat.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/LogSafePreconditionsMessageFormat.java index 40aaf69de..c75635e52 100755 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/LogSafePreconditionsMessageFormat.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/LogSafePreconditionsMessageFormat.java @@ -41,7 +41,7 @@ public final class LogSafePreconditionsMessageFormat extends PreconditionsMessag private static final long serialVersionUID = 1L; private static final Matcher LOGSAFE_PRECONDITIONS_METHOD = MethodMatchers.staticMethod() - .onClassAny("com.palantir.logsafe.Preconditions") + .onClassAny("com.palantir.logsafe.preconditions.Preconditions") .withNameMatching(Pattern.compile("checkArgument|checkState|checkNotNull")); public LogSafePreconditionsMessageFormat() { diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/PreferSafeLoggingPreconditions.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/PreferSafeLoggingPreconditions.java index e92c5283c..00ea2413d 100644 --- a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/PreferSafeLoggingPreconditions.java +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/PreferSafeLoggingPreconditions.java @@ -43,7 +43,7 @@ providesFix = BugPattern.ProvidesFix.REQUIRES_HUMAN_ATTENTION, severity = BugPattern.SeverityLevel.WARNING, summary = "Precondition and similar checks with a constant message and no parameters should use equivalent" - + " checks from com.palantir.logsafe.Preconditions for standardization as functionality is the" + + " checks from com.palantir.logsafe.preconditions.Preconditions for standardization as functionality is the" + " same.") public final class PreferSafeLoggingPreconditions extends BugChecker implements BugChecker.MethodInvocationTreeMatcher { @@ -92,13 +92,15 @@ public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState } SuggestedFix.Builder fix = SuggestedFix.builder(); - String logSafeQualifiedClassName = SuggestedFixes.qualifyType(state, fix, "com.palantir.logsafe.Preconditions"); + String logSafeQualifiedClassName = + SuggestedFixes.qualifyType(state, fix, "com.palantir.logsafe.preconditions.Preconditions"); String logSafeMethodName = getLogSafeMethodName(ASTHelpers.getSymbol(tree)); String replacement = String.format("%s.%s", logSafeQualifiedClassName, logSafeMethodName); return buildDescription(tree) - .setMessage("The call can be replaced with an equivalent one from com.palantir.logsafe.Preconditions " - + "for standardization as the functionality is the same.") + .setMessage( + "The call can be replaced with an equivalent one from com.palantir.logsafe.preconditions.Preconditions " + + "for standardization as the functionality is the same.") .addFix(fix.replace(tree.getMethodSelect(), replacement).build()) .build(); } diff --git a/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/SafeLoggingPreconditionsMigration.java b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/SafeLoggingPreconditionsMigration.java new file mode 100644 index 000000000..149bbf209 --- /dev/null +++ b/baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/SafeLoggingPreconditionsMigration.java @@ -0,0 +1,60 @@ +/* + * (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.errorprone; + +import com.google.auto.service.AutoService; +import com.google.errorprone.BugPattern; +import com.google.errorprone.BugPattern.SeverityLevel; +import com.google.errorprone.VisitorState; +import com.google.errorprone.bugpatterns.BugChecker; +import com.google.errorprone.fixes.SuggestedFix; +import com.google.errorprone.matchers.Description; +import com.google.errorprone.matchers.Matcher; +import com.google.errorprone.matchers.Matchers; +import com.google.errorprone.util.ASTHelpers; +import com.sun.source.tree.MemberSelectTree; +import com.sun.source.tree.Tree; + +@AutoService(BugChecker.class) +@BugPattern( + name = "SafeLoggingPreconditionsMigration", + link = "https://github.com/palantir/gradle-baseline#baseline-error-prone-checks", + linkType = BugPattern.LinkType.CUSTOM, + severity = SeverityLevel.SUGGESTION, + summary = "Prefer the non-deprecated safe-logging preconditions path. " + + "See https://github.com/palantir/safe-logging/pull/515 for context. Using gradle baseline, " + + "failures can be fixed automatically using " + + "`./gradlew classes testClasses -PerrorProneApply=SafeLoggingPreconditionsMigration`") +public final class SafeLoggingPreconditionsMigration extends BugChecker implements BugChecker.MemberSelectTreeMatcher { + + private static final Matcher LEGACY_PRECONDITIONS_MATCHER = + Matchers.isSameType("com.palantir.logsafe.Preconditions"); + + @Override + public Description matchMemberSelect(MemberSelectTree tree, VisitorState state) { + if (LEGACY_PRECONDITIONS_MATCHER.matches(tree, state) + // Only attempt to warn or refactor when the preconditions dependency version is sufficiently new, + // older versions which haven't deprecated "com.palantir.logsafe.Preconditions" won't have the + // replacement. + && ASTHelpers.hasAnnotation(ASTHelpers.getSymbol(tree), Deprecated.class, state)) { + return buildDescription(tree) + .addFix(SuggestedFix.replace(tree, "com.palantir.logsafe.preconditions.Preconditions")) + .build(); + } + return Description.NO_MATCH; + } +} diff --git a/baseline-error-prone/src/test/java/com/palantir/baseline/errorprone/PreconditionsTests.java b/baseline-error-prone/src/test/java/com/palantir/baseline/errorprone/PreconditionsTests.java index df4f93cd5..6cf026929 100755 --- a/baseline-error-prone/src/test/java/com/palantir/baseline/errorprone/PreconditionsTests.java +++ b/baseline-error-prone/src/test/java/com/palantir/baseline/errorprone/PreconditionsTests.java @@ -41,7 +41,7 @@ public final void failLogSafe(String diagnostic, String precondition) { compilationHelper() .addSourceLines( "Test.java", - "import com.palantir.logsafe.Preconditions;", + "import com.palantir.logsafe.preconditions.Preconditions;", "import com.palantir.logsafe.UnsafeArg;", "class Test {", " void f(String param) {", @@ -149,7 +149,7 @@ public final void validLogSafe() throws Exception { compilationHelper() .addSourceLines( "Test.java", - "import com.palantir.logsafe.Preconditions;", + "import com.palantir.logsafe.preconditions.Preconditions;", "import com.palantir.logsafe.UnsafeArg;", "import java.util.Iterator;", "class Test {", diff --git a/baseline-error-prone/src/test/java/com/palantir/baseline/errorprone/PreferSafeLoggingPreconditionsTests.java b/baseline-error-prone/src/test/java/com/palantir/baseline/errorprone/PreferSafeLoggingPreconditionsTests.java index f866ef42e..8fd51da22 100644 --- a/baseline-error-prone/src/test/java/com/palantir/baseline/errorprone/PreferSafeLoggingPreconditionsTests.java +++ b/baseline-error-prone/src/test/java/com/palantir/baseline/errorprone/PreferSafeLoggingPreconditionsTests.java @@ -191,9 +191,9 @@ public void testPreconditionsAutoFixShortNames() { "import com.google.common.base.Preconditions;", "class Test {", " void f(String param) {", - " com.palantir.logsafe.Preconditions.checkArgument(param != \"string\", \"constant\");", - " com.palantir.logsafe.Preconditions.checkState(param != \"string\", \"constant\");", - " com.palantir.logsafe.Preconditions.checkNotNull(param, \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkArgument(param != \"string\", \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkState(param != \"string\", \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkNotNull(param, \"constant\");", " }", "}") .doTest(BugCheckerRefactoringTestHelper.TestMode.TEXT_MATCH); @@ -213,7 +213,7 @@ public void testPreconditionsAutoFixFullNames() { "}") .addOutputLines( "Test.java", - "import com.palantir.logsafe.Preconditions;", + "import com.palantir.logsafe.preconditions.Preconditions;", "class Test {", " void f(String param) {", " Preconditions.checkArgument(param != \"string\", \"constant\");", @@ -229,7 +229,7 @@ public void testMixedGuavaPreconditionsFullNamesAndLogSafeShortNames() { RefactoringValidator.of(new PreferSafeLoggingPreconditions(), getClass()) .addInputLines( "Test.java", - "import com.palantir.logsafe.Preconditions;", + "import com.palantir.logsafe.preconditions.Preconditions;", "class Test {", " void f(String param) {", " com.google.common.base.Preconditions.checkArgument(param != \"string\", \"constant\");", @@ -242,7 +242,7 @@ public void testMixedGuavaPreconditionsFullNamesAndLogSafeShortNames() { "}") .addOutputLines( "Test.java", - "import com.palantir.logsafe.Preconditions;", + "import com.palantir.logsafe.preconditions.Preconditions;", "class Test {", " void f(String param) {", " Preconditions.checkArgument(param != \"string\", \"constant\");", @@ -267,9 +267,9 @@ public void testMixedGuavaPreconditionsShortNamesAndLogSafeFullNames() { " Preconditions.checkArgument(param != \"string\", \"constant\");", " Preconditions.checkState(param != \"string\", \"constant\");", " Preconditions.checkNotNull(param, \"constant\");", - " com.palantir.logsafe.Preconditions.checkArgument(param != \"string\", \"constant\");", - " com.palantir.logsafe.Preconditions.checkState(param != \"string\", \"constant\");", - " com.palantir.logsafe.Preconditions.checkNotNull(param, \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkArgument(param != \"string\", \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkState(param != \"string\", \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkNotNull(param, \"constant\");", " }", "}") .addOutputLines( @@ -277,12 +277,12 @@ public void testMixedGuavaPreconditionsShortNamesAndLogSafeFullNames() { "import com.google.common.base.Preconditions;", "class Test {", " void f(String param) {", - " com.palantir.logsafe.Preconditions.checkArgument(param != \"string\", \"constant\");", - " com.palantir.logsafe.Preconditions.checkState(param != \"string\", \"constant\");", - " com.palantir.logsafe.Preconditions.checkNotNull(param, \"constant\");", - " com.palantir.logsafe.Preconditions.checkArgument(param != \"string\", \"constant\");", - " com.palantir.logsafe.Preconditions.checkState(param != \"string\", \"constant\");", - " com.palantir.logsafe.Preconditions.checkNotNull(param, \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkArgument(param != \"string\", \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkState(param != \"string\", \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkNotNull(param, \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkArgument(param != \"string\", \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkState(param != \"string\", \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkNotNull(param, \"constant\");", " }", "}") .doTest(BugCheckerRefactoringTestHelper.TestMode.TEXT_MATCH); @@ -301,7 +301,7 @@ public void testObjectsAutoFixShortNames() { "}") .addOutputLines( "Test.java", - "import com.palantir.logsafe.Preconditions;", + "import com.palantir.logsafe.preconditions.Preconditions;", "import java.util.Objects;", "class Test {", " void f(String param) {", @@ -323,7 +323,7 @@ public void testObjectsAutoFixFullNames() { "}") .addOutputLines( "Test.java", - "import com.palantir.logsafe.Preconditions;", + "import com.palantir.logsafe.preconditions.Preconditions;", "class Test {", " void f(String param) {", " Preconditions.checkNotNull(param, \"constant\");", @@ -337,7 +337,7 @@ public void testMixedObjectsFullNamesAndLogSafeShortNames() { RefactoringValidator.of(new PreferSafeLoggingPreconditions(), getClass()) .addInputLines( "Test.java", - "import com.palantir.logsafe.Preconditions;", + "import com.palantir.logsafe.preconditions.Preconditions;", "class Test {", " void f(String param) {", " java.util.Objects.requireNonNull(param, \"constant\");", @@ -346,7 +346,7 @@ public void testMixedObjectsFullNamesAndLogSafeShortNames() { "}") .addOutputLines( "Test.java", - "import com.palantir.logsafe.Preconditions;", + "import com.palantir.logsafe.preconditions.Preconditions;", "class Test {", " void f(String param) {", " Preconditions.checkNotNull(param, \"constant\");", @@ -365,17 +365,17 @@ public void testMixedObjectsShortNamesAndLogSafeFullNames() { "class Test {", " void f(String param) {", " Objects.requireNonNull(param, \"constant\");", - " com.palantir.logsafe.Preconditions.checkNotNull(param, \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkNotNull(param, \"constant\");", " }", "}") .addOutputLines( "Test.java", - "import com.palantir.logsafe.Preconditions;", + "import com.palantir.logsafe.preconditions.Preconditions;", "import java.util.Objects;", "class Test {", " void f(String param) {", " Preconditions.checkNotNull(param, \"constant\");", - " com.palantir.logsafe.Preconditions.checkNotNull(param, \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkNotNull(param, \"constant\");", " }", "}") .doTest(BugCheckerRefactoringTestHelper.TestMode.TEXT_MATCH); @@ -396,7 +396,7 @@ public void testMixedValidateAutoFixShortNames() { "}") .addOutputLines( "Test.java", - "import com.palantir.logsafe.Preconditions;", + "import com.palantir.logsafe.preconditions.Preconditions;", "import org.apache.commons.lang3.Validate;", "class Test {", " void f(String param) {", @@ -422,7 +422,7 @@ public void testMixedValidateAutoFixFullNames() { "}") .addOutputLines( "Test.java", - "import com.palantir.logsafe.Preconditions;", + "import com.palantir.logsafe.preconditions.Preconditions;", "class Test {", " void f(String param) {", " Preconditions.checkArgument(param != \"string\", \"constant\");", @@ -438,7 +438,7 @@ public void testMixedValidateFullNamesAndLogSafeShortNames() { RefactoringValidator.of(new PreferSafeLoggingPreconditions(), getClass()) .addInputLines( "Test.java", - "import com.palantir.logsafe.Preconditions;", + "import com.palantir.logsafe.preconditions.Preconditions;", "class Test {", " void f(String param) {", " org.apache.commons.lang3.Validate.isTrue(param != \"string\", \"constant\");", @@ -451,7 +451,7 @@ public void testMixedValidateFullNamesAndLogSafeShortNames() { "}") .addOutputLines( "Test.java", - "import com.palantir.logsafe.Preconditions;", + "import com.palantir.logsafe.preconditions.Preconditions;", "class Test {", " void f(String param) {", " Preconditions.checkArgument(param != \"string\", \"constant\");", @@ -476,23 +476,23 @@ public void testMixedValidateShortNamesAndLogSafeFullNames() { " Validate.isTrue(param != \"string\", \"constant\");", " Validate.validState(param != \"string\", \"constant\");", " Validate.notNull(param, \"constant\");", - " com.palantir.logsafe.Preconditions.checkArgument(param != \"string\", \"constant\");", - " com.palantir.logsafe.Preconditions.checkState(param != \"string\", \"constant\");", - " com.palantir.logsafe.Preconditions.checkNotNull(param, \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkArgument(param != \"string\", \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkState(param != \"string\", \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkNotNull(param, \"constant\");", " }", "}") .addOutputLines( "Test.java", - "import com.palantir.logsafe.Preconditions;", + "import com.palantir.logsafe.preconditions.Preconditions;", "import org.apache.commons.lang3.Validate;", "class Test {", " void f(String param) {", " Preconditions.checkArgument(param != \"string\", \"constant\");", " Preconditions.checkState(param != \"string\", \"constant\");", " Preconditions.checkNotNull(param, \"constant\");", - " com.palantir.logsafe.Preconditions.checkArgument(param != \"string\", \"constant\");", - " com.palantir.logsafe.Preconditions.checkState(param != \"string\", \"constant\");", - " com.palantir.logsafe.Preconditions.checkNotNull(param, \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkArgument(param != \"string\", \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkState(param != \"string\", \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkNotNull(param, \"constant\");", " }", "}") .doTest(BugCheckerRefactoringTestHelper.TestMode.TEXT_MATCH); @@ -519,10 +519,10 @@ public void testMixedGuavaPreconditionsAndObjectsAutoFixShortNames() { "import java.util.Objects;", "class Test {", " void f(String param) {", - " com.palantir.logsafe.Preconditions.checkNotNull(param, \"constant\");", - " com.palantir.logsafe.Preconditions.checkArgument(param != \"string\", \"constant\");", - " com.palantir.logsafe.Preconditions.checkState(param != \"string\", \"constant\");", - " com.palantir.logsafe.Preconditions.checkNotNull(param, \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkNotNull(param, \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkArgument(param != \"string\", \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkState(param != \"string\", \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkNotNull(param, \"constant\");", " }", "}") .doTest(BugCheckerRefactoringTestHelper.TestMode.TEXT_MATCH); @@ -543,7 +543,7 @@ public void testMixedGuavaPreconditionsAndObjectsAutoFixFullNames() { "}") .addOutputLines( "Test.java", - "import com.palantir.logsafe.Preconditions;", + "import com.palantir.logsafe.preconditions.Preconditions;", "class Test {", " void f(String param) {", " Preconditions.checkNotNull(param, \"constant\");", @@ -573,7 +573,7 @@ public void testMixedGuavaPreconditionsAndObjectsAndValidateAutoFixFullNames() { "}") .addOutputLines( "Test.java", - "import com.palantir.logsafe.Preconditions;", + "import com.palantir.logsafe.preconditions.Preconditions;", "class Test {", " void f(String param) {", " Preconditions.checkNotNull(param, \"constant\");", @@ -614,13 +614,13 @@ public void testMixedGuavaPreconditionsAndObjectsAndValidateAutoFixShortNames() "import java.util.Objects;", "class Test {", " void f(String param) {", - " com.palantir.logsafe.Preconditions.checkNotNull(param, \"constant\");", - " com.palantir.logsafe.Preconditions.checkArgument(param != \"string\", \"constant\");", - " com.palantir.logsafe.Preconditions.checkState(param != \"string\", \"constant\");", - " com.palantir.logsafe.Preconditions.checkNotNull(param, \"constant\");", - " com.palantir.logsafe.Preconditions.checkArgument(param != \"string\", \"constant\");", - " com.palantir.logsafe.Preconditions.checkState(param != \"string\", \"constant\");", - " com.palantir.logsafe.Preconditions.checkNotNull(param, \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkNotNull(param, \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkArgument(param != \"string\", \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkState(param != \"string\", \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkNotNull(param, \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkArgument(param != \"string\", \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkState(param != \"string\", \"constant\");", + " com.palantir.logsafe.preconditions.Preconditions.checkNotNull(param, \"constant\");", " }", "}") .doTest(BugCheckerRefactoringTestHelper.TestMode.TEXT_MATCH); diff --git a/baseline-error-prone/src/test/java/com/palantir/baseline/errorprone/SafeLoggingPreconditionsMigrationTest.java b/baseline-error-prone/src/test/java/com/palantir/baseline/errorprone/SafeLoggingPreconditionsMigrationTest.java new file mode 100644 index 000000000..293ae9b86 --- /dev/null +++ b/baseline-error-prone/src/test/java/com/palantir/baseline/errorprone/SafeLoggingPreconditionsMigrationTest.java @@ -0,0 +1,108 @@ +/* + * (c) Copyright 2021 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.errorprone; + +import org.junit.jupiter.api.Test; + +class SafeLoggingPreconditionsMigrationTest { + + @Test + void testFullyQualified() { + helper().addInputLines( + "Test.java", + "class Test {", + " void f(Object o) {", + " com.palantir.logsafe.Preconditions.checkNotNull(o);", + " }", + "}") + .addOutputLines( + "Test.java", + "class Test {", + " void f(Object o) {", + " com.palantir.logsafe.preconditions.Preconditions.checkNotNull(o);", + " }", + "}") + .doTest(); + } + + @Test + void testClassImport() { + helper().addInputLines( + "Test.java", + "import com.palantir.logsafe.Preconditions;", + "class Test {", + " void f(Object o) {", + " Preconditions.checkNotNull(o);", + " }", + "}") + .addOutputLines( + "Test.java", + "import com.palantir.logsafe.preconditions.Preconditions;", + "class Test {", + " void f(Object o) {", + " Preconditions.checkNotNull(o);", + " }", + "}") + .doTest(); + } + + @Test + void testStaticImport() { + helper().addInputLines( + "Test.java", + "import static com.palantir.logsafe.Preconditions.checkNotNull;", + "class Test {", + " void f(Object o) {", + " checkNotNull(o);", + " }", + "}") + .addOutputLines( + "Test.java", + "import static com.palantir.logsafe.preconditions.Preconditions.checkNotNull;", + "class Test {", + " void f(Object o) {", + " checkNotNull(o);", + " }", + "}") + .doTest(); + } + + @Test + void testStaticStarImport() { + helper().addInputLines( + "Test.java", + "import static com.palantir.logsafe.Preconditions.*;", + "class Test {", + " void f(Object o) {", + " checkNotNull(o);", + " }", + "}") + .addOutputLines( + "Test.java", + "import static com.palantir.logsafe.preconditions.Preconditions.*;", + "class Test {", + " void f(Object o) {", + " checkNotNull(o);", + " }", + "}") + .doTest(); + } + + private RefactoringValidator helper() { + return RefactoringValidator.of(new SafeLoggingPreconditionsMigration(), getClass()); + } +} diff --git a/changelog/@unreleased/pr-1632.v2.yml b/changelog/@unreleased/pr-1632.v2.yml new file mode 100644 index 000000000..e9ea8979f --- /dev/null +++ b/changelog/@unreleased/pr-1632.v2.yml @@ -0,0 +1,5 @@ +type: improvement +improvement: + description: Migrate preconditions to the new package + links: + - https://github.com/palantir/gradle-baseline/pull/1632 diff --git a/docs/java-style-guide/readme.md b/docs/java-style-guide/readme.md index 2ca0323b3..c78ca2983 100644 --- a/docs/java-style-guide/readme.md +++ b/docs/java-style-guide/readme.md @@ -332,7 +332,7 @@ the exception of the members of the following classes: - `java.util.Collections` - `java.util.stream.Collectors` -- `com.palantir.logsafe.Preconditions` +- `com.palantir.logsafe.preconditions.Preconditions` - `com.google.common.base.Preconditions` - `org.apache.commons.lang3.Validate` diff --git a/gradle-baseline-java-config/resources/checkstyle/checkstyle.xml b/gradle-baseline-java-config/resources/checkstyle/checkstyle.xml index af0eb2640..4a2aeb5d5 100644 --- a/gradle-baseline-java-config/resources/checkstyle/checkstyle.xml +++ b/gradle-baseline-java-config/resources/checkstyle/checkstyle.xml @@ -81,7 +81,7 @@ - + diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineErrorProneExtension.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineErrorProneExtension.java index 83c7d5c96..a1415bfa1 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineErrorProneExtension.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineErrorProneExtension.java @@ -58,6 +58,7 @@ public class BaselineErrorProneExtension { "ReadReturnValueIgnored", "RedundantMethodReference", "RedundantModifier", + "SafeLoggingPreconditionsMigration", "Slf4jLevelCheck", "Slf4jLogsafeArgs", "Slf4jThrowable",