fastlane-plugin-saucectl 0.1.2 → 0.1.3.pre

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

@@ -1,115 +0,0 @@
-# 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

@@ -1,97 +0,0 @@
-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

@@ -1,93 +0,0 @@
-require "find"
-require "open3"
-require "json"
-require_relative "file_utils"
-
-module Fastlane
-  module Saucectl
-    # This class is responsible for creating test execution plans for android 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

@@ -1,27 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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(version)
-        timeout_in_seconds = 90
-        Timeout.timeout(timeout_in_seconds) do
-          download_saucectl_installer
-          execute_saucectl_installer(version)
-          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', ssl_verify_mode: OpenSSL::SSL::VERIFY_NONE).read
-        end
-      end
-
-      def execute_saucectl_installer(version)
-        saucectl_version = version[:version].nil? ? '' : "v#{version[:version]}"
-        status = system("sh sauce #{saucectl_version}")
-        status == 1 ? UI.user_error!("❌ failed to install saucectl") : 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 do |out|
-              UI.message(out)
-            end
-          end
-          stdin.close
-          wait_thread.value
-        end
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-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 do |out|
-              message = out.gsub(/(?:\[[^\]].*\])|(?:\(\d{4}\))/, '')
-              puts(message)
-            end
-          end
-          stdin.close
-          wait_thread.value
-        end
-      end
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-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

@@ -1,219 +0,0 @@
-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
-          default_execution_suite
-        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
-          default_execution_suite
-        end
-      end
-
-      def default_execution_suite
-        type = @config[:annotation] ? 'annotation' : 'size'
-        UI.user_error!("❌ execution by #{type} is not supported on the iOS platform!") if @config[:platform].eql?('ios') && (@config[:size] || @config[:annotation])
-        is_real_device = @config[:devices]
-        test_devices = @config[:devices] || @config[:emulators]
-        test_suites = []
-        if @config[:size] || @config[:annotation]
-          test_devices.each do |device|
-            test_suites << {
-              'name' => suite_name(@config[:size] || @config[:annotation]).downcase,
-              'testOptions' => default_test_options(@config[:size])
-            }.merge(is_real_device ? real_device_options(device) : virtual_device_options(device))
-          end
-        else
-          test_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(is_real_device ? real_device_options(device) : virtual_device_options(device))
-            end
-          end
-        end
-        test_suites
-      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)
-        if @config[:platform] == 'android'
-          test_option_type(test_type)
-        else
-          { 'class' => test_type }
-        end
-      end
-
-      def test_option_type(test_type)
-        if @config[:size] || @config[:annotation]
-          key = @config[:size] ? 'size' : 'annotation'
-          value = @config[:size] || @config[:annotation]
-          { key => value }.merge(android_test_options)
-        else
-          test_option_type = @config[:test_distribution].eql?('package') ? 'package' : 'class'
-          { test_option_type => test_type }.merge(android_test_options)
-        end
-      end
-
-      def android_test_options
-        {
-          'clearPackageData' => @config[:clear_data],
-          'useTestOrchestrator' => @config[:use_test_orchestrator]
-        }
-      end
-    end
-  end
-end