-
Notifications
You must be signed in to change notification settings - Fork 90
/
ComposeRememberMissingCheckTest.kt
137 lines (127 loc) · 4.47 KB
/
ComposeRememberMissingCheckTest.kt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
// Copyright 2022 Twitter, Inc.
// SPDX-License-Identifier: Apache-2.0
package com.twitter.compose.rules.detekt
import com.twitter.compose.rules.ComposeRememberMissing
import io.gitlab.arturbosch.detekt.api.Config
import io.gitlab.arturbosch.detekt.api.SourceLocation
import io.gitlab.arturbosch.detekt.test.assertThat
import io.gitlab.arturbosch.detekt.test.lint
import org.intellij.lang.annotations.Language
import org.junit.jupiter.api.Test
class ComposeRememberMissingCheckTest {
private val rule = ComposeRememberMissingCheck(Config.empty)
@Test
fun `passes when a non-remembered mutableStateOf is used outside of a Composable`() {
@Language("kotlin")
val code =
"""
val msof = mutableStateOf("X")
""".trimIndent()
val errors = rule.lint(code)
assertThat(errors).isEmpty()
}
@Test
fun `errors when a non-remembered mutableStateOf is used in a Composable`() {
@Language("kotlin")
val code =
"""
@Composable
fun MyComposable() {
val something = mutableStateOf("X")
}
@Composable
fun MyComposable(something: State<String> = mutableStateOf("X")) {
}
""".trimIndent()
val errors = rule.lint(code)
assertThat(errors).hasSize(2)
.hasStartSourceLocations(
SourceLocation(3, 21),
SourceLocation(6, 45)
)
for (error in errors) {
assertThat(error).hasMessage(ComposeRememberMissing.MutableStateOfNotRemembered)
}
}
@Test
fun `passes when a remembered mutableStateOf is used in a Composable`() {
@Language("kotlin")
val code =
"""
@Composable
fun MyComposable(
something: State<String> = remember { mutableStateOf("X") }
) {
val something = remember { mutableStateOf("X") }
val something2 by remember { mutableStateOf("Y") }
}
""".trimIndent()
val errors = rule.lint(code)
assertThat(errors).isEmpty()
}
@Test
fun `passes when a rememberSaveable mutableStateOf is used in a Composable`() {
@Language("kotlin")
val code =
"""
@Composable
fun MyComposable(
something: State<String> = rememberSaveable { mutableStateOf("X") }
) {
val something = rememberSaveable { mutableStateOf("X") }
val something2 by rememberSaveable { mutableStateOf("Y") }
}
""".trimIndent()
val errors = rule.lint(code)
assertThat(errors).isEmpty()
}
@Test
fun `passes when a non-remembered derivedStateOf is used outside of a Composable`() {
@Language("kotlin")
val code =
"""
val dsof = derivedStateOf("X")
""".trimIndent()
val errors = rule.lint(code)
assertThat(errors).isEmpty()
}
@Test
fun `errors when a non-remembered derivedStateOf is used in a Composable`() {
@Language("kotlin")
val code =
"""
@Composable
fun MyComposable() {
val something = derivedStateOf { "X" }
}
@Composable
fun MyComposable(something: State<String> = derivedStateOf { "X" }) {
}
""".trimIndent()
val errors = rule.lint(code)
assertThat(errors).hasSize(2)
.hasStartSourceLocations(
SourceLocation(3, 21),
SourceLocation(6, 45)
)
for (error in errors) {
assertThat(error).hasMessage(ComposeRememberMissing.DerivedStateOfNotRemembered)
}
}
@Test
fun `passes when a remembered derivedStateOf is used in a Composable`() {
@Language("kotlin")
val code =
"""
@Composable
fun MyComposable(
something: State<String> = remember { derivedStateOf { "X" } }
) {
val something = remember { derivedStateOf { "X" } }
val something2 by remember { derivedStateOf { "Y" } }
}
""".trimIndent()
val errors = rule.lint(code)
assertThat(errors).isEmpty()
}
}