avito-android

1
import com.avito.instrumentation.configuration.InstrumentationConfiguration
2
import com.avito.instrumentation.configuration.InstrumentationFilter.FromRunHistory
3
import com.avito.instrumentation.configuration.KubernetesViaCredentials
4
import com.avito.instrumentation.configuration.report.ReportConfig
5
import com.avito.instrumentation.reservation.request.Device
6
import com.avito.kotlin.dsl.getMandatoryStringProperty
7
import com.avito.kotlin.dsl.getOptionalStringProperty
8
import java.time.Duration
9

10
plugins {
11
    id("convention.kotlin-android-app")
12
    id("com.avito.android.instrumentation-tests")
13
}
14

15
android {
16

17
    namespace = "com.avito.android.ui"
18

19
    defaultConfig {
20
        versionName = "1.0"
21
        versionCode = 1
22
        testInstrumentationRunner = "com.avito.android.test.app.core.TestAppRunner"
23

24
        val instrumentationArgs = mapOf(
25
            "videoRecording" to "failed",
26
        )
27

28
        // These arguments are updated in IDE configuration only after sync!
29
        testInstrumentationRunnerArguments.putAll(instrumentationArgs)
30
    }
31

32
    testOptions {
33
        execution = "ANDROIDX_TEST_ORCHESTRATOR"
34
    }
35

36
    packagingOptions {
37
        resources.pickFirsts.add("META-INF/okhttp.kotlin_module")
38
    }
39
}
40

41
dependencies {
42
    implementation(libs.androidXtracing) {
43
        because("androidx libs bring 1.0.0 instead of 1.1.0")
44
        because("https://github.com/android/android-test/issues/1755")
45
    }
46
    implementation(libs.appcompat)
47
    implementation(libs.material)
48
    implementation(libs.playServicesBase)
49
    implementation(libs.recyclerView)
50
    implementation(libs.swipeRefreshLayout)
51

52
    implementation(project(":subprojects:android-lib:proxy-toast"))
53

54
    androidTestImplementation(project(":subprojects:test-runner:test-inhouse-runner"))
55
    androidTestImplementation(project(":subprojects:test-runner:test-report-android"))
56
    androidTestImplementation(project(":subprojects:test-runner:test-annotations"))
57
    androidTestImplementation(project(":subprojects:test-runner:report-viewer"))
58
    androidTestImplementation(project(":subprojects:android-test:ui-testing-core"))
59
    androidTestImplementation(project(":subprojects:android-test:toast-rule"))
60
    androidTestImplementation(project(":subprojects:common:truth-extensions"))
61

62
    androidTestUtil(libs.testOrchestrator)
63
}
64

65
val avitoRegistry = getOptionalStringProperty("avito.registry")
66

67
instrumentation {
68
    val reportKey = "avito.report.sender"
69
    val reportConfig = when (getOptionalStringProperty(reportKey, "noop")) {
70
        "noop" -> ReportConfig.NoOp
71
        "runner" -> ReportConfig.ReportViewer.SendFromRunner(
72
            reportApiUrl = getMandatoryStringProperty("avito.report.url"),
73
            reportViewerUrl = getMandatoryStringProperty("avito.report.viewerUrl"),
74
            fileStorageUrl = getMandatoryStringProperty("avito.fileStorage.url"),
75
            planSlug = "UiTestingCoreApp",
76
            jobSlug = "FunctionalTests"
77
        )
78

79
        else -> throw IllegalArgumentException("Invalid value for $reportKey property")
80
    }
81

82
    report.set(reportConfig)
83

84
    logcatTags = setOf(
85
        "UITestRunner:*",
86
        "ActivityManager:*",
87
        "ReportTestListener:*",
88
        "StorageJsonTransport:*",
89
        "TestReport:*",
90
        "VideoCaptureListener:*",
91
        "TestRunner:*",
92
        "SystemDialogsManager:*",
93
        "AndroidJUnitRunner:*",
94
        "ito.android.de:*", // по этому тэгу система пишет логи об использовании hidden/restricted api https://developer.android.com/distribute/best-practices/develop/restrictions-non-sdk-interfaces
95
        "*:E"
96
    )
97

98
    filters {
99
        register("ci") {
100
            fromSource.excludeFlaky = true
101
            fromRunHistory.excludePreviousStatuses(
102
                setOf(
103
                    FromRunHistory.RunStatus.Success,
104
                    FromRunHistory.RunStatus.Manual
105
                )
106
            )
107
        }
108

109
        register("local") {
110
            fromSource
111
        }
112
    }
113

114
    environments {
115
        register<KubernetesViaCredentials>("kubernetes") {
116
            token.set(getMandatoryStringProperty("kubernetesToken"))
117
            url.set(getMandatoryStringProperty("kubernetesUrl"))
118
            namespace.set(getMandatoryStringProperty("kubernetesNamespace"))
119
        }
120
    }
121

122
    experimental {
123
        useLegacyExtensionsV1Beta.set(false)
124
    }
125

126
    val defaultCpuRequest = "1.15"
127
    val defaultCpuLimit = "1.3"
128
    val defaultMemoryLimit = "4Gi"
129

130
    val emulator24 = Device.CloudEmulator(
131
        name = "api24",
132
        api = 24,
133
        model = "Android_SDK_built_for_x86",
134
        image = emulatorImage(24, "3a1f15409f37"),
135
        cpuCoresRequest = defaultCpuRequest,
136
        cpuCoresLimit = defaultCpuLimit,
137
        memoryLimit = defaultMemoryLimit
138
    )
139

140
    configurations {
141
        register("local") {
142
            filter = "local"
143
            targets {
144
                register("api34") {
145
                    deviceName = "API34"
146
                    scheduling {
147
                        quota {
148
                            retryCount = 1
149
                            minimumSuccessCount = 1
150
                        }
151
                        testsCountBasedReservation {
152
                            device = Device.LocalEmulator.device(34, "sdk_gphone64_x86_64")
153
                            maximum = 1
154
                            testsPerEmulator = 1
155
                        }
156
                    }
157
                }
158
            }
159
        }
160

161
        register(
162
            "PRCheck",
163
            instrumentationConfiguration(
164
                targetDevices = setOf(emulator24),
165
            )
166
        )
167
    }
168
}
169

170
fun instrumentationConfiguration(
171
    targetDevices: Set<Device>,
172
): Action<InstrumentationConfiguration> {
173
    return Action {
174
        testRunnerExecutionTimeout = Duration.ofMinutes(10)
175
        instrumentationTaskTimeout = Duration.ofMinutes(10)
176
        reportSkippedTests = true
177
        filter = "ci"
178

179
        targetDevices.forEach { targetDevice ->
180
            targets {
181
                register(targetDevice.name) {
182
                    scheduling {
183
                        deviceName = targetDevice.name
184

185
                        quota {
186
                            retryCount = 1
187
                            minimumSuccessCount = 1
188
                        }
189

190
                        testsCountBasedReservation {
191
                            device = targetDevice
192
                            minimum = 1
193
                            maximum = 5
194
                            testsPerEmulator = 12
195
                        }
196
                    }
197
                }
198
            }
199
        }
200
    }
201
}
202

203
fun emulatorImage(api: Int, label: String): String {
204
    return if (avitoRegistry != null) {
205
        "$avitoRegistry/android/emulator-hermetic-$api:$label"
206
    } else {
207
        "avitotech/android-emulator-$api:$label"
208
    }
209
}
210

211
val isLocalCheck = project.providers.gradleProperty("localCheck").getOrElse("false").toBoolean()
212

213
if (!isLocalCheck) {
214
    tasks.check {
215
        dependsOn(tasks.named("instrumentationPRCheckKubernetes"))
216
    }
217
}
218