Merge remote-tracking branch 'upstream/8.0.x-hibernate7-dev' into 8.0.x-hibernate7

Author: jdaugherty

AGENTS.md

@@ -52,7 +52,8 @@ export GRADLE_OPTS="-Xms2G -Xmx5G"
 9. **Test via public APIs** - Tests must exercise behavior through the same APIs an end user calls; never invoke internal implementations, package-private methods, or bypass the public surface directly
 10. **Always review and extend tests** - Review existing unit and functional tests before making changes; every code change must include new or enhanced tests that cover the affected behavior
 11. **Every code touch must update all tests for the changed class** - When a class is modified, find and update every test that covers it — unit, integration, and TCK. Do not leave any existing test out of sync with the new code.
-12. **Clean violations before commit** - Before every automated commit, run `./gradlew clean test aggregateTestFailures --continue` from the root and ensure that `TEST_FAILURES.md` reports no issues and is removed.
+12. **Clean violations before commit** - Before every automated commit, run `./gradlew clean aggregateStyleViolations test aggregateTestFailures --continue` from the root and ensure that `CHECKSTYLE_VIOLATIONS.md`, `CODENARC_VIOLATIONS.md`, `PMD_VIOLATIONS.md`, and `TEST_FAILURES.md` report no issues and are removed.
+13. **Mandatory test coverage** - Any class touched in a commit MUST be covered with tests that verify all behavior. You must run ALL tests in the affected module(s) and ensure they pass before committing.
 
 ## Available Skills
 
@@ -232,7 +233,8 @@ class MyService { }
 2. **Run tests** before submitting: `./gradlew build --rerun-tasks`
 3. **Run code style checks**: `./gradlew codeStyle`
 4. **Clean style violations**: Before committing, run `./gradlew clean aggregateStyleViolations` from the root and ensure that `CHECKSTYLE_VIOLATIONS.md`, `CODENARC_VIOLATIONS.md`, and `PMD_VIOLATIONS.md` have no issues.
-5. **Squash commits** into a single meaningful commit message
+5. **Verify test coverage**: Ensure any touched class is covered by tests verifying all behavior. You must run ALL tests in the affected module(s) and ensure they pass before submission.
+6. **Squash commits** into a single meaningful commit message
 6. **Reference issues** in PR description (e.g., "Fixes #1234")
 
 ### Review Process

build-logic/plugins/src/main/groovy/org/apache/grails/buildsrc/GrailsCodeStylePlugin.groovy

@@ -49,6 +49,10 @@ import com.github.spotbugs.snom.Effort
 import com.github.spotbugs.snom.SpotBugsExtension
 import com.github.spotbugs.snom.SpotBugsPlugin
 import com.github.spotbugs.snom.SpotBugsTask
+import org.gradle.api.tasks.testing.Test
+import org.gradle.testing.jacoco.plugins.JacocoPlugin
+import org.gradle.testing.jacoco.plugins.JacocoPluginExtension
+import org.gradle.testing.jacoco.tasks.JacocoReport
 
 /**
  * Convention plugin for Grails code style enforcement.
@@ -77,6 +81,8 @@ class GrailsCodeStylePlugin implements Plugin<Project> {
 
     static String SPOTBUGS_ENABLED_PROPERTY = 'grails.codestyle.enabled.spotbugs'
 
+    static String JACOCO_ENABLED_PROPERTY = 'grails.codestyle.enabled.jacoco'
+
     static String IGNORE_FAILURES_PROPERTY = 'grails.codestyle.ignoreFailures'
 
     static String TEST_STYLING_PROPERTY = 'grails.codestyle.enabled.tests'
@@ -88,6 +94,44 @@ class GrailsCodeStylePlugin implements Plugin<Project> {
         initExtension(project)
         configureCodeStyle(project)
         configureAggregation(project)
+        
+        boolean jacocoEnabled = GradleUtils.lookupProperty(project, JACOCO_ENABLED_PROPERTY, false)
+        if (jacocoEnabled) {
+            configureJacoco(project)
+            if (project == project.rootProject) {
+                project.logger.info("JaCoCo enabled globally, applying to subprojects")
+                project.subprojects.each { subproject ->
+                    subproject.pluginManager.withPlugin('java') {
+                        configureJacoco(subproject)
+                    }
+                    subproject.pluginManager.withPlugin('groovy') {
+                        configureJacoco(subproject)
+                    }
+                }
+            }
+        }
+    }
+
+    static void configureJacoco(Project project) {
+        project.logger.info("Configuring JaCoCo for project: ${project.name}")
+        project.pluginManager.apply(JacocoPlugin)
+
+        project.extensions.configure(JacocoPluginExtension) {
+            it.toolVersion = "0.8.14"
+        }
+
+        project.tasks.withType(Test).configureEach {
+            it.finalizedBy 'jacocoTestReport'
+        }
+
+        project.tasks.withType(JacocoReport).configureEach {
+            it.dependsOn project.tasks.withType(Test)
+            it.reports {
+                it.xml.required = true
+                it.html.required = true
+                it.csv.required = true
+            }
+        }
     }
 
     private static void configureAggregation(Project project) {
@@ -101,6 +145,7 @@ class GrailsCodeStylePlugin implements Plugin<Project> {
             task.description = 'Aggregates all code style violations into separate reports'
 
             boolean checkTests = GradleUtils.lookupProperty(project, TEST_STYLING_PROPERTY, false)
+            boolean jacocoEnabled = GradleUtils.lookupProperty(project, JACOCO_ENABLED_PROPERTY, false)
 
             // Dependencies: all check tasks in all subprojects
             root.subprojects.each { subproject ->
@@ -125,13 +170,22 @@ class GrailsCodeStylePlugin implements Plugin<Project> {
                         checkTests || (!t.name.toLowerCase().contains('test') && !t.name.toLowerCase().contains('integrationtest'))
                     })
                 }
+
+                if (jacocoEnabled) {
+                    task.dependsOn(subproject.tasks.withType(JacocoReport))
+                }
             }
 
             def reportsDir = project.extensions.getByType(GrailsCodeStyleExtension).reportsDirectory
-            task.inputs.dir(reportsDir).optional(true)
+            task.inputs.dir(reportsDir).optional()
             task.outputs.file(root.layout.projectDirectory.file('CODENARC_VIOLATIONS.md'))
             task.outputs.file(root.layout.projectDirectory.file('CHECKSTYLE_VIOLATIONS.md'))
             task.outputs.file(root.layout.projectDirectory.file('PMD_VIOLATIONS.md'))
+            task.outputs.file(root.layout.projectDirectory.file('SPOTBUGS_VIOLATIONS.md'))
+            
+            if (jacocoEnabled) {
+                task.outputs.file(root.layout.projectDirectory.file('JACOCO_COVERAGE_VIOLATIONS.md'))
+            }
 
             task.doLast {
                 parseViolations(root, reportsDir.get())
@@ -146,6 +200,7 @@ class GrailsCodeStylePlugin implements Plugin<Project> {
         slurper.setFeature("http://xml.org/sax/features/namespaces", false)
 
         boolean checkTests = GradleUtils.lookupProperty(project, TEST_STYLING_PROPERTY, false)
+        boolean jacocoEnabled = GradleUtils.lookupProperty(project, JACOCO_ENABLED_PROPERTY, false)
 
         def getModule = { String fileName ->
             def lastDash = fileName.lastIndexOf('-')
@@ -294,6 +349,94 @@ class GrailsCodeStylePlugin implements Plugin<Project> {
             }
         }
         writeReport('CHECKSTYLE_VIOLATIONS.md', checkstyleViolations, 'Checkstyle Violations Summary')
+
+        // 4. SpotBugs
+        def spotbugsViolations = []
+        def spotbugsDir = reportsDir.dir('spotbugs').asFile
+        if (spotbugsDir.exists() && GradleUtils.lookupProperty(project, SPOTBUGS_ENABLED_PROPERTY, false)) {
+            spotbugsDir.eachFileMatch(~/.*\.xml/) { file ->
+                if (file.size() == 0 || (!checkTests && isTestFile(file.name))) {
+                    return
+                }
+                def module = getModule(file.name)
+                def xml = slurper.parse(file)
+                xml.BugInstance.each { b ->
+                    def className = b.Class.@classname.text()
+                    if (shouldSkipClass(className)) {
+                        return
+                    }
+                    spotbugsViolations << [
+                            module: module,
+                            className: className,
+                            tool: 'SpotBugs',
+                            type: b.@type.text(),
+                            line: b.SourceLine.@start.text(),
+                            message: b.LongMessage.text().trim()
+                    ]
+                }
+            }
+        }
+        writeReport('SPOTBUGS_VIOLATIONS.md', spotbugsViolations, 'SpotBugs Violations Summary')
+
+        // 5. JaCoCo
+        if (jacocoEnabled) {
+            project.logger.info("Aggregating JaCoCo coverage reports")
+            def jacocoCoverage = []
+            project.rootProject.allprojects.each { p ->
+                // JaCoCo reports for test are usually in build/reports/jacoco/test/jacocoTestReport.csv
+                def csvReport = p.file("build/reports/jacoco/test/jacocoTestReport.csv")
+                if (csvReport.exists()) {
+                    project.logger.debug("Processing JaCoCo report: ${csvReport.absolutePath}")
+                    csvReport.splitEachLine(',') { fields ->
+                        if (fields.size() < 5 || fields[0] == 'GROUP') return // header or malformed line
+                        def module = fields[0]
+                        def pkg = fields[1]
+                        def clazz = fields[2]
+                        def missedStr = fields[3]
+                        def coveredStr = fields[4]
+
+                        // Skip if fields are not numeric
+                        if (missedStr.isNumber() && coveredStr.isNumber()) {
+                            def m = missedStr.toInteger()
+                            def c = coveredStr.toInteger()
+                            def total = m + c
+                            def percent = total > 0 ? (c * 100 / total).round(2) : 100.0
+
+                            jacocoCoverage << [
+                                    module   : module,
+                                    className: "${pkg}.${clazz}",
+                                    percent  : percent
+                            ]
+                        }
+                    }
+                }
+            }
+
+            if (!jacocoCoverage.isEmpty()) {
+                // Filter out classes in the 'org.grails.orm.hibernate.support.hibernate7' package
+                jacocoCoverage.removeIf { it.className.startsWith('org.grails.orm.hibernate.support.hibernate7.') }
+
+                def jacocoReportFile = project.layout.projectDirectory.file('JACOCO_COVERAGE_VIOLATIONS.md').asFile
+                def out = new StringBuilder()
+                out.append("# JaCoCo Coverage Report\n")
+                out.append("Generated on: ${LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))}\n\n")
+
+                def groupedByModule = jacocoCoverage.groupBy { it.module }.sort()
+                groupedByModule.each { module, coverageList ->
+                    out.append("## Module: ${module}\n")
+                    out.append("| Class | % Instructions Covered |\n")
+                    out.append("| :--- | :--- |\n")
+                    coverageList.sort { it.percent }.each { c ->
+                        out.append("| ${c.className} | ${c.percent}% |\n")
+                    }
+                    out.append("\n")
+                }
+                jacocoReportFile.text = out.toString()
+                project.logger.lifecycle("Aggregated JaCoCo report generated: ${jacocoReportFile.absolutePath}")
+            } else {
+                project.logger.info("No JaCoCo coverage reports found to aggregate")
+            }
+        }
     }
 
     private static void initExtension(Project project) {
@@ -451,7 +594,7 @@ class GrailsCodeStylePlugin implements Plugin<Project> {
         }
 
         if (!GradleUtils.lookupProperty(project, TEST_STYLING_PROPERTY, false)) {
-            project.tasks.named('checkstyleTest') {
+            project.tasks.matching { it.name == 'checkstyleTest' }.configureEach {
                 it.enabled = false // Do not check test sources at this time
             }
         }
@@ -661,10 +804,8 @@ class GrailsCodeStylePlugin implements Plugin<Project> {
             project.afterEvaluate {
                 // Do not check test sources at this time
                 ['codenarcIntegrationTest', 'codenarcTest'].each { testTaskName ->
-                    if (project.tasks.names.contains(testTaskName)) {
-                        project.tasks.named(testTaskName) {
-                            it.enabled = false
-                        }
+                    project.tasks.matching { it.name == testTaskName }.configureEach {
+                        it.enabled = false
                     }
                 }
             }

build-logic/plugins/src/test/groovy/org/apache/grails/buildsrc/GrailsCodeStylePluginSpec.groovy

@@ -48,6 +48,90 @@ class GrailsCodeStylePluginSpec extends Specification {
         groovyFile = testProjectDir.resolve('src/main/groovy/Test.groovy').toFile()
     }
 
+    def "test codeStyle and aggregation tasks including jacoco"() {
+        given: "a project structure with violations and jacoco report"
+        testProjectDir.resolve('build/reports/codestyle/checkstyle').toFile().mkdirs()
+        testProjectDir.resolve('build/reports/codestyle/codenarc').toFile().mkdirs()
+        def jacocoDir = testProjectDir.resolve('build/reports/jacoco/test').toFile()
+        jacocoDir.mkdirs()
+        
+        buildFile = testProjectDir.resolve('settings.gradle').toFile()
+        buildFile.text = "include 'app-module'"
+        def moduleDir = testProjectDir.resolve('app-module')
+        def moduleBuildFile = moduleDir.resolve('build.gradle').toFile()
+        moduleBuildFile.parentFile.mkdirs()
+        moduleBuildFile.text = """
+            plugins {
+                id 'groovy'
+                id 'jacoco'
+                id 'org.apache.grails.gradle.grails-code-style'
+            }
+            repositories {
+                mavenCentral()
+            }
+            dependencies {
+                implementation 'org.apache.groovy:groovy:4.0.11'
+            }
+        """
+        def sourceFile = moduleDir.resolve('src/main/groovy/com/example/AppClass.groovy')
+        sourceFile.toFile().parentFile.mkdirs()
+        sourceFile.toFile().text = "package com.example\nclass AppClass {}"
+
+        def checkstyleReport = testProjectDir.resolve('build/reports/codestyle/checkstyle/app-module-checkstyleMain.xml').toFile()
+        checkstyleReport.parentFile.mkdirs()
+        checkstyleReport.text = """<?xml version="1.0" encoding="UTF-8"?>
+<checkstyle version="10.0">
+<file name="${sourceFile.toFile().absolutePath}">
+<error line="1" column="1" severity="error" message="Missing a Javadoc comment." source="com.puppycrawl.tools.checkstyle.checks.javadoc.JavadocPackageCheck"/>
+</file>
+</checkstyle>
+"""
+        def codenarcReport = testProjectDir.resolve('build/reports/codestyle/codenarc/app-module-codenarcMain.xml').toFile()
+        codenarcReport.parentFile.mkdirs()
+        codenarcReport.text = """<?xml version="1.0" encoding="UTF-8"?>
+<CodeNarc version="3.1.0">
+<Package name="com.example">
+<File name="AppClass.groovy">
+<Violation ruleName="EmptyClass" priority="2" lineNumber="1">
+<Message>The class is empty</Message>
+</Violation>
+</File>
+</Package>
+</CodeNarc>
+"""
+        def csvReport = new File(jacocoDir, 'jacocoTestReport.csv')
+        csvReport.text = """GROUP,PACKAGE,CLASS,INSTRUCTION_MISSED,INSTRUCTION_COVERED,BRANCH_MISSED,BRANCH_COVERED,LINE_MISSED,LINE_COVERED,COMPLEXITY_MISSED,COMPLEXITY_COVERED,METHOD_MISSED,METHOD_COVERED
+app-module,com.example,AppClass,1,9,0,0,0,1,0,1,0,1
+"""
+
+        when: "running aggregateStyleViolations with jacoco enabled"
+        def result = GradleRunner.create()
+                .withProjectDir(testProjectDir.toFile())
+                .withArguments('aggregateStyleViolations', '-Pgrails.codestyle.enabled.jacoco=true', '-x', 'checkstyleMain', '-x', 'codenarcMain', '--stacktrace')
+                .withPluginClasspath()
+                .build()
+
+        then: "task finished successfully"
+        result.task(':aggregateStyleViolations').outcome == org.gradle.testkit.runner.TaskOutcome.SUCCESS
+
+        and: "violation reports are generated"
+        testProjectDir.resolve('CHECKSTYLE_VIOLATIONS.md').toFile().exists()
+        testProjectDir.resolve('CODENARC_VIOLATIONS.md').toFile().exists()
+        testProjectDir.resolve('JACOCO_COVERAGE_VIOLATIONS.md').toFile().exists()
+        
+        def checkstyleMd = testProjectDir.resolve('CHECKSTYLE_VIOLATIONS.md').toFile().text
+        checkstyleMd.contains('## Module: app-module')
+        checkstyleMd.contains('| com.example.AppClass | Checkstyle | JavadocPackageCheck | 1 | Missing a Javadoc comment. |')
+
+        def codenarcMd = testProjectDir.resolve('CODENARC_VIOLATIONS.md').toFile().text
+        codenarcMd.contains('## Module: app-module')
+        codenarcMd.contains('| com.example.AppClass | CodeNarc | EmptyClass | 1 | The class is empty |')
+
+        def jacocoMd = testProjectDir.resolve('JACOCO_COVERAGE_VIOLATIONS.md').toFile().text
+        jacocoMd.contains('## Module: app-module')
+        jacocoMd.contains('| com.example.AppClass | 90.00% |')
+    }
+
     def "test codenarcFix task fixes violations"() {
         given: "a file with violations"
         groovyFile.text = """package org.test
@@ -75,13 +159,11 @@ class Test{
         and: "violations are fixed"
         def fixedContent = groovyFile.text
         fixedContent.contains('class Test {') // SpaceBeforeOpeningBrace
-        // Note: ClassStartsWithBlankLine regex in the plugin is:
-        // content.replaceAll(/(class\s+[^{]+\{\n)([ \t]*[^ \s\n\/])/, '$1\n$2')
-        // In our case, it should match "class Test{\n    def map" and insert a newline
         fixedContent.contains('class Test {\n\n    def map') 
-        fixedContent.contains('[key: \'value\']') // SpaceAroundMapEntryColon and UnnecessaryGString
+        fixedContent.contains("[key: 'value']") // SpaceAroundMapEntryColon and UnnecessaryGString
         fixedContent.contains("'unnecessary gstring'") // UnnecessaryGString
-        fixedContent.contains('def semi = \'semicolon\'\n') // UnnecessarySemicolon
-        fixedContent.count('\n\n') == 3 // ConsecutiveBlankLines (3 reduced to 2), plus others
+        fixedContent.contains("def semi = 'semicolon'") // UnnecessarySemicolon
+        !fixedContent.contains(";")
+        fixedContent.count('\n\n') == 3 // ConsecutiveBlankLines
     }
 }

build.gradle

@@ -17,6 +17,7 @@
 
 plugins {
     id 'org.apache.grails.gradle.test-aggregation'
+    id 'org.apache.grails.gradle.grails-code-style'
 }
 
 import java.time.Instant
@@ -87,11 +88,6 @@ subprojects {
             cacheChangingModulesFor(cacheHours, 'hours')
         }
     }
-    pluginManager.withPlugin('jacoco') {
-        jacoco {
-            toolVersion = "0.8.14" // Set the specific tool version here
-        }
-    }
 }
 
 interface ExecSupport {

dependencies.gradle

@@ -38,12 +38,14 @@ ext {
             'jquery.version'                : '3.7.1',
             'objenesis.version'             : '3.4',
             'spring-boot.version'           : '4.0.5',
+            'testcontainers.version'        : '1.20.1',
     ]
 
     // Note: the name of the dependency must be the prefix of the property name so properties in the pom are resolved correctly
     gradleBomPlatformDependencies = [
             'spring-boot-bom' : "org.springframework.boot:spring-boot-dependencies:${gradleBomDependencyVersions['spring-boot.version']}",
             'gradle-spock-bom': "org.spockframework:spock-bom:${gradleBomDependencyVersions['gradle-spock.version']}",
+            'testcontainers-bom': "org.testcontainers:testcontainers-bom:${gradleBomDependencyVersions['testcontainers.version']}",
     ]
 
     // Note: the name of the dependency must be the prefix of the property name so properties in the pom are resolved correctly