fastlane-plugin-saucectl 0.1.0.pre.beta.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9e57867e9ee59c0310b1a657cc77cedad2b6ecd0e7baa01cb03b4862198790b0
+  data.tar.gz: e1e6583d43e376f642cec87a05d8cc8cd67d542878b142d8baa0bbac985d4ff9
+SHA512:
+  metadata.gz: 74976f753280b80f14e02865179eafb767066988bfbb4ac59ff4cf9564468d29ce4a7bde7b11a642d5d03ceba8a592bcfe955479985387a763799d8d1cd6b747
+  data.tar.gz: 85ab453571d3de28d56e6ed9460708d3f5e40af21e2a1f1d24987b26caa2a9ea68e556df0080154dc2389ffe13dd7743b4b5d00bcc3c99c5a215d57cb6923806

data/lib/fastlane/plugin/saucectl/actions/delete_from_storage_action.rb

@@ -0,0 +1,96 @@
+require 'fastlane/action'
+require 'json'
+require 'yaml'
+require_relative '../helper/api'
+require_relative '../helper/storage'
+
+module Fastlane
+  module Actions
+    class DeleteFromStorageAction < Action
+      @messages = YAML.load_file("#{__dir__}/../strings/messages.yml")
+
+      def self.run(params)
+        if params[:group_id].nil?
+          Fastlane::Saucectl::Storage.new(params).delete_app_with_file_id
+        else
+          Fastlane::Saucectl::Storage.new(params).delete_all_apps_for_group_id
+        end
+      end
+
+      def self.description
+        "Delete test artifacts from sauce labs storage"
+      end
+
+      def self.details
+        "Delete test artifacts from sauce labs storage by storage id or group id"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :region,
+                                       description: "Data Center region (us or eu), set using: region: 'eu'",
+                                       optional: false,
+                                       is_string: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!(@messages['region_error'].gsub!('$region', value)) if value.empty? || !@messages['supported_regions'].include?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :sauce_username,
+                                       env_name: "SAUCE_USERNAME",
+                                       description: "Your sauce labs username in order to authenticate delete file from app storage",
+                                       default_value: Actions.lane_context[SharedValues::SAUCE_USERNAME],
+                                       optional: false,
+                                       is_string: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!(@messages['sauce_username_error']) if value.empty?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :sauce_access_key,
+                                       env_name: "SAUCE_ACCESS_KEY",
+                                       description: "Your sauce labs access key in order to authenticate delete file from app storage",
+                                       default_value: Actions.lane_context[SharedValues::SAUCE_ACCESS_KEY],
+                                       optional: false,
+                                       is_string: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!(@messages['sauce_api_key_error']) if value.empty?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :app_id,
+                                       description: "The application id from sauce labs storage",
+                                       optional: true,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :group_id,
+                                       description: "The group id for sauce labs storage",
+                                       optional: true,
+                                       is_string: true)
+        ]
+      end
+
+      def self.authors
+        ["Ian Hamilton"]
+      end
+
+      def self.category
+        :testing
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :android].include?(platform)
+      end
+
+      def self.example_code
+        [
+          "delete_from_storage(
+            region: 'eu',
+            sauce_username: 'sauce username',
+            sauce_access_key: 'sauce api name',
+            app_id: '1234-1234-1234-1234'
+          )",
+          "delete_from_storage(
+            region: 'eu',
+            sauce_username: 'sauce username',
+            sauce_access_key: 'sauce api name',
+            group_id: '123456789'
+          )"
+        ]
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/saucectl/actions/disabled_tests_action.rb

@@ -0,0 +1,86 @@
+require 'fastlane/action'
+require 'json'
+require 'yaml'
+require_relative '../helper/espresso'
+require_relative '../helper/xctest'
+
+module Fastlane
+  module Actions
+    class DisabledTestsAction < Action
+      @messages = YAML.load_file("#{__dir__}/../strings/messages.yml")
+
+      def self.run(params)
+        verify_config(params)
+        if params[:platform].eql?('android')
+          params[:path_to_tests] ? params[:path_to_tests] : params[:path_to_tests] = "app/src/androidTest"
+          Fastlane::Saucectl::Espresso.new(params).fetch_disabled_tests(params[:path_to_tests])
+        else
+          Fastlane::Saucectl::XCTest.new(params).fetch_disabled_tests
+        end
+      end
+
+      def self.verify_config(params)
+        if params[:platform].eql?('ios') && params[:test_plan].nil?
+          UI.user_error!('Cannot get skipped tests for an ios project without a known test_plan')
+        end
+        if params[:platform].eql?('android') && !params[:test_plan].nil?
+          UI.user_error!('test_plan option is reserved for ios projects only')
+        end
+      end
+
+      def self.description
+        "Fetches any disabled ui test cases (for android searches for @Ignore tests, and for ios skipped tests within an xcode test plan). Will be used in future for generating pretty HTML reports"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :platform,
+                                       description: "application under test platform (ios or android)",
+                                       optional: false,
+                                       is_string: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!(@messages['platform_error']) if value.to_s.empty?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :path_to_tests,
+                                       description: "Android only, path to espresso tests. Default to app/src/androidTest",
+                                       optional: true,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :test_plan,
+                                       description: "Name of xcode test plan",
+                                       optional: true,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :test_target,
+                                       description: "Name of xcode test target",
+                                       optional: true,
+                                       is_string: true)
+        ]
+      end
+
+      def self.authors
+        ["Ian Hamilton"]
+      end
+
+      def self.category
+        :testing
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :android].include?(platform)
+      end
+
+      def self.example_code
+        [
+          "disabled_tests({ platform: 'android',
+                            path_to_tests: 'my-demo-app-android/app/src/androidTest'
+          })",
+          "disabled_tests({ platform: 'ios',
+                            test_plan: 'UITests'
+          })",
+          "disabled_tests({ platform: 'ios',
+                            test_plan: 'UITests'
+          })"
+        ]
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/saucectl/actions/install_toolkit_action.rb

@@ -0,0 +1,30 @@
+require 'fastlane/action'
+require_relative '../helper/installer'
+
+module Fastlane
+  module Actions
+    class InstallToolkitAction < Action
+      def self.run(param = '')
+        UI.message("Installing saucectl 🤖 🚀")
+        installer = Saucectl::Installer.new
+        installer.install
+      end
+
+      def self.description
+        "Installs the Sauce Labs saucectl cli binary"
+      end
+
+      def self.authors
+        ["Ian Hamilton"]
+      end
+
+      def self.category
+        :testing
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :android].include?(platform)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/saucectl/actions/sauce_apps_action.rb

@@ -0,0 +1,96 @@
+require 'fastlane/action'
+require 'json'
+require 'yaml'
+require_relative '../helper/api'
+
+module Fastlane
+  module Actions
+    class SauceAppsAction < Action
+      @messages = YAML.load_file("#{__dir__}/../strings/messages.yml")
+      def self.run(params)
+        Fastlane::Saucectl::Api.new(params).retrieve_all_apps
+      end
+
+      def self.description
+        "Returns the set of files by specific app id that have been uploaded to Sauce Storage by the requester"
+      end
+
+      def self.details
+        "Returns the set of files by specific app id that have been uploaded to Sauce Storage by the requester"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :platform,
+                                       description: "application under test platform (ios or android)",
+                                       optional: false,
+                                       type: String,
+                                       verify_block: proc do |value|
+                                         UI.user_error!(@messages['platform_error']) if value.to_s.empty?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :query,
+                                       description: "Any search term (such as build number or file name) by which you want to filter results",
+                                       optional: false,
+                                       type: String,
+                                       verify_block: proc do |value|
+                                         UI.user_error!(@messages['missing_file_name']) if value.to_s.empty?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :region,
+                                       description: "Data Center region (us or eu), set using: region: 'eu'",
+                                       optional: false,
+                                       type: String,
+                                       verify_block: proc do |value|
+                                         UI.user_error!(@messages['region_error'].gsub!('$region', value)) unless @messages['supported_regions'].include?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :sauce_username,
+                                       env_name: "SAUCE_USERNAME",
+                                       description: "Your sauce labs username in order to authenticate upload requests",
+                                       default_value: Actions.lane_context[SharedValues::SAUCE_USERNAME],
+                                       optional: false,
+                                       type: String,
+                                       verify_block: proc do |value|
+                                         UI.user_error!(@messages['sauce_username_error']) unless value && !value.empty?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :sauce_access_key,
+                                       env_name: "SAUCE_ACCESS_KEY",
+                                       description: "Your sauce labs access key in order to authenticate upload requests",
+                                       default_value: Actions.lane_context[SharedValues::SAUCE_ACCESS_KEY],
+                                       optional: false,
+                                       type: String,
+                                       verify_block: proc do |value|
+                                         UI.user_error!(@messages['sauce_api_key_error']) unless value && !value.empty?
+                                       end)
+        ]
+      end
+
+      def self.authors
+        ["Ian Hamilton"]
+      end
+
+      def self.category
+        :testing
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :android].include?(platform)
+      end
+
+      def self.example_code
+        [
+          "sauce_apps({platform: 'android',
+                       query: 'test.apk',
+                       region: 'eu',
+                       sauce_username: 'foo',
+                       sauce_access_key: 'bar123',
+                     })",
+          "sauce_apps({platform: 'ios',
+                       query: 'test.app',
+                       region: 'eu',
+                       sauce_username: 'foo',
+                       sauce_access_key: 'bar123',
+                     })"
+        ]
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/saucectl/actions/sauce_config_action.rb

@@ -0,0 +1,312 @@
+require 'fastlane/action'
+require 'json'
+require 'yaml'
+require_relative '../helper/config'
+require_relative '../helper/runner'
+
+module Fastlane
+  module Actions
+    class SauceConfigAction < Action
+      @messages = YAML.load_file("#{__dir__}/../strings/messages.yml")
+
+      def self.run(params)
+        if params[:platform].eql?('android')
+          UI.user_error!("❌ For android platform you must specify devices or emulators under test in order to execute tests") if params[:emulators].nil? && params[:devices].nil?
+        else
+          if params[:emulators]
+            UI.user_error!("❌ Sauce Labs platform does not currently support virtual device execution for ios apps")
+          end
+          UI.user_error!("❌ For ios platform you must specify devices under test in order to execute tests") if params[:devices].nil?
+        end
+
+        Fastlane::Saucectl::ConfigGenerator.new(params).create
+      end
+
+      def self.description
+        "Create SauceLabs configuration file for test execution based on given parameters"
+      end
+
+      def self.details
+        "Create SauceLabs configuration file for test execution based on given parameters"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :platform,
+                                       description: "application under test platform (ios or android)",
+                                       optional: false,
+                                       type: String,
+                                       verify_block: proc do |value|
+                                         UI.user_error!(@messages['platform_error']) if value.to_s.empty?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :kind,
+                                       description: "Specifies which framework is associated with the automation tests configured in this specification (xcuitest & espresso)",
+                                       optional: false,
+                                       type: String,
+                                       verify_block: proc do |value|
+                                         UI.user_error!(@messages['platform_error']) if value.to_s.empty?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :app,
+                                       description: "The path to the app",
+                                       optional: false,
+                                       type: String,
+                                       verify_block: proc do |value|
+                                         UI.user_error!(@messages['app_name_error']) unless value && !value.empty?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :test_app,
+                                       description: "The path to the testing app",
+                                       optional: false,
+                                       is_string: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!(@messages['test_runner_app_error']) unless value && !value.empty?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :region,
+                                       description: "Data Center region (us or eu), set using: region: 'eu'",
+                                       optional: false,
+                                       type: String,
+                                       verify_block: proc do |value|
+                                         UI.user_error!(@messages['region_error'].gsub!('$region', value)) unless @messages['supported_regions'].include?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :retries,
+                                       description: "Sets the number of times to retry a failed suite",
+                                       optional: true,
+                                       type: Integer,
+                                       default_value: 0),
+          FastlaneCore::ConfigItem.new(key: :test_distribution,
+                                       description: "Test distribution method",
+                                       optional: true,
+                                       type: String,
+                                       default_value: 'class'),
+          FastlaneCore::ConfigItem.new(key: :test_class,
+                                       description: "Array of tests to execute",
+                                       optional: true,
+                                       type: Array),
+          FastlaneCore::ConfigItem.new(key: :emulators,
+                                       description: "The parent property that defines details for running this suite on virtual devices using an emulator",
+                                       optional: true,
+                                       type: Array,
+                                       verify_block: proc do |emulators|
+                                         emulators.each do |emulator|
+                                           if emulator.class != Hash
+                                             UI.user_error!("Each emulator must be represented by a Hash object, #{emulator.class} found")
+                                           end
+                                           verify_device_property(emulator, :name)
+                                           set_default_property(emulator, :orientation, 'portrait')
+                                           verify_device_property(emulator, :platform_versions)
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :devices,
+                                       description: "The parent property that defines details for running this suite on real devices",
+                                       optional: true,
+                                       type: Array,
+                                       verify_block: proc do |devices|
+                                         devices.each do |device|
+                                           if device.class != Hash
+                                             UI.user_error!("Each device must be represented by a Hash object, #{device.class} found")
+                                           end
+                                           verify_optional_device_props(device)
+                                           set_default_property(device, :orientation, 'portrait')
+                                           set_default_property(device, :device_type, 'phone')
+                                           set_default_property(device, :private, true)
+                                           set_default_property(device, :carrier_connectivity, false)
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :name,
+                                       description: "The name of the device or emulator",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :id,
+                                       description: "The id of the device",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :platform_versions,
+                                       description: "Platform versions of the virtual device you wish to test your application on: Virtual Device only",
+                                       optional: true,
+                                       type: Array),
+          FastlaneCore::ConfigItem.new(key: :platform_version,
+                                       description: "Platform version of the real device you wish to test your application on: Real device only",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :orientation,
+                                       description: "The orientation of the device. Default: portrait",
+                                       optional: true,
+                                       type: String,
+                                       default_value: 'portrait'),
+          FastlaneCore::ConfigItem.new(key: :device_type,
+                                       description: "Request that the matching device is a specific type of device. Valid values are: ANY TABLET PHONE any tablet phone",
+                                       optional: true,
+                                       type: String,
+                                       default_value: 'phone'),
+          FastlaneCore::ConfigItem.new(key: :private,
+                                       description: "Request that the matching device is from your organization's private pool",
+                                       optional: true,
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :carrier_connectivity,
+                                       description: "Request that the matching device is also connected to a cellular network",
+                                       optional: true,
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :test_target,
+                                       description: "Name of the Xcode test target name",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :test_plan,
+                                       description: "Name of the Xcode test plan",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :path_to_tests,
+                                       description: "Path to your espresso tests",
+                                       optional: true,
+                                       type: String,
+                                       default_value: "#{Dir.pwd}/app/src/androidTest"),
+          FastlaneCore::ConfigItem.new(key: :clear_data,
+                                       description: "Clear package data from device (android only)",
+                                       optional: true,
+                                       is_string: false,
+                                       default_value: true),
+          FastlaneCore::ConfigItem.new(key: :use_test_orchestrator,
+                                       description: "User Android test orchestrator (android only)",
+                                       optional: true,
+                                       is_string: false,
+                                       default_value: true),
+          FastlaneCore::ConfigItem.new(key: :max_concurrency_size,
+                                       description: "Sets the maximum number of suites to execute at the same time. If the test defines more suites than the max, excess suites are queued and run in order as each suite completes",
+                                       optional: true,
+                                       type: Integer,
+                                       default_value: 1)
+        ]
+      end
+
+      def self.verify_device_property(device, property)
+        UI.user_error!("Each device must have #{property} property") unless device.key?(property)
+      end
+
+      def self.verify_optional_device_props(device)
+        unless device.key?(:name) || device.key?(:id)
+          UI.user_error!("Real devices must have a device name or device id")
+        end
+      end
+
+      private_class_method :verify_device_property
+
+      def self.set_default_property(device, property, default)
+        unless device.key?(property)
+          device[property] = default
+        end
+      end
+
+      private_class_method :set_default_property
+
+      def self.authors
+        ["Ian Hamilton"]
+      end
+
+      def self.category
+        :testing
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :android].include?(platform)
+      end
+
+      def self.example_code
+        [
+          "sauce_config({platform: 'android',
+                         kind: 'espresso',
+                         app: 'path/to/myTestApp.apk',
+                         test_app: 'path/to/myTestRunner.apk',
+                         path_to_tests: 'path/to/app/src/androidTest',
+                         region: 'eu',
+                         emulators: [ {name: 'Android GoogleApi Emulator', platform_versions: %w[10.0 11.0], orientation: 'portrait'}]
+                       })",
+          "sauce_config({platform: 'android',
+                         kind: 'espresso',
+                         app: 'path/to/myTestApp.apk',
+                         test_app: 'path/to/myTestRunner.apk',
+                         path_to_tests: 'path/to/app/src/androidTest',
+                         region: 'eu',
+                         test_distribution: 'testCase',
+                         devices: [ {name: 'RDC One', orientation: 'portrait', platform_version: '11.0'}]
+          })",
+          "sauce_config({platform: 'android',
+                         kind: 'espresso',
+                         app: 'path/to/myTestApp.apk',
+                         test_app: 'path/to/myTestRunner.apk',
+                         path_to_tests: 'path/to/app/src/androidTest',
+                         region: 'eu',
+                         test_distribution: 'shard',
+                         devices: [ {name: 'RDC One', orientation: 'portrait', platform_version: '11.0'}]
+          })",
+          "sauce_config({platform: 'ios',
+                         kind: 'xcuitest',
+                         app: 'path/to/MyTestApp.ipa',
+                         test_app: 'path/to/MyTestAppRunner.ipa',
+                         region: 'eu',
+                         devices: [ {name: 'iPhone RDC One'}, {id: 'iphone_rdc_two'} ],
+                         test_target: 'MyDemoAppUITests'
+          })",
+          "sauce_config({platform: 'ios',
+                         kind: 'xcuitest',
+                         app: 'path/to/MyTestApp.ipa',
+                         test_app: 'path/to/MyTestAppRunner.ipa',
+                         region: 'eu',
+                         devices: [ {name: 'iPhone RDC One'}, {id: 'iphone_rdc_two'} ],
+                         test_target: 'MyDemoAppUITests',
+                         test_distribution: 'shard',
+          })",
+          " sauce_config({platform: 'ios',
+                         kind: 'xcuitest',
+                         app: 'path/to/MyTestApp.ipa',
+                         test_app: 'path/to/MyTestAppRunner.ipa',
+                         region: 'eu',
+                         devices: [ {name: 'iPhone RDC One'}, {id: 'iphone_rdc_two'} ],
+                         test_target: 'MyDemoAppUITests',
+                         test_distribution: 'testCase'
+          })",
+          "sauce_config({platform: 'ios',
+                         kind: 'xcuitest',
+                         app: 'path/to/MyTestApp.ipa',
+                         test_app: 'path/to/MyTestAppRunner.ipa',
+                         region: 'eu',
+                         devices: [ {name: 'iPhone RDC One'}, {id: 'iphone_rdc_two'} ],
+                         test_plan: 'EnabledUITests',
+                         test_distribution: 'shard'
+          })",
+          "sauce_config({platform: 'ios',
+                         kind: 'xcuitest',
+                         app: 'path/to/MyTestApp.ipa',
+                         test_app: 'path/to/MyTestAppRunner.ipa',
+                         region: 'eu',
+                         devices: [ {name: 'iPhone RDC One'}, {id: 'iphone_rdc_two'} ],
+                         test_plan: 'UITests'
+          })",
+          "sauce_config({platform: 'android',
+                         kind: 'espresso',
+                         app: 'path/to/myTestApp.apk',
+                         test_app: 'path/to/myTestRunner.apk',
+                         path_to_tests: 'path/to/app/src/androidTest',
+                         region: 'eu',
+                         devices: [ {name: 'iPhone RDC One'}],
+                         test_class: ['com.some.package.testing.SomeClassOne', 'com.some.package.testing.SomeClassTwo', 'com.some.package.testing.SomeClassThree', 'com.some.package.testing.SomeClassFour']
+          })",
+          "sauce_config({platform: 'android',
+                         kind: 'espresso',
+                         app: 'path/to/myTestApp.apk',
+                         test_app: 'path/to/myTestRunner.apk',
+                         path_to_tests: 'path/to/app/src/androidTest',
+                         region: 'eu',
+                         emulators: [ {name: 'iPhone RDC One', platform_versions: ['11.0']}, {name: 'iPhone RDC Two', platform_versions: ['11.0']}],
+                         test_class: ['com.some.package.testing.SomeClassOne', 'com.some.package.testing.SomeClassTwo', 'com.some.package.testing.SomeClassThree', 'com.some.package.testing.SomeClassFour']
+          })",
+          "sauce_config({platform: 'ios',
+                         kind: 'xcuitest',
+                         app: 'path/to/myTestApp.app',
+                         test_app: 'path/to/myTestRunner.app',
+                         region: 'eu',
+                         devices: [ {name: 'iPhone RDC One'}],
+                         test_class: ['MyDemoAppUITests.SomeClassOne', 'MyDemoAppUITests.SomeClassTwo', 'MyDemoAppUITests.SomeClassThree', 'MyDemoAppUITests.SomeClassFour']
+          })"
+        ]
+      end
+    end
+  end
+end