avito-android

1
package com.avito.instrumentation
2

3
import com.avito.test.gradle.TestProjectGenerator
4
import com.avito.test.gradle.TestResult
5
import com.avito.test.gradle.gradlew
6
import com.avito.test.gradle.module.AndroidAppModule
7
import com.avito.test.gradle.plugin.plugins
8
import org.junit.jupiter.api.Test
9
import org.junit.jupiter.api.io.TempDir
10
import java.io.File
11

12
internal class InstrumentationTestsPluginCIFalseTests {
13

14
    @field:TempDir
15
    lateinit var projectDir: File
16

17
    private val instrumentationTask = ":app:instrumentationApi22Test"
18

19
    @Test
20
    fun `k8s emulator target task is available with credentials`() {
21
        createProject(
22
            projectDir = projectDir,
23
            device = """
24
                |Device.CloudEmulator(
25
                |    name = "api22",
26
                |    api = 22,
27
                |    model = "Android_SDK_built_for_x86",
28
                |    image = "stub",
29
                |    gpu = false,
30
                |    cpuCoresLimit = "1",
31
                |    cpuCoresRequest = "1.3",
32
                |    memoryLimit = "3.5Gi",
33
                |    memoryRequest = "3Gi",
34
                |)
35
                |""".trimMargin()
36
        )
37

38
        executeInstrumentationTask(
39
            instrumentationTask,
40
            false,
41
            "-PkubernetesToken=stub",
42
            "-PkubernetesUrl=stub",
43
        ).assertThat()
44
            .buildSuccessful()
45
            .tasksShouldBeTriggered(instrumentationTask)
46
    }
47

48
    @Test
49
    fun `gradle configuration fails with k8s emulator target without credentials`() {
50
        createProject(
51
            projectDir = projectDir,
52
            device = """
53
                |Device.CloudEmulator(
54
                |    name = "api22",
55
                |    api = 22,
56
                |    model = "Android_SDK_built_for_x86",
57
                |    image = "stub",
58
                |    gpu = false,
59
                |    cpuCoresLimit = "1",
60
                |    cpuCoresRequest = "1.3",
61
                |    memoryLimit = "3.5Gi",
62
                |    memoryRequest = "3Gi",
63
                |)
64
                |""".trimMargin()
65
        )
66
        executeInstrumentationTask(
67
            task = instrumentationTask,
68
            expectFailure = true
69
        ).assertThat()
70
            .buildFailed()
71
            .outputContains("Cannot query the value of property")
72
    }
73

74
    @Test
75
    fun `local emulator target task is always available`() {
76
        createProject(
77
            projectDir = projectDir,
78
            device = "Device.LocalEmulator.device(22)"
79
        )
80

81
        executeInstrumentationTask(
82
            task = ":app:instrumentationApi22Local",
83
            expectFailure = false
84
        ).assertThat()
85
            .buildSuccessful()
86
            .tasksShouldBeTriggered(":app:instrumentationApi22Local")
87
    }
88

89
    private fun executeInstrumentationTask(
90
        task: String,
91
        expectFailure: Boolean,
92
        vararg params: String
93
    ): TestResult = gradlew(
94
        projectDir,
95
        task,
96
        *params,
97
        "-Pavito.build=local",
98
        "-Pavito.git.state=local",
99
        "-Pci=false",
100
        expectFailure = expectFailure,
101
        dryRun = true
102
    )
103

104
    private fun createProject(
105
        projectDir: File,
106
        device: String
107
    ) {
108
        TestProjectGenerator(
109
            plugins = plugins {
110
                  id("com.avito.android.gradle-logger")
111
            },
112
            modules = listOf(
113
                AndroidAppModule(
114
                    "app",
115
                    plugins = plugins {
116
                        id(instrumentationPluginId)
117
                    },
118
                    buildGradleExtra = instrumentationConfiguration(
119
                        device = device
120
                    ),
121
                    useKts = true,
122
                )
123
            )
124
        ).generateIn(projectDir)
125
    }
126

127
    private fun instrumentationConfiguration(device: String): String = """
128
    |import com.avito.instrumentation.reservation.request.Device
129
    |import com.avito.instrumentation.configuration.KubernetesViaCredentials
130
    |import com.avito.kotlin.dsl.getOptionalStringProperty
131
    |import com.avito.instrumentation.configuration.report.ReportConfig
132
    |
133
    |instrumentation {
134
    |
135
    |    outputDir.set(rootProject.file("outputs"))
136
    |    report.set(ReportConfig.NoOp)
137
    |    environments {
138
    |       register<KubernetesViaCredentials>("test") {
139
    |           url.set("http://stub")
140
    |           namespace.set("android-emulator")
141
    |           token.set(getOptionalStringProperty("kubernetesToken"))
142
    |       }
143
    |    }
144
    |
145
    |    configurations {
146
    |        register("api22") {
147
    |            targets {
148
    |                register("api22") {
149
    |                    deviceName = "api22"
150
    |
151
    |                    scheduling {
152
    |                        quota {
153
    |                            minimumSuccessCount = 1
154
    |                        }
155
    |
156
    |                        staticDevicesReservation {
157
    |                            device = $device
158
    |                            count = 1
159
    |                        }
160
    |                    }
161
    |                }
162
    |            }
163
    |        }
164
    |    }
165
    |}
166
    |android {
167
    |    defaultConfig {
168
    |        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
169
    |    }
170
    |}
171
    |""".trimMargin()
172
}
173