From 66bc7966a682c945ba089598defc6c1e8acec2fd Mon Sep 17 00:00:00 2001 From: Nacho Lopez Sais Date: Wed, 22 Jun 2022 12:35:22 +0200 Subject: [PATCH] Updates ktlint to 0.46.1 ktlint had a significant update in 0.46.x, including a bunch of breaking changes in tests. The new API is nicer though. This patch includes all the migration to the new test style, and to pass the default tests. NOTE: At the moment of writing this, spotless hasn't been updated yet to support the new ktlint version. https://github.com/diffplug/spotless/issues/1239 --- docs/rules.md | 18 +-- gradle/libs.versions.toml | 4 +- .../compose/ComposeModifierMissingCheck.kt | 2 +- .../compose/ComposeModifierUsedOnceCheck.kt | 2 +- .../ComposeMultipleContentEmittersCheck.kt | 2 +- .../compose/ComposeMutableParametersCheck.kt | 2 +- .../ktlint/compose/ComposeNamingCheck.kt | 2 +- .../compose/ComposeRememberMissingCheck.kt | 2 +- .../ComposeViewModelForwardingCheck.kt | 2 +- .../compose/ComposeViewModelInjectionCheck.kt | 2 +- .../ComposeModifierMissingCheckTest.kt | 86 +++++------- .../ComposeModifierUsedOnceCheckTest.kt | 127 ++++++------------ ...ComposeMultipleContentEmittersCheckTest.kt | 70 ++++------ .../ComposeMutableParametersCheckTest.kt | 34 ++--- .../ktlint/compose/ComposeNamingCheckTest.kt | 46 +++---- .../ComposeRememberMissingCheckTest.kt | 60 +++------ .../ComposeViewModelForwardingCheckTest.kt | 32 ++--- .../ComposeViewModelInjectionCheckTest.kt | 60 +++------ 18 files changed, 190 insertions(+), 363 deletions(-) diff --git a/docs/rules.md b/docs/rules.md index cccf7496..d4deaf17 100644 --- a/docs/rules.md +++ b/docs/rules.md @@ -12,13 +12,13 @@ Instead pass down the relevant data to the function, and optional lambdas for ca More information: [State and Jetpack Compose](https://developer.android.com/jetpack/compose/state) -Related rule: [compose-vm-forwarding-check](https://github.com/twitter/compose-rules/blob/main/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeViewModelForwardingCheck.kt) +Related rule: [twitter-compose:vm-forwarding-check](https://github.com/twitter/compose-rules/blob/main/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeViewModelForwardingCheck.kt) ### State should be remembered in composables Be careful when using `mutableStateOf` (or any of the other state builders) to make sure that you `remember` the instance. If you don't `remember` the state instance, a new state instance will be created when the function is recomposed. -Related rule: [compose-remember-missing-check](https://github.com/twitter/compose-rules/blob/main/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeRememberMissingCheck.kt) +Related rule: [twitter-compose:remember-missing-check](https://github.com/twitter/compose-rules/blob/main/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeRememberMissingCheck.kt) ### Use Immutable annotation whenever possible @@ -40,7 +40,7 @@ There are a few reasons for this, but the main one is that it is very easy to us Passing `ArrayList`, `MutableState`, `ViewModel` are common examples of this (but not limited to those types). -Related rule: [compose-mutable-params-check](https://github.com/twitter/compose-rules/blob/main/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeMutableParametersCheck.kt) +Related rule: [twitter-compose:mutable-params-check](https://github.com/twitter/compose-rules/blob/main/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeMutableParametersCheck.kt) ### Do not emit content and return a result @@ -50,7 +50,7 @@ If a composable should offer additional control surfaces to its caller, those co More info: [Compose API guidelines](https://github.com/androidx/androidx/blob/androidx-main/compose/docs/compose-api-guidelines.md#emit-xor-return-a-value) -Related rule: [compose-multiple-emitters-check](https://github.com/twitter/compose-rules/blob/main/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeMultipleContentEmittersCheck.kt) +Related rule: [twitter-compose:multiple-emitters-check](https://github.com/twitter/compose-rules/blob/main/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeMultipleContentEmittersCheck.kt) ### Do not emit multiple pieces of content @@ -96,7 +96,7 @@ private fun ColumnScope.InnerContent() { ``` This effectively ties the function to be called from a Column, but is still not recommended (although permitted). -Related rule: [compose-multiple-emitters-check](https://github.com/twitter/compose-rules/blob/main/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeMultipleContentEmittersCheck.kt) +Related rule: [twitter-compose:multiple-emitters-check](https://github.com/twitter/compose-rules/blob/main/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeMultipleContentEmittersCheck.kt) ### Naming @Composable functions properly @@ -106,7 +106,7 @@ However, Composable functions that return a value should start with a lowercase More information: [Naming Unit @Composable functions as entities](https://github.com/androidx/androidx/blob/androidx-main/compose/docs/compose-api-guidelines.md#naming-unit-composable-functions-as-entities) and [Naming @Composable functions that return values](https://github.com/androidx/androidx/blob/androidx-main/compose/docs/compose-api-guidelines.md#naming-composable-functions-that-return-values) -Related rule: [compose-naming-check](https://github.com/twitter/compose-rules/blob/main/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeNamingCheck.kt) +Related rule: [twitter-compose:naming-check](https://github.com/twitter/compose-rules/blob/main/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeNamingCheck.kt) ### Make dependencies explicit @@ -137,7 +137,7 @@ private fun MyComposable( ``` -Related rule: [compose-vm-injection-check](https://github.com/twitter/compose-rules/blob/main/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeViewModelInjectionCheck.kt) +Related rule: [twitter-compose:vm-injection-check](https://github.com/twitter/compose-rules/blob/main/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeViewModelInjectionCheck.kt) ## Modifiers @@ -149,7 +149,7 @@ They are especially important for your public components, as they allow callers More info: [Always provide a Modifier parameter](https://chris.banes.dev/always-provide-a-modifier/) -Related rule: [compose-modifier-check](https://github.com/twitter/compose-rules/blob/main/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeModifierMissingCheck.kt) +Related rule: [twitter-compose:modifier-check](https://github.com/twitter/compose-rules/blob/main/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeModifierMissingCheck.kt) ### Don't re-use modifiers @@ -180,4 +180,4 @@ private fun InnerContent(modifier: Modifier = Modifier) { } ``` -Related rule: [compose-modifier-used-once-check](https://github.com/twitter/compose-rules/blob/main/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeModifierUsedOnceCheck.kt) +Related rule: [twitter-compose:modifier-used-once-check](https://github.com/twitter/compose-rules/blob/main/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeModifierUsedOnceCheck.kt) diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index 240e580a..2843a359 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -1,6 +1,6 @@ [versions] -kotlin = "1.6.21" -ktlint = "0.45.2" +kotlin = "1.7.0" +ktlint = "0.46.1" junit = "5.8.2" [libraries] diff --git a/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeModifierMissingCheck.kt b/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeModifierMissingCheck.kt index 84e4b879..5da4461c 100644 --- a/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeModifierMissingCheck.kt +++ b/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeModifierMissingCheck.kt @@ -16,7 +16,7 @@ import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.psi.KtFunction import org.jetbrains.kotlin.psi.psiUtil.isPublic -class ComposeModifierMissingCheck : TwitterKtRule("compose-modifier-check") { +class ComposeModifierMissingCheck : TwitterKtRule("twitter-compose:modifier-check") { override fun visitFile(file: KtFile, autoCorrect: Boolean, emitter: Emitter) { file.findChildrenByClass() diff --git a/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeModifierUsedOnceCheck.kt b/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeModifierUsedOnceCheck.kt index b0a37da7..cfedaace 100644 --- a/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeModifierUsedOnceCheck.kt +++ b/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeModifierUsedOnceCheck.kt @@ -17,7 +17,7 @@ import org.jetbrains.kotlin.psi.KtValueArgumentName import org.jetbrains.kotlin.psi.psiUtil.siblings import org.jetbrains.kotlin.psi.psiUtil.startOffset -class ComposeModifierUsedOnceCheck : TwitterKtRule("compose-modifier-used-once-check") { +class ComposeModifierUsedOnceCheck : TwitterKtRule("twitter-compose:modifier-used-once-check") { override fun visitFunction(function: KtFunction, autoCorrect: Boolean, emitter: Emitter) { if (!function.isComposable) return diff --git a/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeMultipleContentEmittersCheck.kt b/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeMultipleContentEmittersCheck.kt index 9c486206..cf086ab2 100644 --- a/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeMultipleContentEmittersCheck.kt +++ b/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeMultipleContentEmittersCheck.kt @@ -12,7 +12,7 @@ import org.jetbrains.kotlin.psi.KtCallExpression import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.psi.KtFunction -class ComposeMultipleContentEmittersCheck : TwitterKtRule("compose-multiple-emitters-check") { +class ComposeMultipleContentEmittersCheck : TwitterKtRule("twitter-compose:multiple-emitters-check") { override fun visitFile(file: KtFile, autoCorrect: Boolean, emitter: Emitter) { // CHECK #1 : We want to find the composables first that are at risk of emitting content from multiple sources. diff --git a/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeMutableParametersCheck.kt b/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeMutableParametersCheck.kt index c791533b..3997052b 100644 --- a/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeMutableParametersCheck.kt +++ b/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeMutableParametersCheck.kt @@ -7,7 +7,7 @@ import com.twitter.rules.core.ktlint.TwitterKtRule import com.twitter.rules.core.ktlint.report import org.jetbrains.kotlin.psi.KtFunction -class ComposeMutableParametersCheck : TwitterKtRule("compose-mutable-params-check") { +class ComposeMutableParametersCheck : TwitterKtRule("twitter-compose:mutable-params-check") { override fun visitFunction(function: KtFunction, autoCorrect: Boolean, emitter: Emitter) { if (!function.isComposable) return diff --git a/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeNamingCheck.kt b/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeNamingCheck.kt index 6966b7fe..51db9824 100644 --- a/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeNamingCheck.kt +++ b/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeNamingCheck.kt @@ -7,7 +7,7 @@ import com.twitter.rules.core.ktlint.report import com.twitter.rules.core.returnsValue import org.jetbrains.kotlin.psi.KtFunction -class ComposeNamingCheck : TwitterKtRule("compose-naming-check") { +class ComposeNamingCheck : TwitterKtRule("twitter-compose:naming-check") { override fun visitFunction(function: KtFunction, autoCorrect: Boolean, emitter: Emitter) { if (!function.isComposable) return diff --git a/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeRememberMissingCheck.kt b/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeRememberMissingCheck.kt index 4947b604..35fbb8f6 100644 --- a/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeRememberMissingCheck.kt +++ b/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeRememberMissingCheck.kt @@ -9,7 +9,7 @@ import org.jetbrains.kotlin.psi.KtCallExpression import org.jetbrains.kotlin.psi.KtFunction import org.jetbrains.kotlin.psi.psiUtil.startOffset -class ComposeRememberMissingCheck : TwitterKtRule("compose-remember-missing-check") { +class ComposeRememberMissingCheck : TwitterKtRule("twitter-compose:remember-missing-check") { override fun visitFunction(function: KtFunction, autoCorrect: Boolean, emitter: Emitter) { if (!function.isComposable) return diff --git a/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeViewModelForwardingCheck.kt b/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeViewModelForwardingCheck.kt index 519baef1..01e08b87 100644 --- a/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeViewModelForwardingCheck.kt +++ b/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeViewModelForwardingCheck.kt @@ -13,7 +13,7 @@ import org.jetbrains.kotlin.psi.KtFunction import org.jetbrains.kotlin.psi.KtReferenceExpression import org.jetbrains.kotlin.psi.psiUtil.startOffset -class ComposeViewModelForwardingCheck : TwitterKtRule("compose-vm-forwarding-check") { +class ComposeViewModelForwardingCheck : TwitterKtRule("twitter-compose:vm-forwarding-check") { override fun visitFile(file: KtFile, autoCorrect: Boolean, emitter: Emitter) { file.findChildrenByClass() diff --git a/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeViewModelInjectionCheck.kt b/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeViewModelInjectionCheck.kt index 99710eaf..fe9f2616 100644 --- a/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeViewModelInjectionCheck.kt +++ b/rules/ktlint/src/main/kotlin/com/twitter/rules/ktlint/compose/ComposeViewModelInjectionCheck.kt @@ -21,7 +21,7 @@ import org.jetbrains.kotlin.psi.KtFunctionType import org.jetbrains.kotlin.psi.KtProperty import org.jetbrains.kotlin.psi.KtPsiFactory -class ComposeViewModelInjectionCheck : TwitterKtRule("compose-vm-injection-check") { +class ComposeViewModelInjectionCheck : TwitterKtRule("twitter-compose:vm-injection-check") { override fun visitFile(file: KtFile, autoCorrect: Boolean, emitter: Emitter) { file.findChildrenByClass() diff --git a/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeModifierMissingCheckTest.kt b/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeModifierMissingCheckTest.kt index ac100b53..8d27a5a3 100644 --- a/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeModifierMissingCheckTest.kt +++ b/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeModifierMissingCheckTest.kt @@ -1,20 +1,18 @@ package com.twitter.rules.ktlint.compose -import com.pinterest.ktlint.core.LintError -import com.pinterest.ktlint.test.format -import com.pinterest.ktlint.test.lint -import org.assertj.core.api.Assertions.assertThat +import com.pinterest.ktlint.test.KtLintAssertThat.Companion.assertThat +import com.pinterest.ktlint.test.LintViolation import org.intellij.lang.annotations.Language import org.junit.jupiter.api.Test class ComposeModifierMissingCheckTest { - private val rule = ComposeModifierMissingCheck() + private val modifierRuleAssertThat = ComposeModifierMissingCheck().assertThat() @Test fun `errors when a Composable has a layout inside and it doesn't have a modifier`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun Something() { @@ -40,37 +38,30 @@ class ComposeModifierMissingCheckTest { } } """.trimIndent() - ) - val expectedErrors = listOf( - LintError( + + modifierRuleAssertThat(code).hasLintViolationsWithoutAutoCorrect( + LintViolation( line = 2, col = 5, - ruleId = "compose-modifier-check", detail = ComposeModifierMissingCheck.MissingModifierContentComposable, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 7, col = 5, - ruleId = "compose-modifier-check", detail = ComposeModifierMissingCheck.MissingModifierContentComposable, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 12, col = 5, - ruleId = "compose-modifier-check", detail = ComposeModifierMissingCheck.MissingModifierContentComposable, - canBeAutoCorrected = false ) ) - assertThat(errors).isEqualTo(expectedErrors) } @Test fun `errors when a Composable without modifiers has a Composable inside with a modifier`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun Something() { @@ -85,30 +76,23 @@ class ComposeModifierMissingCheckTest { } } """.trimIndent() - ) - val expectedErrors = listOf( - LintError( + + modifierRuleAssertThat(code).hasLintViolationsWithoutAutoCorrect( + LintViolation( line = 2, col = 5, - ruleId = "compose-modifier-check", detail = ComposeModifierMissingCheck.MissingModifierContentComposable, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 7, col = 5, - ruleId = "compose-modifier-check", detail = ComposeModifierMissingCheck.MissingModifierContentComposable, - canBeAutoCorrected = false ) ) - assertThat(errors).isEqualTo(expectedErrors) } @Test fun `errors when a Composable has modifiers but without default values, and is able to auto fixing it`() { - val check = rule - @Language("kotlin") val composableCode = """ @Composable @@ -117,33 +101,28 @@ class ComposeModifierMissingCheckTest { } } """.trimIndent() - val errors = check.lint(composableCode) - val expectedErrors = listOf( - LintError( + + modifierRuleAssertThat(composableCode) + .hasLintViolation( line = 2, col = 15, - ruleId = "compose-modifier-check", detail = ComposeModifierMissingCheck.MissingModifierDefaultParam, - canBeAutoCorrected = true ) - ) - assertThat(errors).isEqualTo(expectedErrors) - val autoFixCode = check.format(composableCode) - assertThat(autoFixCode).isEqualTo( - """ + .isFormattedAs( + """ @Composable fun Something(modifier: Modifier = Modifier) { Row(modifier = modifier) { } } """.trimIndent() - ) + ) } @Test fun `passes when a Composable has modifiers with defaults`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun Something(modifier: Modifier = Modifier) { @@ -161,14 +140,13 @@ class ComposeModifierMissingCheckTest { } } """.trimIndent() - ) - assertThat(errors).isEmpty() + modifierRuleAssertThat(code).hasNoLintViolations() } @Test fun `non-public visibility Composables are ignored`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable private fun Something() { @@ -193,14 +171,13 @@ class ComposeModifierMissingCheckTest { } } """.trimIndent() - ) - assertThat(errors).isEmpty() + modifierRuleAssertThat(code).hasNoLintViolations() } @Test fun `interface Composables are ignored`() { @Language("kotlin") - val errors = rule.lint( + val code = """ interface MyInterface { @Composable @@ -216,14 +193,13 @@ class ComposeModifierMissingCheckTest { } } """.trimIndent() - ) - assertThat(errors).isEmpty() + modifierRuleAssertThat(code).hasNoLintViolations() } @Test fun `overridden Composables are ignored`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable override fun Content() { @@ -241,14 +217,13 @@ class ComposeModifierMissingCheckTest { } } """.trimIndent() - ) - assertThat(errors).isEmpty() + modifierRuleAssertThat(code).hasNoLintViolations() } @Test fun `Composables that return a type that is not Unit shouldn't be processed`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun Something(): Int { @@ -256,7 +231,6 @@ class ComposeModifierMissingCheckTest { } } """.trimIndent() - ) - assertThat(errors).isEmpty() + modifierRuleAssertThat(code).hasNoLintViolations() } } diff --git a/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeModifierUsedOnceCheckTest.kt b/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeModifierUsedOnceCheckTest.kt index 713d667d..3d36156d 100644 --- a/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeModifierUsedOnceCheckTest.kt +++ b/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeModifierUsedOnceCheckTest.kt @@ -1,6 +1,7 @@ package com.twitter.rules.ktlint.compose -import com.pinterest.ktlint.core.LintError +import com.pinterest.ktlint.test.KtLintAssertThat.Companion.assertThat +import com.pinterest.ktlint.test.LintViolation import com.pinterest.ktlint.test.lint import org.assertj.core.api.Assertions.assertThat import org.intellij.lang.annotations.Language @@ -8,12 +9,12 @@ import org.junit.jupiter.api.Test class ComposeModifierUsedOnceCheckTest { - private val rule = ComposeModifierUsedOnceCheck() + private val modifierRuleAssertThat = ComposeModifierUsedOnceCheck().assertThat() @Test fun `errors when the modifier parameter of a Composable is used more than once by siblings or parent-children`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun Something(modifier: Modifier) { @@ -44,79 +45,60 @@ class ComposeModifierUsedOnceCheckTest { } } """.trimIndent() - ) - val expectedErrors = listOf( - LintError( + + modifierRuleAssertThat(code).hasLintViolationsWithoutAutoCorrect( + LintViolation( line = 3, col = 5, - ruleId = "compose-modifier-used-once-check", detail = ComposeModifierUsedOnceCheck.ModifierShouldBeUsedOnceOnly, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 4, col = 9, - ruleId = "compose-modifier-used-once-check", detail = ComposeModifierUsedOnceCheck.ModifierShouldBeUsedOnceOnly, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 9, col = 5, - ruleId = "compose-modifier-used-once-check", detail = ComposeModifierUsedOnceCheck.ModifierShouldBeUsedOnceOnly, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 11, col = 9, - ruleId = "compose-modifier-used-once-check", detail = ComposeModifierUsedOnceCheck.ModifierShouldBeUsedOnceOnly, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 16, col = 5, - ruleId = "compose-modifier-used-once-check", detail = ComposeModifierUsedOnceCheck.ModifierShouldBeUsedOnceOnly, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 19, col = 5, - ruleId = "compose-modifier-used-once-check", detail = ComposeModifierUsedOnceCheck.ModifierShouldBeUsedOnceOnly, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 20, col = 5, - ruleId = "compose-modifier-used-once-check", detail = ComposeModifierUsedOnceCheck.ModifierShouldBeUsedOnceOnly, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 25, col = 9, - ruleId = "compose-modifier-used-once-check", detail = ComposeModifierUsedOnceCheck.ModifierShouldBeUsedOnceOnly, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 26, col = 9, - ruleId = "compose-modifier-used-once-check", detail = ComposeModifierUsedOnceCheck.ModifierShouldBeUsedOnceOnly, - canBeAutoCorrected = false ), ) - assertThat(errors).isEqualTo(expectedErrors) } @Test fun `errors when the modifier parameter of a Composable is tweaked or reassigned and reused`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun Something(modifier: Modifier) { @@ -139,58 +121,44 @@ class ComposeModifierUsedOnceCheckTest { } } """.trimIndent() - ) - val expectedErrors = listOf( - LintError( + modifierRuleAssertThat(code).hasLintViolationsWithoutAutoCorrect( + LintViolation( line = 3, col = 5, - ruleId = "compose-modifier-used-once-check", detail = ComposeModifierUsedOnceCheck.ModifierShouldBeUsedOnceOnly, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 4, col = 9, - ruleId = "compose-modifier-used-once-check", detail = ComposeModifierUsedOnceCheck.ModifierShouldBeUsedOnceOnly, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 9, col = 5, - ruleId = "compose-modifier-used-once-check", detail = ComposeModifierUsedOnceCheck.ModifierShouldBeUsedOnceOnly, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 11, col = 9, - ruleId = "compose-modifier-used-once-check", detail = ComposeModifierUsedOnceCheck.ModifierShouldBeUsedOnceOnly, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 17, col = 5, - ruleId = "compose-modifier-used-once-check", detail = ComposeModifierUsedOnceCheck.ModifierShouldBeUsedOnceOnly, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 18, col = 9, - ruleId = "compose-modifier-used-once-check", detail = ComposeModifierUsedOnceCheck.ModifierShouldBeUsedOnceOnly, - canBeAutoCorrected = false ) ) - assertThat(errors).isEqualTo(expectedErrors) } @Test fun `errors when multiple Composables use the modifier even when it's been assigned to a new val`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun Something(modifier: Modifier) { @@ -216,65 +184,49 @@ class ComposeModifierUsedOnceCheckTest { } } """.trimIndent() - ) - val expectedErrors = listOf( - LintError( + modifierRuleAssertThat(code).hasLintViolationsWithoutAutoCorrect( + LintViolation( line = 6, col = 5, - ruleId = "compose-modifier-used-once-check", detail = ComposeModifierUsedOnceCheck.ModifierShouldBeUsedOnceOnly, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 8, col = 9, - ruleId = "compose-modifier-used-once-check", detail = ComposeModifierUsedOnceCheck.ModifierShouldBeUsedOnceOnly, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 9, col = 9, - ruleId = "compose-modifier-used-once-check", detail = ComposeModifierUsedOnceCheck.ModifierShouldBeUsedOnceOnly, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 12, col = 5, - ruleId = "compose-modifier-used-once-check", detail = ComposeModifierUsedOnceCheck.ModifierShouldBeUsedOnceOnly, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 16, col = 5, - ruleId = "compose-modifier-used-once-check", detail = ComposeModifierUsedOnceCheck.ModifierShouldBeUsedOnceOnly, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 20, col = 9, - ruleId = "compose-modifier-used-once-check", detail = ComposeModifierUsedOnceCheck.ModifierShouldBeUsedOnceOnly, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 21, col = 9, - ruleId = "compose-modifier-used-once-check", detail = ComposeModifierUsedOnceCheck.ModifierShouldBeUsedOnceOnly, - canBeAutoCorrected = false ), ) - assertThat(errors).isEqualTo(expectedErrors) } @Test fun `passes when a Composable only passes its modifier parameter to the root level layout`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun Something(modifier: Modifier) { @@ -310,14 +262,13 @@ class ComposeModifierUsedOnceCheckTest { } } """.trimIndent() - ) - assertThat(errors).isEmpty() + modifierRuleAssertThat(code).hasNoLintViolations() } @Test fun `passes when modifiers are reused for mutually exclusive branches`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun Something(modifier: Modifier = Modifier) { @@ -328,14 +279,13 @@ class ComposeModifierUsedOnceCheckTest { } } """.trimIndent() - ) - assertThat(errors).isEmpty() + modifierRuleAssertThat(code).hasNoLintViolations() } @Test fun `passes when used on vals with lambdas`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun Something(modifier: Modifier) { @@ -368,7 +318,6 @@ class ComposeModifierUsedOnceCheckTest { } } """.trimIndent() - ) - assertThat(errors).isEmpty() + modifierRuleAssertThat(code).hasNoLintViolations() } } diff --git a/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeMultipleContentEmittersCheckTest.kt b/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeMultipleContentEmittersCheckTest.kt index 1d905d60..76bfbec3 100644 --- a/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeMultipleContentEmittersCheckTest.kt +++ b/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeMultipleContentEmittersCheckTest.kt @@ -1,19 +1,19 @@ package com.twitter.rules.ktlint.compose -import com.pinterest.ktlint.core.LintError -import com.pinterest.ktlint.test.lint -import org.assertj.core.api.Assertions.assertThat + +import com.pinterest.ktlint.test.KtLintAssertThat.Companion.assertThat +import com.pinterest.ktlint.test.LintViolation import org.intellij.lang.annotations.Language import org.junit.jupiter.api.Test class ComposeMultipleContentEmittersCheckTest { - private val rule = ComposeMultipleContentEmittersCheck() + private val emittersRuleAssertThat = ComposeMultipleContentEmittersCheck().assertThat() @Test fun `passes when only one item emits up at the top level`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun Something() { @@ -26,14 +26,13 @@ class ComposeMultipleContentEmittersCheckTest { } } """.trimIndent() - ) - assertThat(errors).isEmpty() + emittersRuleAssertThat(code).hasNoLintViolations() } @Test fun `passes when the composable is an extension function`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun ColumnScope.Something() { @@ -46,14 +45,13 @@ class ComposeMultipleContentEmittersCheckTest { Text("Hola") } """.trimIndent() - ) - assertThat(errors).isEmpty() + emittersRuleAssertThat(code).hasNoLintViolations() } @Test fun `errors when a Composable function has more than one UI emitter at the top level`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun Something() { @@ -66,30 +64,24 @@ class ComposeMultipleContentEmittersCheckTest { Text("Hola") } """.trimIndent() - ) - val expectedErrors = listOf( - LintError( + emittersRuleAssertThat(code).hasLintViolationsWithoutAutoCorrect( + LintViolation( line = 2, col = 5, - ruleId = "compose-multiple-emitters-check", detail = ComposeMultipleContentEmittersCheck.MultipleContentEmittersDetected, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 7, col = 5, - ruleId = "compose-multiple-emitters-check", detail = ComposeMultipleContentEmittersCheck.MultipleContentEmittersDetected, - canBeAutoCorrected = false ), ) - assertThat(errors).isEqualTo(expectedErrors) } @Test fun `errors when a Composable function has more than one indirect UI emitter at the top level`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun Something1() { @@ -114,30 +106,24 @@ class ComposeMultipleContentEmittersCheckTest { Something4() } """.trimIndent() - ) - val expectedErrors = listOf( - LintError( + emittersRuleAssertThat(code).hasLintViolationsWithoutAutoCorrect( + LintViolation( line = 6, col = 5, - ruleId = "compose-multiple-emitters-check", detail = ComposeMultipleContentEmittersCheck.MultipleContentEmittersDetected, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 19, col = 5, - ruleId = "compose-multiple-emitters-check", detail = ComposeMultipleContentEmittersCheck.MultipleContentEmittersDetected, - canBeAutoCorrected = false ), ) - assertThat(errors).isEqualTo(expectedErrors) } @Test fun `make sure to not report twice the same composable`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun Something() { @@ -150,23 +136,19 @@ class ComposeMultipleContentEmittersCheckTest { Text("Alo") } """.trimIndent() - ) - val expectedErrors = listOf( - LintError( + emittersRuleAssertThat(code).hasLintViolationsWithoutAutoCorrect( + LintViolation( line = 2, col = 5, - ruleId = "compose-multiple-emitters-check", detail = ComposeMultipleContentEmittersCheck.MultipleContentEmittersDetected, - canBeAutoCorrected = false ), ) - assertThat(errors).isEqualTo(expectedErrors) } @Test fun `error out when detecting a content emitting composable that returns something other than unit`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun Something(): String { // This one emits content directly and should fail @@ -183,23 +165,17 @@ class ComposeMultipleContentEmittersCheckTest { HorizonIcon(icon = HorizonIcon.Arrow) } """.trimIndent() - ) - val expectedErrors = listOf( - LintError( + emittersRuleAssertThat(code).hasLintViolationsWithoutAutoCorrect( + LintViolation( line = 2, col = 5, - ruleId = "compose-multiple-emitters-check", detail = ComposeMultipleContentEmittersCheck.ContentEmitterReturningValuesToo, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 7, col = 5, - ruleId = "compose-multiple-emitters-check", detail = ComposeMultipleContentEmittersCheck.ContentEmitterReturningValuesToo, - canBeAutoCorrected = false ), ) - assertThat(errors).isEqualTo(expectedErrors) } } diff --git a/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeMutableParametersCheckTest.kt b/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeMutableParametersCheckTest.kt index 262e5595..469ac8ad 100644 --- a/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeMutableParametersCheckTest.kt +++ b/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeMutableParametersCheckTest.kt @@ -1,19 +1,18 @@ package com.twitter.rules.ktlint.compose -import com.pinterest.ktlint.core.LintError -import com.pinterest.ktlint.test.lint -import org.assertj.core.api.Assertions.assertThat +import com.pinterest.ktlint.test.KtLintAssertThat.Companion.assertThat +import com.pinterest.ktlint.test.LintViolation import org.intellij.lang.annotations.Language import org.junit.jupiter.api.Test class ComposeMutableParametersCheckTest { - private val rule = ComposeMutableParametersCheck() + private val mutableParamRuleAssertThat = ComposeMutableParametersCheck().assertThat() @Test fun `errors when a Composable has a mutable parameter`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun Something(a: MutableState) {} @@ -24,51 +23,40 @@ class ComposeMutableParametersCheckTest { @Composable fun Something(a: MutableMap) {} """.trimIndent() - ) - val expectedErrors = listOf( - LintError( + mutableParamRuleAssertThat(code).hasLintViolationsWithoutAutoCorrect( + LintViolation( line = 2, col = 15, - ruleId = "compose-mutable-params-check", detail = ComposeMutableParametersCheck.MutableParameterInCompose, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 4, col = 15, - ruleId = "compose-mutable-params-check", detail = ComposeMutableParametersCheck.MutableParameterInCompose, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 6, col = 15, - ruleId = "compose-mutable-params-check", detail = ComposeMutableParametersCheck.MutableParameterInCompose, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 8, col = 15, - ruleId = "compose-mutable-params-check", detail = ComposeMutableParametersCheck.MutableParameterInCompose, - canBeAutoCorrected = false ) ) - assertThat(errors).isEqualTo(expectedErrors) } @Test fun `no errors when a Composable has valid parameters`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun Something(a: String, b: (Int) -> Unit) {} @Composable fun Something(a: State) {} """.trimIndent() - ) - assertThat(errors).isEmpty() + mutableParamRuleAssertThat(code).hasNoLintViolations() } } diff --git a/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeNamingCheckTest.kt b/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeNamingCheckTest.kt index cbfa6b6e..12e05d4b 100644 --- a/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeNamingCheckTest.kt +++ b/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeNamingCheckTest.kt @@ -1,45 +1,42 @@ package com.twitter.rules.ktlint.compose -import com.pinterest.ktlint.core.LintError -import com.pinterest.ktlint.test.lint -import org.assertj.core.api.Assertions.assertThat +import com.pinterest.ktlint.test.KtLintAssertThat.Companion.assertThat +import com.pinterest.ktlint.test.LintViolation import org.intellij.lang.annotations.Language import org.junit.jupiter.api.Test class ComposeNamingCheckTest { - private val rule = ComposeNamingCheck() + private val namingRuleAssertThat = ComposeNamingCheck().assertThat() @Test fun `passes when a composable that returns values is lowercase`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun myComposable(): Something { } """.trimIndent() - ) - assertThat(errors).isEmpty() + namingRuleAssertThat(code).hasNoLintViolations() } @Test fun `passes when a composable that returns nothing or Unit is uppercase`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun MyComposable() { } @Composable fun MyComposable(): Unit { } """.trimIndent() - ) - assertThat(errors).isEmpty() + namingRuleAssertThat(code).hasNoLintViolations() } @Test fun `passes when a composable doesn't have a body block, is a property or a lambda`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun MyComposable() = Text("bleh") @@ -52,35 +49,30 @@ class ComposeNamingCheckTest { val whatever = @Composable { } """.trimIndent() - ) - assertThat(errors).isEmpty() + namingRuleAssertThat(code).hasNoLintViolations() } @Test fun `errors when a composable returns a value and is capitalized`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun MyComposable(): Something { } """.trimIndent() - ) - val expectedErrors = listOf( - LintError( + namingRuleAssertThat(code).hasLintViolationsWithoutAutoCorrect( + LintViolation( line = 2, col = 5, - ruleId = "compose-naming-check", detail = ComposeNamingCheck.ComposablesThatReturnResultsShouldBeLowercase, - canBeAutoCorrected = false ), ) - assertThat(errors).isEqualTo(expectedErrors) } @Test fun `errors when a composable returns nothing or Unit and is lowercase`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun myComposable() { } @@ -88,23 +80,17 @@ class ComposeNamingCheckTest { @Composable fun myComposable(): Unit { } """.trimIndent() - ) - val expectedErrors = listOf( - LintError( + namingRuleAssertThat(code).hasLintViolationsWithoutAutoCorrect( + LintViolation( line = 2, col = 5, - ruleId = "compose-naming-check", detail = ComposeNamingCheck.ComposablesThatDoNotReturnResultsShouldBeCapitalized, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 5, col = 5, - ruleId = "compose-naming-check", detail = ComposeNamingCheck.ComposablesThatDoNotReturnResultsShouldBeCapitalized, - canBeAutoCorrected = false ), ) - assertThat(errors).isEqualTo(expectedErrors) } } diff --git a/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeRememberMissingCheckTest.kt b/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeRememberMissingCheckTest.kt index fbaeaebc..852a183f 100644 --- a/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeRememberMissingCheckTest.kt +++ b/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeRememberMissingCheckTest.kt @@ -1,30 +1,28 @@ package com.twitter.rules.ktlint.compose -import com.pinterest.ktlint.core.LintError -import com.pinterest.ktlint.test.lint -import org.assertj.core.api.Assertions.assertThat +import com.pinterest.ktlint.test.KtLintAssertThat.Companion.assertThat +import com.pinterest.ktlint.test.LintViolation import org.intellij.lang.annotations.Language import org.junit.jupiter.api.Test class ComposeRememberMissingCheckTest { - private val rule = ComposeRememberMissingCheck() + private val rememberRuleAssertThat = ComposeRememberMissingCheck().assertThat() @Test fun `passes when a non-remembered mutableStateOf is used outside of a Composable`() { @Language("kotlin") - val errors = rule.lint( + val code = """ val msof = mutableStateOf("X") """.trimIndent() - ) - assertThat(errors).isEmpty() + rememberRuleAssertThat(code).hasNoLintViolations() } @Test fun `errors when a non-remembered mutableStateOf is used in a Composable`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun MyComposable() { @@ -34,30 +32,24 @@ class ComposeRememberMissingCheckTest { fun MyComposable(something: State = mutableStateOf("X")) { } """.trimIndent() - ) - val expectedErrors = listOf( - LintError( + rememberRuleAssertThat(code).hasLintViolationsWithoutAutoCorrect( + LintViolation( line = 3, col = 21, - ruleId = "compose-remember-missing-check", detail = ComposeRememberMissingCheck.MutableStateOfNotRemembered, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 6, col = 45, - ruleId = "compose-remember-missing-check", detail = ComposeRememberMissingCheck.MutableStateOfNotRemembered, - canBeAutoCorrected = false ), ) - assertThat(errors).isEqualTo(expectedErrors) } @Test fun `passes when a remembered mutableStateOf is used in a Composable`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun MyComposable( @@ -67,14 +59,13 @@ class ComposeRememberMissingCheckTest { val something2 by remember { mutableStateOf("Y") } } """.trimIndent() - ) - assertThat(errors).isEmpty() + rememberRuleAssertThat(code).hasNoLintViolations() } @Test fun `passes when a rememberSaveable mutableStateOf is used in a Composable`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun MyComposable( @@ -84,25 +75,23 @@ class ComposeRememberMissingCheckTest { val something2 by rememberSaveable { mutableStateOf("Y") } } """.trimIndent() - ) - assertThat(errors).isEmpty() + rememberRuleAssertThat(code).hasNoLintViolations() } @Test fun `passes when a non-remembered derivedStateOf is used outside of a Composable`() { @Language("kotlin") - val errors = rule.lint( + val code = """ val dsof = derivedStateOf("X") """.trimIndent() - ) - assertThat(errors).isEmpty() + rememberRuleAssertThat(code).hasNoLintViolations() } @Test fun `errors when a non-remembered derivedStateOf is used in a Composable`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun MyComposable() { @@ -112,30 +101,24 @@ class ComposeRememberMissingCheckTest { fun MyComposable(something: State = derivedStateOf { "X" }) { } """.trimIndent() - ) - val expectedErrors = listOf( - LintError( + rememberRuleAssertThat(code).hasLintViolationsWithoutAutoCorrect( + LintViolation( line = 3, col = 21, - ruleId = "compose-remember-missing-check", detail = ComposeRememberMissingCheck.DerivedStateOfNotRemembered, - canBeAutoCorrected = false ), - LintError( + LintViolation( line = 6, col = 45, - ruleId = "compose-remember-missing-check", detail = ComposeRememberMissingCheck.DerivedStateOfNotRemembered, - canBeAutoCorrected = false ), ) - assertThat(errors).isEqualTo(expectedErrors) } @Test fun `passes when a remembered derivedStateOf is used in a Composable`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun MyComposable( @@ -145,7 +128,6 @@ class ComposeRememberMissingCheckTest { val something2 by remember { derivedStateOf { "Y" } } } """.trimIndent() - ) - assertThat(errors).isEmpty() + rememberRuleAssertThat(code).hasNoLintViolations() } } diff --git a/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeViewModelForwardingCheckTest.kt b/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeViewModelForwardingCheckTest.kt index 4f730162..d0a14a4d 100644 --- a/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeViewModelForwardingCheckTest.kt +++ b/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeViewModelForwardingCheckTest.kt @@ -1,19 +1,18 @@ package com.twitter.rules.ktlint.compose -import com.pinterest.ktlint.core.LintError -import com.pinterest.ktlint.test.lint -import org.assertj.core.api.Assertions.assertThat +import com.pinterest.ktlint.test.KtLintAssertThat.Companion.assertThat +import com.pinterest.ktlint.test.LintViolation import org.intellij.lang.annotations.Language import org.junit.jupiter.api.Test class ComposeViewModelForwardingCheckTest { - private val rule = ComposeViewModelForwardingCheck() + private val forwardingRuleAssertThat = ComposeViewModelForwardingCheck().assertThat() @Test fun `allows the forwarding of ViewModels in overridden Composable functions`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable override fun Content() { @@ -21,14 +20,13 @@ class ComposeViewModelForwardingCheckTest { AnotherComposable(viewModel) } """.trimIndent() - ) - assertThat(errors).isEmpty() + forwardingRuleAssertThat(code).hasNoLintViolations() } @Test fun `allows the forwarding of ViewModels in interface Composable functions`() { @Language("kotlin") - val errors = rule.lint( + val code = """ interface MyInterface { @Composable @@ -38,14 +36,13 @@ class ComposeViewModelForwardingCheckTest { } } """.trimIndent() - ) - assertThat(errors).isEmpty() + forwardingRuleAssertThat(code).hasNoLintViolations() } @Test fun `using state hoisting properly shouldn't be flagged`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun MyComposable(viewModel: MyViewModel = weaverViewModel()) { @@ -53,30 +50,25 @@ class ComposeViewModelForwardingCheckTest { AnotherComposable(state, onAvatarClicked = { viewModel(AvatarClickedIntent) }) } """.trimIndent() - ) - assertThat(errors).isEmpty() + forwardingRuleAssertThat(code).hasNoLintViolations() } @Test fun `errors when a ViewModel is forwarded to another Composable`() { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun MyComposable(viewModel: MyViewModel) { AnotherComposable(viewModel) } """.trimIndent() - ) - val expectedErrors = listOf( - LintError( + forwardingRuleAssertThat(code).hasLintViolationsWithoutAutoCorrect( + LintViolation( line = 3, col = 5, - ruleId = "compose-vm-forwarding-check", detail = ComposeViewModelForwardingCheck.AvoidViewModelForwarding, - canBeAutoCorrected = false ) ) - assertThat(errors).isEqualTo(expectedErrors) } } diff --git a/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeViewModelInjectionCheckTest.kt b/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeViewModelInjectionCheckTest.kt index 8ee5859a..d89c86e5 100644 --- a/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeViewModelInjectionCheckTest.kt +++ b/rules/ktlint/src/test/kotlin/com/twitter/rules/ktlint/compose/ComposeViewModelInjectionCheckTest.kt @@ -1,22 +1,20 @@ package com.twitter.rules.ktlint.compose -import com.pinterest.ktlint.core.LintError -import com.pinterest.ktlint.test.format -import com.pinterest.ktlint.test.lint -import org.assertj.core.api.Assertions.assertThat +import com.pinterest.ktlint.test.KtLintAssertThat.Companion.assertThat +import com.pinterest.ktlint.test.LintViolation import org.intellij.lang.annotations.Language import org.junit.jupiter.params.ParameterizedTest import org.junit.jupiter.params.provider.ValueSource class ComposeViewModelInjectionCheckTest { - private val rule = ComposeViewModelInjectionCheck() + private val injectionRuleAssertThat = ComposeViewModelInjectionCheck().assertThat() @ParameterizedTest @ValueSource(strings = ["viewModel", "weaverViewModel"]) fun `passes when a weaverViewModel is used as a default param`(viewModel: String) { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun MyComposable( @@ -25,30 +23,28 @@ class ComposeViewModelInjectionCheckTest { viewModel2: MyVM = $viewModel(), ) { } """.trimIndent() - ) - assertThat(errors).isEmpty() + injectionRuleAssertThat(code).hasNoLintViolations() } @ParameterizedTest @ValueSource(strings = ["viewModel", "weaverViewModel"]) fun `overridden functions are ignored`(viewModel: String) { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable override fun Content() { val viewModel = $viewModel() } """.trimIndent() - ) - assertThat(errors).isEmpty() + injectionRuleAssertThat(code).hasNoLintViolations() } @ParameterizedTest @ValueSource(strings = ["viewModel", "weaverViewModel"]) fun `errors when a weaverViewModel is used at the beginning of a Composable`(viewModel: String) { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun MyComposable(modifier: Modifier) { @@ -63,38 +59,30 @@ class ComposeViewModelInjectionCheckTest { val viewModel: MyVM = $viewModel() } """.trimIndent() - ) - val expectedErrors = listOf( - LintError( + injectionRuleAssertThat(code).hasLintViolations( + LintViolation( line = 3, col = 9, - ruleId = "compose-vm-injection-check", detail = ComposeViewModelInjectionCheck.errorMessage(viewModel), - canBeAutoCorrected = true ), - LintError( + LintViolation( line = 7, col = 9, - ruleId = "compose-vm-injection-check", detail = ComposeViewModelInjectionCheck.errorMessage(viewModel), - canBeAutoCorrected = true ), - LintError( + LintViolation( line = 11, col = 9, - ruleId = "compose-vm-injection-check", detail = ComposeViewModelInjectionCheck.errorMessage(viewModel), - canBeAutoCorrected = true ) ) - assertThat(errors).isEqualTo(expectedErrors) } @ParameterizedTest @ValueSource(strings = ["viewModel", "weaverViewModel"]) fun `errors when a weaverViewModel is used in different branches`(viewModel: String) { @Language("kotlin") - val errors = rule.lint( + val code = """ @Composable fun MyComposable(modifier: Modifier) { @@ -105,24 +93,18 @@ class ComposeViewModelInjectionCheckTest { } } """.trimIndent() - ) - val expectedErrors = listOf( - LintError( + injectionRuleAssertThat(code).hasLintViolations( + LintViolation( line = 4, col = 13, - ruleId = "compose-vm-injection-check", detail = ComposeViewModelInjectionCheck.errorMessage(viewModel), - canBeAutoCorrected = true ), - LintError( + LintViolation( line = 6, col = 13, - ruleId = "compose-vm-injection-check", detail = ComposeViewModelInjectionCheck.errorMessage(viewModel), - canBeAutoCorrected = true ) ) - assertThat(errors).isEqualTo(expectedErrors) } @ParameterizedTest @@ -149,8 +131,8 @@ class ComposeViewModelInjectionCheckTest { fun MyComposableNoParams(viewModel: MyVM = $viewModel(named = "meh")) { } """.trimIndent() - val fixedCode = rule.format(badCode) - assertThat(fixedCode).isEqualTo(expectedCode) + + injectionRuleAssertThat(badCode).isFormattedAs(expectedCode) } @ParameterizedTest @@ -177,8 +159,7 @@ class ComposeViewModelInjectionCheckTest { fun MyComposable(modifier: Modifier = Modifier,viewModel: MyVM = $viewModel(),) { } """.trimIndent() - val fixedCode = rule.format(badCode) - assertThat(fixedCode).isEqualTo(expectedCode) + injectionRuleAssertThat(badCode).isFormattedAs(expectedCode) } @ParameterizedTest @@ -218,7 +199,6 @@ class ComposeViewModelInjectionCheckTest { ) { } """.trimIndent() - val fixedCode = rule.format(badCode) - assertThat(fixedCode).isEqualTo(expectedCode) + injectionRuleAssertThat(badCode).isFormattedAs(expectedCode) } }