avito-android

1
package com.avito.instrumentation
2

3
import com.android.build.api.variant.AndroidComponentsExtension
4
import com.android.build.gradle.BasePlugin
5
import com.avito.android.stats.statsdConfig
6
import com.avito.instrumentation.configuration.InstrumentationConfiguration
7
import com.avito.instrumentation.configuration.InstrumentationFilter
8
import com.avito.instrumentation.configuration.InstrumentationTestsPluginExtension
9
import com.avito.instrumentation.configuration.KubernetesViaContext
10
import com.avito.instrumentation.configuration.KubernetesViaCredentials
11
import com.avito.instrumentation.configuration.LocalAdb
12
import com.avito.instrumentation.internal.ConfiguratorsFactory
13
import com.avito.instrumentation.internal.ExtensionCorrectnessChecker
14
import com.avito.instrumentation.internal.InstrumentationTaskConfigurator
15
import com.avito.instrumentation.internal.TaskValidatorsFactory
16
import com.avito.kotlin.dsl.getBooleanProperty
17
import com.avito.kotlin.dsl.getMandatoryLongProperty
18
import com.avito.utils.buildFailer
19
import org.gradle.api.Plugin
20
import org.gradle.api.Project
21
import org.gradle.kotlin.dsl.create
22
import org.gradle.kotlin.dsl.register
23
import org.gradle.kotlin.dsl.withType
24
import java.time.Duration
25

26
public class InstrumentationTestsPlugin : Plugin<Project> {
27

28
    override fun apply(project: Project) {
29
        val extension = project.createInstrumentationPluginExtension()
30

31
        // cache enabled only on pr's
32
        val buildCacheEnabled = project.getBooleanProperty(
33
            name = "avito.instrumentation.buildCacheEnabled",
34
            default = false,
35
        )
36

37
        val factory = ConfiguratorsFactory(project, extension, buildCacheEnabled)
38

39
        val filtersFactory = TaskValidatorsFactory()
40

41
        val extensionCorrectnessChecker = ExtensionCorrectnessChecker(extension)
42

43
        project.plugins.withType<BasePlugin> {
44

45
            val androidComponents = project.extensions.getByType(AndroidComponentsExtension::class.java)
46

47
            androidComponents.finalizeDsl { androidExtension ->
48
                factory.setupLocalInstrumentationArgsUseCase.setupLocalRunParams(androidExtension)
49
            }
50

51
            extension.configurationsContainer.all { configuration ->
52

53
                extension.environmentsContainer.all { environment ->
54

55
                    // todo how to write "only testBuildType" selector?
56

57
                    androidComponents.onVariants { variant ->
58

59
                        extensionCorrectnessChecker.check(variant)
60

61
                        val configurators = factory.createTaskConfigurators(
62
                            configuration = configuration,
63
                            environment = environment,
64
                            variant = variant
65
                        )
66

67
                        val filters = filtersFactory.create()
68

69
                        if (configurators != null && filters.all { it.filter(configuration, environment) }) {
70

71
                            project.tasks.register(
72
                                instrumentationTaskName(
73
                                    configuration = configuration.name,
74
                                    environment = environment.name,
75
                                    flavor = variant.flavorName
76
                                ),
77
                                configureInstrumentationTask(
78
                                    configurators = configurators,
79
                                    configuration = configuration,
80
                                    extension = extension,
81
                                )
82
                            )
83
                        }
84
                    }
85
                }
86
            }
87
        }
88
    }
89

90
    private fun configureInstrumentationTask(
91
        configurators: List<InstrumentationTaskConfigurator>,
92
        configuration: InstrumentationConfiguration,
93
        extension: InstrumentationTestsPluginExtension,
94
    ): InstrumentationTestsTask.() -> Unit {
95
        return {
96
            timeout.set(configuration.instrumentationTaskTimeout)
97
            group = CI_TASK_GROUP
98

99
            projectName.set(project.name)
100
            statsDConfig.set(project.statsdConfig)
101
            buildFailer.set(project.buildFailer)
102
            gradleTestKitRun.set(project.getBooleanProperty("isGradleTestKitRun"))
103
            logcatTags.set(extension.logcatTags)
104
            enableDeviceDebug.set(configuration.enableDeviceDebug)
105
            kubernetesHttpTries.set(extension.kubernetesHttpTries.convention(3))
106
            adbPullTimeout.set(
107
                Duration.ofSeconds(
108
                    extension.adbPullTimeoutSeconds.getOrElse(
109
                        project.getMandatoryLongProperty("avito.device.adbPullTimeoutSeconds")
110
                    )
111
                )
112
            )
113

114
            configurators.forEach {
115
                it.configure(this)
116
            }
117
        }
118
    }
119

120
    private fun Project.createInstrumentationPluginExtension(): InstrumentationTestsPluginExtension {
121
        val extension = extensions.create<InstrumentationTestsPluginExtension>("instrumentation")
122

123
        extension.filters.register("default") {
124
            it.fromRunHistory.excludePreviousStatuses(
125
                setOf(
126
                    InstrumentationFilter.FromRunHistory.RunStatus.Manual,
127
                    InstrumentationFilter.FromRunHistory.RunStatus.Success
128
                )
129
            )
130
        }
131

132
        extension.environmentsContainer.registerFactory(KubernetesViaCredentials::class.java) {
133
            project.objects.newInstance(KubernetesViaCredentials::class.java, it)
134
        }
135
        extension.environmentsContainer.registerFactory(KubernetesViaContext::class.java) {
136
            project.objects.newInstance(KubernetesViaContext::class.java, it)
137
        }
138
        extension.environmentsContainer.registerFactory(LocalAdb::class.java) {
139
            project.objects.newInstance(LocalAdb::class.java, it)
140
        }
141

142
        extension.environmentsContainer.register<LocalAdb>("local")
143

144
        return extension
145
    }
146
}
147