avito-android

1
package com.avito.plugin
2

3
import com.avito.http.HttpCodes
4
import com.avito.test.gradle.TestProjectGenerator
5
import com.avito.test.gradle.TestResult
6
import com.avito.test.gradle.gradlew
7
import com.avito.test.gradle.module.AndroidAppModule
8
import com.avito.test.gradle.plugin.plugins
9
import com.avito.test.http.MockWebServerFactory
10
import com.google.common.truth.Truth.assertThat
11
import okhttp3.mockwebserver.MockResponse
12
import org.junit.jupiter.api.AfterEach
13
import org.junit.jupiter.api.DynamicTest
14
import org.junit.jupiter.api.DynamicTest.dynamicTest
15
import org.junit.jupiter.api.TestFactory
16
import org.junit.jupiter.api.io.TempDir
17
import java.io.File
18

19
internal class QAppsPluginIntegrationTest {
20

21
    private val mockWebServer = MockWebServerFactory.create()
22

23
    @AfterEach
24
    fun teardown() {
25
        mockWebServer.shutdown()
26
    }
27

28
    private data class TestCase(
29
        val releaseBuildVariants: List<String>,
30
        val releaseChain: Boolean,
31
        val expectedReleaseChain: Boolean
32
    )
33

34
    @TestFactory
35
    fun uploadApkIntegration(@TempDir tempPath: File): Collection<DynamicTest> {
36
        return listOf(
37
            TestCase(
38
                releaseBuildVariants = listOf("debug"),
39
                releaseChain = false,
40
                expectedReleaseChain = false,
41
            ),
42
            TestCase(
43
                releaseBuildVariants = listOf("debug"),
44
                releaseChain = true,
45
                expectedReleaseChain = true,
46
            ),
47
            TestCase(
48
                releaseBuildVariants = emptyList(),
49
                releaseChain = true,
50
                expectedReleaseChain = false,
51
            ),
52
            TestCase(
53
                releaseBuildVariants = emptyList(),
54
                releaseChain = false,
55
                expectedReleaseChain = false,
56
            ),
57
        ).flatMap { testCase ->
58
            prepareProject(tempPath, testCase)
59

60
            val runResult = runUpload(tempPath)
61

62
            val testCollection = mutableListOf<DynamicTest>()
63

64
            testCollection += dynamicTest("build is successful") {
65
                runResult.assertThat().buildSuccessful()
66
            }
67

68
            val request = mockWebServer.takeRequest()
69

70
            testCollection += dynamicTest("request path is correct") {
71
                assertThat(request.path).isEqualTo("/qapps/api/os/android/upload")
72
            }
73

74
            val body = request.body.readUtf8()
75

76
            testCollection += listOf(
77
                "branch" to "My-feature-branch",
78
                "comment" to "my awesome apk",
79
                "version_code" to "111",
80
                "version_name" to "12.3",
81
                "package_name" to "com.qapps.app",
82
                "release_chain" to testCase.expectedReleaseChain.toString()
83
            )
84
                .map { (key, value) ->
85
                    dynamicTest("param $key passed with correct value") {
86
                        assertThat(body).containsMatch(multipartBodyFormData(key, value))
87
                    }
88
                }
89

90
            testCollection
91
        }
92
    }
93

94
    private fun multipartBodyFormData(key: String, value: String) =
95
        Regex("Content-Disposition: form-data; name=\"$key\"[\\s]+Content-Length: [0-9]+[\\s]+$value")
96
            .toPattern()
97

98
    private fun runUpload(projectDir: File): TestResult {
99
        mockWebServer.enqueue(MockResponse().setResponseCode(HttpCodes.OK))
100

101
        return gradlew(
102
            projectDir,
103
            "-Pavito.build=local",
104
            "-Pavito.git.state=local",
105
            ":app:qappsUploadUnsignedDebug",
106
            expectFailure = false
107
        )
108
    }
109

110
    private fun prepareProject(
111
        projectDir: File,
112
        testCase: QAppsPluginIntegrationTest.TestCase,
113
    ) {
114
        val releaseBuildVariants = testCase.releaseBuildVariants
115
            .joinToString(separator = ",") {
116
                "\"$it\""
117
            }
118

119
        TestProjectGenerator(
120
            modules = listOf(
121
                AndroidAppModule(
122
                    "app",
123
                    enableKotlinAndroidPlugin = false,
124
                    imports = listOf(
125
                        "import com.avito.plugin.qappsUploadUnsignedTaskProvider",
126
                        "import com.avito.plugin.QAppsUploadTask"
127
                    ),
128
                    plugins = plugins {
129
                        id("com.avito.android.qapps")
130
                    },
131
                    versionCode = 111,
132
                    versionName = "12.3",
133
                    packageName = "com.qapps.app",
134
                    buildGradleExtra = """
135
                         qapps {
136
                            serviceUrl.set("${mockWebServer.url("/")}")
137
                            branchName.set("My-feature-branch")
138
                            comment.set("my awesome apk")
139
                            releaseBuildVariants.set(listOf($releaseBuildVariants))
140
                         }
141
                         tasks.withType<QAppsUploadTask>().configureEach {
142
                            releaseChain.set(${testCase.releaseChain})
143
                         }
144
                         afterEvaluate {
145
                            tasks.qappsUploadUnsignedTaskProvider("debug").configure {
146
                                apkDirectory.set(file("${'$'}buildDir/outputs/apk/debug"))
147
                            }
148
                         }
149
                    """.trimIndent(),
150
                    useKts = true
151
                )
152
            )
153
        ).generateIn(projectDir)
154

155
        val apkDirectory = File(projectDir, "app/build/outputs/apk/debug")
156
        apkDirectory.mkdirs()
157

158
        val apk = File(apkDirectory, "app-debug.apk")
159
        apk.createNewFile()
160
        apk.writeText("stub apk content")
161
    }
162
}
163