jlengrand/detekt
1
0
Fork 0
mirror of https://github.com/jlengrand/detekt.git synced 2026-03-10 08:11:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

Migrate detekt-gradle-plugin tests to JUnit (#4529)

Browse Source 
* Migrate detekt-gradle-plugin functional tests to JUnit

* Migrate detekt-gradle-plugin tests to JUnit

* Remove unused dependencies

* Removed unused function
This commit is contained in:
Matthew Haughton
2022-02-10 18:34:33 +11:00
committed by GitHub
parent 7d87c80e24
commit 00a472812b
22 changed files with 894 additions and 726 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
config/detekt/detekt.yml
View File

@@ -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:

4
detekt-gradle-plugin/build.gradle.kts
View File

@@ -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)
}
}
}

146
detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/CreateBaselineTaskDslSpec.kt
View File

@@ -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()
}
}
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()
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()
gradleRunner.runTasksAndExpectFailure("detektBaseline") { result ->
assertThat(result.output).contains("property 'baseline' doesn't have a configured value")
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()
}
}
})
@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()
}
}
@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()
}
}
}
private const val DEFAULT_BASELINE_FILENAME = "detekt-baseline.xml"

149
detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/DetektReportMergeSpec.kt
View File

@@ -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<Arguments> = listOf(
arguments(groovy, groovyBuildFileContent),
arguments(kotlin, kotlinBuildFileContent)
)
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()
}
@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()
}
}
}
}
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<Arguments> = listOf(
arguments(groovy, groovyBuildFileContent),
arguments(kotlin, kotlinBuildFileContent)
)
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("<error column=\"30\" line=\"4\"")
projectLayout.submodules.forEach {
assertThat(projectFile("${it.name}/build/reports/detekt/detekt.xml")).exists()
}
@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("<error column=\"30\" line=\"4\"")
projectLayout.submodules.forEach {
assertThat(projectFile("${it.name}/build/reports/detekt/detekt.xml")).exists()
}
}
}
}
})
}

282
detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/DetektTaskMultiModuleSpec.kt
View File

@@ -1,34 +1,31 @@
package io.gitlab.arturbosch.detekt
import io.gitlab.arturbosch.detekt.testkit.DslGradleRunner
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
import org.junit.jupiter.api.Nested
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.MethodSource
internal class DetektTaskMultiModuleSpec : Spek({
class DetektTaskMultiModuleSpec {
describe("The Detekt Gradle plugin used in a multi module project") {
@Nested
inner class `The Detekt Gradle plugin used in a multi module project` {
listOf(groovy(), kotlin()).forEach { builder ->
@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)
}
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)
}
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)
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()
}
}
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)
}
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)
}
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 mainBuildFileContent: String = """
@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)
}
val mainBuildFileContent: String = """
|${builder.gradlePlugins}
|
|allprojects {
@@ -79,33 +76,35 @@ internal class DetektTaskMultiModuleSpec : Spek({
|}
|""".trimMargin()
val gradleRunner = DslGradleRunner(projectLayout, builder.gradleBuildName, mainBuildFileContent)
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()
}
}
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()
}
}
}
val mainBuildFileContent: String = """
@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 = """
|${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)
}
it("allows changing defaults in allprojects block that can be overwritten in subprojects") {
val child2DetektConfig = """
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()
}
}
}
@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)
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()
}
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()
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()
}
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()
}
}
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()
}
}
}
}
})
}

86
detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/DetektTaskSpec.kt
View File

@@ -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
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.MethodSource
internal class DetektTaskSpec : Spek({
class DetektTaskSpec {
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
)
private val projectLayoutWithTooManyIssues = ProjectLayout(
numberOfSourceFilesInRootPerSourceDir = 15,
numberOfCodeSmellsInRootPerSourceDir = 15
)
it("build succeeds with more issues than threshold if enabled") {
@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 config = """
|detekt {
| ignoreFailures = true
|}
"""
val gradleRunner = builder
.withProjectLayout(projectLayoutWithTooManyIssues)
.withDetektConfig(config)
.build()
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()
}
}
}
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()
}
}

61
detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/GenerateConfigTaskSpec.kt
View File

@@ -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/other/detekt.yml")).exists()
}
}
}
gradleRunner.runTasksAndCheckResult("detektGenerateConfig") { result ->
assertThat(result.task(":detektGenerateConfig")?.outcome).isEqualTo(TaskOutcome.SUCCESS)
assertThat(projectFile("config/detekt/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()
}
}
}

10
detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/JvmSpec.kt
View File

@@ -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]")
}
})
}

37
detekt-gradle-plugin/src/functionalTest/kotlin/io/gitlab/arturbosch/detekt/PluginTaskBehaviorSpec.kt
View File

@@ -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 = """
|<some>
| <more/>
@@ -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({
}
}
}
})
}

51
detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/ConfigurationCacheSpec.kt
View File

@@ -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.")
}
}
})
}

146
detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektAndroidSpec.kt
View File

@@ -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
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
object DetektAndroidSpec : Spek({
describe(
"When applying detekt in an Android project",
skip = skipIfAndroidEnvironmentRequirementsUnmet()
) {
describe("configures android tasks for android application") {
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") = """
<manifest package="$packageName"
xmlns:android="http://schemas.android.com/apk/res/android"/>

44
detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektJvmSpec.kt
View File

@@ -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")
}
}
}
}
})
}

106
detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektMultiplatformSpec.kt
View File

@@ -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")

26
detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektPlainSpec.kt
View File

@@ -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({
}
}
}
})
}

311
detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/DetektTaskDslSpec.kt
View File

@@ -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<io.gitlab.arturbosch.detekt.Detekt>("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")
}
}
}
}
})
}

46
detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/GradleVersionSpec.kt
View File

@@ -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)
}

23
detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/internal/ClassLoaderCacheSpec.kt
View File

@@ -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() {

9
detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/invoke/DefaultCliInvokerSpec.kt
View File

@@ -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...")
}
})
}

28
detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/report/ReportMergeSpec.kt
View File

@@ -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({
}
}
}
})
}

24
detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/report/SarifReportMergerSpec.kt
View File

@@ -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

14
detekt-gradle-plugin/src/test/kotlin/io/gitlab/arturbosch/detekt/report/XmlReportMergerSpec.kt
View File

@@ -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)
}
}
})
}

7
detekt-gradle-plugin/src/testFixtures/kotlin/io/gitlab/arturbosch/detekt/testkit/DslTestBuilder.kt
View File

@@ -71,6 +71,9 @@ abstract class DslTestBuilder {
companion object {
fun kotlin(): DslTestBuilder = KotlinBuilder()
fun groovy(): DslTestBuilder = GroovyBuilder()
@JvmStatic
fun builders(): Set<DslTestBuilder> = 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"
}