Add AssertToAssertions which turns JUnit4 Assert into JUnit5 Assertions

Author: sambsnyd

src/before/java/org/openrewrite/java/testing/junit5/ExampleJunitTestClass.java

@@ -58,11 +58,14 @@ public void foo2() {
 
     @Test
     public void assertsStuff() {
-        Assert.assertEquals(1, 1);
-        Assert.assertArrayEquals(new int[]{}, new int[]{});
-        Assert.assertNotEquals(1, 2);
-        Assert.assertFalse(false);
-        Assert.assertTrue(true);
+        Assert.assertEquals("One is one", 1, 1);
+        Assert.assertArrayEquals("Empty is empty", new int[]{}, new int[]{});
+        Assert.assertNotEquals("one is not two", 1, 2);
+        Assert.assertFalse("false is false", false);
+        Assert.assertTrue("true is true", true);
+        Assert.assertEquals("foo is foo", "foo", "foo");
+        Assert.assertNull("null is null", null);
+        Assert.fail("fail");
     }
 
     @Test

src/main/java/org/openrewrite/java/testing/junit5/AssertToAssertions.java

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2020 the original author or authors.
+ * <p>
+ * 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
+ * <p>
+ * https://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * 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 org.openrewrite.java.testing.junit5;
+
+import org.openrewrite.AutoConfigure;
+import org.openrewrite.Formatting;
+import org.openrewrite.java.ChangeType;
+import org.openrewrite.java.JavaIsoRefactorVisitor;
+import org.openrewrite.java.search.SemanticallyEqual;
+import org.openrewrite.java.tree.Expression;
+import org.openrewrite.java.tree.J;
+import org.openrewrite.java.tree.JavaType;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * Change JUnit4's org.junit.Assert into JUnit5's org.junit.jupiter.api.Assertions
+ * The most significant difference between these classes is that in JUnit4 the optional String message is the first
+ * parameter, and the JUnit5 versions have the optional message as the final parameter
+ */
+@AutoConfigure
+public class AssertToAssertions extends JavaIsoRefactorVisitor {
+
+    @Override
+    public J.ClassDecl visitClassDecl(J.ClassDecl classDecl) {
+        ChangeType ct = new ChangeType();
+        ct.setType("org.junit.Assert");
+        ct.setTargetType("org.junit.jupiter.api.Assertions");
+        andThen(ct);
+        return super.visitClassDecl(classDecl);
+    }
+
+    @Override
+    public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method) {
+        J.MethodInvocation m = super.visitMethodInvocation(method);
+        if(!isJunitAssertMethod(m)) {
+            return m;
+        }
+        List<Expression> args = m.getArgs().getArgs();
+        Expression firstArg = args.get(0);
+        // Suppress arg-switching for Assertions.assertEquals(String, String)
+        if(args.size() == 2 && isString(firstArg.getType()) && isString(args.get(1).getType())) {
+            return m;
+        }
+        if(isString(firstArg.getType())) {
+            // Move the first arg to be the last argument, then switch the formatting of the first and last arguments
+            Formatting firstFormatting = firstArg.getFormatting();
+            Formatting lastFormatting = args.get(args.size() - 1).getFormatting();
+
+            List<Expression> newArgs = Stream.concat(
+                 args.stream().skip(1),
+                 Stream.of(firstArg)
+            ).collect(Collectors.toList());
+
+            int lastIndex = newArgs.size() - 1;
+            newArgs.set(0, newArgs.get(0).withFormatting(firstFormatting));
+            newArgs.set(lastIndex, newArgs.get(lastIndex).withFormatting(lastFormatting));
+
+            m = m.withArgs(m.getArgs().withArgs(newArgs));
+        }
+
+        return m;
+    }
+
+    private boolean isJunitAssertMethod(J.MethodInvocation method) {
+        if(!(method.getSelect() instanceof J.Ident)) {
+            return false;
+        }
+        J.Ident receiver = (J.Ident) method.getSelect();
+        if(!(receiver.getType() instanceof JavaType.FullyQualified)) {
+            return false;
+        }
+        JavaType.FullyQualified receiverType = (JavaType.FullyQualified) receiver.getType();
+        return receiverType.getFullyQualifiedName().equals("org.junit.Assert");
+    }
+
+    private boolean isString(JavaType type) {
+        return type instanceof JavaType.Primitive
+                && ((JavaType.Primitive)type).name().equals("String");
+    }
+}

src/main/resources/META-INF/rewrite/junit5.yml

@@ -40,8 +40,6 @@ visitors:
       type: org.junit.Assume
       targetType: org.junit.jupiter.api.Assumptions
 ---
-
----
 type: specs.openrewrite.org/v1beta/recipe
 name: org.openrewrite.java.testing.JUnit5Migration
 include:

src/test/kotlin/org/openrewrite/java/testing/junit5/AssertToAssertionsTest.kt

@@ -0,0 +1,143 @@
+/*
+ * Copyright 2020 the original author or authors.
+ * <p>
+ * 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
+ * <p>
+ * https://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * 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 org.openrewrite.java.testing.junit5
+
+import org.junit.jupiter.api.Test
+import org.openrewrite.RefactorVisitorTestForParser
+import org.openrewrite.java.JavaParser
+import org.openrewrite.java.tree.J
+
+class AssertToAssertionsTest : RefactorVisitorTestForParser<J.CompilationUnit> {
+    override val parser: JavaParser = JavaParser.fromJavaVersion()
+            .classpath("junit")
+            .build()
+
+    override val visitors = listOf(AssertToAssertions())
+
+    @Test
+    fun assertWithoutMessage() = assertRefactored(
+            before = """
+                import org.junit.Assert;
+                
+                class A {
+                
+                    void foo() {
+                        Assert.assertEquals(1, 1);
+                        Assert.assertArrayEquals(new int[]{}, new int[]{});
+                        Assert.assertNotEquals(1, 2);
+                        Assert.assertFalse(false);
+                        Assert.assertTrue(true);
+                        Assert.assertEquals("foo", "foo");
+                        Assert.assertNull(null);
+                        Assert.fail();
+                    }
+                }
+            """,
+            after = """
+                import org.junit.jupiter.api.Assertions;
+                
+                class A {
+                
+                    void foo() {
+                        Assertions.assertEquals(1, 1);
+                        Assertions.assertArrayEquals(new int[]{}, new int[]{});
+                        Assertions.assertNotEquals(1, 2);
+                        Assertions.assertFalse(false);
+                        Assertions.assertTrue(true);
+                        Assertions.assertEquals("foo", "foo");
+                        Assertions.assertNull(null);
+                        Assertions.fail();
+                    }
+                }
+            """
+    )
+
+    @Test
+    fun staticAssertWithoutMessage() = assertRefactored(
+            before = """
+                import static org.junit.Assert.*;
+                
+                class A {
+                
+                    void foo() {
+                        assertEquals(1, 1);
+                        assertArrayEquals(new int[]{}, new int[]{});
+                        assertNotEquals(1, 2);
+                        assertFalse(false);
+                        assertTrue(true);
+                        assertEquals("foo", "foo");
+                        assertNull(null);
+                        fail();
+                    }
+                }
+            """,
+            after = """
+                import static org.junit.jupiter.api.Assertions.*;
+                
+                class A {
+                
+                    void foo() {
+                        assertEquals(1, 1);
+                        assertArrayEquals(new int[]{}, new int[]{});
+                        assertNotEquals(1, 2);
+                        assertFalse(false);
+                        assertTrue(true);
+                        assertEquals("foo", "foo");
+                        assertNull(null);
+                        fail();
+                    }
+                }
+            """
+    )
+
+    @Test
+    fun assertWithMessage() = assertRefactored(
+            before = """
+                import org.junit.Assert;
+                
+                class A {
+                
+                    void foo() {
+                        Assert.assertEquals("One is one", 1, 1);
+                        Assert.assertArrayEquals("Empty is empty", new int[]{}, new int[]{});
+                        Assert.assertNotEquals("one is not two", 1, 2);
+                        Assert.assertFalse("false is false", false);
+                        Assert.assertTrue("true is true", true);
+                        Assert.assertEquals("foo is foo", "foo", "foo");
+                        Assert.assertNull("null is null", null);
+                        Assert.fail("fail");
+                    }
+                }
+            """,
+            after = """
+                import org.junit.jupiter.api.Assertions;
+                
+                class A {
+                
+                    void foo() {
+                        Assertions.assertEquals(1, 1, "One is one");
+                        Assertions.assertArrayEquals(new int[]{}, new int[]{}, "Empty is empty");
+                        Assertions.assertNotEquals(1, 2, "one is not two");
+                        Assertions.assertFalse(false, "false is false");
+                        Assertions.assertTrue(true, "true is true");
+                        Assertions.assertEquals("foo", "foo", "foo is foo");
+                        Assertions.assertNull(null, "null is null");
+                        Assertions.fail("fail");
+                    }
+                }
+            """
+    )
+}