fastlane-plugin-saucectl 0.1.0.pre

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

@@ -0,0 +1,95 @@
+require 'fastlane/action'
+require_relative '../helper/api'
+
+module Fastlane
+  module Actions
+    class SauceDevicesAction < Action
+      @messages = YAML.load_file("#{__dir__}/../strings/messages.yml")
+
+      def self.run(params)
+        platform = params[:platform]
+        case platform
+        when 'android'
+          Fastlane::Saucectl::Api.new(params).fetch_android_devices
+        when 'ios'
+          Fastlane::Saucectl::Api.new(params).fetch_ios_devices
+        else
+          Fastlane::Saucectl::Api.new(params).available_devices
+        end
+      end
+
+      def self.description
+        "Returns a list of Device IDs for all devices in the data center that are currently free for testing."
+      end
+
+      def self.details
+        "Returns a list of Device IDs for all devices in the data center that are currently free for testing."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :platform,
+                                       description: "Device platform that you wish to query",
+                                       optional: true,
+                                       is_string: true,
+                                       default_value: ''),
+          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_devices({platform: 'android',
+                          region: 'eu',
+                          sauce_username: 'foo',
+                          sauce_access_key: 'bar123',
+                       })",
+          "sauce_devices({region: 'eu',
+                          sauce_username: 'foo',
+                          sauce_access_key: 'bar123',
+                       })",
+          "sauce_devices({region: 'us',
+                          sauce_username: 'foo',
+                          sauce_access_key: 'bar123',
+                       })"
+        ]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require_relative '../helper/runner'
+
+module Fastlane
+  module Actions
+    class SauceRunnerAction < Action
+      @messages = YAML.load_file("#{__dir__}/../strings/messages.yml")
+
+      def self.run(run = '')
+        Saucectl::Runner.new.execute
+      end
+
+      def self.description
+        "Execute automated tests on sauce labs platform via saucectl binary for specified configuration"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :sauce_username,
+                                       env_name: "SAUCE_USERNAME",
+                                       default_value: Actions.lane_context[SharedValues::SAUCE_USERNAME],
+                                       description: "Your sauce labs 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",
+                                       default_value: Actions.lane_context[SharedValues::SAUCE_ACCESS_KEY],
+                                       description: "Your sauce labs access key",
+                                       optional: false,
+                                       is_string: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!(@messages['sauce_api_key_error']) if 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
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+require 'fastlane/action'
+require 'json'
+require 'yaml'
+require_relative '../helper/api'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      SAUCE_USERNAME = :SAUCE_USERNAME
+      SAUCE_ACCESS_KEY = :SAUCE_ACCESS_KEY
+    end
+
+    class SauceUploadAction < Action
+      @messages = YAML.load_file("#{__dir__}/../strings/messages.yml")
+
+      def self.run(params)
+        response = Fastlane::Saucectl::Api.new(params).upload
+        body = JSON.parse(response.body)
+        body['item']['id']
+      end
+
+      def self.description
+        "Upload test artifacts to sauce labs storage"
+      end
+
+      def self.details
+        "Upload test artifacts to sauce labs storage"
+      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: :file,
+                                       description: "File to upload to sauce storage",
+                                       optional: false,
+                                       is_string: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!(@messages['file_error']) unless value && !value.empty?
+                                         if value
+                                           UI.user_error!("Could not find file to upload \"#{value}\" ") unless File.exist?(value)
+                                           extname = File.extname(value)
+                                           UI.user_error!("Extension not supported for \"#{value}\" ") unless @messages['accepted_file_types'].include?(extname)
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :app,
+                                       description: "Name of the application to be uploaded",
+                                       optional: false,
+                                       is_string: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!(@messages['app_name_error']) unless value && !value.empty?
+                                       end),
+          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)) 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_upload({
+                    platform: 'android',
+                    sauce_username: 'username',
+                    sauce_access_key: 'accessKey',
+                    app: 'Android.MyCustomApp.apk',
+                    file: 'app/build/outputs/apk/debug/app-debug.apk',
+                    region: 'eu'
+                  })",
+          "sauce_upload({
+                    platform: 'android',
+                    sauce_username: 'username',
+                    sauce_access_key: 'accessKey',
+                    app: 'Android.MyCustomApp.apk',
+                    file: 'app/build/outputs/apk/debug/app-debug.apk',
+                    region: 'eu',
+                    app_description: 'this is a test description'
+                  })",
+          "sauce_upload({
+                    platform: 'ios',
+                    sauce_username: 'username',
+                    sauce_access_key: 'accessKey',
+                    app: 'MyTestApp.ipa',
+                    file: 'path/to/my/app/MyTestApp.ipa',
+                    region: 'eu'
+                  })"
+        ]
+      end
+
+      def self.return_value
+        "Returns the application id of the app uploaded"
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/saucectl/helper/api.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'net/http'
+require 'open-uri'
+require 'json'
+require 'base64'
+require 'timeout'
+require 'fastlane_core/ui/ui'
+require 'fileutils'
+
+module Fastlane
+  module Saucectl
+    #
+    # This class provides the functions required to interact with the saucectl api
+    # for more information see: https://docs.saucelabs.com/dev/api/storage/
+    #
+    class Api
+      UI = FastlaneCore::UI unless Fastlane.const_defined?(:UI)
+
+      def initialize(config)
+        @config = config
+        @encoded_auth_string = Base64.strict_encode64("#{@config[:sauce_username]}:#{@config[:sauce_access_key]}")
+        @messages = YAML.load_file("#{__dir__}/../strings/messages.yml")
+      end
+
+      def available_devices
+        path = 'v1/rdc/devices/available'
+        https, url = build_http_request_for(path)
+        request = Net::HTTP::Get.new(url)
+        request['Authorization'] = "Basic #{@encoded_auth_string}"
+        response = https.request(request)
+        UI.user_error!("❌ Request failed: #{response.code} #{response.message}") unless response.kind_of?(Net::HTTPOK)
+
+        JSON.parse(response.body)
+      end
+
+      def fetch_ios_devices
+        devices = []
+        get_devices = available_devices
+        get_devices.each do |device|
+          devices << device if device =~ /iPhone_.*/ || device =~ /iPad_.*/
+        end
+        devices
+      end
+
+      def fetch_android_devices
+        devices = []
+        get_devices = available_devices
+        get_devices.each do |device|
+          devices << device unless device =~ /iPhone_.*/ || device =~ /iPad_.*/
+        end
+        devices
+      end
+
+      def retrieve_all_apps
+        UI.message("retrieving all apps for \"#{@config[:query]}\".")
+        path = "v1/storage/files?q=#{@config[:query]}&kind=#{@config[:platform]}"
+        https, url = build_http_request_for(path)
+        request = Net::HTTP::Get.new(url)
+        request['Authorization'] = "Basic #{@encoded_auth_string}"
+        response = https.request(request)
+
+        UI.user_error!("❌ Request failed: #{response.code} #{response.message}") unless response.kind_of?(Net::HTTPOK)
+
+        response
+      end
+
+      def upload
+        UI.message("⏳ Uploading \"#{@config[:app]}\" upload to Sauce Labs.")
+        path = 'v1/storage/upload'
+        https, url = build_http_request_for(path)
+        request = Net::HTTP::Post.new(url)
+        request['Authorization'] = "Basic #{@encoded_auth_string}"
+        form_data = [['payload', File.open(@config[:file])], ['name', @config[:app]]]
+        request.set_form(form_data, 'multipart/form-data')
+        response = https.request(request)
+        UI.success("✅ Successfully uploaded app to sauce labs: \n #{response.body}") if response.code.eql?('201')
+        UI.user_error!("❌ Request failed: #{response.code} #{response.message}") unless response.code.eql?('201')
+
+        response
+      end
+
+      def delete_app(path)
+        https, url = build_http_request_for(path)
+        request = Net::HTTP::Delete.new(url.path)
+        request['Authorization'] = "Basic #{@encoded_auth_string}"
+        response = https.request(request)
+        UI.success("✅ Successfully deleted app from sauce labs storage: \n #{response.body}") if response.kind_of?(Net::HTTPOK)
+        UI.user_error!("❌ Request failed: #{response.code} #{response.message}") unless response.kind_of?(Net::HTTPOK)
+
+        response
+      end
+
+      def base_url_for_region
+        case @config[:region]
+        when 'eu' then base_url('eu-central-1')
+        when 'us' then base_url('us-west-1')
+        else UI.user_error!("#{@config[:region]} is an invalid region ❌. Available: #{@messages['supported_regions']}")
+        end
+      end
+
+      def build_http_request_for(path)
+        url = URI("#{base_url_for_region}/#{path}")
+        https = Net::HTTP.new(url.host, url.port)
+        https.use_ssl = true
+        [https, url]
+      end
+
+      def base_url(region)
+        "https://api.#{region}.saucelabs.com"
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/saucectl/helper/config.rb

@@ -0,0 +1,97 @@
+require 'fileutils'
+require 'yaml'
+require 'uri'
+require 'net/http'
+require 'json'
+require 'base64'
+require 'open3'
+require_relative 'suites'
+
+module Fastlane
+  module Saucectl
+    #
+    # This class creates saucectl config.yml file based on given specifications
+    #
+    class ConfigGenerator
+      UI = FastlaneCore::UI unless Fastlane.const_defined?(:UI)
+
+      def initialize(config)
+        @config = config
+      end
+
+      def base_config
+        {
+          'apiVersion' => 'v1alpha',
+          'kind' => @config[:kind],
+          'retries' => @config[:retries],
+          'sauce' => {
+            'region' => set_region.to_s,
+            'concurrency' => @config[:max_concurrency_size],
+            'metadata' => {
+              'name' => "#{ENV['JOB_NAME']}-#{ENV['BUILD_NUMBER']}",
+              'build' => "Release #{ENV['CI_COMMIT_SHORT_SHA']}"
+            }
+          },
+          (@config[:kind]).to_s => set_apps,
+          'artifacts' => {
+            'download' => {
+              'when' => 'always',
+              'match' => ['junit.xml'],
+              'directory' => './artifacts/'
+            }
+          },
+          'reporters' => {
+            'junit' => {
+              'enabled' => true
+            }
+          }
+        }
+      end
+
+      def set_region
+        case @config[:region]
+        when 'eu'
+          'eu-central-1'
+        else
+          'us-west-1'
+        end
+      end
+
+      def set_apps
+        {
+          'app' => @config[:app],
+          'testApp' => @config[:test_app]
+        }
+      end
+
+      def create
+        UI.message("Creating saucectl config .....🚕💨")
+        file_name = 'config.yml'
+        UI.user_error!("❌ Sauce Labs platform does not support virtual device execution for ios apps") if @config[:platform].eql?('ios') && @config[:emulators]
+
+        config = base_config.merge(create_suite)
+        out_file = File.new(file_name, 'w')
+        out_file.puts(config.to_yaml)
+        out_file.close
+        creat_sauce_dir
+        FileUtils.move(file_name, './.sauce')
+        UI.message("Successfully created saucectl config ✅") if Dir.exist?('.sauce')
+        UI.user_error!("Failed to create saucectl config ❌") unless Dir.exist?('.sauce')
+      end
+
+      def create_suite
+        suite = Fastlane::Saucectl::Suites.new(@config)
+        { 'suites' => if @config[:emulators]
+                        suite.create_virtual_device_suites
+                      else
+                        suite.create_real_device_suites
+                      end }
+      end
+
+      def creat_sauce_dir
+        dirname = '.sauce'
+        FileUtils.mkdir_p(dirname) unless File.directory?(dirname)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/saucectl/helper/espresso.rb

@@ -0,0 +1,93 @@
+require "find"
+require "open3"
+require "json"
+require_relative "file_utils"
+
+module Fastlane
+  module Saucectl
+    # This class is responsible for creating test execution plans for ios applications and will distribute tests
+    # that will be be executed via the cloud provider.
+    #
+    class Espresso
+      include FileUtils
+      UI = FastlaneCore::UI unless Fastlane.const_defined?(:UI)
+
+      TEST_FUNCTION_REGEX = /([a-z]+[A-Z][a-zA-Z]+)[(][)]/.freeze
+
+      def initialize(config)
+        @config = config
+      end
+
+      def test_data
+        test_details = []
+        search_retrieve_test_classes(@config[:path_to_tests]).each do |f|
+          next unless File.basename(f) =~ CLASS_NAME_REGEX
+
+          test_details << { package: File.readlines(f).first.chomp.gsub("package ", "").gsub(";", ""),
+                            class: File.basename(f).gsub(FILE_TYPE_REGEX, ""),
+                            tests: tests_from(f) }
+        end
+
+        strip_empty(test_details)
+      end
+
+      def test_distribution
+        test_distribution_check
+        tests_arr = []
+        case @config[:test_distribution]
+        when "package"
+          test_data.each { |type| tests_arr << type[:package] }
+        when 'class', 'shard'
+          test_data.each { |type| tests_arr << "#{type[:package]}.#{type[:class]}" }
+        else
+          test_data.each do |type|
+            type[:tests].each { |test| tests_arr << "#{type[:package]}.#{type[:class]}##{test}" }
+          end
+        end
+        tests_arr.uniq
+      end
+
+      def test_distribution_check
+        return @config[:test_distribution] if @config[:test_distribution].kind_of?(Array)
+
+        distribution_types = %w[class testCase package shard]
+        unless distribution_types.include?(@config[:test_distribution]) || @config[:test_distribution].nil?
+          UI.user_error!("#{@config[:test_distribution]} is not a valid method of test distribution")
+        end
+      end
+
+      def strip_empty(test_details)
+        tests = []
+        test_details.each { |test| tests << test unless test[:tests].size.zero? }
+        tests
+      end
+
+      def tests_from(path)
+        stdout, = find(path, "@Test")
+        test_cases = []
+        stdout.split.each do |line|
+          test_cases << line.match(TEST_FUNCTION_REGEX).to_s.gsub(/[()]/, "") if line =~ TEST_FUNCTION_REGEX
+        end
+        strip_skipped(path, test_cases)
+      end
+
+      def fetch_disabled_tests(path)
+        stdout, = find(path, "@Ignore")
+        test_cases = []
+        stdout.split.each do |line|
+          test_cases << line.match(TEST_FUNCTION_REGEX).to_s.gsub(/[()]/, "") if line =~ TEST_FUNCTION_REGEX
+        end
+        test_cases
+      end
+
+      def strip_skipped(path, tests)
+        enabled_ui_tests = []
+        skipped_tests = fetch_disabled_tests(path)
+        tests.each do |test|
+          enabled_ui_tests << test unless skipped_tests.include?(test)
+        end
+        enabled_ui_tests
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/saucectl/helper/file_utils.rb

@@ -0,0 +1,27 @@
+require "open3"
+
+# utility module for helper functions
+module FileUtils
+  CLASS_NAME_REGEX = /(Spec|Specs|Test|Tests)/.freeze
+  FILE_TYPE_REGEX = /(.swift|.kt|.java)/.freeze
+
+  def read_file(name)
+    raise "File not found: #{name}" unless File.exist?(name)
+
+    File.read(name).split
+  end
+
+  def search_retrieve_test_classes(path)
+    Find.find(path).select do |f|
+      File.file?(f) if File.basename(f) =~ CLASS_NAME_REGEX
+    end
+  end
+
+  def find(class_name, regex)
+    syscall("find '#{class_name}' -type f -exec grep -h -C2 '#{regex}' {} +")
+  end
+
+  def syscall(*cmd)
+    Open3.capture3(*cmd)
+  end
+end

data/lib/fastlane/plugin/saucectl/helper/installer.rb

@@ -0,0 +1,51 @@
+require 'fastlane_core/ui/ui'
+require 'fastlane'
+require 'open-uri'
+require_relative 'file_utils'
+
+module Fastlane
+  module Saucectl
+    #
+    # This class provides the functions required to install the saucectl binary
+    #
+    class Installer
+      include FileUtils
+      UI = FastlaneCore::UI unless Fastlane.const_defined?(:UI)
+
+      def install
+        timeout_in_seconds = 30
+        Timeout.timeout(timeout_in_seconds) do
+          download_saucectl_installer
+          execute_saucectl_installer
+          UI.success("✅ Successfully installed saucectl runner binary 🚀")
+        rescue OpenURI::HTTPError => e
+          response = e.io
+          UI.user_error!("❌ Failed to install saucectl binary: status #{response.status[0]}")
+        end
+      end
+
+      def download_saucectl_installer
+        URI.open('sauce', 'wb') do |file|
+          file << URI.open('https://saucelabs.github.io/saucectl/install').read
+        end
+      end
+
+      def execute_saucectl_installer
+        status = system('sh sauce')
+        status == 1 ? UI.user_error!("❌ failed to install saucectl: #{stderr}") : status
+        executable = 'saucectl'
+        FileUtils.mv("bin/#{executable}", executable) unless File.exist?(executable)
+      end
+
+      def system(*cmd)
+        Open3.popen2e(*cmd) do |stdin, stdout_stderr, wait_thread|
+          Thread.new do
+            stdout_stderr.each { |out| UI.message(out) }
+          end
+          stdin.close
+          wait_thread.value
+        end
+      end
+    end
+  end
+end