From 8daf49ec7c44ca772092e9af2841245272b05265 Mon Sep 17 00:00:00 2001 From: M Schalk <30376729+schalkms@users.noreply.github.com> Date: Sun, 6 Oct 2019 17:46:28 +0200 Subject: [PATCH] Use inline code snippets instead of case files (#1976) This commit inlines the code snippets for data class related rules in the style ruleset. --- .../io/gitlab/arturbosch/detekt/rules/Case.kt | 4 -- .../style/DataClassContainsFunctionsSpec.kt | 61 +++++++++++++--- .../style/DataClassShouldBeImmutableSpec.kt | 70 ++++++++++++++++--- .../DataClassContainsFunctionsNegative.kt | 26 ------- .../DataClassContainsFunctionsPositive.kt | 15 ---- .../DataClassShouldBeImmutableNegative.kt | 34 --------- .../DataClassShouldBeImmutablePositive.kt | 30 -------- 7 files changed, 112 insertions(+), 128 deletions(-) delete mode 100644 detekt-rules/src/test/resources/cases/DataClassContainsFunctionsNegative.kt delete mode 100644 detekt-rules/src/test/resources/cases/DataClassContainsFunctionsPositive.kt delete mode 100644 detekt-rules/src/test/resources/cases/DataClassShouldBeImmutableNegative.kt delete mode 100644 detekt-rules/src/test/resources/cases/DataClassShouldBeImmutablePositive.kt diff --git a/detekt-rules/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/Case.kt b/detekt-rules/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/Case.kt index 23a74fac77a..8db7816c47e 100644 --- a/detekt-rules/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/Case.kt +++ b/detekt-rules/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/Case.kt @@ -11,10 +11,6 @@ enum class Case(val file: String) { CollapsibleIfsNegative("/cases/CollapsibleIfsNegative.kt"), ComplexMethods("/cases/ComplexMethods.kt"), ConstInObjects("/cases/ConstInObjects.kt"), - DataClassContainsFunctionsPositive("/cases/DataClassContainsFunctionsPositive.kt"), - DataClassContainsFunctionsNegative("/cases/DataClassContainsFunctionsNegative.kt"), - DataClassShouldBeImmutablePositive("/cases/DataClassShouldBeImmutablePositive.kt"), - DataClassShouldBeImmutableNegative("/cases/DataClassShouldBeImmutableNegative.kt"), Default("/cases/Default.kt"), Empty("/cases/Empty.kt"), EmptyKtFile("/cases/EmptyKtFile.kt"), diff --git a/detekt-rules/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/style/DataClassContainsFunctionsSpec.kt b/detekt-rules/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/style/DataClassContainsFunctionsSpec.kt index a4c03b7cea6..5cea80fa8d1 100644 --- a/detekt-rules/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/style/DataClassContainsFunctionsSpec.kt +++ b/detekt-rules/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/style/DataClassContainsFunctionsSpec.kt @@ -1,8 +1,7 @@ package io.gitlab.arturbosch.detekt.rules.style -import io.gitlab.arturbosch.detekt.rules.Case +import io.gitlab.arturbosch.detekt.test.compileAndLint import io.gitlab.arturbosch.detekt.test.TestConfig -import io.gitlab.arturbosch.detekt.test.lint import org.assertj.core.api.Assertions.assertThat import org.spekframework.spek2.Spek import org.spekframework.spek2.style.specification.describe @@ -12,20 +11,60 @@ class DataClassContainsFunctionsSpec : Spek({ describe("DataClassContainsFunctions rule") { - val path = Case.DataClassContainsFunctionsPositive.path() + context("flagged functions in data class") { + val code = """ + data class C(val s: String) { + fun f() {} - it("reports valid data class w/o conversion function") { - assertThat(subject.lint(path)).hasSize(3) + data class Nested(val i: Int) { + fun toConversion() = C(i.toString()) + } + } + """ + + it("reports valid data class w/o conversion function") { + assertThat(subject.compileAndLint(code)).hasSize(2) + } + + it("reports valid data class w/ conversion function") { + val config = TestConfig(mapOf(DataClassContainsFunctions.CONVERSION_FUNCTION_PREFIX to "to")) + val rule = DataClassContainsFunctions(config) + assertThat(rule.compileAndLint(code)).hasSize(1) + } + } + + it("does not report a data class without a function") { + val code = "data class C(val i: Int)" + assertThat(subject.compileAndLint(code)).isEmpty() } - it("reports valid data class w/ conversion function") { - val config = TestConfig(mapOf(DataClassContainsFunctions.CONVERSION_FUNCTION_PREFIX to "to")) - val rule = DataClassContainsFunctions(config) - assertThat(rule.lint(path)).hasSize(2) + it("does not report a non-data class without a function") { + val code = """ + class C { + fun f() {} + } + """ + assertThat(subject.compileAndLint(code)).isEmpty() } - it("does not report data class w/o conversion function") { - assertThat(subject.lint(Case.DataClassContainsFunctionsNegative.path())).hasSize(0) + it("does not report a data class with overridden functions") { + val code = """ + data class C(val i: Int) { + + override fun hashCode(): Int { + return super.hashCode() + } + + override fun equals(other: Any?): Boolean { + return super.equals(other) + } + + override fun toString(): String { + return super.toString() + } + } + """ + assertThat(subject.compileAndLint(code)).isEmpty() } } }) diff --git a/detekt-rules/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/style/DataClassShouldBeImmutableSpec.kt b/detekt-rules/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/style/DataClassShouldBeImmutableSpec.kt index 4295bfa0c75..2d365f69d43 100644 --- a/detekt-rules/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/style/DataClassShouldBeImmutableSpec.kt +++ b/detekt-rules/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/style/DataClassShouldBeImmutableSpec.kt @@ -1,7 +1,6 @@ package io.gitlab.arturbosch.detekt.rules.style -import io.gitlab.arturbosch.detekt.rules.Case -import io.gitlab.arturbosch.detekt.test.lint +import io.gitlab.arturbosch.detekt.test.compileAndLint import org.assertj.core.api.Assertions.assertThat import org.spekframework.spek2.Spek import org.spekframework.spek2.style.specification.describe @@ -11,14 +10,69 @@ class DataClassShouldBeImmutableSpec : Spek({ describe("DataClassShouldBeImmutable rule") { - it("reports positive cases") { - val path = Case.DataClassShouldBeImmutablePositive.path() - assertThat(subject.lint(path)).hasSize(4) + it("reports mutable variable in primary constructor") { + val code = "data class C(var i: Int)" + assertThat(subject.compileAndLint(code)).hasSize(1) } - it("does not report negative cases") { - val path = Case.DataClassShouldBeImmutableNegative.path() - assertThat(subject.lint(path)).hasSize(0) + it("reports mutable property in class body") { + val code = """ + data class C(val i: Int) { + var s: String? = null + } + """ + assertThat(subject.compileAndLint(code)).hasSize(1) + } + + it("reports mutable private property in class body") { + val code = """ + data class C(val i: Int) { + var s: String = "" + private set + } + """ + assertThat(subject.compileAndLint(code)).hasSize(1) + } + + it("reports lateinit property in class body") { + val code = """ + data class C(val i: Int) { + lateinit var s: String + } + """ + assertThat(subject.compileAndLint(code)).hasSize(1) + } + + it("does not report readonly variable in primary constructor") { + val code = "data class C(val i: Int)" + assertThat(subject.compileAndLint(code)).isEmpty() + } + + it("does not report readonly property in class body") { + val code = """ + data class C(val i: Int) { + val s: String? = null + } + """ + assertThat(subject.compileAndLint(code)).isEmpty() + } + + it("does not report lazy property in class body") { + val code = """ + data class C(val i: Int) { + val s: String by lazy { "" } + } + """ + assertThat(subject.compileAndLint(code)).isEmpty() + } + + it("does not report mutable variables in non-data classes") { + val code = """ + class C(var i: Int) { + val s: String by lazy { "" } + } + """ + assertThat(subject.compileAndLint(code)).isEmpty() } } }) diff --git a/detekt-rules/src/test/resources/cases/DataClassContainsFunctionsNegative.kt b/detekt-rules/src/test/resources/cases/DataClassContainsFunctionsNegative.kt deleted file mode 100644 index 72a59375077..00000000000 --- a/detekt-rules/src/test/resources/cases/DataClassContainsFunctionsNegative.kt +++ /dev/null @@ -1,26 +0,0 @@ -@file:Suppress("unused", "RedundantOverride") - -package cases - -data class ValidDataClass(val i: Int) - -data class DataClassWithOverriddenMethods(val i: Int) { - - override fun hashCode(): Int { - return super.hashCode() - } - - override fun equals(other: Any?): Boolean { - return super.equals(other) - } - - override fun toString(): String { - return super.toString() - } -} - -class ClassWithRegularFunctions { - - fun f1() {} - fun f2() {} -} diff --git a/detekt-rules/src/test/resources/cases/DataClassContainsFunctionsPositive.kt b/detekt-rules/src/test/resources/cases/DataClassContainsFunctionsPositive.kt deleted file mode 100644 index f3d4a9469ab..00000000000 --- a/detekt-rules/src/test/resources/cases/DataClassContainsFunctionsPositive.kt +++ /dev/null @@ -1,15 +0,0 @@ -@file:Suppress("unused") - -package cases - -// reports 2 - for each defined function in the data class -data class DataClassWithFunctions(val i: Int) { - - fun f1() {} - fun f2() {} - - // reports 1 - for each defined conversion function in the data class - data class NestedDataClassWithConversionFunction(val i: Int) { - fun toDataClassWithOverriddenMethods() = DataClassWithOverriddenMethods(i) - } -} diff --git a/detekt-rules/src/test/resources/cases/DataClassShouldBeImmutableNegative.kt b/detekt-rules/src/test/resources/cases/DataClassShouldBeImmutableNegative.kt deleted file mode 100644 index f0841ea0981..00000000000 --- a/detekt-rules/src/test/resources/cases/DataClassShouldBeImmutableNegative.kt +++ /dev/null @@ -1,34 +0,0 @@ -@file:Suppress("unused") - -package cases - -data class ImmutableDataClass1( - val i: Int, - val s: String -) - -data class ImmutableDataClass2( - val i: Int -) { - - val s: String? = null -} - -data class ImmutableDataClass3( - val i: Int -) { - - val s: String by lazy { "" } -} - -class MutableClass1( - val i: Int, - var s: String -) - -class MutableClass2( - val i: Int -) { - - var s: String = "" -} diff --git a/detekt-rules/src/test/resources/cases/DataClassShouldBeImmutablePositive.kt b/detekt-rules/src/test/resources/cases/DataClassShouldBeImmutablePositive.kt deleted file mode 100644 index 997601cdedd..00000000000 --- a/detekt-rules/src/test/resources/cases/DataClassShouldBeImmutablePositive.kt +++ /dev/null @@ -1,30 +0,0 @@ -@file:Suppress("unused") - -package cases - -data class MutableDataClass1( - val i: Int, - var s: String -) - -data class MutableDataClass2( - val i: Int -) { - - var s: String? = null -} - -data class MutableDataClass3( - val i: Int -) { - - var s: String = "" - private set -} - -data class MutableDataClass4( - val i: Int -) { - - lateinit var s: String -}