Fix ChangeTestAnnotation not putting {} around some single-line statements in lambda bodies

Author: sambsnyd

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

@@ -16,6 +16,7 @@
 package org.openrewrite.java.testing.junit5;
 
 import org.junit.AfterClass;
+import org.junit.Assert;
 import org.junit.BeforeClass;
 import org.junit.Rule;
 import org.junit.Test;
@@ -50,14 +51,25 @@ public void foo() throws IOException {
         throw new RuntimeException(foo);
     }
 
-    @Test(timeout = 500)
-    public void bar() { }
+    @Test(expected = IndexOutOfBoundsException.class)
+    public void foo2() {
+        int arr = new int[]{}[0];
+    }
 
-private File newFolder(File root, String ... folders) throws IOException {
-    File result = new File(root, String.join("/", folders));
-    if(!result.mkdirs()) {
-        throw new IOException("Couldn't create folders " + root);
+    @Test
+    public void assertsStuff() {
+        Assert.assertEquals(1, 1);
+        Assert.assertArrayEquals(new int[]{}, new int[]{});
+        Assert.assertNotEquals(1, 2);
+        Assert.assertFalse(false);
+        Assert.assertTrue(true);
     }
-    return result;
-}
+
+    @Test
+    public void lambdaThrow() {
+
+    }
+
+    @Test(timeout = 500)
+    public void bar() { }
 }

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

@@ -75,15 +75,21 @@ public J.MethodDecl visitMethod(J.MethodDecl method) {
                         if(assignParamName.equals("expected")) {
                             List<Statement> statements = m.getBody().getStatements();
 
-                            Statement assertBlock = statements.size() == 1 ?
-                                    statements.get(0).withPrefix(" ") :
-                                    new J.Block<>(
-                                            randomId(),
-                                            null,
-                                            statements,
-                                            format(" "),
-                                            new J.Block.End(randomId(), format("\n"))
-                                    );
+                            // The Java 11 Specification says that lambda bodies can be either a single expression
+                            // or a block. So put a block around anything that isn't exactly one expression.
+                            boolean isSingleExpression = statements.size() == 1 && statements.get(0) instanceof Expression;
+                            Statement assertBlock;
+                            if(isSingleExpression) {
+                                assertBlock = statements.get(0).withPrefix(" ");
+                            } else {
+                                assertBlock = new J.Block<>(
+                                        randomId(),
+                                        null,
+                                        statements,
+                                        format(" "),
+                                        new J.Block.End(randomId(), format("\n"))
+                                );
+                            }
 
                             J.MethodInvocation assertThrows = new J.MethodInvocation(
                                     randomId(),

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

@@ -40,6 +40,8 @@ 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/BeforeToAfter.kt

@@ -30,7 +30,7 @@ fun main(args: Array<String>) {
             .classpath("mockito-all", "junit")
             .build()
 
-    val visitors = loadVisitorsForTest("org.openrewrite.java.testing.Mockito", "org.openrewrite.java.testing.junit5.migration")
+    val visitors = loadVisitorsForTest("org.openrewrite.java.testing.JUnit5Migration", "org.openrewrite.java.testing.Mockito1to3Migration")
     val sources = parser.parse(listJavaSources(beforeDir), beforeDir)
     val changes = Refactor(true)
             .visit(visitors)

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

@@ -51,12 +51,76 @@ class ChangeTestAnnotationTest: RefactorVisitorTestForParser<J.CompilationUnit>
                 
                     @Test
                     public void test() {
-                        assertThrows(IllegalArgumentException.class, () -> throw new IllegalArgumentException("boom"));
+                        assertThrows(IllegalArgumentException.class, () -> {
+                            throw new IllegalArgumentException("boom");
+                        });
                     }
                 }
             """.trimIndent()
     )
 
+    @Test
+    fun assertThrowsSingleStatement() = assertRefactored(
+            before = """
+                import org.junit.Test;
+                
+                public class A {
+                
+                    @Test(expected = IndexOutOfBoundsException.class)
+                    public void test() {
+                        int arr = new int[]{}[0];
+                    }
+                }
+            """,
+            after = """
+                import org.junit.jupiter.api.Test;
+                
+                import static org.junit.jupiter.api.Assertions.assertThrows;
+                
+                public class A {
+                
+                    @Test
+                    public void test() {
+                        assertThrows(IndexOutOfBoundsException.class, () -> {
+                            int arr = new int[]{}[0];
+                        });
+                    }
+                }
+            """
+    )
+
+    @Test
+    fun assertThrowsMultiLine() = assertRefactored(
+            before = """
+                import org.junit.Test;
+                
+                public class A {
+                
+                    @Test(expected = IllegalArgumentException.class)
+                    public void test() {
+                        String foo = "foo";
+                        throw new IllegalArgumentException("boom");
+                    }
+                }
+            """,
+            after = """
+                import org.junit.jupiter.api.Test;
+                
+                import static org.junit.jupiter.api.Assertions.assertThrows;
+                
+                public class A {
+                
+                    @Test
+                    public void test() {
+                        assertThrows(IllegalArgumentException.class, () -> {
+                            String foo = "foo";
+                            throw new IllegalArgumentException("boom");
+                        });
+                    }
+                }
+            """
+    )
+
     @Test
     fun noTestAnnotationValues() = assertRefactored(
             before = """
@@ -127,7 +191,9 @@ class ChangeTestAnnotationTest: RefactorVisitorTestForParser<J.CompilationUnit>
                     @Test
                     @Timeout(500)
                     public void test() {
-                        assertThrows(IllegalArgumentException.class, () -> throw new IllegalArgumentException("boom"));
+                        assertThrows(IllegalArgumentException.class, () -> {
+                            throw new IllegalArgumentException("boom");
+                        });
                     }
                 }
             """