avito-android

1
package com.avito.instrumentation
2

3
import com.avito.test.gradle.TestProjectGenerator
4
import com.avito.test.gradle.ciRun
5
import com.avito.test.gradle.gradlew
6
import com.avito.test.gradle.module.AndroidAppModule
7
import com.avito.test.gradle.module.AndroidLibModule
8
import com.avito.test.gradle.module.Module
9
import com.avito.test.gradle.plugin.plugins
10
import org.junit.jupiter.api.Disabled
11
import org.junit.jupiter.api.Test
12
import org.junit.jupiter.api.io.TempDir
13
import java.io.File
14

15
internal class InstrumentationTestsPluginTest {
16

17
    @Test
18
    fun `configuration - ok - empty instrumentation block`(@TempDir projectDir: File) {
19
        createProject(
20
            projectDir = projectDir,
21
            module = AndroidAppModule(
22
                "app",
23
                plugins = plugins {
24
                    id(instrumentationPluginId)
25
                },
26
                buildGradleExtra = """
27
                    instrumentation {
28
                    }
29
                """.trimIndent(),
30
                useKts = true,
31
            )
32
        )
33

34
        gradlew(projectDir, "help", dryRun = true).assertThat().buildSuccessful()
35
    }
36

37
    @Test
38
    fun `tasks resolution - ok - empty instrumentation block`(@TempDir projectDir: File) {
39
        createProject(
40
            projectDir = projectDir,
41
            module = AndroidAppModule(
42
                "app",
43
                plugins = plugins {
44
                    id(instrumentationPluginId)
45
                },
46
                buildGradleExtra = """
47
                    instrumentation {
48
                    }
49
                """.trimIndent(),
50
                useKts = true,
51
            )
52
        )
53

54
        gradlew(projectDir, "tasks", dryRun = false).assertThat().buildSuccessful()
55
    }
56

57
    /**
58
     * IDE will turn red resolving script with plugin applied, it uses tasks or some equivalent in process
59
     *
60
     * todo Parameter: teamcityBuildId is required (must be digit)
61
     */
62
    @Disabled
63
    @Test
64
    fun `tasks resolution - ok - with configurations set and no args`(@TempDir projectDir: File) {
65
        createProject(
66
            projectDir = projectDir,
67
            module = AndroidAppModule(
68
                "app",
69
                plugins = plugins {
70
                    id(instrumentationPluginId)
71
                },
72
                buildGradleExtra = instrumentationConfiguration(),
73
                useKts = true,
74
            )
75
        )
76

77
        gradlew(projectDir, "tasks", dryRun = false).assertThat().buildSuccessful()
78
    }
79

80
    @Test
81
    fun `run instrumentation by name - ok - in application project`(@TempDir projectDir: File) {
82
        val moduleName = "app"
83

84
        createProject(
85
            projectDir = projectDir,
86
            module = AndroidAppModule(
87
                moduleName,
88
                plugins = plugins {
89
                    id(instrumentationPluginId)
90
                },
91
                buildGradleExtra = instrumentationConfiguration(),
92
                useKts = true,
93
            )
94
        )
95

96
        runGradle(projectDir, ":$moduleName:instrumentationTwoTest", "-PrunOnlyFailedTests=false").assertThat()
97
            .run {
98
                tasksShouldBeTriggered(":$moduleName:instrumentationTwoTest")
99
            }
100
    }
101

102
    @Test
103
    fun `run instrumentation by name - ok - in application project with flavors`(@TempDir projectDir: File) {
104
        val moduleName = "app"
105

106
        createProject(
107
            projectDir = projectDir,
108
            module = AndroidAppModule(
109
                moduleName,
110
                plugins = plugins {
111
                    id(instrumentationPluginId)
112
                },
113
                buildGradleExtra = """
114
                    |${instrumentationConfiguration()}
115
                    |    
116
                    |android {
117
                    |   flavorDimensions("version")
118
                    |   productFlavors {
119
                    |       register("demo") { 
120
                    |           setDimension("version")
121
                    |       }
122
                    |       register("full") {
123
                    |           setDimension("version")
124
                    |       }
125
                    |   }
126
                    |}
127
                    |""".trimMargin(),
128
                useKts = true,
129
            )
130
        )
131

132
        runGradle(
133
            projectDir,
134
            ":$moduleName:instrumentationDemoTwoTest",
135
            ":$moduleName:instrumentationFullTwoTest",
136
            "-PrunOnlyFailedTests=false"
137
        ).assertThat()
138
            .run {
139
                tasksShouldBeTriggered(
140
                    ":$moduleName:instrumentationDemoTwoTest",
141
                    ":$moduleName:instrumentationFullTwoTest"
142
                ).inOrder()
143
            }
144
    }
145

146
    @Test
147
    fun `run instrumentation by name - ok - in application project with multidimensional flavors`(
148
        @TempDir projectDir: File
149
    ) {
150
        val moduleName = "app"
151

152
        createProject(
153
            projectDir = projectDir,
154
            module = AndroidAppModule(
155
                moduleName,
156
                plugins = plugins {
157
                    id(instrumentationPluginId)
158
                },
159
                buildGradleExtra = """
160
                    |${instrumentationConfiguration()}
161
                    |    
162
                    |android {
163
                    |   flavorDimensions("version", "monetization")
164
                    |    productFlavors {
165
                    |       register("demo") { 
166
                    |           setDimension("version")
167
                    |       }
168
                    |       register("full") {
169
                    |           setDimension("version")
170
                    |       }
171
                    |       register("free") {
172
                    |           setDimension("monetization")
173
                    |       }
174
                    |       register("paid") {
175
                    |           setDimension("monetization")
176
                    |       }
177
                    |    }
178
                    |}
179
                    |""".trimMargin(),
180
                useKts = true,
181
            )
182
        )
183

184
        runGradle(
185
            projectDir,
186
            ":$moduleName:instrumentationDemoFreeTwoTest",
187
            ":$moduleName:instrumentationFullPaidTwoTest",
188
            "-PrunOnlyFailedTests=false"
189
        ).assertThat()
190
            .run {
191
                tasksShouldBeTriggered(
192
                    ":$moduleName:instrumentationDemoFreeTwoTest",
193
                    ":$moduleName:instrumentationFullPaidTwoTest"
194
                ).inOrder()
195
            }
196
    }
197

198
    @Test
199
    fun `run instrumentation by name - ok - in library project`(@TempDir projectDir: File) {
200
        val moduleName = "lib"
201

202
        createProject(
203
            projectDir = projectDir,
204
            module = AndroidLibModule(
205
                moduleName,
206
                plugins = plugins {
207
                    id(instrumentationPluginId)
208
                },
209
                buildGradleExtra = instrumentationConfiguration(),
210
                useKts = true,
211
            )
212
        )
213

214
        runGradle(projectDir, ":$moduleName:instrumentationTwoTest", "-PrunOnlyFailedTests=false").assertThat()
215
            .run {
216
                tasksShouldBeTriggered(":$moduleName:instrumentationTwoTest")
217
            }
218
    }
219

220
    private fun createProject(projectDir: File, module: Module) {
221
        TestProjectGenerator(
222
            plugins = plugins {
223
                id("com.avito.android.gradle-logger")
224
            },
225
            modules = listOf(module)
226
        ).generateIn(projectDir)
227
    }
228

229
    private fun runGradle(projectDir: File, vararg args: String) =
230
        ciRun(
231
            projectDir, *args,
232
            "-PdeviceName=LOCAL",
233
            "-PteamcityBuildId=0",
234
            "-Papp.versionName=1",
235
            "-Papp.versionCode=1",
236
            "-Pavito.bitbucket.url=http://bitbucket",
237
            "-Pavito.bitbucket.projectKey=AA",
238
            "-Pavito.bitbucket.repositorySlug=android",
239
            "-Pavito.stats.enabled=false",
240
            "-Pavito.stats.host=http://stats",
241
            "-Pavito.stats.fallbackHost=http://stats",
242
            "-Pavito.stats.port=80",
243
            "-Pavito.stats.namespace=android",
244
            dryRun = true
245
        )
246
}
247

248
internal fun instrumentationConfiguration(): String = """
249
    |import com.avito.instrumentation.reservation.request.Device
250
    |import com.avito.instrumentation.configuration.KubernetesViaCredentials
251
    |import com.avito.kotlin.dsl.getOptionalStringProperty
252
    |import com.avito.instrumentation.configuration.report.ReportConfig
253
    |
254
    |instrumentation {
255
    |    outputDir.set(project.file("outputs"))
256
    |    report.set(ReportConfig.NoOp)
257
    |    environments {
258
    |       register<KubernetesViaCredentials>("test") {
259
    |           url.set("http://stub")
260
    |           namespace.set("android-emulator")
261
    |           token.set(getOptionalStringProperty("kubernetesToken"))
262
    |       }
263
    |    }
264
    |    
265
    |    instrumentationParams = mapOf(
266
    |        "jobSlug" to "FunctionalTests"
267
    |    )
268
    |    
269
    |    configurations {
270
    |
271
    |        register("functional") {
272
    |            instrumentationParams = mapOf(
273
    |                "deviceName" to "api22"
274
    |            )
275
    |
276
    |            targets {
277
    |                register("api22") {
278
    |                    deviceName = "api22"
279
    |
280
    |                    scheduling {
281
    |                        quota {
282
    |                            minimumSuccessCount = 1
283
    |                        }
284
    |
285
    |                        staticDevicesReservation {
286
    |                            device = Device.LocalEmulator.device(27)
287
    |                            count = 1
288
    |                        }
289
    |                    }
290
    |                }
291
    |            }
292
    |        }
293
    |
294
    |        register("two") {
295
    |            instrumentationParams = mapOf(
296
    |                "deviceName" to "api22"
297
    |            )
298
    |
299
    |            targets {
300
    |                register("api22") {
301
    |                    deviceName = "api22"
302
    |
303
    |                    scheduling {
304
    |                        quota {
305
    |                            minimumSuccessCount = 1
306
    |                        }
307
    |
308
    |                        staticDevicesReservation {
309
    |                            device = Device.LocalEmulator.device(27)
310
    |                            count = 1
311
    |                        }
312
    |                    }
313
    |                }
314
    |            }
315
    |        }
316
    |    }
317
    |}
318
    |
319
    |android {
320
    |    defaultConfig {
321
    |        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
322
    |        testInstrumentationRunnerArguments(mapOf("planSlug" to "AvitoAndroid"))
323
    |    }
324
    |}
325
    |""".trimMargin()
326