Merge branch '3.0.x' into 3.1.x

Author: graemerocher

grails-core/src/main/groovy/org/grails/transaction/transform/TransactionalTransform.groovy

@@ -75,6 +75,7 @@ class TransactionalTransform implements ASTTransformation{
     private static final String METHOD_EXECUTE = "execute"
     private static final Set<String> METHOD_NAME_EXCLUDES = new HashSet<String>(Arrays.asList("afterPropertiesSet", "destroy"));
     private static final Set<String> ANNOTATION_NAME_EXCLUDES = new HashSet<String>(Arrays.asList(PostConstruct.class.getName(), PreDestroy.class.getName(), Transactional.class.getName(), Rollback.class.getName(), "grails.web.controllers.ControllerMethod", NotTransactional.class.getName()));
+    private static final Set<String> JUNIT_ANNOTATION_NAMES = new HashSet<String>(Arrays.asList("org.junit.Before", "org.junit.After"));
     private static final String SPEC_CLASS = "spock.lang.Specification";
     public static final String PROPERTY_DATA_SOURCE = "datasource"
 
@@ -116,7 +117,8 @@ class TransactionalTransform implements ASTTransformation{
         for (MethodNode md in methods) {
             String methodName = md.getName()
             int modifiers = md.modifiers
-            if (!md.isSynthetic() && Modifier.isPublic(modifiers) && !Modifier.isAbstract(modifiers) && !Modifier.isStatic(modifiers)) {
+            if (!md.isSynthetic() && Modifier.isPublic(modifiers) && !Modifier.isAbstract(modifiers) &&
+                !Modifier.isStatic(modifiers) && !hasJunitAnnotation(md)) {
                 if(hasExcludedAnnotation(md)) continue
 
                 def startsWithSpock = methodName.startsWith('$spock')
@@ -138,7 +140,8 @@ class TransactionalTransform implements ASTTransformation{
                 if(hasAnnotation(md, DelegatingMethod.class)) continue
                 weaveTransactionalMethod(source, classNode, annotationNode, md);
             }
-            else if(("setup".equals(methodName) ||  "cleanup".equals(methodName)) && isSpockTest(classNode)) {
+            else if ((("setup".equals(methodName) || "cleanup".equals(methodName)) && isSpockTest(classNode)) ||
+                hasJunitAnnotation(md)) {
                 def requiresNewTransaction = new AnnotationNode(annotationNode.classNode)
                 requiresNewTransaction.addMember("propagation", new PropertyExpression(new ClassExpression(ClassHelper.make(Propagation.class)), "REQUIRES_NEW"))
                 weaveTransactionalMethod(source, classNode, requiresNewTransaction, md, "execute")
@@ -161,6 +164,17 @@ class TransactionalTransform implements ASTTransformation{
         excludedAnnotation
     }
 
+    private boolean hasJunitAnnotation(MethodNode md) {
+        boolean excludedAnnotation = false;
+        for (AnnotationNode annotation : md.getAnnotations()) {
+            if(JUNIT_ANNOTATION_NAMES.contains(annotation.getClassNode().getName())) {
+                excludedAnnotation = true;
+                break;
+            }
+        }
+        excludedAnnotation
+    }
+
     ClassNode getAnnotationClassNode(String annotationName) {
         try {
             final classLoader = Thread.currentThread().contextClassLoader

grails-core/src/test/groovy/grails/transaction/TransactionalTransformSpec.groovy

@@ -130,6 +130,46 @@ class TransactionalTransformSpec extends Specification {
 
     }
 
+  void "Test @Rollback when applied to JUnit specifications"() {
+    when:
+    Class mySpec = new GroovyShell().evaluate('''
+    import grails.transaction.*
+    import org.junit.Test
+    import org.junit.Before
+    import org.junit.After
+
+    @Rollback
+    class MyJunitTest {
+        @Before
+        def junitSetup() {
+
+        }
+
+        @After
+        def junitCleanup() {
+
+        }
+
+        @Test
+        void junitTest() {
+            expect:
+                1 == 1
+        }
+    }
+    MyJunitTest
+    ''')
+
+    then: "It implements TransactionManagerAware"
+    TransactionManagerAware.isAssignableFrom(mySpec)
+    mySpec.getDeclaredMethod('junitSetup')
+    mySpec.getDeclaredMethod('$tt__junitSetup', TransactionStatus)
+    mySpec.getDeclaredMethod('junitCleanup')
+    mySpec.getDeclaredMethod('$tt__junitCleanup', TransactionStatus)
+
+    mySpec.getDeclaredMethod('junitTest')
+    mySpec.getDeclaredMethod('$tt__junitTest', TransactionStatus)
+  }
+
     void "Test @Rollback when applied to Spock specifications"() {
         when: "A new instance of a class with a @Transactional method is created that subclasses another transactional class"
         Class mySpec = new GroovyShell().evaluate('''

grails-gradle-plugin/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy

@@ -34,6 +34,7 @@ import org.gradle.api.artifacts.ConfigurationContainer
 import org.gradle.api.artifacts.Dependency
 import org.gradle.api.artifacts.DependencyResolveDetails
 import org.gradle.api.file.CopySpec
+import org.gradle.api.file.FileCollection
 import org.gradle.api.java.archives.Manifest
 import org.gradle.api.plugins.GroovyPlugin
 import org.gradle.api.plugins.WarPlugin
@@ -489,7 +490,7 @@ class GrailsGradlePlugin extends GroovyPlugin {
 
     protected void configurePathingJar(Project project) {
         project.afterEvaluate {
-            ConfigurationContainer configurations =  project.configurations
+            ConfigurationContainer configurations = project.configurations
             Configuration runtime = configurations.getByName('runtime')
             Configuration console = configurations.getByName('console')
 
@@ -507,25 +508,28 @@ class GrailsGradlePlugin extends GroovyPlugin {
             }
 
             Jar pathingJar = createPathingJarTask(project, "pathingJar", runtime)
+            FileCollection pathingClasspath = project.files("${project.buildDir}/classes/main",
+              "${project.buildDir}/resources/main", "${project.projectDir}/gsp-classes", pathingJar.archivePath)
             Jar pathingJarCommand = createPathingJarTask(project, "pathingJarCommand", runtime, console)
+            FileCollection pathingClasspathCommand = project.files("${project.buildDir}/classes/main",
+              "${project.buildDir}/resources/main", "${project.projectDir}/gsp-classes", pathingJarCommand.archivePath)
 
             GrailsExtension grailsExt = project.extensions.getByType(GrailsExtension)
 
             if (grailsExt.pathingJar && Os.isFamily(Os.FAMILY_WINDOWS)) {
-
-                TaskContainer tasks = project.tasks
-
-                tasks.withType(JavaExec) { JavaExec task ->
-                    task.dependsOn(pathingJar)
-                    task.doFirst {
-                        classpath = project.files("${project.buildDir}/classes/main", "${project.buildDir}/resources/main", "${project.projectDir}/gsp-classes", pathingJar.archivePath)
+                project.tasks.withType(JavaExec) { JavaExec task ->
+                    if (task.name in ['console', 'shell'] || task instanceof ApplicationContextCommandTask) {
+                        task.dependsOn(pathingJarCommand)
+                        task.doFirst {
+                            classpath = pathingClasspathCommand
+                        }
+                    } else {
+                        task.dependsOn(pathingJar)
+                        task.doFirst {
+                            classpath = pathingClasspath
+                        }
                     }
                 }
-
-                tasks.withType(ApplicationContextCommandTask) { ApplicationContextCommandTask task ->
-                    task.dependsOn(pathingJarCommand)
-                    task.systemProperties = ['grails.env': 'development']
-                }
             }
         }
     }