flank/test_runner/src/main/kotlin/ftl/args/IosArgs.kt at 51a2fa590af23f152308391b20549d01b2f30558 · sravanmedarapu/flank · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
package ftl.args

import ftl.args.ArgsHelper.assertFileExists
import ftl.args.ArgsHelper.assertGcsFileExists
import ftl.args.ArgsHelper.evaluateFilePath
import ftl.args.ArgsHelper.mergeYmlMaps
import ftl.args.ArgsHelper.validateTestMethods
import ftl.args.ArgsHelper.yamlMapper
import ftl.args.ArgsToString.devicesToString
import ftl.args.ArgsToString.listToString
import ftl.args.yml.FlankYml
import ftl.args.yml.GcloudYml
import ftl.args.yml.IosFlankYml
import ftl.args.yml.IosGcloudYml
import ftl.config.Device
import ftl.config.FtlConstants
import ftl.ios.IosCatalog
import ftl.ios.Xctestrun
import ftl.util.Utils
import java.nio.file.Files
import java.nio.file.Path

class IosArgs(
    gcloudYml: GcloudYml,
    iosGcloudYml: IosGcloudYml,
    flankYml: FlankYml,
    iosFlankYml: IosFlankYml,
    override val data: String
) : IArgs {

    private val gcloud = gcloudYml.gcloud
    override val resultsBucket = gcloud.resultsBucket
    override val recordVideo = gcloud.recordVideo
    override val testTimeout = gcloud.timeout
    override val async = gcloud.async
    override val projectId = gcloud.project
    override val resultsHistoryName = gcloud.resultsHistoryName

    private val iosGcloud = iosGcloudYml.gcloud
    var xctestrunZip = iosGcloud.test
    var xctestrunFile = iosGcloud.xctestrunFile
    val xcodeVersion = iosGcloud.xcodeVersion
    val devices = iosGcloud.device

    private val flank = flankYml.flank
    override val testShards = flank.testShards
    override val repeatTests = flank.repeatTests
    override val testTargetsAlwaysRun = flank.testTargetsAlwaysRun

    private val iosFlank = iosFlankYml.flank
    val testTargets = iosFlank.testTargets

    // computed properties not specified in yaml
    override val testShardChunks: List<List<String>> by lazy {
        val validTestMethods = Xctestrun.findTestNames(xctestrunFile)
        validateTestMethods(testTargets, validTestMethods, "xctest binary")
        val testsToShard = if (testTargets.isEmpty()) {
            validTestMethods
        } else {
            testTargets
        }

        ArgsHelper.calculateShards(
            testMethodsToShard = testsToShard,
            testMethodsAlwaysRun = testTargetsAlwaysRun,
            testShards = testShards
            )
    }

    init {
        if (xctestrunZip.startsWith(FtlConstants.GCS_PREFIX)) {
            assertGcsFileExists(xctestrunZip)
        } else {
            xctestrunZip = evaluateFilePath(xctestrunZip)
            assertFileExists(xctestrunZip, "xctestrunZip")
        }
        xctestrunFile = evaluateFilePath(xctestrunFile)
        assertFileExists(xctestrunFile, "xctestrunFile")

        devices.forEach { device -> assertDeviceSupported(device) }
        assertXcodeSupported(xcodeVersion)
    }

    private fun assertXcodeSupported(xcodeVersion: String?) {
        if (xcodeVersion == null) return
        if (!IosCatalog.supportedXcode(xcodeVersion)) {
            Utils.fatalError(("Xcode $xcodeVersion is not a supported Xcode version"))
        }
    }

    private fun assertDeviceSupported(device: Device) {
        if (!IosCatalog.supportedDevice(device.model, device.version)) {
            Utils.fatalError("iOS ${device.version} on ${device.model} is not a supported device")
        }
    }

    override fun toString(): String {
        return """
IosArgs
    gcloud:
      results-bucket: $resultsBucket
      record-video: $recordVideo
      timeout: $testTimeout
      async: $async
      project: $projectId
      results-history-name: $resultsHistoryName
      # iOS gcloud
      test: $xctestrunZip
      xctestrun-file: $xctestrunFile
      xcode-version: $xcodeVersion
      device:
${devicesToString(devices)}

    flank:
      testShards: $testShards
      repeatTests: $repeatTests
      test-targets-always-run:
${listToString(testTargetsAlwaysRun)}
      # iOS flank
      test-targets:
${listToString(testTargets)}
    """.trimIndent()
    }

    companion object : IArgsCompanion {
        override val validArgs by lazy {
            mergeYmlMaps(GcloudYml, IosGcloudYml, FlankYml, IosFlankYml)
        }

        fun load(data: Path): IosArgs = IosArgs.load(String(Files.readAllBytes(data)))

        fun load(data: String): IosArgs {
            val flankYml = yamlMapper.readValue(data, FlankYml::class.java)
            val iosFlankYml = yamlMapper.readValue(data, IosFlankYml::class.java)
            val gcloudYml = yamlMapper.readValue(data, GcloudYml::class.java)
            val iosGcloudYml = yamlMapper.readValue(data, IosGcloudYml::class.java)

            return IosArgs(
                gcloudYml,
                iosGcloudYml,
                flankYml,
                iosFlankYml,
                data
            )
        }
    }
}