Gradle plugin tests & fixes (#654)

### What's done:
* Respect ignoreFailures flag
* Made excludes non-nullable
* Fix for file patterns
* Use plugin.apply in unit tests
* Use GradleVersion from gradle API instead of custom
* Jacoco reports for all functional tests
* Introduced Utils for runctional tests
* Functional tests for Groovy DSL

diktat-gradle-plugin/build.gradle.kts

@@ -13,6 +13,7 @@ repositories {
         // to use snapshot diktat without necessary installing
         dirs("../diktat-rules/target")
     }
+    mavenLocal()  // to use snapshot diktat
     mavenCentral()
     jcenter()
 }
@@ -21,6 +22,7 @@ repositories {
 val ktlintVersion = project.properties.getOrDefault("ktlintVersion", "0.39.0") as String
 val diktatVersion = project.version.takeIf { it.toString() != Project.DEFAULT_VERSION } ?: "0.1.7"
 val junitVersion = project.properties.getOrDefault("junitVersion", "5.7.0") as String
+val jacocoVersion = project.properties.getOrDefault("jacocoVersion", "0.8.6") as String
 dependencies {
     implementation(kotlin("gradle-plugin-api"))
 
@@ -84,12 +86,13 @@ val jacocoMergeTask by tasks.register<JacocoMerge>("jacocoMerge")
 tasks.withType<Test> {
     useJUnitPlatform()
 }
+jacoco.toolVersion = jacocoVersion
 
 // === integration testing
 // fixme: should probably use KotlinSourceSet instead
 val functionalTest = sourceSets.create("functionalTest") {
-        compileClasspath += sourceSets.main.get().output + configurations.testRuntimeClasspath
-        runtimeClasspath += output + compileClasspath
+    compileClasspath += sourceSets.main.get().output + configurations.testRuntimeClasspath
+    runtimeClasspath += output + compileClasspath
 }
 tasks.getByName<Test>("functionalTest") {
     dependsOn("test")
@@ -110,7 +113,11 @@ jacocoTestKit {
 }
 tasks.getByName("jacocoMerge", JacocoMerge::class) {
     dependsOn(functionalTestTask)
-    executionData(tasks.test, functionalTestTask)
+    executionData(
+        fileTree("$buildDir/jacoco").apply {
+            include("*.exec")
+        }
+    )
 }
 tasks.jacocoTestReport {
     dependsOn(jacocoMergeTask)

diktat-gradle-plugin/pom.xml

@@ -78,6 +78,7 @@
                                 <argument>-Pdescription=${project.description}</argument>
                                 <argument>-PktlintVersion=${ktlint.version}</argument>
                                 <argument>-PjunitVersion=${junit.version}</argument>
+                                <argument>-PjacocoVersion=${jacoco.version}</argument>
                                 <argument>-S</argument>
                             </arguments>
                             <skip>${skip.gradle.test}</skip>
@@ -98,6 +99,7 @@
                                 <argument>-Pdescription=${project.description}</argument>
                                 <argument>-PktlintVersion=${ktlint.version}</argument>
                                 <argument>-PjunitVersion=${junit.version}</argument>
+                                <argument>-PjacocoVersion=${jacoco.version}</argument>
                                 <argument>-S</argument>
                                 <argument>${gradle.exclude.check}</argument>
                             </arguments>

diktat-gradle-plugin/src/functionalTest/kotlin/org/cqfn/diktat/plugin/gradle/DiktatGradlePluginFunctionalTest.kt

@@ -1,8 +1,8 @@
 package org.cqfn.diktat.plugin.gradle
 
 import org.cqfn.diktat.plugin.gradle.DiktatGradlePlugin.Companion.DIKTAT_CHECK_TASK
+import org.gradle.buildinit.plugins.internal.modifiers.BuildInitDsl
 import org.gradle.internal.impldep.org.junit.rules.TemporaryFolder
-import org.gradle.testkit.runner.GradleRunner
 import org.gradle.testkit.runner.TaskOutcome
 import org.junit.jupiter.api.AfterEach
 import org.junit.jupiter.api.Assertions
@@ -17,22 +17,9 @@ class DiktatGradlePluginFunctionalTest {
     @BeforeEach
     fun setUp() {
         testProjectDir.create()
-        File("../examples/gradle-kotlin-dsl").copyRecursively(testProjectDir.root)
-        File(testProjectDir.root, "build.gradle.kts").delete()
-        buildFile = testProjectDir.newFile("build.gradle.kts").apply {
-            writeText(
-                """
-                plugins {
-                    id("org.cqfn.diktat.diktat-gradle-plugin")
-                }
-                
-                repositories {
-                    mavenLocal()
-                    mavenCentral()
-                }
-            """.trimIndent()
-            )
-        }
+        val buildInitDsl = BuildInitDsl.KOTLIN
+        createExampleProject(testProjectDir, File("../examples/gradle-kotlin-dsl"), buildInitDsl)
+        buildFile = testProjectDir.root.resolve(buildInitDsl.fileNameFor("build"))
     }
 
     @AfterEach
@@ -42,7 +29,7 @@ class DiktatGradlePluginFunctionalTest {
 
     @Test
     fun `should execute diktatCheck on default values`() {
-        val result = runDiktat()
+        val result = runDiktat(testProjectDir, shouldSucceed = false)
 
         val diktatCheckBuildResult = result.task(":$DIKTAT_CHECK_TASK")
         requireNotNull(diktatCheckBuildResult)
@@ -61,7 +48,7 @@ class DiktatGradlePluginFunctionalTest {
                 }
             """.trimIndent()
         )
-        val result = runDiktat()
+        val result = runDiktat(testProjectDir, shouldSucceed = false)
 
         val diktatCheckBuildResult = result.task(":$DIKTAT_CHECK_TASK")
         requireNotNull(diktatCheckBuildResult)
@@ -71,31 +58,121 @@ class DiktatGradlePluginFunctionalTest {
         )
     }
 
-    private fun runDiktat() = GradleRunner.create()
-        .withProjectDir(testProjectDir.root)
-        .withArguments(DIKTAT_CHECK_TASK)
-        .withPluginClasspath()
-        .withJaCoCo()
-        .forwardOutput()
-        .runCatching {
-            buildAndFail()
-        }
-        .also {
-            require(it.isSuccess) { "Running gradle returned exception ${it.exceptionOrNull()}" }
+    @Test
+    fun `should execute diktatCheck with excludes`() {
+        buildFile.appendText(
+            """${System.lineSeparator()}
+                diktat {
+                    inputs = files("src/**/*.kt")
+                    excludes = files("src/**/Test.kt")
+                }
+            """.trimIndent()
+        )
+        val result = runDiktat(testProjectDir)
+
+        val diktatCheckBuildResult = result.task(":$DIKTAT_CHECK_TASK")
+        requireNotNull(diktatCheckBuildResult)
+        Assertions.assertEquals(TaskOutcome.SUCCESS, diktatCheckBuildResult.outcome)
+    }
+
+    @Test
+    fun `should not run diktat with ktlint's default includes when no files match include patterns`() {
+        buildFile.appendText(
+            """${System.lineSeparator()}
+                diktat {
+                    inputs = files("nonexistent-directory/src/**/*.kt")
+                }
+            """.trimIndent()
+        )
+        val result = runDiktat(testProjectDir, arguments = listOf("--info"))
+
+        // if patterns in gradle are not checked for matching, they are passed to ktlint, which does nothing
+        val diktatCheckBuildResult = result.task(":$DIKTAT_CHECK_TASK")
+        requireNotNull(diktatCheckBuildResult)
+        Assertions.assertEquals(TaskOutcome.SUCCESS, diktatCheckBuildResult.outcome)
+        Assertions.assertFalse(
+            result.output.contains("Skipping diktat execution")
+        )
+        Assertions.assertFalse(
+            result.output.contains("Inputs for $DIKTAT_CHECK_TASK do not exist, will not run diktat")
+        )
+    }
+
+    @Test
+    fun `should not run diktat with ktlint's default includes when no files match include patterns - 2`() {
+        buildFile.appendText(
+            """${System.lineSeparator()}
+                diktat {
+                    inputs = fileTree("nonexistent-directory/src").apply { include("**/*.kt") }
+                }
+            """.trimIndent()
+        )
+        val result = runDiktat(testProjectDir, arguments = listOf("--info"))
+
+        val diktatCheckBuildResult = result.task(":$DIKTAT_CHECK_TASK")
+        requireNotNull(diktatCheckBuildResult)
+        Assertions.assertEquals(TaskOutcome.SUCCESS, diktatCheckBuildResult.outcome)
+        Assertions.assertTrue(
+            result.output.contains("Skipping diktat execution")
+        )
+        Assertions.assertTrue(
+            result.output.contains("Inputs for $DIKTAT_CHECK_TASK do not exist, will not run diktat")
+        )
+    }
+
+    @Test
+    fun `should execute diktatCheck with absolute paths`() {
+        val path = testProjectDir.root
+            .resolve("src/**/*.kt")
+            .absolutePath
+            .replace("\\", "\\\\")
+        buildFile.appendText(
+            """${System.lineSeparator()}
+                diktat {
+                    inputs = files("$path")
+                }
+            """.trimIndent()
+        )
+        val result = runDiktat(testProjectDir, shouldSucceed = false)
+
+        val diktatCheckBuildResult = result.task(":$DIKTAT_CHECK_TASK")
+        requireNotNull(diktatCheckBuildResult)
+        Assertions.assertEquals(TaskOutcome.FAILED, diktatCheckBuildResult.outcome)
+        Assertions.assertTrue(
+            result.output.contains("[HEADER_MISSING_OR_WRONG_COPYRIGHT]")
+        )
+    }
+
+    @Test
+    fun `should execute diktatCheck with gradle older than 6_4`() {
+        val result = runDiktat(testProjectDir, shouldSucceed = false, arguments = listOf("--info")) {
+            withGradleVersion("5.0")
         }
-        .getOrNull()!!
-
-    /**
-     * This is support for jacoco reports in tests run with gradle TestKit
-     */
-    private fun GradleRunner.withJaCoCo() = apply {
-        javaClass.classLoader
-            .getResourceAsStream("testkit-gradle.properties")
-            .also { it ?: println("properties file for testkit is not available, check build configuration") }
-            ?.use { propertiesFileStream ->
-                File(projectDir, "gradle.properties").outputStream().use {
-                    propertiesFileStream.copyTo(it)
+
+        val diktatCheckBuildResult = result.task(":$DIKTAT_CHECK_TASK")
+        requireNotNull(diktatCheckBuildResult)
+        Assertions.assertEquals(TaskOutcome.FAILED, diktatCheckBuildResult.outcome)
+        Assertions.assertTrue(
+            result.output.contains("[HEADER_MISSING_OR_WRONG_COPYRIGHT]")
+        )
+    }
+
+    @Test
+    fun `should respect ignoreFailures setting`() {
+        buildFile.appendText(
+            """${System.lineSeparator()}
+                diktat {
+                    ignoreFailures = true
                 }
-            }
+            """.trimIndent()
+        )
+        val result = runDiktat(testProjectDir, shouldSucceed = true, arguments = listOf("--info"))
+
+        val diktatCheckBuildResult = result.task(":$DIKTAT_CHECK_TASK")
+        requireNotNull(diktatCheckBuildResult)
+        Assertions.assertEquals(TaskOutcome.SUCCESS, diktatCheckBuildResult.outcome)
+        Assertions.assertTrue(
+            result.output.contains("[HEADER_MISSING_OR_WRONG_COPYRIGHT]")
+        )
     }
 }

diktat-gradle-plugin/src/functionalTest/kotlin/org/cqfn/diktat/plugin/gradle/DiktatGradlePluginGroovyFunctionalTest.kt

@@ -0,0 +1,40 @@
+package org.cqfn.diktat.plugin.gradle
+
+import org.gradle.buildinit.plugins.internal.modifiers.BuildInitDsl
+import org.gradle.internal.impldep.org.junit.rules.TemporaryFolder
+import org.gradle.testkit.runner.TaskOutcome
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import java.io.File
+
+class DiktatGradlePluginGroovyFunctionalTest {
+    private val testProjectDir = TemporaryFolder()
+    private lateinit var buildFile: File
+
+    @BeforeEach
+    fun setUp() {
+        testProjectDir.create()
+        val buildInitDsl = BuildInitDsl.GROOVY
+        createExampleProject(testProjectDir, File("../examples/gradle-groovy-dsl"), buildInitDsl)
+        buildFile = testProjectDir.root.resolve(buildInitDsl.fileNameFor("build"))
+    }
+
+    @AfterEach
+    fun tearDown() {
+        testProjectDir.delete()
+    }
+
+    @Test
+    fun `should execute diktatCheck on default values`() {
+        val result = runDiktat(testProjectDir, shouldSucceed = false)
+
+        val diktatCheckBuildResult = result.task(":${DiktatGradlePlugin.DIKTAT_CHECK_TASK}")
+        requireNotNull(diktatCheckBuildResult)
+        Assertions.assertEquals(TaskOutcome.FAILED, diktatCheckBuildResult.outcome)
+        Assertions.assertTrue(
+            result.output.contains("[HEADER_MISSING_OR_WRONG_COPYRIGHT]")
+        )
+    }
+}

diktat-gradle-plugin/src/functionalTest/kotlin/org/cqfn/diktat/plugin/gradle/Utils.kt

@@ -0,0 +1,70 @@
+package org.cqfn.diktat.plugin.gradle
+
+import org.gradle.buildinit.plugins.internal.modifiers.BuildInitDsl
+import org.gradle.internal.impldep.org.junit.rules.TemporaryFolder
+import org.gradle.testkit.runner.GradleRunner
+import java.io.File
+import java.util.concurrent.atomic.AtomicInteger
+
+internal val testsCounter = AtomicInteger(0)
+
+internal fun createExampleProject(testProjectDir: TemporaryFolder,
+                                  exampleProject: File,
+                                  buildInitDsl: BuildInitDsl
+) {
+    exampleProject.copyRecursively(testProjectDir.root)
+    val buildFileName = buildInitDsl.fileNameFor("build")
+    File(testProjectDir.root, buildFileName).delete()
+    testProjectDir.newFile(buildFileName).apply {
+        writeText(
+            """
+                plugins {
+                    id("org.cqfn.diktat.diktat-gradle-plugin")
+                }
+                
+                repositories {
+                    mavenLocal()
+                    mavenCentral()
+                }
+            """.trimIndent()
+        )
+    }
+}
+
+/**
+ * @param arguments additional arguments to pass to [GradleRunner]
+ */
+internal fun runDiktat(testProjectDir: TemporaryFolder,
+                      shouldSucceed: Boolean = true,
+                      arguments: List<String> = emptyList(),
+                      configureRunner: GradleRunner.() -> GradleRunner = { this }
+) = GradleRunner.create()
+    .run(configureRunner)
+    .withProjectDir(testProjectDir.root)
+    .withArguments(*arguments.toTypedArray(), DiktatGradlePlugin.DIKTAT_CHECK_TASK)
+    .withPluginClasspath()
+    .withJaCoCo(testsCounter.incrementAndGet())
+    .forwardOutput()
+    .runCatching {
+        if (shouldSucceed) build() else buildAndFail()
+    }
+    .also {
+        require(it.isSuccess) { "Running gradle returned exception ${it.exceptionOrNull()}" }
+    }
+    .getOrNull()!!
+
+/**
+ * This is support for jacoco reports in tests run with gradle TestKit
+ */
+private fun GradleRunner.withJaCoCo(number: Int) = apply {
+    javaClass.classLoader
+        .getResourceAsStream("testkit-gradle.properties")
+        .also { it ?: error("properties file for testkit is not available, check build configuration") }
+        ?.use { propertiesFileStream ->
+            val text = propertiesFileStream.reader().readText()
+            File(projectDir, "gradle.properties").createNewFile()
+            File(projectDir, "gradle.properties").writer().use {
+                it.write(text.replace("functionalTest.exec", "functionalTest-$number.exec"))
+            }
+        }
+}

diktat-gradle-plugin/src/main/kotlin/org/cqfn/diktat/plugin/gradle/DiktatExtension.kt

@@ -7,6 +7,11 @@ import org.gradle.api.file.FileCollection
  * An extension to configure diktat in build.gradle(.kts) file
  */
 open class DiktatExtension {
+    /**
+     * Boolean flag to support `ignoreFailures` property of [VerificationTask].
+     */
+    var ignoreFailures: Boolean = false
+
     /**
      * Flag that indicates whether to turn debug logging on
      */
@@ -21,7 +26,7 @@ open class DiktatExtension {
     /**
      * Paths that will be excluded from diktat run
      */
-    var excludes: FileCollection? = null
+    lateinit var excludes: FileCollection
 
     /**
      * Ktlint's [Reporter] which will be used during run.