fastlane-plugin-try_scan 0.2.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 871975db0faec46bf64db099bd0d14829460ff8e542bfa8dffcdd39c6d491854
-  data.tar.gz: d518a6bcb11b1b4833d06bad970b8ba5764301be2f7ff9f8d0c3f92621f8c8b5
+  metadata.gz: 9a2ac62b11641f4b9eedad2e76438debeec8e6e85ce255c1d556f8bed37df3bf
+  data.tar.gz: f131bd125d5dddb9b2ee61858e1d089a73ed1883d761db1ba8202305330ef70d
 SHA512:
-  metadata.gz: 913b1a9891ea9a4fcd066daa4d36c3fd96d0d18e05a0923691c82b32ad320766337a615615bd2bfa6894cc01657b67bb0224732fcfb8d6063c3b3eee92a3ac64
-  data.tar.gz: e299cfc1124d6ce7545289eb8620d95b2eaf2da62062ce377c5ef3b86ed9ee613ce244ea5880298a4357f8758f0592a0da7fdf4feed5c55cc79facc4105f9ab2
+  metadata.gz: 1cd2f40bdd31874c7a531a411e4fa0524fcb9d21950eaade21cca1db6e73424ccf59cfdc5f8ff8ada9a452eacc28710313657ee0ac3a356245a093b7d696d505
+  data.tar.gz: 89333c0f2af0d2f258e3596268da05e44ead692bba3f80eab9e1cf86bcdc034c7b3dc9ee3b2da08aa4644bfee04361fa19a4816e89e80f96872bb1b296db4b69

data/README.md

@@ -2,36 +2,38 @@
 
 [![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-try_scan)
 
+## About try_scan
+
+The easiest way to rerun tests of your iOS and Mac app 🚀
+
+Under the hood `try_scan` uses official [`fastlane scan action`](https://docs.fastlane.tools/actions/scan/), it means that you are able to provide any `scan` options and use `Scanfile` as before — everything will work like a charm, `try_scan` just brings couple of new amazing options:
+
+| Option | Description | Default |
+| ------- |------------ | ------- |
+| try_count | Number of times to try to get your tests green | 1 |
+| try_parallel | Should first run be executed in parallel? Equivalent to `-parallel-testing-enabled` | true |
+| retry_parallel | Should subsequent runs be executed in parallel? Required `try_parallel: true` | true |
+| parallel_workers | Specify the exact number of test runners that will be spawned during parallel testing. Equivalent to `-parallel-testing-worker-count` and `concurrent_workers` |  |
+| retry_strategy | What would you like to retry after failure: test, class or suite? | test |
+
+## Requirements
+
+* Xcode 11.x or greater. Download it at the [Apple Developer - Downloads](https://developer.apple.com/downloads) or the [Mac App Store](https://apps.apple.com/us/app/xcode/id497799835?mt=12).
+
 ## Getting Started
 
-This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `try_scan`, add it to your project by running:
+To get started with `try_scan`, add it to your project by running:
 
 ```bash
-fastlane add_plugin try_scan
+$ fastlane add_plugin try_scan
 ```
 
-## About try_scan
-
-Simple way to retry your scan action 🚀
-
 ## Usage
 
 ```ruby
 try_scan(
   workspace: "Example.xcworkspace",
-  devices: ["iPhone 6s", "iPad Air"],
+  devices: ["iPhone 7", "iPad Air"],
   try_count: 3
 )
 ```
-
-## Issues and Feedback
-
-For any other issues and feedback about this plugin, please submit it to this repository.
-
-## Troubleshooting
-
-If you have trouble using plugins, check out the [Plugins Troubleshooting](https://docs.fastlane.tools/plugins/plugins-troubleshooting/) guide.
-
-## About _fastlane_
-
-_fastlane_ is the easiest way to automate beta deployments and releases for your iOS and Android apps. To learn more, check out [fastlane.tools](https://fastlane.tools).

data/lib/fastlane/plugin/try_scan/actions/try_scan_action.rb

@@ -2,7 +2,6 @@ module Fastlane
   module Actions
 
     require 'json'
-    require 'nokogiri'
     require 'fastlane/actions/scan'
     require_relative '../helper/scan_helper'
     require_relative '../helper/try_scan_runner'
@@ -11,61 +10,16 @@ module Fastlane
 
     class TryScanAction < Action
       def self.run(params)
-        prepare_for_testing(params)
-        success = TryScanManager::Runner.new(params.values).run
+        if Helper.xcode_at_least?('11.0.0')
+          params[:destination] = [params[:destination]] if params[:destination] && !params[:destination].kind_of?(Array)
+          success = TryScanManager::Runner.new(params.values).run
 
-        raise FastlaneCore::UI.test_failure!('Tests have failed') if params[:fail_build] && !success
-      end
-
-      def self.prepare_for_testing(params)
-        warn_of_xcode11_result_bundle_incompatability(params)
-        use_scanfile_to_override_settings(params.values)
-        turn_off_concurrent_workers(params.values)
-        prepare_scan_config(params.values)
-        coerce_destination_to_array(params)
-      end
-
-      def self.warn_of_xcode11_result_bundle_incompatability(params)
-        if FastlaneCore::Helper.xcode_at_least?('11.0.0')
-          if params[:result_bundle]
-            FastlaneCore::UI.important('As of Xcode 11, test_result bundles created in the output directory are actually symbolic links to an xcresult bundle')
-          end
-        elsif params[:output_types]&.include?('xcresult')
-          FastlaneCore::UI.important("The 'xcresult' :output_type is only supported for Xcode 11 and greater. You are using #{FastlaneCore::Helper.xcode_version}.")
-        end
-      end
-
-      def self.coerce_destination_to_array(params)
-        destination = params[:destination] || Scan.config[:destination] || []
-        unless destination.kind_of?(Array)
-          params[:destination] = Scan.config[:destination] = [destination]
-        end
-      end
-
-      def self.turn_off_concurrent_workers(scan_options)
-        if Gem::Version.new(Fastlane::VERSION) >= Gem::Version.new('2.142.0')
-          scan_options.delete(:concurrent_workers) if scan_options[:concurrent_workers].to_i > 0
-        end
-      end
-
-      def self.use_scanfile_to_override_settings(scan_options)
-        overridden_options = FastlaneScanHelper.options_from_configuration_file(
-          FastlaneScanHelper.scan_options_from_try_scan_options(scan_options)
-        )
-
-        unless overridden_options.empty?
-          FastlaneCore::UI.important("Scanfile found: overriding try_scan options with it's values.")
-          overridden_options.each { |key, val| scan_options[key] = val }
+          raise FastlaneCore::UI.test_failure!('Tests have failed') if params[:fail_build] && !success
+        else
+          raise FastlaneCore::UI.user_error!("Minimum supported Xcode: `v11.0.0` (used: `v#{Helper.xcode_version}`)")
         end
       end
 
-      def self.prepare_scan_config(scan_options)
-        Scan.config ||= FastlaneCore::Configuration.create(
-          Fastlane::Actions::ScanAction.available_options,
-          FastlaneScanHelper.scan_options_from_try_scan_options(scan_options)
-        )
-      end
-
       #####################################################
       #                   Documentation                   #
       #####################################################
@@ -78,20 +32,52 @@ module Fastlane
         ["Alexey Alter-Pesotskiy"]
       end
 
-      def self.scan_options
-        ScanAction.available_options.reject { |config| %i[output_types].include?(config.key) }
-      end
-
       def self.available_options
-        scan_options = ScanAction.available_options.reject { |config| %i[output_types].include?(config.key) }
-        scan_options + [
+        ScanAction.available_options + [
           FastlaneCore::ConfigItem.new(
             key: :try_count,
             env_name: "FL_TRY_SCAN_TRY_COUNT",
-            description: "The number of times to retry running tests via scan",
+            description: "Number of times to try to get your tests green",
             type: Integer,
             is_string: false,
+            optional: true,
             default_value: 1
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :try_parallel,
+            env_name: "FL_TRY_SCAN_TRY_PARALLEL",
+            description: "Should first run be executed in parallel? Equivalent to -parallel-testing-enabled",
+            is_string: false,
+            optional: true,
+            default_value: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :retry_parallel,
+            env_name: "FL_TRY_SCAN_RETRY_PARALLEL",
+            description: "Should subsequent runs be executed in parallel? Required :try_parallel: true",
+            is_string: false,
+            optional: true,
+            default_value: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :parallel_workers,
+            env_name: "FL_TRY_SCAN_PARALLEL_WORKERS",
+            description: "Specify the exact number of test runners that will be spawned during parallel testing. Equivalent to -parallel-testing-worker-count and :concurrent_workers",
+            type: Integer,
+            is_string: false,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :retry_strategy,
+            env_name: "FL_TRY_SCAN_RETRY_STRATEGY",
+            description: "What would you like to retry after failure: test, class or suite?",
+            is_string: true,
+            optional: true,
+            default_value: 'test',
+            verify_block: proc do |strategy|
+              possible_strategies = ['test', 'class', 'suite']
+              UI.user_error!("Error: :retry_strategy must equal to one of the following values: #{possible_strategies}") unless possible_strategies.include?(strategy)
+            end
           )
         ]
       end
@@ -101,7 +87,7 @@ module Fastlane
       end
 
       def self.is_supported?(platform)
-        [:ios].include?(platform)
+        [:ios, :mac].include?(platform)
       end
     end
   end

data/lib/fastlane/plugin/try_scan/helper/scan_helper.rb

@@ -19,31 +19,9 @@ module TryScanManager
       end
 
       def self.scan_options_from_try_scan_options(params)
-        valid_scan_keys = Fastlane::Actions::ScanAction.available_options.map(&:key)
         params.select { |key, _| valid_scan_keys.include?(key) }
       end
 
-      def self.options_from_configuration_file(params)
-        config = FastlaneCore::Configuration.create(
-          Fastlane::Actions::ScanAction.available_options,
-          params
-        )
-        config_file = config.load_configuration_file(Scan.scanfile_name, nil, true)
-        overridden_options = config_file ? config_file.options : {}
-
-        FastlaneCore::Project.detect_projects(config)
-        project = FastlaneCore::Project.new(config)
-
-        imported_path = File.expand_path(Scan.scanfile_name)
-        Dir.chdir(File.expand_path("..", project.path)) do
-          if File.expand_path(Scan.scanfile_name) != imported_path
-            config_file = config.load_configuration_file(Scan.scanfile_name, nil, true)
-          end
-          overridden_options.merge!(config_file.options) if config_file
-        end
-        overridden_options
-      end
-
       def self.remove_preexisting_simulator_logs(params)
         return unless params[:include_simulator_logs]
 
@@ -90,4 +68,4 @@ module TryScanManager
       end
     end
   end
-end
+end

data/lib/fastlane/plugin/try_scan/helper/try_scan_runner.rb

@@ -5,42 +5,39 @@ module TryScanManager
 
     def initialize(options = {})
       @options = options
+      @options[:try_count] = 1 if @options[:try_count] < 1
+      @options[:result_bundle] = true
     end
 
     def run
-      update_scan_config
+      configure_xcargs
+      prepare_scan_config(@options)
       print_summary
       @attempt = 1
       begin
         warn_of_performing_attempts
         clear_preexisting_data
         Scan::Runner.new.run
-        print_parallel_scan_result
+        print_try_scan_result
         return true
       rescue FastlaneCore::Interface::FastlaneTestFailure => _
-        failed_tests = extract_failed_tests
-        print_parallel_scan_result(failed_tests_count: failed_tests.size)
-        update_scan_junit_report
-        return false if @attempt >= @options[:try_count]
+        failed_tests = failed_tests_from_xcresult_report
+        print_try_scan_result(failed_tests_count: failed_tests.size)
+        return false if finish?
 
         @attempt += 1
         update_scan_options(failed_tests)
         retry
       rescue FastlaneCore::Interface::FastlaneBuildFailure => _
-        return false if @attempt >= @options[:try_count]
+        return false if finish?
 
         @attempt += 1
         retry
       end
     end
 
-    def update_scan_config
-      if !Scan.config[:output_types].include?('junit') && !parallel_running?
-        output_types = Scan.config[:output_types].split(',')
-        output_types << 'junit'
-        Scan.config[:output_types] = output_types.join(',')
-      end
-      @options[:try_count] = 1 if @options[:try_count] < 1
+    def finish?
+      @attempt >= @options[:try_count]
     end
 
     def print_summary
@@ -70,9 +67,7 @@ module TryScanManager
       FastlaneScanHelper.remove_report_files
     end
 
-    def print_parallel_scan_result(failed_tests_count: 0)
-      return unless parallel_running?
-
+    def print_try_scan_result(failed_tests_count: 0)
       FastlaneCore::UI.important("TryScan: result after #{ordinalized_attempt} shot 👇")
       FastlaneCore::PrintTable.print_values(
         config: {"Number of tests" => tests_count_from_xcresult_report, "Number of failures" => failed_tests_count},
@@ -93,98 +88,73 @@ module TryScanManager
       end
     end
 
-    def update_scan_options(failed_tests)
-      scan_options = @options.select { |key,  _|
-        FastlaneScanHelper.valid_scan_keys.include?(key)
-      }.merge(plugin_scan_options)
-      scan_options[:only_testing] = failed_tests
-      scan_options[:skip_build] = true
-      scan_options[:test_without_building] = true
-      scan_options[:build_for_testing] = false
-      scan_options.delete(:skip_testing)
-      Scan.cache.clear
-      scan_options.each do |key, val|
-        next if val.nil?
+    def prepare_scan_config(scan_options)
+      Scan.config = FastlaneCore::Configuration.create(
+        Fastlane::Actions::ScanAction.available_options,
+        FastlaneScanHelper.scan_options_from_try_scan_options(scan_options)
+      )
+    end
 
-        Scan.config.set(key, val) unless val.nil?
-        FastlaneCore::UI.verbose("\tSetting #{key.to_s} to #{val}")
+    def configure_xcargs
+      if @options[:xcargs]&.include?('-parallel-testing-enabled')
+        FastlaneCore::UI.important("TryScan overwrites `-parallel-testing-enabled` in :xcargs, use :try_parallel option instead")
+        @options[:xcargs].gsub!(/-parallel-testing-enabled(=|\s+)(YES|NO)/, '')
       end
-    end
 
-    def plugin_scan_options
-      xcargs = @options[:xcargs] || ''
-      if xcargs&.include?('build-for-testing')
-        FastlaneCore::UI.important(":xcargs, #{xcargs}, contained 'build-for-testing', removing it")
-        xcargs.slice!('build-for-testing')
+      if @options[:xcargs]&.include?('-parallel-testing-worker-count')
+        FastlaneCore::UI.important("TryScan overwrites `-parallel-testing-worker-count` in :xcargs, use :concurrent_workers option instead")
+        @options[:xcargs].gsub!(/-parallel-testing-worker-count(=|\s+)(\d+)/, '')
       end
-      if xcargs.include?('-quiet')
-        FastlaneCore::UI.important('Disabling -quiet as failing tests cannot be found with it enabled.')
-        xcargs.gsub!('-quiet', '')
+
+      if @options[:xcargs]&.include?('build-for-testing') || @options[:build_for_testing]
+        FastlaneCore::UI.important("TryScan rejects `build-for-testing` request, use it in a separate scan lane")
+        @options[:xcargs].slice!('build-for-testing')
+        @options[:build_for_testing] = nil
       end
-      @options.select { |key, _| FastlaneScanHelper.valid_scan_keys.include?(key) }.merge({ xcargs: xcargs })
-    end
 
-    def extract_failed_tests
-      if parallel_running?
-        failed_tests_from_xcresult_report
+      xcargs = []
+      if @options[:try_parallel]
+        xcargs << '-parallel-testing-enabled YES'
+        if @options[:parallel_workers] || @options[:concurrent_workers]
+          workers_count = [@options[:parallel_workers].to_i, @options[:concurrent_workers].to_i].max
+          xcargs << "-parallel-testing-worker-count #{workers_count}"
+          @options[:concurrent_workers] = nil
+        end
       else
-        failed_tests_from_junit_report
+        xcargs << '-parallel-testing-enabled NO'
       end
+      @options[:xcargs] = "#{@options[:xcargs].to_s} #{xcargs.join(' ')}"
     end
 
-    def parallel_running?
-      return @options[:concurrent_workers].to_i > 0 ||
-            (@options[:devices] && @options[:devices].size > 1) ||
-            (@options[:xcargs] && (@options[:xcargs] =~ /-parallel-testing-enabled(=|\s+)YES/ || @options[:xcargs].split('-destination').size > 2))
-    end
+    def update_scan_options(failed_tests)
+      scan_options = FastlaneScanHelper.scan_options_from_try_scan_options(@options)
+      scan_options[:only_testing] = failed_tests
+      scan_options[:skip_build] = true
+      scan_options.delete(:skip_testing)
+      if @options[:try_parallel] && !@options[:retry_parallel]
+        scan_options[:xcargs].gsub!(/-parallel-testing-enabled(=|\s+)(YES|NO)/, '-parallel-testing-enabled NO')
+        scan_options[:xcargs].gsub!(/-parallel-testing-worker-count(=|\s+)(\d+)/, '')
+      end
 
-    def failed_tests_from_junit_report
-      report = junit_report
-      suite_name = report.xpath('testsuites/@name').to_s.split('.')[0]
-      test_cases = report.xpath('//testcase')
-      only_testing = []
-      test_cases.each do |test_case|
-        next if test_case.xpath('failure').empty?
+      Scan.cache.clear
+      scan_options.each do |key, val|
+        next if val.nil?
 
-        test_class = test_case.xpath('@classname').to_s.split('.')[1]
-        test_name = test_case.xpath('@name')
-        only_testing << "#{suite_name}/#{test_class}/#{test_name}"
+        Scan.config.set(key, val)
+        FastlaneCore::UI.verbose("\tSetting #{key.to_s} to #{val}")
       end
-      only_testing
     end
 
-    def junit_report(cached: false)
-      unless cached
-        report_options = FastlaneScanHelper.report_options
-        output_files = report_options.instance_variable_get(:@output_files)
-        output_directory = report_options.instance_variable_get(:@output_directory)
-        file_name = output_files.select { |name| name.include?('.xml') }.first
-        @junit_report_path = "#{output_directory}/#{file_name}"
-        @cached_junit_report = File.open(@junit_report_path) { |f| Nokogiri::XML(f) }
-      end
-      @cached_junit_report
+    def retry_failed_test?
+      @options[:retry_strategy] == 'test'
     end
 
-    def update_scan_junit_report
-      return if @attempt == 1 || parallel_running?
-
-      old_junit_report = junit_report(cached: true)
-      new_junit_report = junit_report(cached: false)
-
-      new_junit_report.css("testsuites").zip(old_junit_report.css("testsuites")).each do |new_suites, old_suites|
-        old_suites.attributes["failures"].value = new_suites.attributes["failures"].value
-        new_suites.css("testsuite").zip(old_suites.css("testsuite")).each do |new_suite, old_suite|
-          old_suite.attributes["failures"].value = new_suite.attributes["failures"].value
-        end
-      end
-
-      new_junit_report.css('testcase').each do |node1|
-        old_junit_report.css('testcase').each do |node2|
-          node2.children = node1.children if node1['name'] == node2['name']
-        end
-      end
+    def retry_failed_class?
+      @options[:retry_strategy] == 'class'
+    end
 
-      File.open(@junit_report_path, "w+") { |f| f.write(old_junit_report.to_xml) }
+    def retry_failed_suite?
+      @options[:retry_strategy] == 'suite'
     end
 
     def parse_xcresult_report
@@ -200,18 +170,24 @@ module TryScanManager
     def failed_tests_from_xcresult_report
       only_testing = []
       parse_xcresult_report['issues']['testFailureSummaries']['_values'].each do |failed_test|
-        is_a_swift_file = failed_test['documentLocationInCreatingWorkspace']['url']['_value'].include?('.swift')
         suite_name = failed_test['producingTarget']['_value']
-        if is_a_swift_file
-          test_class = failed_test['testCaseName']['_value'].split('.').first
-          test_name = failed_test['testCaseName']['_value'].split('.')[1].split('(').first
-        else
-          test_class = failed_test['testCaseName']['_value'].split('[')[1].split(' ').first
-          test_name = failed_test['testCaseName']['_value'].split(' ')[1].split(']').first
+        test_path = failed_test['testCaseName']['_value']
+        begin
+          test_class = test_path.split('.').first
+          test_name = test_path.split('.')[1].split('(').first
+        rescue NoMethodError => _
+          test_class = test_path.split('[')[1].split(' ').first
+          test_name = test_path.split(' ')[1].split(']').first
+        end
+        only_testing << if retry_failed_test?
+          "#{suite_name}/#{test_class}/#{test_name}"
+        elsif retry_failed_class?
+          "#{suite_name}/#{test_class}"
+        elsif retry_failed_suite?
+          suite_name
         end
-        only_testing << "#{suite_name}/#{test_class}/#{test_name}"
       end
-      only_testing
+      only_testing.uniq
     end
 
     def tests_count_from_xcresult_report

data/lib/fastlane/plugin/try_scan/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module TryScan
-    VERSION = "0.2.1"
+    VERSION = "1.0.0"
   end
 end

metadata

@@ -1,43 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-try_scan
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Alexey Alter-Pesotskiy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-15 00:00:00.000000000 Z
+date: 2020-06-27 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: nokogiri
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: json
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -165,7 +137,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 2.144.0
 description: 
-email: 33gri@bk.ru
+email: a.alterpesotskiy@mail.ru
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -200,5 +172,5 @@ requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
-summary: Simple way to retry your scan action
+summary: The easiest way to retry your fastlane scan action
 test_files: []