feat(apple): macOS parsing

cli/build.gradle.kts

@@ -35,6 +35,7 @@ distributions {
 dependencies {
     implementation(project(":core"))
     implementation(project(":vendor:vendor-apple:ios"))
+    implementation(project(":vendor:vendor-apple:macos"))
     implementation(project(":vendor:vendor-android"))
     implementation(project(":analytics:usage"))
     implementation(Libraries.kotlinStdLib)

cli/src/main/kotlin/com/malinskiy/marathon/cli/ApplicationView.kt

@@ -21,6 +21,7 @@ import com.malinskiy.marathon.config.vendor.VendorConfiguration
 import com.malinskiy.marathon.di.marathonStartKoin
 import com.malinskiy.marathon.exceptions.ExceptionsReporterFactory
 import com.malinskiy.marathon.apple.ios.IosVendor
+import com.malinskiy.marathon.apple.macos.MacosVendor
 import com.malinskiy.marathon.log.MarathonLogging
 import org.koin.core.context.stopKoin
 import org.koin.dsl.module
@@ -71,6 +72,9 @@ private fun execute(cliConfiguration: CliConfiguration) {
             is VendorConfiguration.AndroidConfiguration -> {
                 AndroidVendor + module { single { vendorConfiguration } } + listOf(adamModule)
             }
+            is VendorConfiguration.MacosConfiguration -> {
+                MacosVendor + module { single { vendorConfiguration } }
+            }
             else -> throw ConfigurationException("No vendor config present in ${marathonStartConfiguration.marathonfile.absolutePath}")
         }
 

configuration/src/main/kotlin/com/malinskiy/marathon/config/vendor/VendorConfiguration.kt

@@ -13,20 +13,19 @@ import com.malinskiy.marathon.config.vendor.android.SerialStrategy
 import com.malinskiy.marathon.config.vendor.android.TestAccessConfiguration
 import com.malinskiy.marathon.config.vendor.android.TestParserConfiguration
 import com.malinskiy.marathon.config.vendor.android.ThreadingConfiguration
-import com.malinskiy.marathon.config.vendor.android.TimeoutConfiguration
 import com.malinskiy.marathon.config.vendor.apple.AppleTestBundleConfiguration
 import com.malinskiy.marathon.config.vendor.apple.ios.LifecycleConfiguration
 import com.malinskiy.marathon.config.vendor.apple.ios.PermissionsConfiguration
 import com.malinskiy.marathon.config.vendor.apple.RsyncConfiguration
 import com.malinskiy.marathon.config.vendor.apple.ios.SigningConfiguration
 import com.malinskiy.marathon.config.vendor.apple.SshConfiguration
+import com.malinskiy.marathon.config.vendor.apple.TimeoutConfiguration as AppleTimeoutConfiguration
 import com.malinskiy.marathon.config.vendor.apple.ios.XcresultConfiguration
 import java.io.File
+import com.malinskiy.marathon.config.vendor.android.TimeoutConfiguration as AndroidTimeoutConfiguration
 import com.malinskiy.marathon.config.vendor.apple.TestParserConfiguration as AppleTestParserConfiguration
 import com.malinskiy.marathon.config.vendor.apple.ios.ScreenRecordConfiguration as IosScreenRecordConfiguration
 import com.malinskiy.marathon.config.vendor.apple.ThreadingConfiguration as AppleThreadingConfiguration
-import com.malinskiy.marathon.config.vendor.apple.ios.TimeoutConfiguration as IosTimeoutConfiguration
-import com.malinskiy.marathon.config.vendor.apple.macos.TimeoutConfiguration as MacosTimeoutConfiguration1
 
 const val DEFAULT_INIT_TIMEOUT_MILLIS = 30_000
 const val DEFAULT_AUTO_GRANT_PERMISSION = false
@@ -66,7 +65,7 @@ sealed class VendorConfiguration {
         @JsonProperty("screenRecordConfiguration") val screenRecordConfiguration: ScreenRecordConfiguration = ScreenRecordConfiguration(),
         @JsonProperty("waitForDevicesTimeoutMillis") val waitForDevicesTimeoutMillis: Long = DEFAULT_WAIT_FOR_DEVICES_TIMEOUT,
         @JsonProperty("allureConfiguration") val allureConfiguration: AllureConfiguration = AllureConfiguration(),
-        @JsonProperty("timeoutConfiguration") val timeoutConfiguration: TimeoutConfiguration = TimeoutConfiguration(),
+        @JsonProperty("timeoutConfiguration") val timeoutConfiguration: AndroidTimeoutConfiguration = AndroidTimeoutConfiguration(),
         @JsonProperty("fileSyncConfiguration") val fileSyncConfiguration: FileSyncConfiguration = FileSyncConfiguration(),
         @JsonProperty("threadingConfiguration") val threadingConfiguration: ThreadingConfiguration = ThreadingConfiguration(),
         @JsonProperty("testParserConfiguration") val testParserConfiguration: TestParserConfiguration = TestParserConfiguration.LocalTestParserConfiguration,
@@ -114,7 +113,7 @@ sealed class VendorConfiguration {
         var screenRecordConfiguration: ScreenRecordConfiguration = ScreenRecordConfiguration()
         var waitForDevicesTimeoutMillis: Long = DEFAULT_WAIT_FOR_DEVICES_TIMEOUT
         var allureConfiguration: AllureConfiguration = AllureConfiguration()
-        var timeoutConfiguration: TimeoutConfiguration = TimeoutConfiguration()
+        var timeoutConfiguration: AndroidTimeoutConfiguration = AndroidTimeoutConfiguration()
         var fileSyncConfiguration: FileSyncConfiguration = FileSyncConfiguration()
         var threadingConfiguration: ThreadingConfiguration = ThreadingConfiguration()
         var testParserConfiguration: TestParserConfiguration = TestParserConfiguration.LocalTestParserConfiguration
@@ -159,7 +158,7 @@ sealed class VendorConfiguration {
         @JsonProperty("xctestrunEnv") val xctestrunEnv: Map<String, String> = emptyMap(),
         @JsonProperty("lifecycle") val lifecycleConfiguration: LifecycleConfiguration = LifecycleConfiguration(),
         @JsonProperty("permissions") val permissions: PermissionsConfiguration = PermissionsConfiguration(),
-        @JsonProperty("timeoutConfiguration") val timeoutConfiguration: IosTimeoutConfiguration = IosTimeoutConfiguration(),
+        @JsonProperty("timeoutConfiguration") val timeoutConfiguration: AppleTimeoutConfiguration = AppleTimeoutConfiguration(),
         @JsonProperty("threadingConfiguration") val threadingConfiguration: AppleThreadingConfiguration = AppleThreadingConfiguration(),
         @JsonProperty("hideRunnerOutput") val hideRunnerOutput: Boolean = false,
         @JsonProperty("compactOutput") val compactOutput: Boolean = false,
@@ -185,7 +184,7 @@ sealed class VendorConfiguration {
 
         @JsonProperty("xcresult") val xcresult: XcresultConfiguration = XcresultConfiguration(),
         @JsonProperty("xctestrunEnv") val xctestrunEnv: Map<String, String> = emptyMap(),
-        @JsonProperty("timeoutConfiguration") val timeoutConfiguration: MacosTimeoutConfiguration1 = MacosTimeoutConfiguration1(),
+        @JsonProperty("timeoutConfiguration") val timeoutConfiguration: AppleTimeoutConfiguration = AppleTimeoutConfiguration(),
         @JsonProperty("threadingConfiguration") val threadingConfiguration: AppleThreadingConfiguration = AppleThreadingConfiguration(),
         @JsonProperty("hideRunnerOutput") val hideRunnerOutput: Boolean = false,
         @JsonProperty("compactOutput") val compactOutput: Boolean = false,

configuration/src/main/kotlin/com/malinskiy/marathon/config/vendor/apple/ios/TimeoutConfiguration.kt → configuration/src/main/kotlin/com/malinskiy/marathon/config/vendor/apple/TimeoutConfiguration.kt

@@ -1,4 +1,4 @@
-package com.malinskiy.marathon.config.vendor.apple.ios
+package com.malinskiy.marathon.config.vendor.apple
 
 import com.fasterxml.jackson.annotation.JsonProperty
 import java.time.Duration

vendor/vendor-apple/base/src/main/kotlin/com/malinskiy/marathon/apple/AppleApplicationInstaller.kt

@@ -24,7 +24,8 @@ open class AppleApplicationInstaller<in T: AppleDevice>(
         val xcresultConfiguration = vendorConfiguration.xcresultConfiguration() ?: throw IllegalArgumentException("No xcresult configuration provided")
         val xctest = bundleConfiguration?.xctest ?: throw IllegalArgumentException("No test bundle provided")
         val app = bundleConfiguration.app
-        val bundle = AppleTestBundle(app, xctest)
+        val bundle = AppleTestBundle(app, xctest, device.sdk)
+        val relativeTestBinaryPath = bundle.relativeTestBinaryPath
 
         logger.debug { "Moving xctest to ${device.serialNumber}" }
         val remoteXctest = device.remoteFileManager.remoteXctestFile()
@@ -37,22 +38,12 @@ open class AppleApplicationInstaller<in T: AppleDevice>(
         }
         logger.debug { "Generating test root for ${device.serialNumber}" }
 
-        val possibleTestBinaries = xctest.listFiles()?.filter { it.isFile && it.extension == "" }
-            ?: throw ConfigurationException("missing test binaries in xctest folder at $xctest")
-        val testBinary = when (possibleTestBinaries.size) {
-            0 -> throw ConfigurationException("missing test binaries in xctest folder at $xctest")
-            1 -> possibleTestBinaries[0]
-            else -> {
-                logger.warn { "Multiple test binaries present in xctest folder" }
-                possibleTestBinaries.find { it.name == xctest.nameWithoutExtension } ?: possibleTestBinaries.first()
-            }
-        }
-        val remoteTestBinary = device.remoteFileManager.joinPath(remoteXctest, testBinary.name)
+        val testBinary = bundle.testBinary
+        val remoteTestBinary = device.remoteFileManager.joinPath(remoteXctest, *relativeTestBinaryPath, testBinary.name)
         val testType = getTestTypeFor(device, device.sdk, remoteTestBinary)
         TestRootFactory(device, xctestrunEnv, xcresultConfiguration).generate(testType, bundle, useXctestParser)
         afterInstall(device as T)
 
-
         bundleConfiguration.extraApplications?.forEach {
             if (it.isDirectory && it.extension == "app") {
                 logger.debug { "Installing extra application $it to ${device.serialNumber}" }

vendor/vendor-apple/base/src/main/kotlin/com/malinskiy/marathon/apple/AppleLogConfigurator.kt

@@ -7,7 +7,6 @@ import ch.qos.logback.classic.PatternLayout
 import ch.qos.logback.classic.spi.ILoggingEvent
 import ch.qos.logback.core.ConsoleAppender
 import ch.qos.logback.core.encoder.LayoutWrappingEncoder
-import com.malinskiy.marathon.config.vendor.VendorConfiguration
 import com.malinskiy.marathon.log.MarathonLogConfigurator
 import com.malinskiy.marathon.report.timeline.TimelineSummaryProvider
 import net.schmizz.sshj.DefaultConfig
@@ -16,11 +15,10 @@ import net.schmizz.sshj.transport.kex.Curve25519SHA256
 import net.schmizz.sshj.transport.random.BouncyCastleRandom
 import org.slf4j.LoggerFactory
 
-class AppleLogConfigurator(private val vendorConfiguration: VendorConfiguration.IOSConfiguration) : MarathonLogConfigurator {
+class AppleLogConfigurator(private val compactOutput: Boolean) : MarathonLogConfigurator {
     override fun configure() {
         val loggerContext = LoggerFactory.getILoggerFactory() as LoggerContext
 
-        val compactOutput = vendorConfiguration.compactOutput
         val layout = PatternLayout()
         layout.pattern = if (compactOutput) {
             "%highlight(%.-1level [%thread] <%logger{48}> %msg%n)"

vendor/vendor-apple/base/src/main/kotlin/com/malinskiy/marathon/apple/NmTestParser.kt

@@ -1,6 +1,6 @@
 package com.malinskiy.marathon.apple
 
-import com.malinskiy.marathon.apple.extensions.testBundle
+import com.malinskiy.marathon.apple.extensions.bundleConfiguration
 import com.malinskiy.marathon.apple.model.AppleTestBundle
 import com.malinskiy.marathon.config.Configuration
 import com.malinskiy.marathon.config.exceptions.ConfigurationException
@@ -25,10 +25,13 @@ class NmTestParser(
     private val logger = MarathonLogging.logger(NmTestParser::class.java.simpleName)
 
     override suspend fun extract(device: Device): List<Test> {
-        val bundle = vendorConfiguration.testBundle()
         return withRetry(3, 0) {
             try {
                 val device = device as? AppleDevice ?: throw ConfigurationException("Unexpected device type for remote test parsing")
+                val bundleConfiguration = vendorConfiguration.bundleConfiguration()
+                val xctest = bundleConfiguration?.xctest ?: throw IllegalArgumentException("No test bundle provided")
+                val app = bundleConfiguration.app
+                val bundle = AppleTestBundle(app, xctest, device.sdk)
                 return@withRetry parseTests(device, bundle)
             } catch (e: CancellationException) {
                 throw e
@@ -44,6 +47,7 @@ class NmTestParser(
         bundle: AppleTestBundle,
     ): List<Test> {
         val testBinary = bundle.testBinary
+        val relativeTestBinaryPath = bundle.relativeTestBinaryPath
         val xctest = bundle.testApplication
 
         logger.debug { "Found test binary $testBinary for xctest $xctest" }
@@ -54,7 +58,7 @@ class NmTestParser(
         if (!device.pushFile(xctest, remoteXctest)) {
             throw TestParsingException("failed to push xctest for test parsing")
         }
-        val remoteTestBinary = device.remoteFileManager.joinPath(remoteXctest, testBinary.name)
+        val remoteTestBinary = device.remoteFileManager.joinPath(remoteXctest, *relativeTestBinaryPath, testBinary.name)
 
         val rawSwiftTests = device.binaryEnvironment.nm.swiftTests(remoteTestBinary)
         val swiftTests = rawSwiftTests.map { it.trim().split('.') }

vendor/vendor-apple/base/src/main/kotlin/com/malinskiy/marathon/apple/RemoteFileManager.kt

@@ -136,6 +136,8 @@ class RemoteFileManager(private val device: AppleDevice) {
         )
     }
 
+    private fun String.bashEscape() = "'" + replace("'", "'\\''") + "'"
+
     companion object {
         const val FILE_SEPARATOR = "/"
     }

vendor/vendor-apple/base/src/main/kotlin/com/malinskiy/marathon/apple/XCTestParser.kt

@@ -1,7 +1,6 @@
 package com.malinskiy.marathon.apple
 
 import com.malinskiy.marathon.apple.extensions.bundleConfiguration
-import com.malinskiy.marathon.apple.extensions.testBundle
 import com.malinskiy.marathon.apple.model.AppleTestBundle
 import com.malinskiy.marathon.apple.test.TestEvent
 import com.malinskiy.marathon.apple.test.TestRequest
@@ -23,7 +22,7 @@ import kotlin.io.path.outputStream
 
 class XCTestParser<T: AppleDevice>(
     private val configuration: Configuration,
-    private val vendorConfiguration: VendorConfiguration.IOSConfiguration,
+    private val vendorConfiguration: VendorConfiguration.MacosConfiguration,
     private val testBundleIdentifier: AppleTestBundleIdentifier,
     private val applicationInstaller: AppleApplicationInstaller<T>,
 ) : RemoteTestParser<DeviceProvider>, LineListener {
@@ -34,7 +33,11 @@ class XCTestParser<T: AppleDevice>(
             try {
                 val device =
                     device as? T ?: throw ConfigurationException("Unexpected device type for remote test parsing")
-                return@withRetry parseTests(device, configuration, vendorConfiguration, applicationInstaller)
+                val bundleConfiguration = vendorConfiguration.bundleConfiguration()
+                val xctest = bundleConfiguration?.xctest ?: throw IllegalArgumentException("No test bundle provided")
+                val app = bundleConfiguration.app
+                val bundle = AppleTestBundle(app, xctest, device.sdk)
+                return@withRetry parseTests(device, bundle, applicationInstaller)
             } catch (e: CancellationException) {
                 throw e
             } catch (e: Exception) {
@@ -46,13 +49,12 @@ class XCTestParser<T: AppleDevice>(
 
     private suspend fun parseTests(
         device: AppleDevice,
-        configuration: Configuration,
-        vendorConfiguration: VendorConfiguration,
+        bundle: AppleTestBundle,
         applicationInstaller: AppleApplicationInstaller<T>,
     ): List<Test> {
         applicationInstaller.prepareInstallation(device, useXctestParser = true)
 
-        val platform = "iPhoneSimulator"
+        val platform = device.sdk.platformName
         val dylib = javaClass.getResourceAsStream("/libxctest-parser/$platform/libxctest-parser.dylib")
         val tempFile = kotlin.io.path.createTempFile().apply {
             outputStream().use {
@@ -86,11 +88,12 @@ class XCTestParser<T: AppleDevice>(
                     when (event) {
                         is TestStarted -> {
                             //Target name is never printed via xcodebuild. We create it using the bundle id in com.malinskiy.marathon.ios.xctestrun.TestRootFactory
-                            val testWithTargetName = event.id.copy(pkg = vendorConfiguration.testBundle().testBundleId)
+                            val testWithTargetName = event.id.copy(pkg = bundle.testBundleId)
                             tests.add(testWithTargetName)
                         }
                         else -> Unit
                     }
+
                 }
             }
 
@@ -104,25 +107,12 @@ class XCTestParser<T: AppleDevice>(
             device.removeLineListener(this)
         }
 
-        val xctest = vendorConfiguration.bundleConfiguration()?.xctest ?: throw IllegalArgumentException("No test bundle provided")
-        val possibleTestBinaries = xctest.listFiles()?.filter { it.isFile && it.extension == "" }
-            ?: throw ConfigurationException("missing test binaries in xctest folder at $xctest")
-        val testBinary = when (possibleTestBinaries.size) {
-            0 -> throw ConfigurationException("missing test binaries in xctest folder at $xctest")
-            1 -> possibleTestBinaries[0]
-            else -> {
-                logger.warn { "Multiple test binaries present in xctest folder" }
-                possibleTestBinaries.find { it.name == xctest.nameWithoutExtension } ?: possibleTestBinaries.first()
-            }
-        }
-
         if (tests.size == 0) {
             logger.warn { "XCTestParser failed to parse tests. xcodebuild output:" + System.lineSeparator() + "$lineBuffer" }
         }
 
-        val testBundle = AppleTestBundle(vendorConfiguration.bundleConfiguration()?.app, xctest)
         val result = tests.toList()
-        result.forEach { testBundleIdentifier.put(it, testBundle) }
+        result.forEach { testBundleIdentifier.put(it, bundle) }
 
         return result
     }

vendor/vendor-apple/base/src/main/kotlin/com/malinskiy/marathon/apple/bin/AppleBinaryEnvironment.kt

@@ -3,29 +3,34 @@ package com.malinskiy.marathon.apple.bin
 import com.google.gson.Gson
 import com.malinskiy.marathon.apple.bin.codesign.Codesign
 import com.malinskiy.marathon.apple.bin.getconf.Getconf
+import com.malinskiy.marathon.apple.bin.ioreg.Ioreg
 import com.malinskiy.marathon.apple.bin.lipo.Lipo
 import com.malinskiy.marathon.apple.bin.nm.Nm
 import com.malinskiy.marathon.apple.bin.plistbuddy.PlistBuddy
+import com.malinskiy.marathon.apple.bin.swvers.SwVers
+import com.malinskiy.marathon.apple.bin.systemprofiler.SystemProfiler
 import com.malinskiy.marathon.apple.bin.xcodeselect.Xcodeselect
 import com.malinskiy.marathon.apple.bin.xcrun.Xcrun
 import com.malinskiy.marathon.apple.cmd.CommandExecutor
 import com.malinskiy.marathon.config.Configuration
 import com.malinskiy.marathon.config.vendor.VendorConfiguration
+import com.malinskiy.marathon.config.vendor.apple.TimeoutConfiguration
 
 class AppleBinaryEnvironment(
     commandExecutor: CommandExecutor,
     configuration: Configuration,
-    vendorConfiguration: VendorConfiguration.IOSConfiguration,
+    timeoutConfiguration: TimeoutConfiguration,
     gson: Gson
 ) {
-    private val timeoutConfiguration = vendorConfiguration.timeoutConfiguration
-
     val codesign: Codesign = Codesign(commandExecutor, timeoutConfiguration)
     val getconf: Getconf =
         Getconf(commandExecutor, timeoutConfiguration)
     val lipo: Lipo = Lipo(commandExecutor, timeoutConfiguration)
     val nm: Nm = Nm(commandExecutor, timeoutConfiguration)
     val plistBuddy = PlistBuddy(commandExecutor, timeoutConfiguration)
     val xcodeselect: Xcodeselect = Xcodeselect(commandExecutor, timeoutConfiguration)
-    val xcrun: Xcrun = Xcrun(commandExecutor, configuration, vendorConfiguration, gson)
+    val ioreg: Ioreg = Ioreg(commandExecutor, timeoutConfiguration)
+    val systemProfiler: SystemProfiler = SystemProfiler(commandExecutor, timeoutConfiguration)
+    val swvers: SwVers = SwVers(commandExecutor, timeoutConfiguration)
+    val xcrun: Xcrun = Xcrun(commandExecutor, configuration, timeoutConfiguration, gson)
 }

vendor/vendor-apple/base/src/main/kotlin/com/malinskiy/marathon/apple/bin/codesign/Codesign.kt

@@ -2,7 +2,7 @@ package com.malinskiy.marathon.apple.bin.codesign
 
 import com.malinskiy.marathon.apple.cmd.CommandExecutor
 import com.malinskiy.marathon.apple.cmd.CommandResult
-import com.malinskiy.marathon.config.vendor.apple.ios.TimeoutConfiguration
+import com.malinskiy.marathon.config.vendor.apple.TimeoutConfiguration
 import com.malinskiy.marathon.exceptions.DeviceSetupException
 import java.time.Duration