From ebf5d77b627100815c8ed2bc7076f8b75425212f Mon Sep 17 00:00:00 2001 From: Matthew Haughton <3flex@users.noreply.github.com> Date: Thu, 10 Feb 2022 18:34:33 +1100 Subject: [PATCH] Migrate detekt-gradle-plugin tests to JUnit (#4529) * Migrate detekt-gradle-plugin functional tests to JUnit * Migrate detekt-gradle-plugin tests to JUnit * Remove unused dependencies * Removed unused function --- config/detekt/detekt.yml | 10 + detekt-gradle-plugin/build.gradle.kts | 4 - .../detekt/CreateBaselineTaskDslSpec.kt | 138 ++++---- .../detekt/DetektReportMergeSpec.kt | 149 +++++---- .../detekt/DetektTaskMultiModuleSpec.kt | 300 ++++++++--------- .../arturbosch/detekt/DetektTaskSpec.kt | 96 +++--- .../detekt/GenerateConfigTaskSpec.kt | 59 ++-- .../io/gitlab/arturbosch/detekt/JvmSpec.kt | 10 +- .../detekt/PluginTaskBehaviorSpec.kt | 37 ++- .../detekt/ConfigurationCacheSpec.kt | 51 +-- .../arturbosch/detekt/DetektAndroidSpec.kt | 148 ++++++--- .../gitlab/arturbosch/detekt/DetektJvmSpec.kt | 44 ++- .../detekt/DetektMultiplatformSpec.kt | 106 +++--- .../arturbosch/detekt/DetektPlainSpec.kt | 26 +- .../arturbosch/detekt/DetektTaskDslSpec.kt | 311 +++++++++++------- .../arturbosch/detekt/GradleVersionSpec.kt | 46 +-- .../detekt/internal/ClassLoaderCacheSpec.kt | 23 +- .../detekt/invoke/DefaultCliInvokerSpec.kt | 9 +- .../detekt/report/ReportMergeSpec.kt | 28 +- .../detekt/report/SarifReportMergerSpec.kt | 24 +- .../detekt/report/XmlReportMergerSpec.kt | 14 +- .../detekt/testkit/DslTestBuilder.kt | 7 + 22 files changed, 904 insertions(+), 736 deletions(-) diff --git a/config/detekt/detekt.yml b/config/detekt/detekt.yml index c7ff829f3647..ff5d02b72714 100644 --- a/config/detekt/detekt.yml +++ b/config/detekt/detekt.yml @@ -105,6 +105,16 @@ formatting: naming: ClassNaming: excludes: ['**/*Spec.kt'] + FunctionNaming: + active: true + excludes: + - '**/test/**' + - '**/androidTest/**' + - '**/commonTest/**' + - '**/functionalTest/**' + - '**/jvmTest/**' + - '**/jsTest/**' + - '**/iosTest/**' TopLevelPropertyNaming: constantPattern: '[a-z][_A-Za-z0-9]*|[A-Z][_A-Z0-9]*' InvalidPackageDeclaration: diff --git a/detekt-gradle-plugin/build.gradle.kts b/detekt-gradle-plugin/build.gradle.kts index d00fcb7bc4f3..398f1f990e91 100644 --- a/detekt-gradle-plugin/build.gradle.kts +++ b/detekt-gradle-plugin/build.gradle.kts @@ -19,10 +19,8 @@ testing { getByName("test", JvmTestSuite::class) { dependencies { implementation(libs.assertj) - implementation(libs.spek.dsl) implementation(libs.kotlin.gradle) implementation(gradleKotlinDsl()) - runtimeOnly(libs.spek.runner) // Workaround for gradle/gradle#16774, see // https://github.com/gradle/gradle/issues/16774#issuecomment-853407822 @@ -51,8 +49,6 @@ testing { dependencies { implementation(libs.assertj) - implementation(libs.spek.dsl) - runtimeOnly(libs.spek.runner) } } } diff --git a/detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/CreateBaselineTaskDslSpec.kt b/detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/CreateBaselineTaskDslSpec.kt index 6e8b481c0092..328206c860f7 100644 --- a/detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/CreateBaselineTaskDslSpec.kt +++ b/detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/CreateBaselineTaskDslSpec.kt @@ -4,83 +4,83 @@ import io.gitlab.arturbosch.detekt.testkit.DslTestBuilder import io.gitlab.arturbosch.detekt.testkit.ProjectLayout import org.assertj.core.api.Assertions.assertThat import org.gradle.testkit.runner.TaskOutcome -import org.spekframework.spek2.Spek -import org.spekframework.spek2.style.specification.describe +import org.junit.jupiter.params.ParameterizedTest +import org.junit.jupiter.params.provider.MethodSource -internal class CreateBaselineTaskDslSpec : Spek({ - describe("The detektBaseline task of the Detekt Gradle plugin") { - listOf(DslTestBuilder.groovy(), DslTestBuilder.kotlin()).forEach { builder -> - describe("using ${builder.gradleBuildName}") { - it("can be executed when baseline file is specified") { - val baselineFilename = "baseline.xml" +class CreateBaselineTaskDslSpec { + @ParameterizedTest(name = "Using {0}, detektBaseline task can be executed when baseline file is specified") + @MethodSource("io.gitlab.arturbosch.detekt.testkit.DslTestBuilder#builders") + fun baselineTaskExecutableWhenBaselineFileSpecified(builder: DslTestBuilder) { + val baselineFilename = "baseline.xml" - val detektConfig = """ - |detekt { - | baseline = file("$baselineFilename") - |} - """ - val gradleRunner = builder - .withProjectLayout( - ProjectLayout( - numberOfSourceFilesInRootPerSourceDir = 1, - numberOfCodeSmellsInRootPerSourceDir = 1, - ) - ) - .withDetektConfig(detektConfig) - .build() + val detektConfig = """ + |detekt { + | baseline = file("$baselineFilename") + |} + """ + val gradleRunner = builder + .withProjectLayout( + ProjectLayout( + numberOfSourceFilesInRootPerSourceDir = 1, + numberOfCodeSmellsInRootPerSourceDir = 1, + ) + ) + .withDetektConfig(detektConfig) + .build() - gradleRunner.runTasksAndCheckResult("detektBaseline") { result -> - assertThat(result.task(":detektBaseline")?.outcome).isEqualTo(TaskOutcome.SUCCESS) - assertThat(projectFile(baselineFilename)).exists() - assertThat(projectFile(DEFAULT_BASELINE_FILENAME)).doesNotExist() - } - } + gradleRunner.runTasksAndCheckResult("detektBaseline") { result -> + assertThat(result.task(":detektBaseline")?.outcome).isEqualTo(TaskOutcome.SUCCESS) + assertThat(projectFile(baselineFilename)).exists() + assertThat(projectFile(DEFAULT_BASELINE_FILENAME)).doesNotExist() + } + } - it("can be executed when baseline file is not specified") { - val detektConfig = """ - |detekt { - |} - """ - val gradleRunner = builder - .withProjectLayout( - ProjectLayout( - numberOfSourceFilesInRootPerSourceDir = 1, - numberOfCodeSmellsInRootPerSourceDir = 1, - ) - ) - .withDetektConfig(detektConfig) - .build() + @ParameterizedTest(name = "Using {0}, detektBaseline task can be executed when baseline file is not specified") + @MethodSource("io.gitlab.arturbosch.detekt.testkit.DslTestBuilder#builders") + fun baselineTaskExecutableWhenBaselineFileNotSpecified(builder: DslTestBuilder) { + val detektConfig = """ + |detekt { + |} + """ + val gradleRunner = builder + .withProjectLayout( + ProjectLayout( + numberOfSourceFilesInRootPerSourceDir = 1, + numberOfCodeSmellsInRootPerSourceDir = 1, + ) + ) + .withDetektConfig(detektConfig) + .build() - gradleRunner.runTasksAndCheckResult("detektBaseline") { result -> - assertThat(result.task(":detektBaseline")?.outcome).isEqualTo(TaskOutcome.SUCCESS) - assertThat(projectFile(DEFAULT_BASELINE_FILENAME)).exists() - } - } + gradleRunner.runTasksAndCheckResult("detektBaseline") { result -> + assertThat(result.task(":detektBaseline")?.outcome).isEqualTo(TaskOutcome.SUCCESS) + assertThat(projectFile(DEFAULT_BASELINE_FILENAME)).exists() + } + } - it("can not be executed when baseline file is specified null") { - val detektConfig = """ - |detekt { - | baseline = null - |} - """ - val gradleRunner = builder - .withProjectLayout( - ProjectLayout( - numberOfSourceFilesInRootPerSourceDir = 1, - numberOfCodeSmellsInRootPerSourceDir = 1, - ) - ) - .withDetektConfig(detektConfig) - .build() + @ParameterizedTest(name = "Using {0}, detektBaseline task can not be executed when baseline file is specified null") + @MethodSource("io.gitlab.arturbosch.detekt.testkit.DslTestBuilder#builders") + fun baselineTaskNotExecutableWhenBaselineFileIsNull(builder: DslTestBuilder) { + val detektConfig = """ + |detekt { + | baseline = null + |} + """ + val gradleRunner = builder + .withProjectLayout( + ProjectLayout( + numberOfSourceFilesInRootPerSourceDir = 1, + numberOfCodeSmellsInRootPerSourceDir = 1, + ) + ) + .withDetektConfig(detektConfig) + .build() - gradleRunner.runTasksAndExpectFailure("detektBaseline") { result -> - assertThat(result.output).contains("property 'baseline' doesn't have a configured value") - assertThat(projectFile(DEFAULT_BASELINE_FILENAME)).doesNotExist() - } - } - } + gradleRunner.runTasksAndExpectFailure("detektBaseline") { result -> + assertThat(result.output).contains("property 'baseline' doesn't have a configured value") + assertThat(projectFile(DEFAULT_BASELINE_FILENAME)).doesNotExist() } } -}) +} private const val DEFAULT_BASELINE_FILENAME = "detekt-baseline.xml" diff --git a/detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/DetektReportMergeSpec.kt b/detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/DetektReportMergeSpec.kt index 565dbfe0915b..69b8f351fc4c 100644 --- a/detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/DetektReportMergeSpec.kt +++ b/detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/DetektReportMergeSpec.kt @@ -4,15 +4,19 @@ import io.gitlab.arturbosch.detekt.testkit.DslGradleRunner import io.gitlab.arturbosch.detekt.testkit.DslTestBuilder import io.gitlab.arturbosch.detekt.testkit.ProjectLayout import org.assertj.core.api.Assertions.assertThat -import org.spekframework.spek2.Spek -import org.spekframework.spek2.style.specification.describe +import org.junit.jupiter.api.Nested +import org.junit.jupiter.params.ParameterizedTest +import org.junit.jupiter.params.provider.Arguments +import org.junit.jupiter.params.provider.Arguments.arguments +import org.junit.jupiter.params.provider.MethodSource -internal class DetektReportMergeSpec : Spek({ +class DetektReportMergeSpec { - describe("Sarif merge is configured correctly for multi module project") { + @Nested + inner class `Sarif merge is configured correctly for multi module project` { - val groovy by memoized { DslTestBuilder.groovy() } - val groovyBuildFileContent by memoized { + val groovy = DslTestBuilder.groovy() + val groovyBuildFileContent = """ |${groovy.gradlePlugins} | @@ -41,9 +45,8 @@ internal class DetektReportMergeSpec : Spek({ | } |} |""".trimMargin() - } - val kotlin by memoized { DslTestBuilder.kotlin() } - val kotlinBuildFileContent by memoized { + val kotlin = DslTestBuilder.kotlin() + val kotlinBuildFileContent = """ |${kotlin.gradlePlugins} | @@ -72,45 +75,47 @@ internal class DetektReportMergeSpec : Spek({ | } |} |""".trimMargin() - } - it("using Groovy and Kotlin") { - listOf( - groovy to groovyBuildFileContent, - kotlin to kotlinBuildFileContent - ).forEach { (builder, mainBuildFileContent) -> - val projectLayout = ProjectLayout(numberOfSourceFilesInRootPerSourceDir = 0).apply { - addSubmodule( - name = "child1", - numberOfSourceFilesPerSourceDir = 2, - numberOfCodeSmells = 2 - ) - addSubmodule( - name = "child2", - numberOfSourceFilesPerSourceDir = 4, - numberOfCodeSmells = 4 - ) - } + fun scenarios(): List = listOf( + arguments(groovy, groovyBuildFileContent), + arguments(kotlin, kotlinBuildFileContent) + ) + + @ParameterizedTest(name = "Using {0}") + @MethodSource("scenarios") + fun sarifMerge(builder: DslTestBuilder, mainBuildFileContent: String) { + val projectLayout = ProjectLayout(numberOfSourceFilesInRootPerSourceDir = 0).apply { + addSubmodule( + name = "child1", + numberOfSourceFilesPerSourceDir = 2, + numberOfCodeSmells = 2 + ) + addSubmodule( + name = "child2", + numberOfSourceFilesPerSourceDir = 4, + numberOfCodeSmells = 4 + ) + } - val gradleRunner = DslGradleRunner(projectLayout, builder.gradleBuildName, mainBuildFileContent) - gradleRunner.setupProject() - gradleRunner.runTasksAndExpectFailure("detekt", "sarifReportMerge", "--continue") { _ -> - assertThat(projectFile("build/reports/detekt/detekt.sarif")).doesNotExist() - assertThat(projectFile("build/reports/detekt/merge.sarif")).exists() - assertThat(projectFile("build/reports/detekt/merge.sarif").readText()) - .contains("\"ruleId\": \"detekt.style.MagicNumber\"") - projectLayout.submodules.forEach { - assertThat(projectFile("${it.name}/build/reports/detekt/detekt.sarif")).exists() - } + val gradleRunner = DslGradleRunner(projectLayout, builder.gradleBuildName, mainBuildFileContent) + gradleRunner.setupProject() + gradleRunner.runTasksAndExpectFailure("detekt", "sarifReportMerge", "--continue") { _ -> + assertThat(projectFile("build/reports/detekt/detekt.sarif")).doesNotExist() + assertThat(projectFile("build/reports/detekt/merge.sarif")).exists() + assertThat(projectFile("build/reports/detekt/merge.sarif").readText()) + .contains("\"ruleId\": \"detekt.style.MagicNumber\"") + projectLayout.submodules.forEach { + assertThat(projectFile("${it.name}/build/reports/detekt/detekt.sarif")).exists() } } } } - describe("XML merge is configured correctly for multi module project") { + @Nested + inner class `XML merge is configured correctly for multi module project` { - val groovy by memoized { DslTestBuilder.groovy() } - val groovyBuildFileContent by memoized { + val groovy = DslTestBuilder.groovy() + val groovyBuildFileContent = """ |${groovy.gradlePlugins} | @@ -139,9 +144,8 @@ internal class DetektReportMergeSpec : Spek({ | } |} |""".trimMargin() - } - val kotlin by memoized { DslTestBuilder.kotlin() } - val kotlinBuildFileContent by memoized { + val kotlin = DslTestBuilder.kotlin() + val kotlinBuildFileContent = """ |${kotlin.gradlePlugins} | @@ -170,38 +174,39 @@ internal class DetektReportMergeSpec : Spek({ | } |} |""".trimMargin() - } - it("using Groovy and Kotlin") { - listOf( - groovy to groovyBuildFileContent, - kotlin to kotlinBuildFileContent - ).forEach { (builder, mainBuildFileContent) -> - val projectLayout = ProjectLayout(numberOfSourceFilesInRootPerSourceDir = 0).apply { - addSubmodule( - name = "child1", - numberOfSourceFilesPerSourceDir = 2, - numberOfCodeSmells = 2 - ) - addSubmodule( - name = "child2", - numberOfSourceFilesPerSourceDir = 4, - numberOfCodeSmells = 4 - ) - } + fun scenarios(): List = listOf( + arguments(groovy, groovyBuildFileContent), + arguments(kotlin, kotlinBuildFileContent) + ) + + @ParameterizedTest(name = "Using {0}") + @MethodSource("scenarios") + fun sarifMerge(builder: DslTestBuilder, mainBuildFileContent: String) { + val projectLayout = ProjectLayout(numberOfSourceFilesInRootPerSourceDir = 0).apply { + addSubmodule( + name = "child1", + numberOfSourceFilesPerSourceDir = 2, + numberOfCodeSmells = 2 + ) + addSubmodule( + name = "child2", + numberOfSourceFilesPerSourceDir = 4, + numberOfCodeSmells = 4 + ) + } - val gradleRunner = DslGradleRunner(projectLayout, builder.gradleBuildName, mainBuildFileContent) - gradleRunner.setupProject() - gradleRunner.runTasksAndExpectFailure("detekt", "xmlReportMerge", "--continue") { _ -> - assertThat(projectFile("build/reports/detekt/detekt.xml")).doesNotExist() - assertThat(projectFile("build/reports/detekt/merge.xml")).exists() - assertThat(projectFile("build/reports/detekt/merge.xml").readText()) - .contains(" + assertThat(projectFile("build/reports/detekt/detekt.xml")).doesNotExist() + assertThat(projectFile("build/reports/detekt/merge.xml")).exists() + assertThat(projectFile("build/reports/detekt/merge.xml").readText()) + .contains(" - - describe("using ${builder.gradleBuildName}") { - - it( - """ - |is applied with defaults to all subprojects individually - |without sources in root project using the subprojects block - """.trimMargin() - ) { - val projectLayout = ProjectLayout(0).apply { - addSubmodule("child1", 2) - addSubmodule("child2", 4) - } +import org.junit.jupiter.api.Nested +import org.junit.jupiter.params.ParameterizedTest +import org.junit.jupiter.params.provider.MethodSource + +class DetektTaskMultiModuleSpec { + + @Nested + inner class `The Detekt Gradle plugin used in a multi module project` { + + @ParameterizedTest( + name = "Using {0}, it is applied with defaults to all subprojects individually without " + + "sources in root project using the subprojects block" + ) + @MethodSource("io.gitlab.arturbosch.detekt.testkit.DslTestBuilder#builders") + fun applyToSubprojectsWithoutSources(builder: DslTestBuilder) { + val projectLayout = ProjectLayout(0).apply { + addSubmodule("child1", 2) + addSubmodule("child2", 4) + } - val mainBuildFileContent: String = """ + val mainBuildFileContent: String = """ |${builder.gradlePlugins} | |allprojects { @@ -39,38 +36,38 @@ internal class DetektTaskMultiModuleSpec : Spek({ |} |""".trimMargin() - val gradleRunner = DslGradleRunner(projectLayout, builder.gradleBuildName, mainBuildFileContent) - - gradleRunner.setupProject() - gradleRunner.runDetektTaskAndCheckResult { result -> - assertThat(result.task(":detekt")?.outcome).isEqualTo(TaskOutcome.NO_SOURCE) - projectLayout.submodules.forEach { submodule -> - assertThat(result.task(":${submodule.name}:detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) - } - - assertThat(projectFile("build/reports/detekt/detekt.xml")).doesNotExist() - assertThat(projectFile("build/reports/detekt/detekt.html")).doesNotExist() - assertThat(projectFile("build/reports/detekt/detekt.txt")).doesNotExist() - projectLayout.submodules.forEach { - assertThat(projectFile("${it.name}/build/reports/detekt/detekt.xml")).exists() - assertThat(projectFile("${it.name}/build/reports/detekt/detekt.html")).exists() - assertThat(projectFile("${it.name}/build/reports/detekt/detekt.txt")).exists() - } - } + val gradleRunner = DslGradleRunner(projectLayout, builder.gradleBuildName, mainBuildFileContent) + + gradleRunner.setupProject() + gradleRunner.runDetektTaskAndCheckResult { result -> + assertThat(result.task(":detekt")?.outcome).isEqualTo(TaskOutcome.NO_SOURCE) + projectLayout.submodules.forEach { submodule -> + assertThat(result.task(":${submodule.name}:detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) + } + + assertThat(projectFile("build/reports/detekt/detekt.xml")).doesNotExist() + assertThat(projectFile("build/reports/detekt/detekt.html")).doesNotExist() + assertThat(projectFile("build/reports/detekt/detekt.txt")).doesNotExist() + projectLayout.submodules.forEach { + assertThat(projectFile("${it.name}/build/reports/detekt/detekt.xml")).exists() + assertThat(projectFile("${it.name}/build/reports/detekt/detekt.html")).exists() + assertThat(projectFile("${it.name}/build/reports/detekt/detekt.txt")).exists() } + } + } + + @ParameterizedTest( + name = "Using {0}, it is applied with defaults to main project and subprojects " + + "individually using the allprojects block" + ) + @MethodSource("io.gitlab.arturbosch.detekt.testkit.DslTestBuilder#builders") + fun applyWithAllprojectsBlock(builder: DslTestBuilder) { + val projectLayout = ProjectLayout(1).apply { + addSubmodule("child1", 2) + addSubmodule("child2", 4) + } - it( - """ - |is applied with defaults to main project - |and subprojects individually using the allprojects block - """.trimMargin() - ) { - val projectLayout = ProjectLayout(1).apply { - addSubmodule("child1", 2) - addSubmodule("child2", 4) - } - - val mainBuildFileContent: String = """ + val mainBuildFileContent: String = """ |${builder.gradlePlugins} | |allprojects { @@ -79,33 +76,35 @@ internal class DetektTaskMultiModuleSpec : Spek({ |} |""".trimMargin() - val gradleRunner = DslGradleRunner(projectLayout, builder.gradleBuildName, mainBuildFileContent) - - gradleRunner.setupProject() - gradleRunner.runDetektTaskAndCheckResult { result -> - assertThat(result.task(":detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) - projectLayout.submodules.forEach { submodule -> - assertThat(result.task(":${submodule.name}:detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) - } - - assertThat(projectFile("build/reports/detekt/detekt.xml")).exists() - assertThat(projectFile("build/reports/detekt/detekt.html")).exists() - assertThat(projectFile("build/reports/detekt/detekt.txt")).exists() - projectLayout.submodules.forEach { - assertThat(projectFile("${it.name}/build/reports/detekt/detekt.xml")).exists() - assertThat(projectFile("${it.name}/build/reports/detekt/detekt.html")).exists() - assertThat(projectFile("${it.name}/build/reports/detekt/detekt.txt")).exists() - } - } + val gradleRunner = DslGradleRunner(projectLayout, builder.gradleBuildName, mainBuildFileContent) + + gradleRunner.setupProject() + gradleRunner.runDetektTaskAndCheckResult { result -> + assertThat(result.task(":detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) + projectLayout.submodules.forEach { submodule -> + assertThat(result.task(":${submodule.name}:detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) } - it("uses custom configs when configured in allprojects block") { - val projectLayout = ProjectLayout(1).apply { - addSubmodule("child1", 2) - addSubmodule("child2", 4) - } + assertThat(projectFile("build/reports/detekt/detekt.xml")).exists() + assertThat(projectFile("build/reports/detekt/detekt.html")).exists() + assertThat(projectFile("build/reports/detekt/detekt.txt")).exists() + projectLayout.submodules.forEach { + assertThat(projectFile("${it.name}/build/reports/detekt/detekt.xml")).exists() + assertThat(projectFile("${it.name}/build/reports/detekt/detekt.html")).exists() + assertThat(projectFile("${it.name}/build/reports/detekt/detekt.txt")).exists() + } + } + } + + @ParameterizedTest(name = "Using {0}, it uses custom configs when configured in allprojects block") + @MethodSource("io.gitlab.arturbosch.detekt.testkit.DslTestBuilder#builders") + fun usesCustomConfigsWhenConfiguredInAllprojectsBlock(builder: DslTestBuilder) { + val projectLayout = ProjectLayout(1).apply { + addSubmodule("child1", 2) + addSubmodule("child2", 4) + } - val mainBuildFileContent: String = """ + val mainBuildFileContent: String = """ |${builder.gradlePlugins} | |allprojects { @@ -118,38 +117,43 @@ internal class DetektTaskMultiModuleSpec : Spek({ |} |""".trimMargin() - val gradleRunner = DslGradleRunner(projectLayout, builder.gradleBuildName, mainBuildFileContent) - gradleRunner.setupProject() - gradleRunner.runDetektTaskAndCheckResult { result -> - assertThat(result.task(":detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) - projectLayout.submodules.forEach { submodule -> - assertThat(result.task(":${submodule.name}:detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) - } - - assertThat(projectFile("build/detekt-reports/detekt.xml")).exists() - assertThat(projectFile("build/detekt-reports/detekt.html")).exists() - assertThat(projectFile("build/detekt-reports/detekt.txt")).exists() - projectLayout.submodules.forEach { - assertThat(projectFile("${it.name}/build/detekt-reports/detekt.xml")).exists() - assertThat(projectFile("${it.name}/build/detekt-reports/detekt.html")).exists() - assertThat(projectFile("${it.name}/build/detekt-reports/detekt.txt")).exists() - } - } + val gradleRunner = DslGradleRunner(projectLayout, builder.gradleBuildName, mainBuildFileContent) + gradleRunner.setupProject() + gradleRunner.runDetektTaskAndCheckResult { result -> + assertThat(result.task(":detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) + projectLayout.submodules.forEach { submodule -> + assertThat(result.task(":${submodule.name}:detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) + } + + assertThat(projectFile("build/detekt-reports/detekt.xml")).exists() + assertThat(projectFile("build/detekt-reports/detekt.html")).exists() + assertThat(projectFile("build/detekt-reports/detekt.txt")).exists() + projectLayout.submodules.forEach { + assertThat(projectFile("${it.name}/build/detekt-reports/detekt.xml")).exists() + assertThat(projectFile("${it.name}/build/detekt-reports/detekt.html")).exists() + assertThat(projectFile("${it.name}/build/detekt-reports/detekt.txt")).exists() } + } + } - it("allows changing defaults in allprojects block that can be overwritten in subprojects") { - val child2DetektConfig = """ + @ParameterizedTest( + name = "Using {0}, it allows changing defaults in allprojects block that can be " + + "overwritten in subprojects" + ) + @MethodSource("io.gitlab.arturbosch.detekt.testkit.DslTestBuilder#builders") + fun allowsChangingDefaultsInAllProjectsThatAreOverwrittenInSubprojects(builder: DslTestBuilder) { + val child2DetektConfig = """ |detekt { | reportsDir = file("build/custom") |} |""".trimMargin() - val projectLayout = ProjectLayout(1).apply { - addSubmodule("child1", 2) - addSubmodule("child2", 4, buildFileContent = child2DetektConfig) - } + val projectLayout = ProjectLayout(1).apply { + addSubmodule("child1", 2) + addSubmodule("child2", 4, buildFileContent = child2DetektConfig) + } - val mainBuildFileContent: String = """ + val mainBuildFileContent: String = """ |${builder.gradlePlugins} | |allprojects { @@ -162,34 +166,36 @@ internal class DetektTaskMultiModuleSpec : Spek({ |} |""".trimMargin() - val gradleRunner = DslGradleRunner(projectLayout, builder.gradleBuildName, mainBuildFileContent) - - gradleRunner.setupProject() - gradleRunner.runDetektTaskAndCheckResult { result -> - assertThat(result.task(":detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) - projectLayout.submodules.forEach { submodule -> - assertThat(result.task(":${submodule.name}:detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) - } - - assertThat(projectFile("build/detekt-reports/detekt.xml")).exists() - assertThat(projectFile("build/detekt-reports/detekt.html")).exists() - assertThat(projectFile("build/detekt-reports/detekt.txt")).exists() - assertThat(projectFile("child1/build/detekt-reports/detekt.xml")).exists() - assertThat(projectFile("child1/build/detekt-reports/detekt.html")).exists() - assertThat(projectFile("child1/build/detekt-reports/detekt.txt")).exists() - assertThat(projectFile("child2/build/custom/detekt.xml")).exists() - assertThat(projectFile("child2/build/custom/detekt.html")).exists() - assertThat(projectFile("child2/build/custom/detekt.txt")).exists() - } + val gradleRunner = DslGradleRunner(projectLayout, builder.gradleBuildName, mainBuildFileContent) + + gradleRunner.setupProject() + gradleRunner.runDetektTaskAndCheckResult { result -> + assertThat(result.task(":detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) + projectLayout.submodules.forEach { submodule -> + assertThat(result.task(":${submodule.name}:detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) } - it("can be applied to all files in entire project resulting in 1 report") { - val projectLayout = ProjectLayout(1).apply { - addSubmodule("child1", 2) - addSubmodule("child2", 4) - } + assertThat(projectFile("build/detekt-reports/detekt.xml")).exists() + assertThat(projectFile("build/detekt-reports/detekt.html")).exists() + assertThat(projectFile("build/detekt-reports/detekt.txt")).exists() + assertThat(projectFile("child1/build/detekt-reports/detekt.xml")).exists() + assertThat(projectFile("child1/build/detekt-reports/detekt.html")).exists() + assertThat(projectFile("child1/build/detekt-reports/detekt.txt")).exists() + assertThat(projectFile("child2/build/custom/detekt.xml")).exists() + assertThat(projectFile("child2/build/custom/detekt.html")).exists() + assertThat(projectFile("child2/build/custom/detekt.txt")).exists() + } + } - val detektConfig: String = """ + @ParameterizedTest(name = "Using {0}, it can be applied to all files in entire project resulting in 1 report") + @MethodSource("io.gitlab.arturbosch.detekt.testkit.DslTestBuilder#builders") + fun applyToAllFilesInProjectResultingInSingleReport(builder: DslTestBuilder) { + val projectLayout = ProjectLayout(1).apply { + addSubmodule("child1", 2) + addSubmodule("child2", 4) + } + + val detektConfig: String = """ |detekt { | source = files( | "${"$"}projectDir/src", @@ -198,28 +204,26 @@ internal class DetektTaskMultiModuleSpec : Spek({ | ) |} """.trimMargin() - val gradleRunner = builder - .withProjectLayout(projectLayout) - .withDetektConfig(detektConfig) - .build() - - gradleRunner.runDetektTaskAndCheckResult { result -> - assertThat(result.task(":detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) - projectLayout.submodules.forEach { submodule -> - assertThat(result.task(":${submodule.name}:detekt")).isNull() - } - - assertThat(projectFile("build/reports/detekt/detekt.xml")).exists() - assertThat(projectFile("build/reports/detekt/detekt.html")).exists() - assertThat(projectFile("build/reports/detekt/detekt.txt")).exists() - projectLayout.submodules.forEach { submodule -> - assertThat(projectFile("${submodule.name}/build/reports/detekt/detekt.xml")).doesNotExist() - assertThat(projectFile("${submodule.name}/build/reports/detekt/detekt.html")).doesNotExist() - assertThat(projectFile("${submodule.name}/build/reports/detekt/detekt.txt")).doesNotExist() - } - } + val gradleRunner = builder + .withProjectLayout(projectLayout) + .withDetektConfig(detektConfig) + .build() + + gradleRunner.runDetektTaskAndCheckResult { result -> + assertThat(result.task(":detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) + projectLayout.submodules.forEach { submodule -> + assertThat(result.task(":${submodule.name}:detekt")).isNull() + } + + assertThat(projectFile("build/reports/detekt/detekt.xml")).exists() + assertThat(projectFile("build/reports/detekt/detekt.html")).exists() + assertThat(projectFile("build/reports/detekt/detekt.txt")).exists() + projectLayout.submodules.forEach { submodule -> + assertThat(projectFile("${submodule.name}/build/reports/detekt/detekt.xml")).doesNotExist() + assertThat(projectFile("${submodule.name}/build/reports/detekt/detekt.html")).doesNotExist() + assertThat(projectFile("${submodule.name}/build/reports/detekt/detekt.txt")).doesNotExist() } } } } -}) +} diff --git a/detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/DetektTaskSpec.kt b/detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/DetektTaskSpec.kt index 58a93b297846..9bb3f9ac00d3 100644 --- a/detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/DetektTaskSpec.kt +++ b/detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/DetektTaskSpec.kt @@ -1,58 +1,52 @@ package io.gitlab.arturbosch.detekt -import io.gitlab.arturbosch.detekt.testkit.DslTestBuilder.Companion.groovy -import io.gitlab.arturbosch.detekt.testkit.DslTestBuilder.Companion.kotlin +import io.gitlab.arturbosch.detekt.testkit.DslTestBuilder import io.gitlab.arturbosch.detekt.testkit.ProjectLayout import org.assertj.core.api.Assertions.assertThat import org.gradle.testkit.runner.TaskOutcome -import org.spekframework.spek2.Spek -import org.spekframework.spek2.style.specification.describe - -internal class DetektTaskSpec : Spek({ - - describe("When applying the detekt gradle plugin") { - listOf(groovy(), kotlin()).forEach { builder -> - context(builder.gradleBuildName) { - describe("using the ignoreFailures toggle") { - val projectLayoutWithTooManyIssues = ProjectLayout( - numberOfSourceFilesInRootPerSourceDir = 15, - numberOfCodeSmellsInRootPerSourceDir = 15 - ) - - it("build succeeds with more issues than threshold if enabled") { - - val config = """ - |detekt { - | ignoreFailures = true - |} - """ - - val gradleRunner = builder - .withProjectLayout(projectLayoutWithTooManyIssues) - .withDetektConfig(config) - .build() - - gradleRunner.runDetektTaskAndCheckResult { result -> - assertThat(result.task(":detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) - } - } - it("build fails with more issues than threshold successfully if disabled") { - - val config = """ - |detekt { - | ignoreFailures = false - |} - """ - - val gradleRunner = builder - .withProjectLayout(projectLayoutWithTooManyIssues) - .withDetektConfig(config) - .build() - - gradleRunner.runDetektTaskAndExpectFailure() - } - } - } +import org.junit.jupiter.params.ParameterizedTest +import org.junit.jupiter.params.provider.MethodSource + +class DetektTaskSpec { + + private val projectLayoutWithTooManyIssues = ProjectLayout( + numberOfSourceFilesInRootPerSourceDir = 15, + numberOfCodeSmellsInRootPerSourceDir = 15 + ) + + @ParameterizedTest(name = "Using {0}, build succeeds with more issues than threshold if ignoreFailures = true") + @MethodSource("io.gitlab.arturbosch.detekt.testkit.DslTestBuilder#builders") + fun ignoreFailures(builder: DslTestBuilder) { + val config = """ + |detekt { + | ignoreFailures = true + |} + """ + + val gradleRunner = builder + .withProjectLayout(projectLayoutWithTooManyIssues) + .withDetektConfig(config) + .build() + + gradleRunner.runDetektTaskAndCheckResult { result -> + assertThat(result.task(":detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) } } -}) + + @ParameterizedTest(name = "Using {0}, build fails with more issues than threshold successfully if ignoreFailures = false") + @MethodSource("io.gitlab.arturbosch.detekt.testkit.DslTestBuilder#builders") + fun doNotIgnoreFailures(builder: DslTestBuilder) { + val config = """ + |detekt { + | ignoreFailures = false + |} + """ + + val gradleRunner = builder + .withProjectLayout(projectLayoutWithTooManyIssues) + .withDetektConfig(config) + .build() + + gradleRunner.runDetektTaskAndExpectFailure() + } +} diff --git a/detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/GenerateConfigTaskSpec.kt b/detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/GenerateConfigTaskSpec.kt index 8eb30023d8d7..09d9d0c68c61 100644 --- a/detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/GenerateConfigTaskSpec.kt +++ b/detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/GenerateConfigTaskSpec.kt @@ -3,41 +3,36 @@ package io.gitlab.arturbosch.detekt import io.gitlab.arturbosch.detekt.testkit.DslTestBuilder import org.assertj.core.api.Assertions.assertThat import org.gradle.testkit.runner.TaskOutcome -import org.spekframework.spek2.Spek -import org.spekframework.spek2.style.specification.describe +import org.junit.jupiter.params.ParameterizedTest +import org.junit.jupiter.params.provider.MethodSource -class GenerateConfigTaskSpec : Spek({ +class GenerateConfigTaskSpec { - describe("The generate config task of the Detekt Gradle plugin") { + @ParameterizedTest(name = "Using {0}, can be executed without any configuration") + @MethodSource("io.gitlab.arturbosch.detekt.testkit.DslTestBuilder#builders") + fun emptyConfig(builder: DslTestBuilder) { + val gradleRunner = builder.build() - listOf(DslTestBuilder.groovy(), DslTestBuilder.kotlin()).forEach { builder -> - - describe("using ${builder.gradleBuildName}") { - - it("can be executed without any configuration") { - val gradleRunner = builder.build() - - gradleRunner.runTasksAndCheckResult("detektGenerateConfig") { result -> - assertThat(result.task(":detektGenerateConfig")?.outcome).isEqualTo(TaskOutcome.SUCCESS) - assertThat(projectFile("config/detekt/detekt.yml")).exists() - } - } - - it("chooses the last config file when configured") { - val gradleRunner = builder.withDetektConfig( - """ - |detekt { - | config = files("config/detekt/detekt.yml", "config/other/detekt.yml") - |} - """ - ).build() + gradleRunner.runTasksAndCheckResult("detektGenerateConfig") { result -> + assertThat(result.task(":detektGenerateConfig")?.outcome).isEqualTo(TaskOutcome.SUCCESS) + assertThat(projectFile("config/detekt/detekt.yml")).exists() + } + } - gradleRunner.runTasksAndCheckResult("detektGenerateConfig") { result -> - assertThat(result.task(":detektGenerateConfig")?.outcome).isEqualTo(TaskOutcome.SUCCESS) - assertThat(projectFile("config/other/detekt.yml")).exists() - } - } - } + @ParameterizedTest(name = "Using {0}, chooses the last config file when configured") + @MethodSource("io.gitlab.arturbosch.detekt.testkit.DslTestBuilder#builders") + fun `chooses the last config file when configured`(builder: DslTestBuilder) { + val gradleRunner = builder.withDetektConfig( + """ + |detekt { + | config = files("config/detekt/detekt.yml", "config/other/detekt.yml") + |} + """ + ).build() + + gradleRunner.runTasksAndCheckResult("detektGenerateConfig") { result -> + assertThat(result.task(":detektGenerateConfig")?.outcome).isEqualTo(TaskOutcome.SUCCESS) + assertThat(projectFile("config/other/detekt.yml")).exists() } } -}) +} diff --git a/detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/JvmSpec.kt b/detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/JvmSpec.kt index 89ee010244c4..d50fd178a838 100644 --- a/detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/JvmSpec.kt +++ b/detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/JvmSpec.kt @@ -2,12 +2,12 @@ package io.gitlab.arturbosch.detekt import org.assertj.core.api.Assertions.assertThat import org.gradle.testkit.runner.GradleRunner -import org.spekframework.spek2.Spek -import org.spekframework.spek2.style.specification.describe +import org.junit.jupiter.api.Test import java.io.File -object JvmSpec : Spek({ - describe("Type resolution on JVM") { +class JvmSpec { + @Test + fun `Type resolution on JVM`() { val projectDir = checkNotNull(javaClass.classLoader.getResource("jvm")?.file) val result = GradleRunner.create() .withProjectDir(File(projectDir)) @@ -19,4 +19,4 @@ object JvmSpec : Spek({ assertThat(result.output).contains("ExitOutsideMain - [kotlinExit]") assertThat(result.output).contains("ExitOutsideMain - [javaExit]") } -}) +} diff --git a/detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/PluginTaskBehaviorSpec.kt b/detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/PluginTaskBehaviorSpec.kt index 8e444dd7c22a..4879c152a252 100644 --- a/detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/PluginTaskBehaviorSpec.kt +++ b/detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/PluginTaskBehaviorSpec.kt @@ -4,14 +4,15 @@ import io.gitlab.arturbosch.detekt.testkit.DslGradleRunner import io.gitlab.arturbosch.detekt.testkit.DslTestBuilder.Companion.kotlin import org.assertj.core.api.Assertions.assertThat import org.gradle.testkit.runner.TaskOutcome -import org.spekframework.spek2.Spek -import org.spekframework.spek2.style.specification.describe +import org.junit.jupiter.api.BeforeEach +import org.junit.jupiter.api.Nested +import org.junit.jupiter.api.Test /** * Tests that run the Detekt Gradle Plugins tasks multiple times to check for correct * UP-TO-DATE states and correct build caching. */ -internal class PluginTaskBehaviorSpec : Spek({ +class PluginTaskBehaviorSpec { val configFileName = "config.yml" val baselineFileName = "baseline.xml" @@ -23,10 +24,12 @@ internal class PluginTaskBehaviorSpec : Spek({ |} """ - describe("The Detekt Gradle Plugin :detekt Task") { + @Nested + inner class `The Detekt Gradle Plugin 'detekt' Task` { lateinit var gradleRunner: DslGradleRunner - beforeEachTest { + @BeforeEach + fun setupGradleRunner() { gradleRunner = kotlin() .withDetektConfig(detektConfig) .withBaseline(baselineFileName) @@ -34,7 +37,8 @@ internal class PluginTaskBehaviorSpec : Spek({ .build() } - it("should be UP-TO-DATE the 2nd run without changes") { + @Test + fun `should be UP-TO-DATE the 2nd run without changes`() { gradleRunner.runDetektTaskAndCheckResult { result -> assertThat(result.task(":detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) } @@ -42,7 +46,9 @@ internal class PluginTaskBehaviorSpec : Spek({ assertThat(result.task(":detekt")?.outcome).isEqualTo(TaskOutcome.UP_TO_DATE) } } - it("should pick up build artifacts from the build cache on a 2nd run after deleting the build/ dir") { + + @Test + fun `should pick up build artifacts from the build cache on a 2nd run after deleting the build dir`() { gradleRunner.runDetektTaskAndCheckResult { result -> assertThat(result.task(":detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) } @@ -54,7 +60,9 @@ internal class PluginTaskBehaviorSpec : Spek({ assertThat(result.task(":detekt")?.outcome).isEqualTo(TaskOutcome.FROM_CACHE) } } - it("should pick up build artifacts from the build cache on a 2nd run after running :clean") { + + @Test + fun `should pick up build artifacts from the build cache on a 2nd run after running 'clean'`() { gradleRunner.runDetektTaskAndCheckResult { result -> assertThat(result.task(":detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) } @@ -63,7 +71,9 @@ internal class PluginTaskBehaviorSpec : Spek({ assertThat(result.task(":detekt")?.outcome).isEqualTo(TaskOutcome.FROM_CACHE) } } - it("should run again after changing config") { + + @Test + fun `should run again after changing config`() { val configFileWithCommentsDisabled = """ |comments: | active: false @@ -80,7 +90,9 @@ internal class PluginTaskBehaviorSpec : Spek({ assertThat(result.task(":detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) } } - it("should run again after changing baseline") { + + @Test + fun `should run again after changing baseline`() { val changedBaselineContent = """ | | @@ -99,8 +111,9 @@ internal class PluginTaskBehaviorSpec : Spek({ assertThat(result.task(":detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) } } - it("should run again after changing inputs") { + @Test + fun `should run again after changing inputs`() { gradleRunner.runDetektTaskAndCheckResult { result -> assertThat(result.task(":detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) } @@ -113,4 +126,4 @@ internal class PluginTaskBehaviorSpec : Spek({ } } } -}) +} diff --git a/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/ConfigurationCacheSpec.kt b/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/ConfigurationCacheSpec.kt index 9b456da7d55e..678481d055d1 100644 --- a/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/ConfigurationCacheSpec.kt +++ b/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/ConfigurationCacheSpec.kt @@ -2,33 +2,34 @@ package io.gitlab.arturbosch.detekt import io.gitlab.arturbosch.detekt.testkit.DslTestBuilder import org.assertj.core.api.Assertions.assertThat -import org.spekframework.spek2.Spek -import org.spekframework.spek2.style.specification.describe +import org.junit.jupiter.api.Nested +import org.junit.jupiter.api.Test +import org.junit.jupiter.params.ParameterizedTest +import org.junit.jupiter.params.provider.CsvSource -object ConfigurationCacheSpec : Spek({ - describe("Detekt task") { - listOf( - "regular invocation" to arrayOf("detekt"), - "dry-run invocation" to arrayOf("detekt", "-Pdetekt-dry-run=true"), - ).forEach { (context, arguments) -> - context("given $context") { - it("can be loaded from the configuration cache") { - val gradleRunner = DslTestBuilder.kotlin().build() +class ConfigurationCacheSpec { + @ParameterizedTest(name = "Given {0}, can be loaded from the configuration cache") + @CsvSource( + "regular invocation, 'detekt'", + "dry-run invocation, 'detekt,-Pdetekt-dry-run=true'", + ) + @Suppress("UnusedPrivateMember") // `unused` is used in the parameterized test name + fun detektConfigCache(unused: String, arguments: String) { + val gradleRunner = DslTestBuilder.kotlin().build() - // First run primes the cache - gradleRunner.runTasks("--configuration-cache", *arguments) + // First run primes the cache + gradleRunner.runTasks("--configuration-cache", *arguments.split(',').toTypedArray()) - // Second run reuses the cache - val result = gradleRunner.runTasks("--configuration-cache", *arguments) + // Second run reuses the cache + val result = gradleRunner.runTasks("--configuration-cache", *arguments.split(',').toTypedArray()) - assertThat(result.output).contains("Reusing configuration cache.") - } - } - } + assertThat(result.output).contains("Reusing configuration cache.") } - describe("Create baseline task") { - it("can be loaded from the configuration cache") { + @Nested + inner class `Create baseline task` { + @Test + fun `can be loaded from the configuration cache`() { val detektConfig = """ |detekt { | baseline = file("build/baseline.xml") @@ -49,8 +50,10 @@ object ConfigurationCacheSpec : Spek({ } } - describe("Generate config task") { - it("can be loaded from the configuration cache") { + @Nested + inner class `Generate config task` { + @Test + fun `can be loaded from the configuration cache`() { val gradleRunner = DslTestBuilder.kotlin() .dryRun() .build() @@ -64,4 +67,4 @@ object ConfigurationCacheSpec : Spek({ assertThat(result.output).contains("Reusing configuration cache.") } } -}) +} diff --git a/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektAndroidSpec.kt b/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektAndroidSpec.kt index e6fa4c8acea6..f209a39a24ac 100644 --- a/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektAndroidSpec.kt +++ b/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektAndroidSpec.kt @@ -3,16 +3,21 @@ package io.gitlab.arturbosch.detekt import io.gitlab.arturbosch.detekt.testkit.DslGradleRunner import io.gitlab.arturbosch.detekt.testkit.ProjectLayout import org.assertj.core.api.Assertions.assertThat -import org.spekframework.spek2.Spek -import org.spekframework.spek2.dsl.Skip -import org.spekframework.spek2.style.specification.describe - -object DetektAndroidSpec : Spek({ - describe( - "When applying detekt in an Android project", - skip = skipIfAndroidEnvironmentRequirementsUnmet() - ) { - describe("configures android tasks for android application") { +import org.junit.jupiter.api.DisplayName +import org.junit.jupiter.api.Nested +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.condition.EnabledForJreRange +import org.junit.jupiter.api.condition.EnabledIf +import org.junit.jupiter.api.condition.JRE + +class DetektAndroidSpec { + @Nested + @EnabledForJreRange(min = JRE.JAVA_11, disabledReason = "Android Gradle Plugin 7.0+ requires JDK 11 or newer") + @EnabledIf("io.gitlab.arturbosch.detekt.DetektAndroidSpecKt#isAndroidSdkInstalled") + inner class `When applying detekt in an Android project` { + + @Nested + inner class `configures android tasks for android application` { val projectLayout = ProjectLayout( numberOfSourceFilesInRootPerSourceDir = 0, ).apply { @@ -45,10 +50,13 @@ object DetektAndroidSpec : Spek({ ) ) } - val gradleRunner = createGradleRunnerAndSetupProject(projectLayout) - gradleRunner.writeProjectFile("app/src/main/AndroidManifest.xml", manifestContent()) + val gradleRunner = createGradleRunnerAndSetupProject(projectLayout).also { + it.writeProjectFile("app/src/main/AndroidManifest.xml", manifestContent()) + } - it("task :app:detektMain") { + @Test + @DisplayName("task :app:detektMain") + fun appDetektMain() { gradleRunner.runTasksAndCheckResult(":app:detektMain") { buildResult -> assertThat(buildResult.output).containsPattern("""--baseline \S*[/\\]detekt-baseline-release.xml """) assertThat(buildResult.output).containsPattern("""--baseline \S*[/\\]detekt-baseline-debug.xml """) @@ -68,7 +76,9 @@ object DetektAndroidSpec : Spek({ } } - it("task :app:detektTest") { + @Test + @DisplayName("task :app:detektTest") + fun appDetektTest() { gradleRunner.runTasksAndCheckResult(":app:detektTest") { buildResult -> assertThat(buildResult.output).containsPattern("""--baseline \S*[/\\]detekt-baseline-releaseUnitTest.xml """) assertThat(buildResult.output).containsPattern("""--baseline \S*[/\\]detekt-baseline-debugUnitTest.xml """) @@ -90,7 +100,8 @@ object DetektAndroidSpec : Spek({ } } - describe("does not configures android tasks if user opts out") { + @Nested + inner class `does not configures android tasks if user opts out` { val projectLayout = ProjectLayout(numberOfSourceFilesInRootPerSourceDir = 0).apply { addSubmodule( name = "app", @@ -104,28 +115,36 @@ object DetektAndroidSpec : Spek({ srcDirs = listOf("src/main/java", "src/debug/java", "src/test/java", "src/androidTest/java") ) } - val gradleRunner = createGradleRunnerAndSetupProject(projectLayout) - gradleRunner.writeProjectFile("gradle.properties", "detekt.android.disabled=true") - gradleRunner.writeProjectFile("app/src/main/AndroidManifest.xml", manifestContent()) + val gradleRunner = createGradleRunnerAndSetupProject(projectLayout).also { + it.writeProjectFile("gradle.properties", "detekt.android.disabled=true") + it.writeProjectFile("app/src/main/AndroidManifest.xml", manifestContent()) + } - it("task :app:detekt") { + @Test + @DisplayName("task :app:detekt") + fun appDetekt() { gradleRunner.runTasks(":app:detekt") } - it("task :app:detektMain") { + @Test + @DisplayName("task :app:detektMain") + fun appDetektMain() { gradleRunner.runTasksAndExpectFailure(":app:detektMain") { result -> assertThat(result.output).contains("Task 'detektMain' not found in project") } } - it("task :app:detektTest") { + @Test + @DisplayName("task :app:detektTest") + fun appDetektTest() { gradleRunner.runTasksAndExpectFailure(":app:detektTest") { result -> assertThat(result.output).contains("Task 'detektTest' not found in project") } } } - describe("configures android tasks for android library") { + @Nested + inner class `configures android tasks for android library` { val projectLayout = ProjectLayout(numberOfSourceFilesInRootPerSourceDir = 0).apply { addSubmodule( name = "lib", @@ -147,10 +166,13 @@ object DetektAndroidSpec : Spek({ ) ) } - val gradleRunner = createGradleRunnerAndSetupProject(projectLayout) - gradleRunner.writeProjectFile("lib/src/main/AndroidManifest.xml", manifestContent()) + val gradleRunner = createGradleRunnerAndSetupProject(projectLayout).also { + it.writeProjectFile("lib/src/main/AndroidManifest.xml", manifestContent()) + } - it("task :lib:detektMain") { + @Test + @DisplayName("task :lib:detektMain") + fun libDetektMain() { gradleRunner.runTasksAndCheckResult(":lib:detektMain") { buildResult -> assertThat(buildResult.output).containsPattern("""--baseline \S*[/\\]detekt-baseline-release.xml """) assertThat(buildResult.output).containsPattern("""--baseline \S*[/\\]detekt-baseline-debug.xml """) @@ -166,7 +188,9 @@ object DetektAndroidSpec : Spek({ } } - it("task :lib:detektTest") { + @Test + @DisplayName("task :lib:detektTest") + fun libDetektTest() { gradleRunner.runTasksAndCheckResult(":lib:detektTest") { buildResult -> assertThat(buildResult.output).containsPattern("""--baseline \S*[/\\]detekt-baseline-releaseUnitTest.xml """) assertThat(buildResult.output).containsPattern("""--baseline \S*[/\\]detekt-baseline-debugUnitTest.xml """) @@ -184,7 +208,8 @@ object DetektAndroidSpec : Spek({ } } - describe("configures android tasks for different build variants") { + @Nested + inner class `configures android tasks for different build variants` { val projectLayout = ProjectLayout(numberOfSourceFilesInRootPerSourceDir = 0).apply { addSubmodule( @@ -199,10 +224,13 @@ object DetektAndroidSpec : Spek({ srcDirs = listOf("src/main/java", "src/debug/java", "src/test/java", "src/androidTest/java") ) } - val gradleRunner = createGradleRunnerAndSetupProject(projectLayout) - gradleRunner.writeProjectFile("lib/src/main/AndroidManifest.xml", manifestContent()) + val gradleRunner = createGradleRunnerAndSetupProject(projectLayout).also { + it.writeProjectFile("lib/src/main/AndroidManifest.xml", manifestContent()) + } - it("task :lib:detektMain") { + @Test + @DisplayName("task :lib:detektMain") + fun libDetektMain() { gradleRunner.runTasksAndCheckResult(":lib:detektMain") { buildResult -> assertThat(buildResult.tasks.map { it.path }).containsAll( listOf( @@ -214,7 +242,9 @@ object DetektAndroidSpec : Spek({ } } - it("task :lib:detektTest") { + @Test + @DisplayName("task :lib:detektTest") + fun libDetektTest() { gradleRunner.runTasksAndCheckResult(":lib:detektTest") { buildResult -> assertThat(buildResult.tasks.map { it.path }).containsAll( listOf( @@ -229,7 +259,8 @@ object DetektAndroidSpec : Spek({ } } - describe("configures android tasks for different build variants excluding ignored build types") { + @Nested + inner class `configures android tasks for different build variants excluding ignored build types` { val projectLayout = ProjectLayout(numberOfSourceFilesInRootPerSourceDir = 0).apply { addSubmodule( @@ -246,10 +277,13 @@ object DetektAndroidSpec : Spek({ srcDirs = listOf("src/main/java", "src/debug/java", "src/test/java", "src/androidTest/java") ) } - val gradleRunner = createGradleRunnerAndSetupProject(projectLayout) - gradleRunner.writeProjectFile("lib/src/main/AndroidManifest.xml", manifestContent()) + val gradleRunner = createGradleRunnerAndSetupProject(projectLayout).also { + it.writeProjectFile("lib/src/main/AndroidManifest.xml", manifestContent()) + } - it("task :lib:detektMain") { + @Test + @DisplayName("task :lib:detektMain") + fun libDetektMain() { gradleRunner.runTasksAndCheckResult(":lib:detektMain") { buildResult -> assertThat(buildResult.tasks.map { it.path }).containsAll( listOf( @@ -262,7 +296,9 @@ object DetektAndroidSpec : Spek({ } } - it("task :lib:detektTest") { + @Test + @DisplayName("task :lib:detektTest") + fun libDetektTest() { gradleRunner.runTasksAndCheckResult(":lib:detektTest") { buildResult -> assertThat(buildResult.tasks.map { it.path }).containsAll( listOf( @@ -278,7 +314,8 @@ object DetektAndroidSpec : Spek({ } } - describe("configures android tasks for different build variants excluding ignored variants") { + @Nested + inner class `configures android tasks for different build variants excluding ignored variants` { val projectLayout = ProjectLayout(numberOfSourceFilesInRootPerSourceDir = 0).apply { addSubmodule( @@ -295,10 +332,13 @@ object DetektAndroidSpec : Spek({ srcDirs = listOf("src/main/java", "src/debug/java", "src/test/java", "src/androidTest/java") ) } - val gradleRunner = createGradleRunnerAndSetupProject(projectLayout) - gradleRunner.writeProjectFile("lib/src/main/AndroidManifest.xml", manifestContent()) + val gradleRunner = createGradleRunnerAndSetupProject(projectLayout).also { + it.writeProjectFile("lib/src/main/AndroidManifest.xml", manifestContent()) + } - it("task :lib:detektMain") { + @Test + @DisplayName("task :lib:detektMain") + fun libDetektMain() { gradleRunner.runTasksAndCheckResult(":lib:detektMain") { buildResult -> assertThat(buildResult.tasks.map { it.path }).containsAll( listOf( @@ -311,7 +351,9 @@ object DetektAndroidSpec : Spek({ } } - it("task :lib:detektTest") { + @Test + @DisplayName("task :lib:detektTest") + fun libDetektTest() { gradleRunner.runTasksAndCheckResult(":lib:detektTest") { buildResult -> assertThat(buildResult.tasks.map { it.path }).containsAll( listOf( @@ -327,7 +369,8 @@ object DetektAndroidSpec : Spek({ } } - describe("configures android tasks for different build variants excluding ignored flavors") { + @Nested + inner class `configures android tasks for different build variants excluding ignored flavors` { val projectLayout = ProjectLayout(numberOfSourceFilesInRootPerSourceDir = 0).apply { addSubmodule( @@ -344,10 +387,13 @@ object DetektAndroidSpec : Spek({ srcDirs = listOf("src/main/java", "src/debug/java", "src/test/java", "src/androidTest/java") ) } - val gradleRunner = createGradleRunnerAndSetupProject(projectLayout) - gradleRunner.writeProjectFile("lib/src/main/AndroidManifest.xml", manifestContent()) + val gradleRunner = createGradleRunnerAndSetupProject(projectLayout).also { + it.writeProjectFile("lib/src/main/AndroidManifest.xml", manifestContent()) + } - it("task :lib:detektMain") { + @Test + @DisplayName("task :lib:detektMain") + fun libDetektMain() { gradleRunner.runTasksAndCheckResult(":lib:detektMain") { buildResult -> assertThat(buildResult.tasks.map { it.path }).containsAll( listOf( @@ -360,7 +406,9 @@ object DetektAndroidSpec : Spek({ } } - it("task :lib:detektTest") { + @Test + @DisplayName("task :lib:detektTest") + fun libDetektTest() { gradleRunner.runTasksAndCheckResult(":lib:detektTest") { buildResult -> assertThat(buildResult.tasks.map { it.path }).containsAll( listOf( @@ -376,7 +424,7 @@ object DetektAndroidSpec : Spek({ } } } -}) +} /** * ANDROID_SDK_ROOT is preferred over ANDROID_HOME, but the check here is more lenient. @@ -385,12 +433,6 @@ object DetektAndroidSpec : Spek({ internal fun isAndroidSdkInstalled() = System.getenv("ANDROID_SDK_ROOT") != null || System.getenv("ANDROID_HOME") != null -internal fun skipIfAndroidEnvironmentRequirementsUnmet() = when { - !isAndroidSdkInstalled() -> Skip.Yes("No android SDK.") - getJdkVersion() < 11 -> Skip.Yes("Android Gradle Plugin 7.0+ requires JDK 11 or newer") - else -> Skip.No -} - internal fun manifestContent(packageName: String = "io.gitlab.arturbosch.detekt.app") = """ diff --git a/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektJvmSpec.kt b/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektJvmSpec.kt index 2d15e032619e..87c53e998b33 100644 --- a/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektJvmSpec.kt +++ b/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektJvmSpec.kt @@ -7,12 +7,15 @@ import org.assertj.core.api.Assertions.assertThat import org.gradle.kotlin.dsl.apply import org.gradle.kotlin.dsl.repositories import org.jetbrains.kotlin.gradle.plugin.KotlinPluginWrapper -import org.spekframework.spek2.Spek -import org.spekframework.spek2.style.specification.describe +import org.junit.jupiter.api.Nested +import org.junit.jupiter.api.Test -object DetektJvmSpec : Spek({ - describe("When applying detekt in a JVM project") { - context("disabled TXT report") { +class DetektJvmSpec { + @Nested + inner class `When applying detekt in a JVM project` { + + @Nested + inner class `disabled TXT report` { val gradleRunner = DslGradleRunner( projectLayout = ProjectLayout(numberOfSourceFilesInRootPerSourceDir = 1), @@ -31,10 +34,10 @@ object DetektJvmSpec : Spek({ } } }, - ) - gradleRunner.setupProject() + ).also(DslGradleRunner::setupProject) - it("configures detekt type resolution task main") { + @Test + fun `configures detekt type resolution task main`() { val project = gradleRunner.buildProject() val detektTask = project.tasks.getByPath("detektMain") as Detekt @@ -47,7 +50,7 @@ object DetektJvmSpec : Spek({ assertThat(argumentString).contains("--classpath") } - it("configures detekt type resolution task test") { + fun `configures detekt type resolution task test`() { val project = gradleRunner.buildProject() val detektTask = project.tasks.getByPath("detektTest") as Detekt @@ -61,7 +64,8 @@ object DetektJvmSpec : Spek({ } } - context("report location set on extension & task") { + @Nested + inner class `report location set on extension & task` { val gradleRunner = DslGradleRunner( projectLayout = ProjectLayout(numberOfSourceFilesInRootPerSourceDir = 1), buildFileName = "build.gradle", @@ -89,17 +93,20 @@ object DetektJvmSpec : Spek({ } """.trimIndent(), dryRun = false - ) - gradleRunner.setupProject() + ).also { + it.setupProject() + } - it("logs a warning") { + @Test + fun `logs a warning`() { gradleRunner.runTasksAndCheckResult(":detektMain") { buildResult -> assertThat(buildResult.output).contains("TXT report location set on detekt {} extension will be ignored for detektMain task.") } } } - context("report location set on task only") { + @Nested + inner class `report location set on task only` { val gradleRunner = DslGradleRunner( projectLayout = ProjectLayout(numberOfSourceFilesInRootPerSourceDir = 1), buildFileName = "build.gradle", @@ -121,14 +128,15 @@ object DetektJvmSpec : Spek({ } """.trimIndent(), dryRun = false - ) - gradleRunner.setupProject() + ).also { + it.setupProject() + } - it("logs a warning") { + fun `logs a warning`() { gradleRunner.runTasksAndCheckResult(":detektMain") { buildResult -> assertThat(buildResult.output).doesNotContain("report location set on detekt {} extension will be ignored") } } } } -}) +} diff --git a/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektMultiplatformSpec.kt b/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektMultiplatformSpec.kt index 912a20bde7e9..19a0d7652217 100644 --- a/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektMultiplatformSpec.kt +++ b/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektMultiplatformSpec.kt @@ -4,16 +4,21 @@ import io.gitlab.arturbosch.detekt.testkit.DslGradleRunner import io.gitlab.arturbosch.detekt.testkit.ProjectLayout import org.assertj.core.api.Assertions.assertThat import org.gradle.testkit.runner.BuildResult -import org.spekframework.spek2.Spek -import org.spekframework.spek2.dsl.Skip -import org.spekframework.spek2.style.specification.describe +import org.junit.jupiter.api.Nested +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.condition.EnabledForJreRange +import org.junit.jupiter.api.condition.EnabledIf +import org.junit.jupiter.api.condition.EnabledOnOs +import org.junit.jupiter.api.condition.JRE.JAVA_11 +import org.junit.jupiter.api.condition.OS.MAC import java.util.concurrent.TimeUnit -class DetektMultiplatformSpec : Spek({ +class DetektMultiplatformSpec { - describe("multiplatform projects - Common target") { + @Nested + inner class `multiplatform projects - Common target` { - val gradleRunner by memoized { + val gradleRunner = setupProject { addSubmodule( "shared", @@ -30,13 +35,14 @@ class DetektMultiplatformSpec : Spek({ baselineFiles = listOf("detekt-baseline.xml", "detekt-baseline-metadataMain.xml") ) } - } - it("configures baseline task") { + @Test + fun `configures baseline task`() { gradleRunner.runTasks(":shared:detektBaselineMetadataMain") } - it("configures detekt task without type resolution") { + @Test + fun `configures detekt task without type resolution`() { gradleRunner.runTasksAndCheckResult(":shared:detektMetadataMain") { assertThat(it.output).containsPattern("""--baseline \S*[/\\]detekt-baseline.xml """) assertDetektWithoutClasspath(it) @@ -44,9 +50,10 @@ class DetektMultiplatformSpec : Spek({ } } - describe("multiplatform projects - detekt plain only if user opts out") { + @Nested + inner class `multiplatform projects - detekt plain only if user opts out` { - val gradleRunner by memoized { + val gradleRunner = setupMultiplatformProject { addSubmodule( "shared", @@ -62,23 +69,25 @@ class DetektMultiplatformSpec : Spek({ srcDirs = listOf("src/commonMain/kotlin", "src/commonTest/kotlin") ) } - } - it("does not configure baseline task") { + @Test + fun `does not configure baseline task`() { gradleRunner.runTasksAndExpectFailure(":shared:detektBaselineMetadataMain") { result -> assertThat(result.output).contains("Task 'detektBaselineMetadataMain' not found in project") } } - it("does not configure detekt task") { + @Test + fun `does not configure detekt task`() { gradleRunner.runTasksAndExpectFailure(":shared:detektMetadataMain") { result -> assertThat(result.output).contains("Task 'detektMetadataMain' not found in project") } } } - describe("multiplatform projects - JVM target") { - val gradleRunner by memoized { + @Nested + inner class `multiplatform projects - JVM target` { + val gradleRunner = setupProject { addSubmodule( "shared", @@ -101,23 +110,25 @@ class DetektMultiplatformSpec : Spek({ baselineFiles = listOf("detekt-baseline.xml", "detekt-baseline-main.xml") ) } - } - it("configures baseline task") { + @Test + fun `configures baseline task`() { gradleRunner.runTasks(":shared:detektBaselineJvmBackendMain") gradleRunner.runTasks(":shared:detektBaselineJvmBackendTest") gradleRunner.runTasks(":shared:detektBaselineJvmEmbeddedMain") gradleRunner.runTasks(":shared:detektBaselineJvmEmbeddedTest") } - it("configures detekt task with type resolution backend") { + @Test + fun `configures detekt task with type resolution backend`() { gradleRunner.runTasksAndCheckResult(":shared:detektJvmBackendMain") { assertThat(it.output).containsPattern("""--baseline \S*[/\\]detekt-baseline-main.xml """) assertDetektWithClasspath(it) } } - it("configures detekt task with type resolution embedded") { + @Test + fun `configures detekt task with type resolution embedded`() { gradleRunner.runTasksAndCheckResult(":shared:detektJvmEmbeddedMain") { assertThat(it.output).containsPattern("""--baseline \S*[/\\]detekt-baseline-main.xml """) assertDetektWithClasspath(it) @@ -125,11 +136,11 @@ class DetektMultiplatformSpec : Spek({ } } - describe( - "multiplatform projects - Android target", - skip = skipIfAndroidEnvironmentRequirementsUnmet() - ) { - val gradleRunner by memoized { + @Nested + @EnabledForJreRange(min = JAVA_11, disabledReason = "Android Gradle Plugin 7.0+ requires JDK 11 or newer") + @EnabledIf("io.gitlab.arturbosch.detekt.DetektAndroidSpecKt#isAndroidSdkInstalled") + inner class `multiplatform projects - Android target` { + val gradleRunner = setupAndroidProject { addSubmodule( "shared", @@ -171,20 +182,22 @@ class DetektMultiplatformSpec : Spek({ ) ) } - } - it("configures baseline task") { + @Test + fun `configures baseline task`() { gradleRunner.runTasks(":shared:detektBaselineAndroidDebug") gradleRunner.runTasks(":shared:detektBaselineAndroidRelease") } - it("configures test tasks") { + @Test + fun `configures test tasks`() { gradleRunner.runTasks(":shared:detektAndroidDebugAndroidTest") gradleRunner.runTasks(":shared:detektAndroidDebugUnitTest") gradleRunner.runTasks(":shared:detektAndroidReleaseUnitTest") } - it("configures detekt task with type resolution") { + @Test + fun `configures detekt task with type resolution`() { gradleRunner.runTasksAndCheckResult(":shared:detektAndroidDebug") { assertThat(it.output).containsPattern("""--baseline \S*[/\\]detekt-baseline-debug.xml """) assertDetektWithClasspath(it) @@ -196,8 +209,9 @@ class DetektMultiplatformSpec : Spek({ } } - describe("multiplatform projects - JS target") { - val gradleRunner by memoized { + @Nested + inner class `multiplatform projects - JS target` { + val gradleRunner = setupProject { addSubmodule( "shared", @@ -221,14 +235,15 @@ class DetektMultiplatformSpec : Spek({ baselineFiles = listOf("detekt-baseline.xml") ) } - } - it("configures baseline task") { + @Test + fun `configures baseline task`() { gradleRunner.runTasks(":shared:detektBaselineJsMain") gradleRunner.runTasks(":shared:detektBaselineJsTest") } - it("configures detekt task without type resolution") { + @Test + fun `configures detekt task without type resolution`() { gradleRunner.runTasksAndCheckResult(":shared:detektJsMain") { assertThat(it.output).containsPattern("""--baseline \S*[/\\]detekt-baseline.xml """) assertDetektWithoutClasspath(it) @@ -240,11 +255,11 @@ class DetektMultiplatformSpec : Spek({ } } - describe( - "multiplatform projects - iOS target", - skip = if (isMacOs() && isXCodeInstalled()) Skip.No else Skip.Yes("XCode is not installed.") - ) { - val gradleRunner by memoized { + @Nested + @EnabledOnOs(MAC) + @EnabledIf("io.gitlab.arturbosch.detekt.DetektMultiplatformSpecKt#isXCodeInstalled", disabledReason = "XCode is not installed.") + inner class `multiplatform projects - iOS target` { + val gradleRunner = setupProject { addSubmodule( "shared", @@ -269,16 +284,17 @@ class DetektMultiplatformSpec : Spek({ baselineFiles = listOf("detekt-baseline.xml") ) } - } - it("configures baseline task") { + @Test + fun `configures baseline task`() { gradleRunner.runTasks(":shared:detektBaselineIosArm64Main") gradleRunner.runTasks(":shared:detektBaselineIosArm64Test") gradleRunner.runTasks(":shared:detektBaselineIosX64Main") gradleRunner.runTasks(":shared:detektBaselineIosX64Test") } - it("configures detekt task without type resolution") { + @Test + fun `configures detekt task without type resolution`() { gradleRunner.runTasksAndCheckResult(":shared:detektIosArm64Main") { assertThat(it.output).containsPattern("""--baseline \S*[/\\]detekt-baseline.xml """) assertDetektWithoutClasspath(it) @@ -297,7 +313,7 @@ class DetektMultiplatformSpec : Spek({ } } } -}) +} private fun setupProject(projectLayoutAction: ProjectLayout.() -> Unit): DslGradleRunner { return DslGradleRunner( @@ -357,9 +373,7 @@ private val DETEKT_BLOCK = """ } """.trimIndent() -private fun isMacOs() = System.getProperty("os.name").contains("mac", ignoreCase = true) - -private fun isXCodeInstalled(): Boolean { +fun isXCodeInstalled(): Boolean { return try { val process = ProcessBuilder() .command("xcode-select", "--print-path") diff --git a/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektPlainSpec.kt b/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektPlainSpec.kt index 111d255e1338..9e6ce4d5f826 100644 --- a/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektPlainSpec.kt +++ b/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektPlainSpec.kt @@ -3,11 +3,12 @@ package io.gitlab.arturbosch.detekt import io.gitlab.arturbosch.detekt.testkit.DslGradleRunner import io.gitlab.arturbosch.detekt.testkit.ProjectLayout import org.assertj.core.api.Assertions.assertThat -import org.spekframework.spek2.Spek -import org.spekframework.spek2.style.specification.describe +import org.junit.jupiter.api.Nested +import org.junit.jupiter.api.Test -object DetektPlainSpec : Spek({ - describe("When detekt is applied before JVM plugin") { +class DetektPlainSpec { + @Nested + inner class `When detekt is applied before JVM plugin` { val gradleRunner = DslGradleRunner( projectLayout = ProjectLayout(numberOfSourceFilesInRootPerSourceDir = 1), buildFileName = "build.gradle", @@ -26,17 +27,18 @@ object DetektPlainSpec : Spek({ } """.trimIndent(), dryRun = true - ) - gradleRunner.setupProject() + ).also { it.setupProject() } - it("lazily adds detekt as a dependency of the `check` task") { + @Test + fun `lazily adds detekt as a dependency of the 'check' task`() { gradleRunner.runTasksAndCheckResult("check") { buildResult -> assertThat(buildResult.task(":detekt")).isNotNull } } } - describe("When applying detekt in a project") { + @Nested + inner class `When applying detekt in a project` { val gradleRunner = DslGradleRunner( projectLayout = ProjectLayout(numberOfSourceFilesInRootPerSourceDir = 1), buildFileName = "build.gradle", @@ -60,10 +62,10 @@ object DetektPlainSpec : Spek({ } """.trimIndent(), dryRun = true - ) - gradleRunner.setupProject() + ).also { it.setupProject() } - it("configures detekt plain task") { + @Test + fun `configures detekt plain task`() { gradleRunner.runTasksAndCheckResult(":detekt") { buildResult -> assertThat(buildResult.output).containsPattern("""--baseline \S*[/\\]detekt-baseline.xml """) assertThat(buildResult.output).contains("--report xml:") @@ -73,4 +75,4 @@ object DetektPlainSpec : Spek({ } } } -}) +} diff --git a/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektTaskDslSpec.kt b/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektTaskDslSpec.kt index f97f69d53655..c422ab328030 100644 --- a/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektTaskDslSpec.kt +++ b/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektTaskDslSpec.kt @@ -7,50 +7,64 @@ import io.gitlab.arturbosch.detekt.testkit.ProjectLayout import org.assertj.core.api.Assertions.assertThat import org.gradle.testkit.runner.BuildResult import org.gradle.testkit.runner.TaskOutcome -import org.spekframework.spek2.Spek -import org.spekframework.spek2.style.specification.describe +import org.junit.jupiter.api.BeforeAll +import org.junit.jupiter.api.DisplayName +import org.junit.jupiter.api.Nested +import org.junit.jupiter.api.Test +import org.junit.jupiter.params.ParameterizedTest +import org.junit.jupiter.params.provider.EnumSource -internal object DetektTaskDslSpec : Spek({ +class DetektTaskDslSpec { - describe("When applying the detekt gradle plugin") { + @Nested + inner class `When applying the detekt gradle plugin` { lateinit var gradleRunner: DslGradleRunner lateinit var result: BuildResult val defaultDetektVersion = loadDetektVersion(DetektTaskDslSpec::class.java.classLoader) val builder = kotlin().dryRun() - describe("without detekt config") { + @Nested + inner class `without detekt config` { - beforeGroup { + @BeforeAll + fun beforeGroup() { gradleRunner = builder.build() result = gradleRunner.runDetektTask() } - it("completes successfully") { + @Test + fun `completes successfully`() { assertThat(result.task(":detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) } - it("enables xml report to default location") { + @Test + fun `enables xml report to default location`() { val xmlReportFile = gradleRunner.projectFile("build/reports/detekt/detekt.xml") assertThat(result.output).contains("--report xml:$xmlReportFile") } - it("enables html report to default location") { + @Test + fun `enables html report to default location`() { val htmlReportFile = gradleRunner.projectFile("build/reports/detekt/detekt.html") assertThat(result.output).contains("--report html:$htmlReportFile") } - it("enables text report to default location") { + @Test + fun `enables text report to default location`() { val textReportFile = gradleRunner.projectFile("build/reports/detekt/detekt.txt") assertThat(result.output).contains("--report txt:$textReportFile") } - it("enables sarif report to default location") { + @Test + fun `enables sarif report to default location`() { val sarifReportFile = gradleRunner.projectFile("build/reports/detekt/detekt.sarif") assertThat(result.output).contains("--report sarif:$sarifReportFile") } - it("set as input all the kotlin files in src/main/java and src/main/kotlin") { + @Test + @DisplayName("set as input all the kotlin files in src/main/java and src/main/kotlin") + fun setInputFiles() { val file1 = gradleRunner.projectFile("src/main/java/My0Root0Class.kt") val file2 = gradleRunner.projectFile("src/test/java/My1Root0Class.kt") val file3 = gradleRunner.projectFile("src/main/kotlin/My2Root0Class.kt") @@ -59,9 +73,11 @@ internal object DetektTaskDslSpec : Spek({ } } - describe("without multiple detekt configs") { + @Nested + inner class `without multiple detekt configs` { - beforeGroup { + @BeforeAll + fun beforeGroup() { val config = """ |detekt { | config.setFrom(files("firstConfig.yml", "secondConfig.yml")) @@ -73,7 +89,8 @@ internal object DetektTaskDslSpec : Spek({ result = gradleRunner.runDetektTask() } - it("passes absolute filename of both config files to detekt cli") { + @Test + fun `passes absolute filename of both config files to detekt cli`() { val firstConfig = gradleRunner.projectFile("firstConfig.yml") val secondConfig = gradleRunner.projectFile("secondConfig.yml") @@ -82,11 +99,12 @@ internal object DetektTaskDslSpec : Spek({ } } - describe("with custom baseline file") { + @Nested + inner class `with custom baseline file` { val baselineFilename = "custom-baseline.xml" - beforeGroup { - + @BeforeAll + fun beforeGroup() { val config = """ |detekt { | baseline = file("$baselineFilename") @@ -100,18 +118,20 @@ internal object DetektTaskDslSpec : Spek({ result = gradleRunner.runDetektTask() } - it("sets baseline parameter with absolute filename") { + @Test + fun `sets baseline parameter with absolute filename`() { val baselineFile = gradleRunner.projectFile(baselineFilename) val expectedBaselineArgument = "--baseline $baselineFile" assertThat(result.output).contains(expectedBaselineArgument) } } - describe("with custom baseline file that doesn't exist") { + @Nested + inner class `with custom baseline file that doesn't exist` { val baselineFilename = "detekt-baseline-no-exist.xml" - beforeGroup { - + @BeforeAll + fun beforeGroup() { val config = """ |detekt { | baseline = file("$baselineFilename") @@ -124,17 +144,20 @@ internal object DetektTaskDslSpec : Spek({ result = gradleRunner.runDetektTask() } - it("doesn't set the baseline parameter") { + @Test + fun `doesn't set the baseline parameter`() { assertThat(result.output).doesNotContain("--baseline") } } - describe("[deprecated] with custom input directories using input") { + @Nested + @DisplayName("[deprecated] with custom input directories using input") + inner class CustomInputDirectoriesUsingInput { val customSrc1 = "gensrc/kotlin" val customSrc2 = "src/main/kotlin" - beforeGroup { - + @BeforeAll + fun beforeGroup() { val config = """ |detekt { | input = files("$customSrc1", "$customSrc2", "folder_that_does_not_exist") @@ -149,24 +172,27 @@ internal object DetektTaskDslSpec : Spek({ result = gradleRunner.runDetektTask() } - it("sets input parameter to absolute filenames of all source files") { + @Test + fun `sets input parameter to absolute filenames of all source files`() { val file1 = gradleRunner.projectFile("$customSrc1/My0Root0Class.kt") val file2 = gradleRunner.projectFile("$customSrc2/My1Root0Class.kt") val expectedInputParam = "--input $file1,$file2" assertThat(result.output).contains(expectedInputParam) } - it("ignores input directories that do not exist") { + @Test + fun `ignores input directories that do not exist`() { assertThat(result.output).doesNotContain("folder_that_does_not_exist") } } - describe("with custom input directories") { + @Nested + inner class `with custom input directories` { val customSrc1 = "gensrc/kotlin" val customSrc2 = "src/main/kotlin" - beforeGroup { - + @BeforeAll + fun beforeGroup() { val config = """ |detekt { | source = files("$customSrc1", "$customSrc2", "folder_that_does_not_exist") @@ -181,22 +207,25 @@ internal object DetektTaskDslSpec : Spek({ result = gradleRunner.runDetektTask() } - it("sets input parameter to absolute filenames of all source files") { + @Test + fun `sets input parameter to absolute filenames of all source files`() { val file1 = gradleRunner.projectFile("$customSrc1/My0Root0Class.kt") val file2 = gradleRunner.projectFile("$customSrc2/My1Root0Class.kt") val expectedInputParam = "--input $file1,$file2" assertThat(result.output).contains(expectedInputParam) } - it("ignores input directories that do not exist") { + @Test + fun `ignores input directories that do not exist`() { assertThat(result.output).doesNotContain("folder_that_does_not_exist") } } - describe("with custom reports dir") { - - beforeGroup { + @Nested + inner class `with custom reports dir` { + @BeforeAll + fun beforeGroup() { val config = """ |detekt { | reportsDir = file("build/detekt-reports") @@ -209,31 +238,36 @@ internal object DetektTaskDslSpec : Spek({ result = gradleRunner.runDetektTask() } - it("configures xml report to custom directory") { + @Test + fun `configures xml report to custom directory`() { val xmlReportFile = gradleRunner.projectFile("build/detekt-reports/detekt.xml") assertThat(result.output).contains("--report xml:$xmlReportFile") } - it("configures html report to custom directory") { + @Test + fun `configures html report to custom directory`() { val htmlReportFile = gradleRunner.projectFile("build/detekt-reports/detekt.html") assertThat(result.output).contains("--report html:$htmlReportFile") } - it("configures text report to custom directory") { + @Test + fun `configures text report to custom directory`() { val textReportFile = gradleRunner.projectFile("build/detekt-reports/detekt.txt") assertThat(result.output).contains("--report txt:$textReportFile") } - it("configures sarif report to custom directory") { + @Test + fun `configures sarif report to custom directory`() { val sarifReportFile = gradleRunner.projectFile("build/detekt-reports/detekt.sarif") assertThat(result.output).contains("--report sarif:$sarifReportFile") } } - describe("with custom reports dir and custom report filename") { - - beforeGroup { + @Nested + inner class `with custom reports dir and custom report filename` { + @BeforeAll + fun beforeGroup() { val config = """ |detekt { | reportsDir = file("build/detekt-reports") @@ -252,26 +286,30 @@ internal object DetektTaskDslSpec : Spek({ result = gradleRunner.runDetektTask() } - it("configures xml report to specific absolute filename") { + @Test + fun `configures xml report to specific absolute filename`() { val xmlReportFile = gradleRunner.projectFile("build/xml-reports/custom-detekt.xml") assertThat(result.output).contains("--report xml:$xmlReportFile") } - it("configures html report to default name in custom directory") { + @Test + fun `configures html report to default name in custom directory`() { val htmlReportFile = gradleRunner.projectFile("build/detekt-reports/detekt.html") assertThat(result.output).contains("--report html:$htmlReportFile") } - it("configures text report to default name in custom directory") { + @Test + fun `configures text report to default name in custom directory`() { val textReportFile = gradleRunner.projectFile("build/detekt-reports/detekt.txt") assertThat(result.output).contains("--report txt:$textReportFile") } } - describe("with disabled reports") { - - beforeGroup { + @Nested + inner class `with disabled reports` { + @BeforeAll + fun beforeGroup() { val config = """ |tasks.detekt { | reports { @@ -295,15 +333,18 @@ internal object DetektTaskDslSpec : Spek({ result = gradleRunner.runDetektTask() } - it("no report param is set") { + @Test + fun `no report param is set`() { assertThat(result.output).doesNotContain("--report") } } - describe("with custom report types") { - describe("configured correctly") { - beforeGroup { - + @Nested + inner class `with custom report types` { + @Nested + inner class `configured correctly` { + @BeforeAll + fun beforeGroup() { val config = """ |tasks.detekt { | reports { @@ -323,20 +364,23 @@ internal object DetektTaskDslSpec : Spek({ result = gradleRunner.runDetektTask() } - it("configures custom xml report to absolute filename") { + @Test + fun `configures custom xml report to absolute filename`() { val xmlReportFile = gradleRunner.projectFile("build/reports/custom.xml") assertThat(result.output).contains("--report customXml:$xmlReportFile") } - it("configures custom json report to absolute filename") { + @Test + fun `configures custom json report to absolute filename`() { val xmlReportFile = gradleRunner.projectFile("build/reports/custom.json") assertThat(result.output).contains("--report customJson:$xmlReportFile") } } - describe("report id is missing") { - beforeGroup { - + @Nested + inner class `report id is missing` { + @BeforeAll + fun beforeGroup() { val config = """ |tasks.withType(io.gitlab.arturbosch.detekt.Detekt).configureEach { | reports { @@ -350,14 +394,16 @@ internal object DetektTaskDslSpec : Spek({ gradleRunner = builder.withDetektConfig(config).build() } - it("fails the build") { + @Test + fun `fails the build`() { gradleRunner.runDetektTaskAndExpectFailure() } } - describe("report filename is missing") { - beforeGroup { - + @Nested + inner class `report filename is missing` { + @BeforeAll + fun beforeGroup() { val config = """ |tasks.withType(io.gitlab.arturbosch.detekt.Detekt).configureEach { | reports { @@ -371,14 +417,16 @@ internal object DetektTaskDslSpec : Spek({ gradleRunner = builder.withDetektConfig(config).build() } - it("fails the build") { + @Test + fun `fails the build`() { gradleRunner.runDetektTaskAndExpectFailure() } } - describe("report filename is a directory") { - beforeGroup { - + @Nested + inner class `report filename is a directory` { + @BeforeAll + fun beforeGroup() { val aDirectory = "\${rootDir}/src" val config = """ @@ -395,17 +443,18 @@ internal object DetektTaskDslSpec : Spek({ gradleRunner = builder.withDetektConfig(config).build() } - it("fails the build") { + @Test + fun `fails the build`() { gradleRunner.runDetektTaskAndExpectFailure() } } - describe("using the report id of a well known type") { - DetektReportType.values().forEach { wellKnownType -> - context(wellKnownType.name) { - beforeGroup { - - val config = """ + @Nested + inner class `using the report id of a well known type` { + @ParameterizedTest + @EnumSource(DetektReportType::class) + fun `fails the build`(wellKnownType: DetektReportType) { + val config = """ |tasks.withType(io.gitlab.arturbosch.detekt.Detekt).configureEach { | reports { | custom { @@ -416,20 +465,17 @@ internal object DetektTaskDslSpec : Spek({ |} """ - gradleRunner = builder.withDetektConfig(config).build() - } - } - it("fails the build") { - gradleRunner.runDetektTaskAndExpectFailure() - } + gradleRunner = builder.withDetektConfig(config).build() + gradleRunner.runDetektTaskAndExpectFailure() } } } - describe("with flags") { - - beforeGroup { + @Nested + inner class `with flags` { + @BeforeAll + fun beforeGroup() { val config = """ |detekt { | debug = true @@ -449,53 +495,66 @@ internal object DetektTaskDslSpec : Spek({ result = gradleRunner.runDetektTask() } - it("enables debug mode") { + @Test + fun `enables debug mode`() { assertThat(result.output).contains("--debug") } - it("enables parallel processing") { + @Test + fun `enables parallel processing`() { assertThat(result.output).contains("--parallel") } - it("disables default ruleset") { + @Test + fun `disables default ruleset`() { assertThat(result.output).contains("--disable-default-rulesets") } - it("ignores failures") { + @Test + fun `ignores failures`() { assertThat(result.output).contains("Ignore failures: true") } - it("enables all rules") { + @Test + fun `enables all rules`() { assertThat(result.output).contains("--all-rules") } - it("enables fail fast") { + @Test + fun `enables fail fast`() { assertThat(result.output).contains("--fail-fast") } - it("enables auto correcting") { + @Test + fun `enables auto correcting`() { assertThat(result.output).contains("--auto-correct") } - it("enables using default config as baseline") { + @Test + fun `enables using default config as baseline`() { assertThat(result.output).contains("--build-upon-default-config") } } - describe("with cmdline args") { + @Nested + inner class `with cmdline args` { - beforeGroup { + @BeforeAll + fun beforeGroup() { gradleRunner = builder.build() result = gradleRunner.runDetektTask("--auto-correct") } - it("enables auto correcting") { + @Test + fun `enables auto correcting`() { assertThat(result.output).containsPattern("""Arguments:[^\r\n]*--auto-correct""") } } - describe("with an additional plugin") { - beforeGroup { + @Nested + inner class `with an additional plugin` { + @BeforeAll + fun beforeGroup() { val config = """ |dependencies { | detektPlugins("io.gitlab.arturbosch.detekt:detekt-formatting:$defaultDetektVersion") @@ -508,18 +567,23 @@ internal object DetektTaskDslSpec : Spek({ result = gradleRunner.runTasks("dependencies", "--configuration", "detektPlugins") } - it("successfully checks dependencies") { + @Test + fun `successfully checks dependencies`() { assertThat(result.task(":dependencies")?.outcome).isEqualTo(TaskOutcome.SUCCESS) } - it("adds the formatting lib to the project dependencies") { + @Test + fun `adds the formatting lib to the project dependencies`() { assertThat(result.output).contains("io.gitlab.arturbosch.detekt:detekt-formatting:$defaultDetektVersion") } } - describe("with a custom tool version") { + @Nested + inner class `with a custom tool version` { val customVersion = "1.0.0.RC8" - beforeGroup { + + @BeforeAll + fun beforeGroup() { val config = """ |detekt { | toolVersion = "$customVersion" @@ -532,18 +596,23 @@ internal object DetektTaskDslSpec : Spek({ result = gradleRunner.runTasks("dependencies", "--offline", "--configuration", "detekt") } - it("successfully checks dependencies") { + @Test + fun `successfully checks dependencies`() { assertThat(result.task(":dependencies")?.outcome).isEqualTo(TaskOutcome.SUCCESS) } - it("adds the custom detekt version to the dependencies") { + @Test + fun `adds the custom detekt version to the dependencies`() { assertThat(result.output).contains("io.gitlab.arturbosch.detekt:detekt-cli:$customVersion") } } - describe("and creating a custom task") { - context("using the kotlin dsl") { - beforeGroup { + @Nested + inner class `and creating a custom task` { + @Nested + inner class `using the kotlin dsl` { + @BeforeAll + fun beforeGroup() { val config = """ |task("myDetekt") { | description = "Runs a custom detekt build." @@ -584,53 +653,63 @@ internal object DetektTaskDslSpec : Spek({ result = gradleRunner.runTasks("myDetekt") } - it("completes successfully") { + @Test + fun `completes successfully`() { assertThat(result.task(":myDetekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) } - it("enables xml report to specified location") { + @Test + fun `enables xml report to specified location`() { val xmlReportFile = gradleRunner.projectFile("build/reports/mydetekt.xml") assertThat(result.output).contains("--report xml:$xmlReportFile") } - it("enables html report to specified location") { + @Test + fun `enables html report to specified location`() { val htmlReportFile = gradleRunner.projectFile("build/reports/mydetekt.html") assertThat(result.output).contains("--report html:$htmlReportFile") } - it("enables text report to specified location") { + @Test + fun `enables text report to specified location`() { val textReportFile = gradleRunner.projectFile("build/reports/mydetekt.txt") assertThat(result.output).contains("--report txt:$textReportFile") } - it("enables sarif report to specified location") { + @Test + fun `enables sarif report to specified location`() { val sarifReportFile = gradleRunner.projectFile("build/reports/mydetekt.sarif") assertThat(result.output).contains("--report sarif:$sarifReportFile") } - it("sets base path") { + @Test + fun `sets base path`() { assertThat(result.output).contains("--base-path") } - it("sets absolute filename of both config file to detekt cli") { + @Test + fun `sets absolute filename of both config file to detekt cli`() { val config = gradleRunner.projectFile("config.yml") val expectedConfigParam = "--config $config" assertThat(result.output).contains(expectedConfigParam) } - it("enables debug mode") { + @Test + fun `enables debug mode`() { assertThat(result.output).contains("--debug") } - it("enables parallel processing") { + @Test + fun `enables parallel processing`() { assertThat(result.output).contains("--parallel") } - it("disables the default ruleset") { + @Test + fun `disables the default ruleset`() { assertThat(result.output).contains("--disable-default-rulesets") } } } } -}) +} diff --git a/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/GradleVersionSpec.kt b/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/GradleVersionSpec.kt index 48c4e29bf6b9..1d9e0e2d9759 100644 --- a/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/GradleVersionSpec.kt +++ b/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/GradleVersionSpec.kt @@ -1,42 +1,26 @@ package io.gitlab.arturbosch.detekt -import io.gitlab.arturbosch.detekt.testkit.DslTestBuilder.Companion.groovy -import io.gitlab.arturbosch.detekt.testkit.DslTestBuilder.Companion.kotlin +import io.gitlab.arturbosch.detekt.testkit.DslTestBuilder import org.assertj.core.api.Assertions.assertThat import org.gradle.testkit.runner.TaskOutcome -import org.spekframework.spek2.Spek -import org.spekframework.spek2.dsl.Skip -import org.spekframework.spek2.style.specification.describe +import org.junit.jupiter.api.condition.EnabledForJreRange +import org.junit.jupiter.api.condition.JRE.JAVA_13 +import org.junit.jupiter.params.ParameterizedTest +import org.junit.jupiter.params.provider.MethodSource -object GradleVersionSpec : Spek({ +class GradleVersionSpec { - val gradleVersion = "6.1" - - describe( - "detekt plugin running on oldest supported Gradle version", - skip = if (getJdkVersion() < 13) Skip.No else Skip.Yes("Gradle $gradleVersion unsupported on this Java version") - ) { - listOf(groovy().dryRun(), kotlin().dryRun()).forEach { builder -> - describe("using ${builder.gradleBuildName}") { - it("runs on version $gradleVersion of Gradle") { - val gradleRunner = builder.withGradleVersion(gradleVersion).build() - gradleRunner.runDetektTaskAndCheckResult { result -> - assertThat(result.task(":detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) - } - } - } + @ParameterizedTest(name = "Using {0}, runs on version $gradleVersion") + @MethodSource("io.gitlab.arturbosch.detekt.testkit.DslTestBuilder#builders") + @EnabledForJreRange(max = JAVA_13, disabledReason = "Gradle $gradleVersion unsupported on this Java version") + fun runsOnOldestSupportedGradleVersion(builder: DslTestBuilder) { + val gradleRunner = builder.dryRun().withGradleVersion(gradleVersion).build() + gradleRunner.runDetektTaskAndCheckResult { result -> + assertThat(result.task(":detekt")?.outcome).isEqualTo(TaskOutcome.SUCCESS) } } -}) -internal fun getJdkVersion(): Int { - val version = System.getProperty("java.version") - val majorVersion = if (version.startsWith("1.")) { - version.substring(2, 3) - } else if (!version.contains('.') && version.contains('-')) { - version.substringBefore('-') // early access Java.net versions - } else { - version.substringBefore('.') + companion object { + const val gradleVersion = "6.1" } - return Integer.parseInt(majorVersion) } diff --git a/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/internal/ClassLoaderCacheSpec.kt b/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/internal/ClassLoaderCacheSpec.kt index d153d8075c24..ff84d211bdb4 100644 --- a/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/internal/ClassLoaderCacheSpec.kt +++ b/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/internal/ClassLoaderCacheSpec.kt @@ -3,8 +3,8 @@ package io.gitlab.arturbosch.detekt.internal import io.gitlab.arturbosch.detekt.gradle.TestFileCollection import org.assertj.core.api.Assertions.assertThat import org.gradle.api.internal.file.AbstractFileCollection -import org.spekframework.spek2.Spek -import org.spekframework.spek2.style.specification.describe +import org.junit.jupiter.api.Nested +import org.junit.jupiter.api.Test import java.io.File import java.util.concurrent.CompletableFuture import java.util.concurrent.CountDownLatch @@ -12,11 +12,13 @@ import java.util.concurrent.Executors import java.util.concurrent.TimeUnit import java.util.function.Supplier -internal class ClassLoaderCacheSpec : Spek({ +class ClassLoaderCacheSpec { - describe("classpath changes") { + @Nested + inner class ClasspathChanges { - it("same classloader is returned for the same files") { + @Test + fun `same classloader is returned for the same files`() { val cache = DefaultClassLoaderCache() val initialClassLoader = cache.getOrCreate(TestFileCollection(File("a/b/c"))) val secondClassLoader = cache.getOrCreate(TestFileCollection(File("a/b/c"))) @@ -24,7 +26,8 @@ internal class ClassLoaderCacheSpec : Spek({ assertThat(initialClassLoader === secondClassLoader).isTrue() } - it("different classloaders are returned for different files") { + @Test + fun `different classloaders are returned for different files`() { val cache = DefaultClassLoaderCache() val firstClassLoader = cache.getOrCreate(TestFileCollection(File("a/b/c"))) val secondClassLoader = cache.getOrCreate(TestFileCollection(File("c/b/a"))) @@ -32,7 +35,8 @@ internal class ClassLoaderCacheSpec : Spek({ assertThat(firstClassLoader === secondClassLoader).isFalse() } - it("same classloader for the same files in different order") { + @Test + fun `same classloader for the same files in different order`() { val cache = DefaultClassLoaderCache() val firstClassLoader = cache.getOrCreate(TestFileCollection(File("a/b/c"), File("d/e/f"))) val secondClassLoader = cache.getOrCreate(TestFileCollection(File("d/e/f"), File("a/b/c"))) @@ -40,7 +44,8 @@ internal class ClassLoaderCacheSpec : Spek({ assertThat(firstClassLoader === secondClassLoader).isTrue() } - it("resolves files without synchronization") { + @Test + fun `resolves files without synchronization`() { val file1 = File("/a/b/c") val collection1 = CountdownFileCollection(file1) @@ -71,7 +76,7 @@ internal class ClassLoaderCacheSpec : Spek({ } } } -}) +} private class CountdownFileCollection(private vararg val files: File) : AbstractFileCollection() { diff --git a/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/invoke/DefaultCliInvokerSpec.kt b/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/invoke/DefaultCliInvokerSpec.kt index 041904f23f19..f812fc2822fa 100644 --- a/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/invoke/DefaultCliInvokerSpec.kt +++ b/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/invoke/DefaultCliInvokerSpec.kt @@ -4,12 +4,13 @@ import io.gitlab.arturbosch.detekt.gradle.TestFileCollection import io.gitlab.arturbosch.detekt.internal.ClassLoaderCache import org.assertj.core.api.Assertions.assertThatCode import org.gradle.api.GradleException -import org.spekframework.spek2.Spek +import org.junit.jupiter.api.Test import java.net.URLClassLoader -internal class DefaultCliInvokerSpec : Spek({ +class DefaultCliInvokerSpec { - test("catches ClassCastException and fails build") { + @Test + fun `catches ClassCastException and fails build`() { val stubbedCache = ClassLoaderCache { URLClassLoader(emptyArray()) } assertThatCode { @@ -18,4 +19,4 @@ internal class DefaultCliInvokerSpec : Spek({ }.isInstanceOf(GradleException::class.java) .hasMessageContaining("testing reflection wrapper...") } -}) +} diff --git a/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/report/ReportMergeSpec.kt b/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/report/ReportMergeSpec.kt index e6bc88b9c633..2ecaae366c26 100644 --- a/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/report/ReportMergeSpec.kt +++ b/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/report/ReportMergeSpec.kt @@ -1,20 +1,25 @@ package io.gitlab.arturbosch.detekt.report import io.gitlab.arturbosch.detekt.manifestContent -import io.gitlab.arturbosch.detekt.skipIfAndroidEnvironmentRequirementsUnmet import io.gitlab.arturbosch.detekt.testkit.DslGradleRunner import io.gitlab.arturbosch.detekt.testkit.DslTestBuilder import io.gitlab.arturbosch.detekt.testkit.ProjectLayout import org.assertj.core.api.Assertions.assertThat import org.gradle.testkit.runner.TaskOutcome -import org.spekframework.spek2.Spek -import org.spekframework.spek2.style.specification.describe +import org.junit.jupiter.api.Nested +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.condition.EnabledForJreRange +import org.junit.jupiter.api.condition.EnabledIf +import org.junit.jupiter.api.condition.JRE.JAVA_11 -class ReportMergeSpec : Spek({ +class ReportMergeSpec { - describe("Merging reports in a multi module projects") { + @Nested + inner class `Merging reports in a multi module projects` { - it("for jvm detekt") { + @Suppress("LongMethod") + @Test + fun `for jvm detekt`() { val builder = DslTestBuilder.groovy() val projectLayout = ProjectLayout(0).apply { addSubmodule( @@ -85,10 +90,11 @@ class ReportMergeSpec : Spek({ } } - it( - "for android detekt", - skip = skipIfAndroidEnvironmentRequirementsUnmet() - ) { + @Suppress("LongMethod") + @Test + @EnabledForJreRange(min = JAVA_11, disabledReason = "Android Gradle Plugin 7.0+ requires JDK 11 or newer") + @EnabledIf("io.gitlab.arturbosch.detekt.DetektAndroidSpecKt#isAndroidSdkInstalled") + fun `for android detekt`() { val builder = DslTestBuilder.groovy() val projectLayout = ProjectLayout(0).apply { addSubmodule( @@ -189,4 +195,4 @@ class ReportMergeSpec : Spek({ } } } -}) +} diff --git a/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/report/SarifReportMergerSpec.kt b/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/report/SarifReportMergerSpec.kt index 485e8ca0f5fa..afa9d91939b8 100644 --- a/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/report/SarifReportMergerSpec.kt +++ b/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/report/SarifReportMergerSpec.kt @@ -1,24 +1,22 @@ package io.gitlab.arturbosch.detekt.report import org.assertj.core.api.Assertions.assertThat -import org.spekframework.spek2.Spek -import org.spekframework.spek2.style.specification.describe +import org.junit.jupiter.api.Test import java.io.File import java.net.URL -internal class SarifReportMergerSpec : Spek({ - describe("sarif report merger") { - it("merges input into output successfully") { - val input1 = resourceAsFile("input_1.sarif.json") - val input2 = resourceAsFile("input_2.sarif.json") - val output = File.createTempFile("output", "xml") - SarifReportMerger.merge(listOf(input1, input2), output) +class SarifReportMergerSpec { + @Test + fun `merges input into output successfully`() { + val input1 = resourceAsFile("input_1.sarif.json") + val input2 = resourceAsFile("input_2.sarif.json") + val output = File.createTempFile("output", "xml") + SarifReportMerger.merge(listOf(input1, input2), output) - val expectedOutput = resourceAsFile("output.sarif.json") - assertThat(output.readText()).isEqualToNormalizingNewlines(expectedOutput.readText()) - } + val expectedOutput = resourceAsFile("output.sarif.json") + assertThat(output.readText()).isEqualToNormalizingNewlines(expectedOutput.readText()) } -}) +} internal object Resources diff --git a/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/report/XmlReportMergerSpec.kt b/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/report/XmlReportMergerSpec.kt index 4599044cf3d3..c12def8e5bcd 100644 --- a/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/report/XmlReportMergerSpec.kt +++ b/detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/report/XmlReportMergerSpec.kt @@ -1,17 +1,19 @@ package io.gitlab.arturbosch.detekt.report import org.assertj.core.api.Assertions.assertThat -import org.spekframework.spek2.Spek -import org.spekframework.spek2.style.specification.describe +import org.junit.jupiter.api.Nested +import org.junit.jupiter.api.Test import java.io.File private const val TAB = "\t" -internal class XmlReportMergerSpec : Spek({ +class XmlReportMergerSpec { - describe("classpath changes") { + @Nested + inner class `classpath changes` { - it("passes for same files") { + @Test + fun `passes for same files`() { val file1 = File.createTempFile("detekt1", "xml").apply { writeText( """ @@ -52,4 +54,4 @@ internal class XmlReportMergerSpec : Spek({ assertThat(output.readText()).isEqualToIgnoringNewLines(expectedText) } } -}) +} diff --git a/detekt-gradle-plugin/src/testFixtures/kotlin/io/gitlab/arturbosch/detekt/testkit/DslTestBuilder.kt b/detekt-gradle-plugin/src/testFixtures/kotlin/io/gitlab/arturbosch/detekt/testkit/DslTestBuilder.kt index 7c3fbbe3b794..a1a67462de4c 100644 --- a/detekt-gradle-plugin/src/testFixtures/kotlin/io/gitlab/arturbosch/detekt/testkit/DslTestBuilder.kt +++ b/detekt-gradle-plugin/src/testFixtures/kotlin/io/gitlab/arturbosch/detekt/testkit/DslTestBuilder.kt @@ -71,6 +71,9 @@ abstract class DslTestBuilder { companion object { fun kotlin(): DslTestBuilder = KotlinBuilder() fun groovy(): DslTestBuilder = GroovyBuilder() + + @JvmStatic + fun builders(): Set = setOf(GroovyBuilder(), KotlinBuilder()) } } @@ -96,6 +99,8 @@ private class GroovyBuilder : DslTestBuilder() { override val gradleSubprojectsApplyPlugins = """ |apply plugin: "io.gitlab.arturbosch.detekt" |""" + + override fun toString() = "build.gradle" } private class KotlinBuilder : DslTestBuilder() { @@ -121,4 +126,6 @@ private class KotlinBuilder : DslTestBuilder() { override val gradleSubprojectsApplyPlugins = """ |plugins.apply("io.gitlab.arturbosch.detekt") |""" + + override fun toString() = "build.gradle.kts" }