fastlane-plugin-maestro_orchestration 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 16bca8a824864e18e5022ff562fb194076093be36b157665c8a9b35badbe047e
+  data.tar.gz: 32fe2d534c4d295245009d6672750f748adfdfce4dcd6ca8864a60e989d19936
+SHA512:
+  metadata.gz: 8f5c55f53f32f13711091ebb0e989b7475b133e64739ff839966a62239eef3fd8a53d555ee1c64da888c1ba810bed487b9316f61786f56cc4d8564fdcfe03a5c
+  data.tar.gz: e923fa4cae04e21f78111f8d1dc0083b88a616f3c60a5d1570750087349014608eff5926dec3cc9d9cb734fa7963b13e46cbec082ff4022149e20f4a373bdb0b

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Nemanja Risteski <nemanja.risteski@sourcetoad.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,148 @@
+# maestro_orchestration plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-maestro_orchestration)
+
+## Getting Started
+
+This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-maestro_orchestration`, add it to your project by running:
+
+```bash
+fastlane add_plugin maestro_orchestration
+```
+
+## About maestro_orchestration
+
+The `maestro_orchestration` plugin enhances your Fastlane workflows by integrating with the Maestro testing framework. It provides the following actions:
+
+### 1. `maestro_orchestration` - separate actions for iOS and Android platform.
+Executes Maestro test suites within your Fastlane lanes, facilitating automated UI testing for mobile applications.
+
+## Parameters `iOS`
+
+| Parameter           | Env Name | Notes                                                                                                                                                                        |
+| ------------------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `workspace`         | `MAESTRO_IOS_WORKSPACE`      | Path to the project's Xcode workspace directory.  <br>  **Required**                                                                                     |
+| `scheme`            | `MAESTRO_IOS_SCHEME`         | The iOS app scheme to build.  <br>  **Required**                                                                                                         |
+| `maestro_flow_file` | `MAESTRO_IOS_FLOW_FILE`      | The path to the Maestro flows YAML file. <br> **Required**                                                                                               |
+| `simulator_name`    | `MAESTRO_IOS_DEVICE_NAME`    | The iOS simulator device to boot. <br> **Default value:** 'iPhone 15'                                                                                    |
+| `device_type`       | `MAESTRO_IOS_DEVICE`         | The iOS simulator device type for new simulator (e.g., iPhone #, iPad, etc...). <br> **Default value:** 'com.apple.CoreSimulator.SimDeviceType.iPhone-15'|
+
+## Parameters `Android`
+
+| Parameter           | Env Name                           | Notes                                                                                                                                  |
+| ------------------- | ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
+| `sdk_dir`           | `MAESTRO_ANDROID_SDK_DIR`          | Path to the Android SDK DIR. <br> **Required**              `ENV["ANDROID_HOME"]`, `ENV["ANDROID_SDK_ROOT"]`, `~/Library/Android/sdk`  |
+| `maestro_flow_file` | `MAESTRO_IOS_FLOW_FILE`            | The path to the Maestro flows YAML file.  <br> **Required**                                                                            |
+| `emulator_name`     | `MAESTRO_AVD_NAME`                 | Name of the AVD. <br>  **Default value:**    'Maestro\_Android\_Emulator'                                                              |
+| `emulator_package`  | `MAESTRO_AVD_PACKAGE`              | The selected system image of the emulator. <br> **Default value:** 'system-images;android-35;google_apis_playstore;arm64-v8a'          |
+| `emulator_device`   | `MAESTRO_AVD_DEVICE`               | Type of android device. <br> **Default value:** 'pixel_7_pro'                                                                          |
+| `emulator_port`     | `MAESTRO_AVD_PORT`                 | Port of the emulator. <br>  **Default value:** 5554                                                                                    |
+
+### 2. `maestro_orchestartion_s3_upload`
+Uploads a folder of files (such as screenshots) to an S3 bucket, organizing them based on the app version, theme, and device type.
+
+| Parameter     | Env Name | Notes                                                                                                           |
+| ------------- | -------- | --------------------------------------------------------------------------------------------------------------- |
+| `folder_path` | `MAESTRO_SCREENSHOTS_FOLDER_PATH`            | Path to the local folder containing the files to upload. <br> **Required**  |
+| `bucket`      | `MAESTRO_SCREENSHOTS_S3_BUCKET`              | The name of the S3 bucket where files will be uploaded.  <br> **Required**  |
+| `s3_path`     | `MAESTRO_SCREENSHOTS_S3_PATH`                | The base S3 path (excluding the bucket name).            <br> **Required**  |
+| `version`     | `MAESTRO_SCREENSHOTS_APP_VERSION`            | The app version associated with the uploaded files.      <br> **Required**  |
+| `device`      | `MAESTRO_SCREENSHOTS_DEVICE`                 | The target device type (android or ios).                 <br> **Required**  |
+| `theme`       | `MAESTRO_SCREENSHOTS_APPLICATION_THEME`      | The application theme (e.g., dark or light).             <br> Optional      |
+
+### 3. `maestro_orchestration_api_request`
+Sends an API request with a signed payload, typically used to notify external systems of events such as the completion of test runs or the availability of new screenshots.
+
+| Parameter     | Env Name | Notes                                                                                                                         |
+| ------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------- |
+| `s3_path`     | `MAESTRO_SCREENSHOTS_S3_PATH`                | The base S3 path (excluding the bucket name) where files are uploaded.  <br> **Required** |
+| `version`     | `MAESTRO_SCREENSHOTS_APP_VERSION`            | The version of the app associated with the screenshots or test results. <br> **Required** |
+| `device`      | `MAESTRO_SCREENSHOTS_APP_VERSION`            | The device type (android or ios).                                       <br> **Required** |
+| `theme`       | `MAESTRO_SCREENSHOTS_APPLICATION_THEME`      | The application theme (e.g., dark or light).                            <br> Optional     |
+| `hmac_secret` | `MAESTRO_SCREENSHOTS_HMAC_SECRET`            | The HMAC secret used to sign the payload for security purposes.         <br> **Required** |
+| `url`         | `MAESTRO_SCREENSHOTS_WEBHOOK_URL`            | The endpoint URL to which the API request is sent.                      <br> **Required** |
+
+## Example
+
+**iOS**
+```ruby
+lane :maestro do |options|
+  maestro_orchestration_ios(
+    scheme: your_app,
+    workspace: your_app.xcworskapce,
+    maestro_flow_file: "../.maestro/flow_ios.yaml"
+  )
+
+  maestro_orchestration_s3_upload(
+    folder_path: "../.maestro/android/screenshots,
+    bucket: "your-s3-bucket-name",
+    s3_path: "path/to/s3/folder",
+    version: "1.0.0",
+    device: "android",
+    theme: "dark" # optional
+  )
+
+  maestro_orchestration_api_request(
+    s3_path: "path/to/s3/folder",
+    version: "1.0.0",
+    device: "android",
+    hmac_secret: "your-hmac-secret",
+    url: "https://your-webhook-url.com"
+  )
+end
+```
+**Android**
+```ruby
+lane :maestro do |options|
+  maestro_orchestration_android(
+    maestro_flow_file: "../.maestro/flow_android.yaml
+  )
+
+  maestro_orchestration_s3_upload(
+    folder_path: "../.maestro/android/screenshots,
+    bucket: "your-s3-bucket-name",
+    s3_path: "path/to/s3/folder",
+    version: "1.0.0",
+    device: "android",
+    theme: "dark" # optional
+  )
+
+  maestro_orchestration_api_request(
+    s3_path: "path/to/s3/folder",
+    version: "1.0.0",
+    device: "android",
+    hmac_secret: "your-hmac-secret",
+    url: "https://your-webhook-url.com"
+  )
+end
+```
+**Note:** For Android platform, the plugin relies on the already previously generated build by Fastlane instead of generating a new one like for the iOS. The plugin was intended to run on simulators, and iOS has differents build types for simulators and real devices.
+
+## Run tests for this plugin
+
+To run both the tests, and code style validation, run
+
+```
+rake
+```
+
+To automatically fix many of the styling issues, use
+```
+rubocop -a
+```
+
+## Issues and Feedback
+
+For any other issues and feedback about this plugin, please submit it to this repository.
+
+## Troubleshooting
+
+If you have trouble using plugins, check out the [Plugins Troubleshooting](https://docs.fastlane.tools/plugins/plugins-troubleshooting/) guide.
+
+## Using _fastlane_ Plugins
+
+For more information about how the `fastlane` plugin system works, check out the [Plugins documentation](https://docs.fastlane.tools/plugins/create-plugin/).
+
+## About _fastlane_
+
+_fastlane_ is the easiest way to automate beta deployments and releases for your iOS and Android apps. To learn more, check out [fastlane.tools](https://fastlane.tools).

data/lib/fastlane/plugin/maestro_orchestration/actions/maestro_orchestration_android_action.rb

@@ -0,0 +1,197 @@
+require 'fastlane/action'
+require 'fastlane_core/configuration/config_item'
+require 'fastlane/helper/adb_helper'
+require_relative '../helper/maestro_orchestration_helper'
+
+module Fastlane
+  module Actions
+    class MaestroOrchestrationAndroidAction < Action
+      def self.run(params)
+        required_params = [:emulator_package, :emulator_device, :maestro_flow_file]
+        missing_params = required_params.select { |param| params[param].nil? }
+
+        if missing_params.any?
+          missing_params.each do |param|
+            UI.error("Missing parameter: #{param}")
+          end
+          raise "Missing required parameters: #{missing_params.join(', ')}"
+        end
+
+        UI.message("--------------\n\nSDK DIR: #{params[:sdk_dir]}\n\n--------------")
+        adb = Helper::AdbHelper.new
+
+        setup_emulator(params)
+        sleep(5)
+        demo_mode(params)
+        install_android_app(params)
+
+        UI.message("Running Maestro tests on Android...")
+        devices = adb.load_all_devices
+        if devices.empty?
+          UI.message("No running emulators found.")
+        else
+          sleep(2)
+          UI.message("Devices: #{devices}")
+          devices.each do |device|
+            sh("maestro --device #{device.serial} test #{params[:maestro_flow_file]}")
+            UI.success("Finished Maestro tests on Android.")
+          end
+        end
+
+        UI.message("Exit demo mode and kill Android emulator...")
+        adb.trigger(command: "shell am broadcast -a com.android.systemui.demo -e command exit", serial: devices.first.serial)
+        sleep(5)
+        adb.trigger(command: "emu kill", serial: devices.first.serial)
+        UI.success("Android emulator killed. Process finished.")
+      end
+
+      def self.setup_emulator(params)
+        emulator = Helper::EmulatorHelper.new
+        adb = Helper::AdbHelper.new
+        avdmanager = Helper::AvdHelper.new
+
+        UI.message("Stop all running emulators...")
+        devices = adb.load_all_devices
+        UI.success("Devices: #{devices}")
+
+        if devices.empty?
+          UI.message("No running emulators found.")
+        else
+          devices.each do |device|
+            UI.message("Stopping emulator: #{device.serial}")
+            adb.trigger(command: "emu kill", serial: device.serial)
+            sleep(10)
+            system("Stopped emulator: #{device.serial}")
+          end
+        end
+        UI.message("Waiting for all emulators to stop...")
+        sleep(10)
+
+        UI.message("Setting up new Android emulator...")
+        avdmanager.create_avd(name: params[:emulator_name], package: params[:emulator_package], device: params[:emulator_device])
+
+        UI.message("Starting Android emulator...")
+        emulator.start_emulator(name: params[:emulator_name], port: params[:emulator_port])
+        adb.trigger(command: "wait-for-device", serial: "emulator-#{params[:emulator_port]}")
+
+        max_retries = 10
+        booted = Helper::MaestroOrchestrationHelper.wait_for_emulator_to_boot(adb, max_retries, "emulator-#{params[:emulator_port]}")
+
+        unless booted
+          UI.error("Emulator failed to boot after #{max_retries} attempts. Restarting ADB server...")
+          adb.trigger(command: "kill-server")
+          adb.trigger(command: "start-server")
+          UI.message("ADB server restarted. Retrying boot process...")
+
+          # Retry boot process after restarting ADB server
+          booted = Helper::MaestroOrchestrationHelper.wait_for_emulator_to_boot(adb, max_retries, "emulator-#{params[:emulator_port]}")
+        end
+
+        if booted
+          UI.success("Emulator is online and fully booted!")
+        else
+          UI.error("Emulator failed to boot even after restarting ADB server.")
+          raise "Failed to boot emulator. Please check emulator logs and configuration."
+        end
+      end
+
+      def self.demo_mode(params)
+        adb = Helper::AdbHelper.new
+        adb.load_all_devices
+        serial = adb.devices.first.serial
+
+        UI.message("Checking and allowing demo mode on Android emulator...")
+        adb.trigger(command: "shell settings put global sysui_demo_allowed 1", serial: serial)
+        adb.trigger(command: "shell settings get global sysui_demo_allowed", serial: serial)
+
+        UI.message("Setting demo mode commands...")
+        adb.trigger(command: "shell am broadcast -a com.android.systemui.demo -e command enter", serial: serial)
+        adb.trigger(command: "shell am broadcast -a com.android.systemui.demo -e command clock -e hhmm 1200", serial: serial)
+        adb.trigger(command: "shell am broadcast -a com.android.systemui.demo -e command battery -e level 100", serial: serial)
+      end
+
+      def self.install_android_app(params)
+        UI.message("Installing Android app...")
+
+        adb = Helper::AdbHelper.new
+        adb.load_all_devices
+        serial = adb.devices.first.serial
+
+        apk_path = Dir["app/build/outputs/apk/release/*.apk"].first
+
+        if apk_path.nil?
+          UI.user_error!("Error: APK file not found in build outputs.")
+        end
+
+        UI.message("Found APK file at: #{apk_path}")
+        adb.trigger(command: "install -r '#{apk_path}'", serial: serial)
+        UI.success("APK installed on Android emulator.")
+      end
+
+      def self.description
+        "Boots an Android emulator, builds the app, installs it, and runs Maestro tests"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :sdk_dir,
+            env_name: "MAESTRO_ANDROID_SDK_DIR",
+            description: "Path to the Android SDK DIR",
+            default_value: ENV["ANDROID_HOME"] || ENV["ANDROID_SDK_ROOT"] || "~/Library/Android/sdk",
+            optional: true,
+            verify_block: proc do |value|
+              UI.user_error!("No ANDROID_SDK_DIR given, pass using `sdk_dir: 'sdk_dir'`") unless value && !value.empty?
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :emulator_name,
+            env_name: "MAESTRO_AVD_NAME",
+            description: "Name of the AVD",
+            default_value: "Maestro_Android_Emulator",
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :emulator_package,
+            env_name: "MAESTRO_AVD_PACKAGE",
+            description: "The selected system image of the emulator",
+            default_value: "system-images;android-35;google_apis_playstore;arm64-v8a",
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :emulator_device,
+            env_name: "MAESTRO_AVD_DEVICE",
+            description: "Device",
+            default_value: "pixel_7_pro",
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :location,
+            env_name: "MAESTRO_AVD_LOCATION",
+            description: "Set location of the emulator '<longitude> <latitude>'",
+            default_value: "28.0362979, -82.4930012",
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :emulator_port,
+            env_name: "MAESTRO_AVD_PORT",
+            description: "Port of the emulator",
+            default_value: "5554",
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :maestro_flow_file,
+            env_name: "MAESTRO_ANDROID_FLOW_FILE",
+            description: "The path to the Maestro flow YAML file",
+            optional: false,
+            type: String
+          )
+        ]
+      end
+
+      def self.is_supported?(platform)
+        platform == :android
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/maestro_orchestration/actions/maestro_orchestration_api_request_action.rb

@@ -0,0 +1,144 @@
+require 'fastlane/action'
+require 'openssl'
+require 'net/http'
+require 'uri'
+require 'json'
+require 'fastlane_core/configuration/config_item'
+require_relative '../helper/maestro_orchestration_helper'
+
+module Fastlane
+  module Actions
+    class MaestroOrchestrationApiRequestAction < Action
+      def self.run(params)
+        required_params = [:s3_path, :version, :device, :hmac_secret, :url]
+        missing_params = required_params.select { |param| params[param].nil? }
+
+        if missing_params.any?
+          missing_params.each do |param|
+            UI.error("Missing parameter: #{param}")
+          end
+          raise "Missing required parameters: #{missing_params.join(', ')}"
+        end
+
+        base_path = "#{params[:s3_path]}/ver:#{params[:version]}"
+        base_path += "/theme:#{params[:theme]}" if params[:theme]
+        base_path += "/device:#{params[:device]}"
+
+        payload = {
+          message: "Screenshots uploaded",
+          version: params[:version],
+          folder_path: base_path
+        }
+        payload_json = payload.to_json
+
+        signature = "sha256=#{OpenSSL::HMAC.hexdigest('SHA256', params[:hmac_secret], payload_json)}"
+
+        uri = URI.parse(params[:url])
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+
+        request = Net::HTTP::Post.new(uri.path, {
+          "Content-Type" => "application/json",
+          "X-Action-Signature" => signature
+        })
+        request.body = payload_json
+
+        response = http.request(request)
+
+        if response.kind_of?(Net::HTTPSuccess)
+          UI.success("API request successful: #{response.code} - #{response.body}")
+        else
+          UI.user_error!("API request failed: #{response.code} - #{response.body}")
+        end
+      end
+
+      def self.description
+        "Sends an API request with a signed payload."
+      end
+
+      def self.available_options
+        [
+          s3_path_option,
+          version_option,
+          device_option,
+          theme_option,
+          hmac_secret_option,
+          url_option
+        ]
+      end
+
+      def self.s3_path_option
+        FastlaneCore::ConfigItem.new(
+          key: :s3_path,
+          env_name: "MAESTRO_SCREENSHOTS_S3_PATH",
+          description: "The base S3 path (after the bucket name) where files will be uploaded: $bucket/$s3_path",
+          optional: false
+        )
+      end
+
+      def self.version_option
+        FastlaneCore::ConfigItem.new(
+          key: :version,
+          env_name: "MAESTRO_SCREENSHOTS_APP_VERSION",
+          description: "Version of the app that screenshots are taken from",
+          optional: false,
+          verify_block: proc do |value|
+            UI.user_error!("You must provide a version using the `version` parameter.") unless value && !value.strip.empty?
+          end
+        )
+      end
+
+      def self.device_option
+        FastlaneCore::ConfigItem.new(
+          key: :device,
+          env_name: "MAESTRO_SCREENSHOTS_DEVICE",
+          description: "Device type: android or ios",
+          type: String,
+          optional: false,
+          verify_block: proc do |value|
+            UI.user_error!("You must specify a device type (android or ios).") unless %w[android ios].include?(value.downcase)
+          end
+        )
+      end
+
+      def self.theme_option
+        FastlaneCore::ConfigItem.new(
+          key: :theme,
+          env_name: "MAESTRO_SCREENSHOTS_APPLICATION_THEME",
+          description: "Optional theme parameter (e.g., dark or light)",
+          default_value: nil,
+          optional: true
+        )
+      end
+
+      def self.hmac_secret_option
+        FastlaneCore::ConfigItem.new(
+          key: :hmac_secret,
+          env_name: "MAESTRO_SCREENSHOTS_HMAC_SECRET",
+          description: "The HMAC secret used to sign the payload",
+          optional: false,
+          verify_block: proc do |value|
+            UI.user_error!("You must provide a valid HMAC secret using the `hmac_secret` parameter.") unless value && !value.strip.empty?
+          end
+        )
+      end
+
+      def self.url_option
+        FastlaneCore::ConfigItem.new(
+          key: :url,
+          env_name: "MAESTRO_SCREENSHOTS_WEBHOOK_URL",
+          description: "The URL to send the API request to",
+          optional: false,
+          verify_block: proc do |value|
+            UI.user_error!("You must provide a valid URL using the `url` parameter.") unless value && !value.strip.empty?
+            UI.user_error!("The provided URL is invalid: #{value}") unless value.match?(URI::DEFAULT_PARSER.make_regexp)
+          end
+        )
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/maestro_orchestration/actions/maestro_orchestration_ios_action.rb

@@ -0,0 +1,166 @@
+require 'fastlane/action'
+require 'fastlane_core/configuration/config_item'
+require_relative '../helper/maestro_orchestration_helper'
+
+module Fastlane
+  module Actions
+    class MaestroOrchestrationIosAction < Action
+      def self.run(params)
+        required_params = [:scheme, :workspace, :maestro_flow_file]
+        missing_params = required_params.select { |param| params[param].nil? }
+
+        if missing_params.any?
+          missing_params.each do |param|
+            UI.error("Missing parameter: #{param}")
+          end
+          raise "Missing required parameters: #{missing_params.join(', ')}"
+        end
+
+        boot_ios_simulator(params)
+        demo_mode(params)
+        build_and_install_ios_app(params)
+
+        UI.message("Running Maestro tests on iOS...")
+
+        simulators_list = `xcrun simctl list devices`.strip
+        device_status = simulators_list.match(/#{Regexp.quote(params[:simulator_name])}.*\(([^)]+)\) \(([^)]+)\)/)
+        device_id = device_status[1]
+        `maestro --device #{device_id} test #{params[:maestro_flow_file]}`
+        UI.success("Finished Maestro tests on iOS.")
+
+        UI.message("Killing iOS simulator...")
+        system("xcrun simctl shutdown booted")
+        UI.success("iOS simulator killed. Process finished.")
+      end
+
+      def self.boot_ios_simulator(params)
+        device_name = params[:simulator_name]
+        device_type = params[:device_type]
+
+        UI.message("Shutting down any booted iOS simulator...")
+        system("xcrun simctl shutdown booted")
+
+        UI.message("Checking if simulator '#{device_name}' exists...")
+        simulators_list = `xcrun simctl list devices -j`
+        simulator_data = JSON.parse(simulators_list)["devices"].values.flatten
+
+        existing_simulator = simulator_data.find { |sim| sim["name"] == device_name }
+
+        if existing_simulator
+          device_id = existing_simulator["udid"]
+          UI.message("Found existing simulator '#{device_name}' with ID #{device_id}. Deleting it...")
+          system("xcrun simctl delete #{device_id}")
+        end
+
+        UI.message("Creating a new simulator '#{device_name}'...")
+        system("xcrun simctl create '#{device_name}' #{device_type}")
+
+        # Refresh simulator list after creation
+        simulators_list = `xcrun simctl list devices -j`
+        new_simulator = JSON.parse(simulators_list)["devices"].values.flatten.find { |sim| sim["name"] == device_name }
+
+        unless new_simulator
+          UI.user_error!("Failed to create simulator '#{device_name}'.")
+        end
+
+        new_device_id = new_simulator["udid"]
+        UI.message("Booting the new simulator '#{device_name}' (ID: #{new_device_id})...")
+        system("xcrun simctl boot '#{new_device_id}'")
+
+        UI.message("Waiting for the simulator to fully boot...")
+        until `xcrun simctl list devices`.include?("#{device_name} (#{new_device_id}) (Booted)")
+          UI.message("Waiting for the simulator to boot...")
+          sleep(10)
+        end
+
+        UI.success("Simulator '#{device_name}' is booted and ready.")
+      end
+
+      def self.demo_mode(params)
+        UI.message("Setting demo mode on #{params[:simulator_name]}...")
+        sh("xcrun simctl status_bar '#{params[:simulator_name]}' override --time '09:30'")
+        sh("xcrun simctl status_bar '#{params[:simulator_name]}' override --batteryState charged --batteryLevel 100")
+        sh("xcrun simctl status_bar '#{params[:simulator_name]}' override --wifiBars 3 --cellularBars 4")
+      end
+
+      def self.build_and_install_ios_app(params)
+        UI.message("Building iOS app with scheme: #{params[:scheme]}")
+        other_action.gym(
+          workspace: params[:workspace],
+          scheme: params[:scheme],
+          destination: "platform=iOS Simulator,name=#{params[:simulator_name]}",
+          configuration: "Release",
+          clean: true,
+          sdk: "iphonesimulator",
+          build_path: "./build",
+          skip_archive: true,
+          skip_package_ipa: true,
+          include_symbols: false,
+          include_bitcode: false,
+          xcargs: "-UseModernBuildSystem=YES"
+        )
+
+        derived_data_path = File.expand_path("~/Library/Developer/Xcode/DerivedData")
+        app_path = Dir["#{derived_data_path}/**/Release-iphonesimulator/#{params[:scheme]}.app"].first
+
+        if app_path.nil?
+          UI.user_error!("Error: .app file not found in DerivedData.")
+        end
+
+        UI.message("Found .app file at: #{app_path}")
+        sh("xcrun simctl install booted '#{app_path}'")
+        UI.success("App installed on iOS simulator.")
+      end
+
+      def self.description
+        "Boots an iOS simulator, builds the app, installs it, and runs Maestro tests"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :simulator_name,
+            env_name: "MAESTRO_IOS_DEVICE_NAME",
+            description: "The iOS simulator device to boot",
+            default_value: "iPhone 15",
+            optional: true,
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :device_type,
+            env_name: "MAESTRO_IOS_DEVICE",
+            description: "The iOS simulator device type for new simulator",
+            default_value: "com.apple.CoreSimulator.SimDeviceType.iPhone-15",
+            optional: true,
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :scheme,
+            env_name: "MAESTRO_IOS_SCHEME",
+            description: "The iOS app scheme to build",
+            optional: false,
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :workspace,
+            env_name: "MAESTRO_IOS_WORKSPACE",
+            description: "The Xcode workspace",
+            optional: false,
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :maestro_flow_file,
+            env_name: "MAESTRO_IOS_FLOW_FILE",
+            description: "The path to the Maestro flows YAML file",
+            optional: false,
+            type: String
+          )
+        ]
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/maestro_orchestration/actions/maestro_orchestration_s3_upload_action.rb

@@ -0,0 +1,106 @@
+require 'fastlane/action'
+require 'aws-sdk-s3'
+require 'fastlane_core/configuration/config_item'
+require_relative '../helper/maestro_orchestration_helper'
+
+module Fastlane
+  module Actions
+    class MaestroOrchestrationS3UploadAction < Action
+      def self.run(params)
+        required_params = [:folder_path, :bucket, :version, :device]
+        missing_params = required_params.select { |param| params[param].nil? }
+
+        if missing_params.any?
+          missing_params.each do |param|
+            UI.error("Missing parameter: #{param}")
+          end
+          raise "Missing required parameters: #{missing_params.join(', ')}"
+        end
+
+        UI.message("Uploading screenshots to S3...")
+
+        s3_client = Aws::S3::Client.new(
+          region: ENV.fetch('AWS_REGION', 'us-east-1')
+        )
+
+        base_path = "#{params[:s3_path]}/ver:#{params[:version]}"
+        base_path += "/theme:#{params[:theme]}" if params[:theme]
+        base_path += "/device:#{params[:device]}"
+
+        UI.message("Folder path: #{params[:folder_path]}")
+        Dir.glob("#{params[:folder_path]}/*").each do |file|
+          next if File.directory?(file)
+
+          file_name = File.basename(file)
+          s3_key = File.join(base_path, file_name)
+
+          UI.message("Uploading #{file} to s3://#{params[:bucket]}/#{s3_key}")
+          s3_client.put_object(bucket: params[:bucket], key: s3_key, body: File.open(file))
+        end
+
+        UI.success("Upload to S3 completed.")
+      end
+
+      def self.description
+        "Uploads files to an S3 bucket."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :folder_path,
+            env_name: "MAESTRO_SCREENSHOTS_FOLDER_PATH",
+            description: "Path to the folder to be uploaded to S3",
+            optional: false,
+            verify_block: proc do |value|
+              UI.user_error!("You must provide a valid folder path using the `folder_path` parameter.") unless value && !value.strip.empty?
+              UI.user_error!("The folder path does not exist: #{value}") unless File.directory?(value)
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :bucket,
+            env_name: "MAESTRO_SCREENSHOTS_S3_BUCKET",
+            description: "The S3 bucket name where files will be uploaded",
+            optional: false,
+            verify_block: proc do |value|
+              UI.user_error!("You must provide a valid S3 bucket name using the `bucket` parameter.") unless value && !value.strip.empty?
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :s3_path,
+            env_name: "MAESTRO_SCREENSHOTS_S3_PATH",
+            description: "The base S3 path (after the bucket name) where files will be uploaded: $bucket/$s3_path",
+            optional: false
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :version,
+            env_name: "MAESTRO_SCREENSHOTS_APP_VERSION",
+            description: "Version of the app that screenshots are taken from",
+            optional: false,
+            verify_block: proc do |value|
+              UI.user_error!("You must provide a version using the `version` parameter.") unless value && !value.strip.empty?
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :device,
+            env_name: "MAESTRO_SCREENSHOTS_DEVICE",
+            description: "Device type: android or ios",
+            type: String,
+            optional: false
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :theme,
+            env_name: "MAESTRO_SCREENSHOTS_APPLICATION_THEME",
+            description: "Optional theme parameter (e.g., dark or light)",
+            default_value: nil,
+            optional: true
+          )
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/maestro_orchestration/helper/maestro_orchestration_helper.rb

@@ -0,0 +1,132 @@
+require 'fastlane_core/ui/ui'
+require 'fastlane/action'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?(:UI)
+  Helper = FastlaneCore::Helper unless Fastlane.const_defined?(:Helper)
+
+  module Helper
+    class MaestroOrchestrationHelper
+      # class methods that you define here become available in your action
+      # as `Helper::MaestroOrchestrationHelper.your_method`
+      #
+      def self.show_message
+        UI.message("Hello from the maestro_orchestration plugin helper!")
+      end
+
+      def self.wait_for_emulator_to_boot(adb, max_retries, serial)
+        retries = 0
+        booted = false
+
+        while retries < max_retries
+          result = `#{adb.adb_path} -e shell getprop sys.boot_completed`.strip
+          UI.message("ADB Response (sys.boot_completed): #{result.inspect}")
+
+          if result == "1"
+            booted = true
+            break
+          elsif result.empty? || result.include?("device offline") || result.include?("device unauthorized")
+            UI.error("ADB issue detected: #{result}")
+          end
+
+          retries += 1
+          UI.message("Retrying... Attempt #{retries}/#{max_retries}")
+
+          wait_interval = [1 + (2**retries), 30].min
+
+          UI.message("Waiting for #{wait_interval} seconds before retrying...")
+          sleep(wait_interval)
+        end
+
+        booted
+      end
+    end
+
+    class AvdHelper
+      # Path to the avd binary
+      attr_accessor :avdmanager_path
+      # Available AVDs
+      attr_accessor :avds
+
+      def initialize(avdmanager_path: nil)
+        android_home = ENV.fetch('ANDROID_HOME', nil) || ENV.fetch('ANDROID_SDK_ROOT', nil)
+        if (avdmanager_path.nil? || avdmanager_path == "avdmanager") && android_home
+          # First search for cmdline-tools dir
+          cmdline_tools_path = File.join(android_home, "cmdline-tools")
+
+          # Find the first available 'bin' folder within cmdline-tools
+          available_path = Dir.glob(File.join(cmdline_tools_path, "*", "bin")).first
+          raise "No valid bin path found in #{cmdline_tools_path}" unless available_path
+
+          avdmanager_path = File.join(available_path, "avdmanager")
+        end
+
+        self.avdmanager_path = Helper.get_executable_path(File.expand_path(avdmanager_path))
+      end
+
+      def trigger(command: nil)
+        raise "avdmanager_path is not set" unless avdmanager_path
+
+        # Build and execute the command
+        command = [avdmanager_path.shellescape, command].compact.join(" ").strip
+        Action.sh(command)
+      end
+
+      # Create a new AVD
+      def create_avd(name:, package:, device: "pixel_7_pro")
+        raise "AVD name is required" if name.nil? || name.empty?
+        raise "System image package is required" if package.nil? || package.empty?
+
+        command = [
+          "create avd",
+          "-n #{name.shellescape}",
+          "-f",
+          "-k \"#{package}\"",
+          "-d #{device.shellescape}"
+        ].join(" ")
+
+        trigger(command: command)
+      end
+    end
+
+    class EmulatorHelper
+      attr_accessor :emulator_path
+
+      def initialize(emulator_path: nil)
+        android_home = ENV.fetch('ANDROID_HOME', nil) || ENV.fetch('ANDROID_SDK_ROOT', nil)
+        if (emulator_path.nil? || emulator_path == "avdmanager") && android_home
+          emulator_path = File.join(android_home, "emulator", "emulator")
+        end
+
+        self.emulator_path = Helper.get_executable_path(File.expand_path(emulator_path))
+      end
+
+      def trigger(command: nil)
+        raise "emulator_path is not set" unless emulator_path
+
+        # Build and execute the command
+        command = [emulator_path.shellescape, command].compact.join(" ").strip
+        Action.sh(command)
+      end
+
+      # Start an emulator instance
+      def start_emulator(name:, port:)
+        raise "Emulator name is required" if name.nil? || name.empty?
+        raise "Port is required" if port.nil? || port.to_s.empty?
+
+        command = [
+          "-avd #{name.shellescape}",
+          "-port #{port.shellescape}",
+          "-wipe-data",
+          "-no-boot-anim",
+          "-no-snapshot",
+          "-no-audio",
+          "> /dev/null 2>&1 &"
+        ].join(" ")
+
+        UI.message("Starting emulator #{name} on port #{port}...")
+        trigger(command: command)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/maestro_orchestration/version.rb

@@ -0,0 +1,5 @@
+module Fastlane
+  module MaestroOrchestration
+    VERSION = "0.1.0"
+  end
+end

data/lib/fastlane/plugin/maestro_orchestration.rb

@@ -0,0 +1,16 @@
+require 'fastlane/plugin/maestro_orchestration/version'
+
+module Fastlane
+  module MaestroOrchestration
+    # Return all .rb files inside the "actions" and "helper" directory
+    def self.all_classes
+      Dir[File.expand_path('**/{actions,helper}/*.rb', File.dirname(__FILE__))]
+    end
+  end
+end
+
+# By default we want to import all available actions and helpers
+# A plugin can contain any number of actions and plugins
+Fastlane::MaestroOrchestration.all_classes.each do |current|
+  require current
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-maestro_orchestration
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nemanja Risteski
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-01-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fastlane-plugin-android_emulator
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+description:
+email: nemanja.risteski@sourcetoad.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/maestro_orchestration.rb
+- lib/fastlane/plugin/maestro_orchestration/actions/maestro_orchestration_android_action.rb
+- lib/fastlane/plugin/maestro_orchestration/actions/maestro_orchestration_api_request_action.rb
+- lib/fastlane/plugin/maestro_orchestration/actions/maestro_orchestration_ios_action.rb
+- lib/fastlane/plugin/maestro_orchestration/actions/maestro_orchestration_s3_upload_action.rb
+- lib/fastlane/plugin/maestro_orchestration/helper/maestro_orchestration_helper.rb
+- lib/fastlane/plugin/maestro_orchestration/version.rb
+homepage: https://github.com/sourcetoad/fastlane-plugin-maestro_orchestration
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: Plugin for maestro testing framework.
+test_files: []