fastlane-plugin-saucectl 0.1.3.pre → 0.1.4.pre

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

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

@@ -0,0 +1,36 @@
+require 'fastlane'
+require 'open3'
+require 'fastlane_core/ui/ui'
+require_relative "file_utils"
+
+module Fastlane
+  module Saucectl
+    #
+    # This class provides the ability to execute tests via configured specifications and capture the output of the sauce executable.
+    #
+    class Runner
+      include FileUtils
+      EXECUTABLE = 'saucectl'
+      UI = FastlaneCore::UI unless Fastlane.const_defined?(:UI)
+
+      def execute
+        unless File.exist?(EXECUTABLE)
+          UI.user_error!("❌ sauce labs executable file does not exist! Expected sauce executable file to be located at:'#{Dir.pwd}/#{EXECUTABLE}'")
+        end
+
+        system("chmod +x #{EXECUTABLE}")
+        system("./#{EXECUTABLE} run")
+      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

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

@@ -0,0 +1,46 @@
+require 'uri'
+require 'net/http'
+require 'json'
+require_relative 'api'
+
+module Fastlane
+  module Saucectl
+    # This class provides the ability to store, delete, and retrieve data from the Sauce Labs Storage API
+    class Storage
+      def initialize(config)
+        @config = config
+      end
+
+      # Get App Storage Files
+      # @return the set of files that have been uploaded to Sauce Storage by the requester.
+      def retrieve_all_apps
+        api = Fastlane::Saucectl::Api.new(@config)
+        api.retrieve_all_apps
+      end
+
+      # Delete app by the Sauce Labs identifier of the stored file. You can look up file IDs using the Get App Storage Files endpoint.
+      # https://docs.saucelabs.com/dev/api/storage/#get-app-storage-files
+      # @return json response containing the file id and the number of files deleted.
+      def delete_app_with_file_id
+        api = Fastlane::Saucectl::Api.new(@config)
+        api.delete_app("v1/storage/files/#{@config[:app_id]}")
+      end
+
+      # Deletes the specified group of files from Sauce Storage.
+      # The Sauce Labs identifier of the group of files. You can look up file IDs using the Get App Storage Groups endpoint.
+      # https://docs.saucelabs.com/dev/api/storage/#get-app-storage-groups
+      # @return json response containing the group ID and the number of files deleted.
+      def delete_all_apps_for_group_id
+        path = "v1/storage/files/#{@config[:group_id]}"
+        api = Fastlane::Saucectl::Api.new(@config)
+        api.delete_app(path)
+      end
+
+      # Uploads an application file to Sauce Storage for the purpose of mobile application testing
+      # @return a unique file ID assigned to the app.
+      def upload_app
+        Fastlane::Saucectl::Api.new(@config).upload
+      end
+    end
+  end
+end

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

@@ -0,0 +1,201 @@
+require 'base64'
+require 'fastlane'
+require 'fastlane_core/ui/ui'
+require_relative 'espresso'
+require_relative 'xctest'
+
+module Fastlane
+  module Saucectl
+    #
+    # This class will create test suites based on user specified configuration properties
+    #
+    class Suites
+      include FileUtils
+
+      UI = FastlaneCore::UI unless Fastlane.const_defined?(:UI)
+
+      def initialize(config)
+        @config = config
+      end
+
+      def create_test_plan
+        check_kind
+        if @config[:platform].casecmp('ios').zero?
+          is_ios_reqs_satisfied?
+          Fastlane::Saucectl::XCTest.new(@config)
+        else
+          Fastlane::Saucectl::Espresso.new(@config)
+        end
+      end
+
+      def check_kind
+        if @config[:platform].eql?('android')
+          UI.user_error!("❌ #{@config[:kind]} is not a supported test framework for android. Use espresso") unless @config[:kind].eql?('espresso')
+        else
+          UI.user_error!("❌ #{@config[:kind]} is not a supported test framework for iOS. Use xcuitest") unless @config[:kind].eql?('xcuitest')
+        end
+      end
+
+      def is_ios_reqs_satisfied?
+        if @config[:test_target].nil? && @config[:test_plan].nil?
+          UI.user_error!("❌ For ios you must specify test_target or test_plan")
+        end
+      end
+
+      def test_distribution_array
+        @config[:test_class] || create_test_plan.test_distribution
+      end
+
+      def suite_name(test_type)
+        if ENV['JOB_NAME'].nil? && ENV['BUILD_NUMBER'].nil?
+          "#{@config[:kind]}-#{test_type.split('.')[-1]}"
+        else
+          "#{ENV['JOB_NAME']}-#{ENV['BUILD_NUMBER']}-#{test_type.split('.')[-1]}"
+        end
+      end
+
+      def create_virtual_device_suites
+        if @config[:test_distribution] == 'shard'
+          shard_virtual_device_suites
+        elsif @config[:test_class]
+          custom_test_classes
+        else
+          test_suites = []
+          @config[:emulators].each do |emulator|
+            test_distribution_array.each do |test_type|
+              test_suites << {
+                'name' => suite_name(test_type).downcase,
+                'testOptions' => default_test_options(test_type)
+              }.merge(virtual_device_options(emulator))
+            end
+          end
+          test_suites
+        end
+      end
+
+      def shard_virtual_device_suites
+        UI.user_error!("❌ Cannot split #{@config[:test_distribution]}'s across virtual devices with a single emulator. \nPlease specify a minimum of two devices!") if @config[:emulators].size.eql?(1)
+        test_suites = []
+        arr = test_distribution_array
+        shards = arr.each_slice((arr.size / @config[:emulators].size.to_f).round).to_a
+        shards.each_with_index do |suite, i|
+          test_suites << {
+            'name' => suite_name("shard #{i + 1}").downcase,
+            'testOptions' => default_test_options(suite)
+          }.merge(virtual_device_options(@config[:emulators][i]))
+        end
+        test_suites
+      end
+
+      def shard_real_device_suites
+        test_suites = []
+        arr = test_distribution_array
+        shards = arr.each_slice((arr.size / @config[:devices].size.to_f).round).to_a
+        shards.each_with_index do |suite, i|
+          test_suites << {
+            'name' => suite_name("shard #{i + 1}").downcase,
+            'testOptions' => default_test_options(suite)
+          }.merge(real_device_options(@config[:devices][i]))
+        end
+        test_suites
+      end
+
+      def test_plan_suites
+        test_suites = []
+        @config[:devices].each do |device|
+          test_suites << {
+            'name' => suite_name(@config[:test_plan].to_s).downcase,
+            'testOptions' => default_test_options(test_distribution_array)
+          }.merge(real_device_options(device))
+        end
+        test_suites
+      end
+
+      def custom_test_classes
+        test_suites = []
+        devices = @config[:devices].nil? ? @config[:emulators] : @config[:devices]
+        devices.each do |device|
+          device_options = @config[:devices].nil? ? virtual_device_options(device) : real_device_options(device)
+          test_classes = @config[:test_class].reject(&:empty?).join(',')
+          test_suites << {
+            'name' => suite_name(device[:name]).downcase,
+            'testOptions' => default_test_options(test_classes.split(','))
+          }.merge(device_options)
+        end
+        test_suites
+      end
+
+      def create_real_device_suites
+        if !@config[:test_plan].nil? && @config[:test_distribution].eql?('class')
+          test_plan_suites
+        elsif @config[:test_distribution] == 'shard'
+          shard_real_device_suites
+        elsif @config[:test_class].kind_of?(Array)
+          custom_test_classes
+        else
+          test_suites = []
+          @config[:devices].each do |device|
+            test_distribution_array.each do |test_type|
+              test_suites << {
+                'name' => suite_name(test_type).downcase,
+                'testOptions' => default_test_options(test_type)
+              }.merge(real_device_options(device))
+            end
+          end
+          test_suites
+        end
+      end
+
+      def virtual_device_options(device)
+        platform_versions = device[:platform_versions].reject(&:empty?).join(',')
+        { 'emulators' => [{ 'name' => device[:name],
+                            'orientation' => device[:orientation],
+                            'platformVersions' => platform_versions.split(',') }] }
+      end
+
+      def real_device_options(device)
+        { 'devices' => [rdc_options(device)] }
+      end
+
+      def rdc_options(device)
+        device_type_key = device.key?(:id) ? 'id' : 'name'
+        name = device.key?(:id) ? device[:id] : device[:name]
+
+        base_device_hash = {
+          device_type_key => name,
+          'orientation' => device[:orientation]
+        }.merge('options' => device_options(device))
+
+        unless device[:platform_version].nil?
+          base_device_hash = base_device_hash.merge({ 'platformVersion' => device[:platform_version] })
+        end
+
+        base_device_hash
+      end
+
+      def device_options(device)
+        {
+          'carrierConnectivity' => device[:carrier_connectivity],
+          'deviceType' => device[:device_type].upcase!,
+          'private' => device[:private]
+        }
+      end
+
+      def default_test_options(test_type)
+        test_option_type = @config[:test_distribution].eql?('package') ? 'package' : 'class'
+        if @config[:platform] == 'android'
+          { test_option_type => test_type }.merge(android_test_options)
+        else
+          { 'class' => test_type }
+        end
+      end
+
+      def android_test_options
+        {
+          'clearPackageData' => @config[:clear_data],
+          'useTestOrchestrator' => @config[:use_test_orchestrator]
+        }
+      end
+    end
+  end
+end