fastlane_hotfix 2.165.0

data/fastlane/swift/Screengrabfile.swift

@@ -0,0 +1,20 @@
+// Screengrabfile.swift
+// Copyright (c) 2020 FastlaneTools
+
+// This class is automatically included in FastlaneRunner during build
+
+// This autogenerated file will be overwritten or replaced during build time, or when you initialize `screengrab`
+//
+//  ** NOTE **
+//  This file is provided by fastlane and WILL be overwritten in future updates
+//  If you want to add extra functionality to this project, create a new file in a
+//  new group so that it won't be marked for upgrade
+//
+
+public class Screengrabfile: ScreengrabfileProtocol {
+    // If you want to enable `screengrab`, run `fastlane screengrab init`
+    // After, this file will be replaced with a custom implementation that contains values you supplied
+    // during the `init` process, and you won't see this message
+}
+
+// Generated with fastlane 2.165.0

data/fastlane/swift/ScreengrabfileProtocol.swift

@@ -0,0 +1,99 @@
+// ScreengrabfileProtocol.swift
+// Copyright (c) 2020 FastlaneTools
+
+public protocol ScreengrabfileProtocol: class {
+    /// Path to the root of your Android SDK installation, e.g. ~/tools/android-sdk-macosx
+    var androidHome: String? { get }
+
+    /// The Android build tools version to use, e.g. '23.0.2'
+    var buildToolsVersion: String? { get }
+
+    /// A list of locales which should be used
+    var locales: [String] { get }
+
+    /// Enabling this option will automatically clear previously generated screenshots before running screengrab
+    var clearPreviousScreenshots: Bool { get }
+
+    /// The directory where to store the screenshots
+    var outputDirectory: String { get }
+
+    /// Don't open the summary after running _screengrab_
+    var skipOpenSummary: Bool { get }
+
+    /// The package name of the app under test (e.g. com.yourcompany.yourapp)
+    var appPackageName: String { get }
+
+    /// The package name of the tests bundle (e.g. com.yourcompany.yourapp.test)
+    var testsPackageName: String? { get }
+
+    /// Only run tests in these Java packages
+    var useTestsInPackages: [String]? { get }
+
+    /// Only run tests in these Java classes
+    var useTestsInClasses: [String]? { get }
+
+    /// Additional launch arguments
+    var launchArguments: [String]? { get }
+
+    /// The fully qualified class name of your test instrumentation runner
+    var testInstrumentationRunner: String { get }
+
+    /// Return the device to this locale after running tests
+    var endingLocale: String { get }
+
+    /// Restarts the adb daemon using `adb root` to allow access to screenshots directories on device. Use if getting 'Permission denied' errors
+    var useAdbRoot: Bool { get }
+
+    /// The path to the APK for the app under test
+    var appApkPath: String? { get }
+
+    /// The path to the APK for the the tests bundle
+    var testsApkPath: String? { get }
+
+    /// Use the device or emulator with the given serial number or qualifier
+    var specificDevice: String? { get }
+
+    /// Type of device used for screenshots. Matches Google Play Types (phone, sevenInch, tenInch, tv, wear)
+    var deviceType: String { get }
+
+    /// Whether or not to exit Screengrab on test failure. Exiting on failure will not copy sceenshots to local machine nor open sceenshots summary
+    var exitOnTestFailure: Bool { get }
+
+    /// Enabling this option will automatically uninstall the application before running it
+    var reinstallApp: Bool { get }
+
+    /// Add timestamp suffix to screenshot filename
+    var useTimestampSuffix: Bool { get }
+
+    /// Configure the host used by adb to connect, allows running on remote devices farm
+    var adbHost: String? { get }
+}
+
+public extension ScreengrabfileProtocol {
+    var androidHome: String? { return nil }
+    var buildToolsVersion: String? { return nil }
+    var locales: [String] { return ["en-US"] }
+    var clearPreviousScreenshots: Bool { return false }
+    var outputDirectory: String { return "fastlane/metadata/android" }
+    var skipOpenSummary: Bool { return false }
+    var appPackageName: String { return "" }
+    var testsPackageName: String? { return nil }
+    var useTestsInPackages: [String]? { return nil }
+    var useTestsInClasses: [String]? { return nil }
+    var launchArguments: [String]? { return nil }
+    var testInstrumentationRunner: String { return "androidx.test.runner.AndroidJUnitRunner" }
+    var endingLocale: String { return "en-US" }
+    var useAdbRoot: Bool { return false }
+    var appApkPath: String? { return nil }
+    var testsApkPath: String? { return nil }
+    var specificDevice: String? { return nil }
+    var deviceType: String { return "phone" }
+    var exitOnTestFailure: Bool { return true }
+    var reinstallApp: Bool { return false }
+    var useTimestampSuffix: Bool { return true }
+    var adbHost: String? { return nil }
+}
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.46]

data/fastlane/swift/Snapshotfile.swift

@@ -0,0 +1,20 @@
+// Snapshotfile.swift
+// Copyright (c) 2020 FastlaneTools
+
+// This class is automatically included in FastlaneRunner during build
+
+// This autogenerated file will be overwritten or replaced during build time, or when you initialize `snapshot`
+//
+//  ** NOTE **
+//  This file is provided by fastlane and WILL be overwritten in future updates
+//  If you want to add extra functionality to this project, create a new file in a
+//  new group so that it won't be marked for upgrade
+//
+
+public class Snapshotfile: SnapshotfileProtocol {
+    // If you want to enable `snapshot`, run `fastlane snapshot init`
+    // After, this file will be replaced with a custom implementation that contains values you supplied
+    // during the `init` process, and you won't see this message
+}
+
+// Generated with fastlane 2.165.0

data/fastlane/swift/SnapshotfileProtocol.swift

@@ -0,0 +1,187 @@
+// SnapshotfileProtocol.swift
+// Copyright (c) 2020 FastlaneTools
+
+public protocol SnapshotfileProtocol: class {
+    /// Path the workspace file
+    var workspace: String? { get }
+
+    /// Path the project file
+    var project: String? { get }
+
+    /// Pass additional arguments to xcodebuild for the test phase. Be sure to quote the setting names and values e.g. OTHER_LDFLAGS="-ObjC -lstdc++"
+    var xcargs: String? { get }
+
+    /// Use an extra XCCONFIG file to build your app
+    var xcconfig: String? { get }
+
+    /// A list of devices you want to take the screenshots from
+    var devices: [String]? { get }
+
+    /// A list of languages which should be used
+    var languages: [String] { get }
+
+    /// A list of launch arguments which should be used
+    var launchArguments: [String] { get }
+
+    /// The directory where to store the screenshots
+    var outputDirectory: String { get }
+
+    /// If the logs generated by the app (e.g. using NSLog, perror, etc.) in the Simulator should be written to the output_directory
+    var outputSimulatorLogs: Bool { get }
+
+    /// By default, the latest version should be used automatically. If you want to change it, do it here
+    var iosVersion: String? { get }
+
+    /// Don't open the HTML summary after running _snapshot_
+    var skipOpenSummary: Bool { get }
+
+    /// Do not check for most recent SnapshotHelper code
+    var skipHelperVersionCheck: Bool { get }
+
+    /// Enabling this option will automatically clear previously generated screenshots before running snapshot
+    var clearPreviousScreenshots: Bool { get }
+
+    /// Enabling this option will automatically uninstall the application before running it
+    var reinstallApp: Bool { get }
+
+    /// Enabling this option will automatically erase the simulator before running the application
+    var eraseSimulator: Bool { get }
+
+    /// Enabling this option will prevent displaying the simulator window
+    var headless: Bool { get }
+
+    /// Enabling this option wil automatically override the status bar to show 9:41 AM, full battery, and full reception
+    var overrideStatusBar: Bool { get }
+
+    /// Enabling this option will configure the Simulator's system language
+    var localizeSimulator: Bool { get }
+
+    /// Enabling this option will configure the Simulator to be in dark mode (false for light, true for dark)
+    var darkMode: Bool? { get }
+
+    /// The bundle identifier of the app to uninstall (only needed when enabling reinstall_app)
+    var appIdentifier: String? { get }
+
+    /// A list of photos that should be added to the simulator before running the application
+    var addPhotos: [String]? { get }
+
+    /// A list of videos that should be added to the simulator before running the application
+    var addVideos: [String]? { get }
+
+    /// A path to screenshots.html template
+    var htmlTemplate: String? { get }
+
+    /// The directory where to store the build log
+    var buildlogPath: String { get }
+
+    /// Should the project be cleaned before building it?
+    var clean: Bool { get }
+
+    /// Test without building, requires a derived data path
+    var testWithoutBuilding: Bool? { get }
+
+    /// The configuration to use when building the app. Defaults to 'Release'
+    var configuration: String? { get }
+
+    /// Additional xcpretty arguments
+    var xcprettyArgs: String? { get }
+
+    /// The SDK that should be used for building the application
+    var sdk: String? { get }
+
+    /// The scheme you want to use, this must be the scheme for the UI Tests
+    var scheme: String? { get }
+
+    /// The number of times a test can fail before snapshot should stop retrying
+    var numberOfRetries: Int { get }
+
+    /// Should snapshot stop immediately after the tests completely failed on one device?
+    var stopAfterFirstError: Bool { get }
+
+    /// The directory where build products and other derived data will go
+    var derivedDataPath: String? { get }
+
+    /// Should an Xcode result bundle be generated in the output directory
+    var resultBundle: Bool { get }
+
+    /// The name of the target you want to test (if you desire to override the Target Application from Xcode)
+    var testTargetName: String? { get }
+
+    /// Separate the log files per device and per language
+    var namespaceLogFiles: String? { get }
+
+    /// Take snapshots on multiple simulators concurrently. Note: This option is only applicable when running against Xcode 9
+    var concurrentSimulators: Bool { get }
+
+    /// Disable the simulator from showing the 'Slide to type' prompt
+    var disableSlideToType: Bool { get }
+
+    /// Sets a custom path for Swift Package Manager dependencies
+    var clonedSourcePackagesPath: String? { get }
+
+    /// The testplan associated with the scheme that should be used for testing
+    var testplan: String? { get }
+
+    /// Array of strings matching Test Bundle/Test Suite/Test Cases to run
+    var onlyTesting: String? { get }
+
+    /// Array of strings matching Test Bundle/Test Suite/Test Cases to skip
+    var skipTesting: String? { get }
+
+    /// Disable xcpretty formatting of build
+    var disableXcpretty: Bool? { get }
+
+    /// Suppress the output of xcodebuild to stdout. Output is still saved in buildlog_path
+    var suppressXcodeOutput: Bool? { get }
+}
+
+public extension SnapshotfileProtocol {
+    var workspace: String? { return nil }
+    var project: String? { return nil }
+    var xcargs: String? { return nil }
+    var xcconfig: String? { return nil }
+    var devices: [String]? { return nil }
+    var languages: [String] { return ["en-US"] }
+    var launchArguments: [String] { return [""] }
+    var outputDirectory: String { return "screenshots" }
+    var outputSimulatorLogs: Bool { return false }
+    var iosVersion: String? { return nil }
+    var skipOpenSummary: Bool { return false }
+    var skipHelperVersionCheck: Bool { return false }
+    var clearPreviousScreenshots: Bool { return false }
+    var reinstallApp: Bool { return false }
+    var eraseSimulator: Bool { return false }
+    var headless: Bool { return true }
+    var overrideStatusBar: Bool { return false }
+    var localizeSimulator: Bool { return false }
+    var darkMode: Bool? { return nil }
+    var appIdentifier: String? { return nil }
+    var addPhotos: [String]? { return nil }
+    var addVideos: [String]? { return nil }
+    var htmlTemplate: String? { return nil }
+    var buildlogPath: String { return "~/Library/Logs/snapshot" }
+    var clean: Bool { return false }
+    var testWithoutBuilding: Bool? { return nil }
+    var configuration: String? { return nil }
+    var xcprettyArgs: String? { return nil }
+    var sdk: String? { return nil }
+    var scheme: String? { return nil }
+    var numberOfRetries: Int { return 1 }
+    var stopAfterFirstError: Bool { return false }
+    var derivedDataPath: String? { return nil }
+    var resultBundle: Bool { return false }
+    var testTargetName: String? { return nil }
+    var namespaceLogFiles: String? { return nil }
+    var concurrentSimulators: Bool { return true }
+    var disableSlideToType: Bool { return false }
+    var clonedSourcePackagesPath: String? { return nil }
+    var testplan: String? { return nil }
+    var onlyTesting: String? { return nil }
+    var skipTesting: String? { return nil }
+    var disableXcpretty: Bool? { return nil }
+    var suppressXcodeOutput: Bool? { return nil }
+}
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.40]

data/fastlane/swift/SocketClient.swift

@@ -0,0 +1,327 @@
+// SocketClient.swift
+// Copyright (c) 2020 FastlaneTools
+
+//
+//  ** NOTE **
+//  This file is provided by fastlane and WILL be overwritten in future updates
+//  If you want to add extra functionality to this project, create a new file in a
+//  new group so that it won't be marked for upgrade
+//
+
+import Dispatch
+import Foundation
+
+public enum SocketClientResponse: Error {
+    case alreadyClosedSockets
+    case malformedRequest
+    case malformedResponse
+    case serverError
+    case clientInitiatedCancelAcknowledged
+    case commandTimeout(seconds: Int)
+    case connectionFailure
+    case success(returnedObject: String?, closureArgumentValue: String?)
+}
+
+class SocketClient: NSObject {
+    enum SocketStatus {
+        case ready
+        case closed
+    }
+
+    static let connectTimeoutSeconds = 2
+    static let defaultCommandTimeoutSeconds = 10_800 // 3 hours
+    static let doneToken = "done" // TODO: remove these
+    static let cancelToken = "cancelFastlaneRun"
+
+    fileprivate var inputStream: InputStream!
+    fileprivate var outputStream: OutputStream!
+    fileprivate var cleaningUpAfterDone = false
+    fileprivate let dispatchGroup = DispatchGroup()
+    fileprivate let readSemaphore = DispatchSemaphore(value: 1)
+    fileprivate let writeSemaphore = DispatchSemaphore(value: 1)
+    fileprivate let commandTimeoutSeconds: Int
+
+    private let writeQueue: DispatchQueue
+    private let readQueue: DispatchQueue
+    private let streamQueue: DispatchQueue
+    private let host: String
+    private let port: UInt32
+
+    let maxReadLength = 65536 // max for ipc on 10.12 is kern.ipc.maxsockbuf: 8388608 ($sysctl kern.ipc.maxsockbuf)
+
+    private(set) weak var socketDelegate: SocketClientDelegateProtocol?
+
+    public private(set) var socketStatus: SocketStatus
+
+    // localhost only, this prevents other computers from connecting
+    init(host: String = "localhost", port: UInt32 = 2000, commandTimeoutSeconds: Int = defaultCommandTimeoutSeconds, socketDelegate: SocketClientDelegateProtocol) {
+        self.host = host
+        self.port = port
+        self.commandTimeoutSeconds = commandTimeoutSeconds
+        readQueue = DispatchQueue(label: "readQueue", qos: .background, attributes: .concurrent)
+        writeQueue = DispatchQueue(label: "writeQueue", qos: .background, attributes: .concurrent)
+        streamQueue = DispatchQueue.global(qos: .background)
+        socketStatus = .closed
+        self.socketDelegate = socketDelegate
+        super.init()
+    }
+
+    func connectAndOpenStreams() {
+        var readStream: Unmanaged<CFReadStream>?
+        var writeStream: Unmanaged<CFWriteStream>?
+
+        streamQueue.sync {
+            CFStreamCreatePairWithSocketToHost(kCFAllocatorDefault, self.host as CFString, self.port, &readStream, &writeStream)
+
+            self.inputStream = readStream!.takeRetainedValue()
+            self.outputStream = writeStream!.takeRetainedValue()
+
+            self.inputStream.delegate = self
+            self.outputStream.delegate = self
+
+            self.inputStream.schedule(in: .main, forMode: .defaultRunLoopMode)
+            self.outputStream.schedule(in: .main, forMode: .defaultRunLoopMode)
+        }
+
+        dispatchGroup.enter()
+        readQueue.sync {
+            self.inputStream.open()
+        }
+
+        dispatchGroup.enter()
+        writeQueue.sync {
+            self.outputStream.open()
+        }
+
+        let secondsToWait = DispatchTimeInterval.seconds(SocketClient.connectTimeoutSeconds)
+        let connectTimeout = DispatchTime.now() + secondsToWait
+
+        let timeoutResult = dispatchGroup.wait(timeout: connectTimeout)
+        let failureMessage = "Couldn't connect to ruby process within: \(SocketClient.connectTimeoutSeconds) seconds"
+
+        let success = testDispatchTimeoutResult(timeoutResult, failureMessage: failureMessage, timeToWait: secondsToWait)
+
+        guard success else {
+            socketDelegate?.commandExecuted(serverResponse: .connectionFailure) { _ in }
+            return
+        }
+
+        socketStatus = .ready
+        socketDelegate?.connectionsOpened()
+    }
+
+    public func send(rubyCommand: RubyCommandable) {
+        verbose(message: "sending: \(rubyCommand.json)")
+        send(string: rubyCommand.json)
+        writeSemaphore.signal()
+    }
+
+    public func sendComplete() {
+        closeSession(sendAbort: true)
+    }
+
+    private func testDispatchTimeoutResult(_ timeoutResult: DispatchTimeoutResult, failureMessage: String, timeToWait: DispatchTimeInterval) -> Bool {
+        switch timeoutResult {
+        case .success:
+            return true
+        case .timedOut:
+            log(message: "Timeout: \(failureMessage)")
+
+            if case let .seconds(seconds) = timeToWait {
+                socketDelegate?.commandExecuted(serverResponse: .commandTimeout(seconds: seconds)) { _ in }
+            }
+            return false
+        }
+    }
+
+    private func stopInputSession() {
+        inputStream.close()
+    }
+
+    private func stopOutputSession() {
+        outputStream.close()
+    }
+
+    private func sendThroughQueue(string: String) {
+        let data = string.data(using: .utf8)!
+        _ = data.withUnsafeBytes { self.outputStream.write($0, maxLength: data.count) }
+    }
+
+    private func privateSend(string: String) {
+        writeQueue.sync {
+            writeSemaphore.wait()
+            self.sendThroughQueue(string: string)
+            writeSemaphore.signal()
+            let timeoutSeconds = self.cleaningUpAfterDone ? 1 : self.commandTimeoutSeconds
+            let timeToWait = DispatchTimeInterval.seconds(timeoutSeconds)
+            let commandTimeout = DispatchTime.now() + timeToWait
+            let timeoutResult = writeSemaphore.wait(timeout: commandTimeout)
+
+            _ = self.testDispatchTimeoutResult(timeoutResult, failureMessage: "Ruby process didn't return after: \(SocketClient.connectTimeoutSeconds) seconds", timeToWait: timeToWait)
+        }
+    }
+
+    private func send(string: String) {
+        guard !cleaningUpAfterDone else {
+            // This will happen after we abort if there are commands waiting to be executed
+            // Need to check state of SocketClient in command runner to make sure we can accept `send`
+            socketDelegate?.commandExecuted(serverResponse: .alreadyClosedSockets) { _ in }
+            return
+        }
+
+        if string == SocketClient.doneToken {
+            cleaningUpAfterDone = true
+        }
+
+        privateSend(string: string)
+    }
+
+    func closeSession(sendAbort: Bool = true) {
+        socketStatus = .closed
+
+        stopInputSession()
+
+        if sendAbort {
+            send(rubyCommand: ControlCommand(commandType: .done))
+        }
+
+        stopOutputSession()
+        socketDelegate?.connectionsClosed()
+    }
+
+    public func enter() {
+        dispatchGroup.enter()
+    }
+
+    public func leave() {
+        readSemaphore.signal()
+        writeSemaphore.signal()
+    }
+}
+
+extension SocketClient: StreamDelegate {
+    func stream(_ aStream: Stream, handle eventCode: Stream.Event) {
+        guard !cleaningUpAfterDone else {
+            // Still getting response from server eventhough we are done.
+            // No big deal, we're closing the streams anyway.
+            // That being said, we need to balance out the dispatchGroups
+            dispatchGroup.leave()
+            return
+        }
+
+        if aStream === inputStream {
+            switch eventCode {
+            case Stream.Event.openCompleted:
+                dispatchGroup.leave()
+
+            case Stream.Event.errorOccurred:
+                verbose(message: "input stream error occurred")
+                closeSession(sendAbort: true)
+
+            case Stream.Event.hasBytesAvailable:
+                read()
+
+            case Stream.Event.endEncountered:
+                // nothing special here
+                break
+
+            case Stream.Event.hasSpaceAvailable:
+                // we don't care about this
+                break
+
+            default:
+                verbose(message: "input stream caused unrecognized event: \(eventCode)")
+            }
+
+        } else if aStream === outputStream {
+            switch eventCode {
+            case Stream.Event.openCompleted:
+                dispatchGroup.leave()
+
+            case Stream.Event.errorOccurred:
+                // probably safe to close all the things because Ruby already disconnected
+                verbose(message: "output stream recevied error")
+
+            case Stream.Event.endEncountered:
+                // nothing special here
+                break
+
+            case Stream.Event.hasSpaceAvailable:
+                // we don't care about this
+                break
+
+            default:
+                verbose(message: "output stream caused unrecognized event: \(eventCode)")
+            }
+        }
+    }
+
+    func read() {
+        readQueue.sync {
+            self.readSemaphore.wait()
+            var buffer = [UInt8](repeating: 0, count: maxReadLength)
+            var output = ""
+            while self.inputStream!.hasBytesAvailable {
+                let bytesRead: Int = inputStream!.read(&buffer, maxLength: buffer.count)
+                if bytesRead >= 0 {
+                    guard let read = String(bytes: buffer[..<bytesRead], encoding: .utf8) else {
+                        fatalError("Unable to decode bytes from buffer \(buffer[..<bytesRead])")
+                    }
+                    output.append(contentsOf: read)
+                } else {
+                    verbose(message: "Stream read() error")
+                }
+            }
+            self.processResponse(string: output)
+            readSemaphore.signal()
+        }
+    }
+
+    func handleFailure(message: [String]) {
+        log(message: "Encountered a problem: \(message.joined(separator: "\n"))")
+        let shutdownCommand = ControlCommand(commandType: .cancel(cancelReason: .serverError))
+        send(rubyCommand: shutdownCommand)
+    }
+
+    func processResponse(string: String) {
+        guard !string.isEmpty else {
+            socketDelegate?.commandExecuted(serverResponse: .malformedResponse) {
+                self.handleFailure(message: ["empty response from ruby process"])
+                $0.writeSemaphore.signal()
+            }
+            return
+        }
+
+        let responseString = string.trimmingCharacters(in: .whitespacesAndNewlines)
+        let socketResponse = SocketResponse(payload: responseString)
+        verbose(message: "response is: \(responseString)")
+        switch socketResponse.responseType {
+        case .clientInitiatedCancel:
+            socketDelegate?.commandExecuted(serverResponse: .clientInitiatedCancelAcknowledged) {
+                $0.writeSemaphore.signal()
+                self.closeSession(sendAbort: false)
+            }
+
+        case let .failure(failureInformation):
+            socketDelegate?.commandExecuted(serverResponse: .serverError) {
+                $0.writeSemaphore.signal()
+                self.handleFailure(message: failureInformation)
+            }
+
+        case let .parseFailure(failureInformation):
+            socketDelegate?.commandExecuted(serverResponse: .malformedResponse) {
+                $0.writeSemaphore.signal()
+                self.handleFailure(message: failureInformation)
+            }
+
+        case let .readyForNext(returnedObject, closureArgumentValue):
+            socketDelegate?.commandExecuted(serverResponse: .success(returnedObject: returnedObject, closureArgumentValue: closureArgumentValue)) {
+                $0.writeSemaphore.signal()
+            }
+        }
+    }
+}
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.2]