fastlane-plugin-saucectl 0.1.3.pre → 0.1.3

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

@@ -0,0 +1,180 @@
+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 AndroidSuites
+      include FileUtils
+
+      UI = FastlaneCore::UI unless Fastlane.const_defined?(:UI)
+
+      def initialize(config)
+        UI.user_error!("❌ #{config[:kind]} is not a supported test framework for android. Use espresso") unless config[:kind].eql?('espresso')
+        @devices = config[:devices].nil? ? config[:emulators] : config[:devices]
+        @is_real_device = config[:emulators].nil?
+        @config = config
+      end
+
+      def generate
+        if @config[:test_distribution] || @config[:size] || @config[:annotation]
+          create_test_distribution_suite
+        elsif @config[:test_class].kind_of?(Array)
+          custom_test_class_suite
+        else
+          test_runner_suite
+        end
+      end
+
+      def test_distribution_array
+        @config[:test_class] || Fastlane::Saucectl::Espresso.new(@config).test_distribution
+      end
+
+      def suite_name(test_type)
+        if ENV['JOB_NAME'].nil? && ENV['BUILD_NUMBER'].nil?
+          "#{@config[:kind]}-#{test_type}"
+        else
+          "#{ENV['JOB_NAME']}-#{ENV['BUILD_NUMBER']}-#{test_type}"
+        end
+      end
+
+      def shard_suites
+        UI.user_error!("❌ Cannot split #{@config[:test_distribution]}'s across devices with a single device/emulator. \nPlease specify a minimum of two devices/emulators!") if @devices.size.eql?(1)
+
+        test_suites = []
+        arr = test_distribution_array
+        shards = arr.each_slice((arr.size / @devices.size.to_f).round).to_a
+        shards.each_with_index do |suite, i|
+          device_options = @is_real_device ? real_device_options(@devices[i]) : virtual_device_options(@devices[i])
+          test_suites << {
+            'name' => suite_name("shard #{i + 1}").downcase,
+            'testOptions' => test_option_type(suite)
+          }.merge(device_options)
+        end
+        test_suites
+      end
+
+      def test_runner_suite
+        test_suites = []
+        @devices.each do |device|
+          device_options = @is_real_device ? real_device_options(device) : virtual_device_options(device)
+          device_name = device.key?(:id) ? device[:id] : device[:name]
+          test_suites << {
+            'name' => suite_name(device_name),
+            'testOptions' => test_option_type
+          }.merge(device_options)
+        end
+        test_suites
+      end
+
+      def custom_test_class_suite
+        test_suites = []
+        @devices.each do |device|
+          device_options = @is_real_device ? real_device_options(device) : virtual_device_options(device)
+          test_classes = @config[:test_class].reject(&:empty?).join(',')
+          test_suites << {
+            'name' => suite_name(device[:name]).downcase,
+            'testOptions' => test_option_type(test_classes.split(','))
+          }.merge(device_options)
+        end
+        test_suites
+      end
+
+      def create_test_distribution_suite
+        if @config[:test_distribution].eql?('shard')
+          shard_suites
+        else
+          test_distribution_suite
+        end
+      end
+
+      def test_distribution_suite
+        UI.user_error!("❌ to distribute tests you must specify the path to your espresso tests. For example `path_to_tests:someModule/src/androidTest`") if @config[:path_to_tests].nil?
+
+        test_suites = []
+        if @config[:size] || @config[:annotation]
+          @devices.each do |device|
+            device_options = @is_real_device ? real_device_options(device) : virtual_device_options(device)
+            test_suites << {
+              'name' => suite_name(device[:name]).downcase,
+              'testOptions' => test_option_type
+            }.merge(device_options)
+          end
+        else
+          @devices.each do |device|
+            device_options = @is_real_device ? real_device_options(device) : virtual_device_options(device)
+            test_distribution_array.each do |test_type|
+              test_suites << {
+                'name' => suite_name(test_type).downcase,
+                'testOptions' => test_option_type(test_type)
+              }.merge(device_options)
+            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 test_option_type(test_type = nil)
+        if @config[:size] || @config[:annotation]
+          key = @config[:size] ? 'size' : 'annotation'
+          value = @config[:size] || @config[:annotation]
+          { key => value }.merge(android_test_options)
+        else
+          if test_type.nil?
+            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
+      end
+
+      def android_test_options
+        {
+          'clearPackageData' => @config[:clear_data],
+          'useTestOrchestrator' => @config[:use_test_orchestrator]
+        }
+      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,84 @@
+require 'fileutils'
+require 'yaml'
+require 'uri'
+require 'net/http'
+require 'json'
+require 'base64'
+require 'open3'
+require_relative 'ios_suites'
+require_relative 'android_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]
+          },
+          (@config[:kind]).to_s => set_apps,
+          'artifacts' => {
+            'download' => {
+              'when' => 'always',
+              'match' => ['junit.xml'],
+              'directory' => './artifacts/'
+            }
+          },
+          'reporters' => {
+            'junit' => {
+              'enabled' => true
+            }
+          }
+        }
+      end
+
+      def set_region
+        @config[:region] == 'eu' ? 'eu-central-1' : 'us-west-1'
+      end
+
+      def set_apps
+        {
+          'app' => @config[:app],
+          'testApp' => @config[:test_app]
+        }
+      end
+
+      def suite
+        @config[:platform].eql?('ios') ? Fastlane::Saucectl::IosSuites.new(@config) : Fastlane::Saucectl::AndroidSuites.new(@config)
+      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({ 'suites' => suite.generate })
+        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 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 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

@@ -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,54 @@
+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