Only adopt hasSeconds for isEqualTo in AdoptAssertJDurationAssertions (#1215)

* Stop mapping `Duration#getNano` to `hasNanos` in `AdoptAssertJDurationAssertions`

`Duration#getNano()` returns only the nanosecond-of-second part, while AssertJ `DurationAssert#hasNanos` compares `toNanos()` of the whole duration. Rewriting `assertThat(d.getNano()).isEqualTo(1)` to `assertThat(d).hasNanos(1)` therefore made a passing assertion fail for any duration of a second or more, so the recipe now leaves `getNano()` assertions alone.

* Only convert `isEqualTo` on `Duration#getSeconds` to `hasSeconds` in `AdoptAssertJDurationAssertions`

The `getSeconds()` branch did not check which assertion it was replacing, so `assertThat(d.getSeconds()).isGreaterThan(5)` became `assertThat(d).hasSeconds(5)`, turning a comparison into an equality check. The zero handling also only recognised a method call as the `Duration`, so `assertThat(d.getSeconds()).isGreaterThan(0)` on a variable fell through to `hasSeconds(0)`. The recipe now only adopts `hasSeconds` for `isEqualTo`, and turns zero comparisons into `isPositive()`, `isNegative()` or `isZero()` for any `Duration` expression.

* Stop converting `DurationAssert` units in `AdoptAssertJDurationAssertions`

AssertJ `hasSeconds`, `hasMinutes` and the other unit assertions compare the duration truncated to that unit, so rewriting `hasMillis(5000)` to `hasSeconds(5)` weakened the assertion to also pass for 5999 ms. The conversion also turned a zero argument into `hasDays(0)` and threw an `ArithmeticException` from `Math.toIntExact` for values beyond `int` range. The recipe now leaves the unit assertions as written.

Author: timtebeek

src/main/java/org/openrewrite/java/testing/assertj/AdoptAssertJDurationAssertions.java

@@ -16,7 +16,6 @@
 package org.openrewrite.java.testing.assertj;
 
 import lombok.Getter;
-import org.jspecify.annotations.Nullable;
 import org.openrewrite.ExecutionContext;
 import org.openrewrite.Preconditions;
 import org.openrewrite.Recipe;
@@ -28,9 +27,7 @@
 import org.openrewrite.java.search.UsesMethod;
 import org.openrewrite.java.tree.Expression;
 import org.openrewrite.java.tree.J;
-import org.openrewrite.java.tree.JavaType;
 import org.openrewrite.java.tree.TypeUtils;
-import org.openrewrite.staticanalysis.SimplifyDurationCreationUnits;
 
 import java.util.*;
 
@@ -39,7 +36,6 @@
 
 public class AdoptAssertJDurationAssertions extends Recipe {
 
-    private static final String DURATION_ASSERT_HAS_LONG = "org.assertj.core.api.AbstractDurationAssert has*(long)";
     private static final String INTEGER_ASSERT_IS_EQUAL_TO = "org.assertj.core.api.AbstractIntegerAssert isEqualTo(..)";
     private static final String INTEGER_ASSERT_IS_GREATER_THAN = "org.assertj.core.api.AbstractIntegerAssert isGreaterThan(..)";
     private static final String INTEGER_ASSERT_IS_LESS_THAN = "org.assertj.core.api.AbstractIntegerAssert isLessThan(..)";
@@ -48,10 +44,9 @@ public class AdoptAssertJDurationAssertions extends Recipe {
     private static final String LONG_ASSERT_IS_EQUAL_TO = "org.assertj.core.api.AbstractLongAssert isEqualTo(..)";
 
     private static final MethodMatcher ASSERT_THAT_MATCHER = new MethodMatcher("org.assertj.core.api.Assertions assertThat(..)");
-    private static final MethodMatcher GET_NANO_MATCHER = new MethodMatcher("java.time.Duration getNano()");
     private static final MethodMatcher GET_SECONDS_MATCHER = new MethodMatcher("java.time.Duration getSeconds()");
     private static final MethodMatcher AS_MATCHER = new MethodMatcher("org.assertj.core.api.AbstractObjectAssert as(..)");
-    private static final MethodMatcher TIME_UNIT_MATCHERS = new MethodMatcher(DURATION_ASSERT_HAS_LONG, true);
+    private static final MethodMatcher LONG_IS_EQUAL_TO_MATCHER = new MethodMatcher(LONG_ASSERT_IS_EQUAL_TO, true);
 
     private static final List<MethodMatcher> IS_MATCHERS = Arrays.asList(
             new MethodMatcher(INTEGER_ASSERT_IS_EQUAL_TO, true),
@@ -65,14 +60,6 @@ public class AdoptAssertJDurationAssertions extends Recipe {
 
     private static final Map<String, String> METHOD_MAP = new HashMap<String, String>() {{
         put("getSeconds", "hasSeconds");
-        put("getNano", "hasNanos");
-
-        put("hasNanos", "hasMillis");
-        put("hasMillis", "hasSeconds");
-        put("hasSeconds", "hasMinutes");
-        put("hasMinutes", "hasHours");
-        put("hasHours", "hasDays");
-
         put("isGreaterThan", "isPositive");
         put("isLessThan", "isNegative");
         put("isEqualTo", "isZero");
@@ -88,7 +75,6 @@ public class AdoptAssertJDurationAssertions extends Recipe {
     public TreeVisitor<?, ExecutionContext> getVisitor() {
         return Preconditions.check(
                 or(
-                        new UsesMethod<>(TIME_UNIT_MATCHERS),
                         new UsesMethod<>(INTEGER_ASSERT_IS_EQUAL_TO, true),
                         new UsesMethod<>(INTEGER_ASSERT_IS_GREATER_THAN, true),
                         new UsesMethod<>(INTEGER_ASSERT_IS_LESS_THAN, true),
@@ -99,9 +85,6 @@ public TreeVisitor<?, ExecutionContext> getVisitor() {
                     @Override
                     public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) {
                         J.MethodInvocation mi = super.visitMethodInvocation(method, ctx);
-                        if (TIME_UNIT_MATCHERS.matches(mi)) {
-                            return simplifyTimeUnits(mi, ctx);
-                        }
                         if (IS_MATCHERS.stream().anyMatch(matcher -> matcher.matches(mi))) {
                             return simplifyMultipleAssertions(mi, ctx);
                         }
@@ -139,7 +122,7 @@ private J.MethodInvocation simplifyMultipleAssertions(J.MethodInvocation m, Exec
                             return applyTemplate(ctx, m, formatted_template, assertions, templateParameters.toArray());
                         }
 
-                        if (GET_NANO_MATCHER.matches(assertThatArg) || GET_SECONDS_MATCHER.matches(assertThatArg)) {
+                        if (LONG_IS_EQUAL_TO_MATCHER.matches(m) && GET_SECONDS_MATCHER.matches(assertThatArg)) {
                             Expression assertThatArgSelect = assertThatArg.getSelect();
                             String methodName = assertThatArg.getSimpleName();
                             String formatted_template = formatTemplate("assertThat(#{any()}).%s(#{any()});", methodName, asDescription);
@@ -160,55 +143,13 @@ private boolean isZero(Expression isEqualToArg) {
                         return false;
                     }
 
-                    private J.MethodInvocation simplifyTimeUnits(J.MethodInvocation m, ExecutionContext ctx) {
-                        Expression arg = m.getArguments().get(0);
-                        Long argValue = SimplifyDurationCreationUnits.getConstantIntegralValue(arg);
-                        if (argValue == null) {
-                            return m;
-                        }
-
-                        List<Object> unitInfo = getUnitInfo(m.getSimpleName(), Math.toIntExact(argValue));
-                        String methodName = (String) unitInfo.get(0);
-                        int methodArg = (int) unitInfo.get(1);
-                        if (!m.getSimpleName().equals(methodName)) {
-                            // update method invocation with new name and arg
-                            String template = String.format("#{any()}.%s(%d)", methodName, methodArg);
-                            return applyTemplate(ctx, m, template, null, m.getSelect());
-                        }
-
-                        return m;
-                    }
-
-                    private List<Object> getUnitInfo(String name, int argValue) {
-                        final int timeLength;
-                        if ("hasSeconds".equals(name) || "hasMinutes".equals(name)) {
-                            timeLength = 60;
-                        } else if ("hasNanos".equals(name) || "hasMillis".equals(name)) {
-                            timeLength = 1000;
-                        } else if ("hasHours".equals(name)) {
-                            timeLength = 24;
-                        } else {
-                            return Arrays.asList(name, argValue);
-                        }
-
-                        if (argValue % timeLength == 0) {
-                            String newName = METHOD_MAP.get(name);
-                            return getUnitInfo(newName, argValue / timeLength);
-                        }
-                        // returning name, newArg
-                        return Arrays.asList(name, argValue);
-                    }
-
-                    private J.MethodInvocation applyTemplate(ExecutionContext ctx, J.MethodInvocation m, String template,
-                                                             @Nullable String assertions, Object... parameters) {
-                        JavaTemplate.Builder builder = JavaTemplate.builder(template)
+                    private J.MethodInvocation applyTemplate(ExecutionContext ctx, J.MethodInvocation m, String template, String assertions, Object... parameters) {
+                        maybeAddImport(assertions, "assertThat");
+                        J.MethodInvocation invocation = JavaTemplate.builder(template)
                                 .contextSensitive()
-                                .javaParser(JavaParser.fromJavaVersion().classpathFromResources(ctx, "assertj-core-3"));
-                        if (assertions != null) {
-                            builder.staticImports(assertions + ".assertThat");
-                            maybeAddImport(assertions, "assertThat");
-                        }
-                        J.MethodInvocation invocation = builder.build()
+                                .javaParser(JavaParser.fromJavaVersion().classpathFromResources(ctx, "assertj-core-3"))
+                                .staticImports(assertions + ".assertThat")
+                                .build()
                                 .apply(getCursor(), m.getCoordinates().replace(), parameters);
 
                         // retain whitespace formatting
@@ -223,13 +164,7 @@ private J.MethodInvocation applyTemplate(ExecutionContext ctx, J.MethodInvocatio
                     }
 
                     private boolean checkIfRelatedToDuration(J.MethodInvocation argument) {
-                        if (argument.getSelect() != null) {
-                            if (argument.getSelect() instanceof J.MethodInvocation) {
-                                J.MethodInvocation selectMethod = (J.MethodInvocation) argument.getSelect();
-                                return TypeUtils.isOfType(selectMethod.getType(), JavaType.buildType("java.time.Duration"));
-                            }
-                        }
-                        return false;
+                        return argument.getSelect() != null && TypeUtils.isOfClassType(argument.getSelect().getType(), "java.time.Duration");
                     }
 
                     @SuppressWarnings("ConstantValue")