fastlane-plugin-try_scan 0.1.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 674d55524df14f5d8442d245b9d6bac1c076db872a47528b9e3c469e6c641fdc
-  data.tar.gz: 6a948848f0c9114bb2b35eccbad122e6c242867f2ad55c5a402918cf6127d732
+  metadata.gz: 6423da17416a0d0718726d80c011463f8c11763bea4305c77db114fdca0bac98
+  data.tar.gz: a6650bda5beb09a03105ee929904c8c2b25b9df3faf69e4dbe3db9cccba97f90
 SHA512:
-  metadata.gz: b5c673c0d2738041016915e1028c1f78b2954c0bb8b8344e284703f4a99c4cfbfde4ecd0fc73f5740856731b1cc3fda528998580b015b1f031100e093b223292
-  data.tar.gz: e69f6713be6793ae96a559aaabbf0932b545430955dc070b8abdf7916d6f092598dfa5ca7ccf8414cc6583918c0f2ee6937906a377d66b131b8c1bc133d2c6ca
+  metadata.gz: e9e2661f541ba9b72aa57317e3d9b5cea705086b0360827cbd56722361bf1f56a480b23fdbcaad520070b2bdade410680af2ac6de2d3791cb3e77057d604f2a8
+  data.tar.gz: 22ced8f5d7bc59bfa915557f1febb8b9fdf46556feb555063210f15d6658f423f73d8fe79d9a2afc8b1182a0dafc4fcb0fb8efac6dfac0fabedca4edf58fa5f8

data/README.md

@@ -2,36 +2,37 @@
 
 [![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` |  |
+
+## 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

@@ -10,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]
+          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.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 }
-        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                   #
       #####################################################
@@ -77,20 +32,40 @@ 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,
-            default_value: 0
+            optional: true
           )
         ]
       end
@@ -100,7 +75,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]
 
@@ -88,18 +66,6 @@ module TryScanManager
           end
         end
       end
-
-      def self.update_xctestrun_after_build(scan_options)
-        xctestrun_files = Dir.glob("#{Scan.config[:derived_data_path]}/Build/Products/*.xctestrun")
-        FastlaneCore::UI.verbose("After building, found xctestrun files #{xctestrun_files} (choosing 1st)")
-        scan_options[:xctestrun] = xctestrun_files.first
-      end
-
-      def self.remove_preexisting_xctestrun_files
-        xctestrun_files = Dir.glob("#{Scan.config[:derived_data_path]}/Build/Products/*.xctestrun")
-        FastlaneCore::UI.verbose("Before building, removing pre-existing xctestrun files: #{xctestrun_files}")
-        FileUtils.rm_rf(xctestrun_files)
-      end
     end
   end
-end
+end

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

@@ -5,34 +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
+      @attempt = 1
       begin
-        warn_of_performing_attempts(attempt)
+        warn_of_performing_attempts
         clear_preexisting_data
         Scan::Runner.new.run
+        print_try_scan_result
         return true
-      rescue FastlaneCore::Interface::FastlaneBuildFailure, FastlaneCore::Interface::FastlaneTestFailure => _
-        update_scan_reports(attempt)
-        return false if attempt > @options[:try_count]
+      rescue FastlaneCore::Interface::FastlaneTestFailure => _
+        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
+        @attempt += 1
+        update_scan_options(failed_tests)
+        retry
+      rescue FastlaneCore::Interface::FastlaneBuildFailure => _
+        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] = 0 if @options[:try_count] < 0
+    def finish?
+      @attempt >= @options[:try_count]
     end
 
     def print_summary
@@ -51,8 +56,8 @@ module TryScanManager
       )
     end
 
-    def warn_of_performing_attempts(attempt)
-      FastlaneCore::UI.important("TryScan shot №#{attempt}\n")
+    def warn_of_performing_attempts
+      FastlaneCore::UI.important("TryScan: Getting started #{ordinalized_attempt} shot\n")
     end
 
     def clear_preexisting_data
@@ -62,101 +67,78 @@ module TryScanManager
       FastlaneScanHelper.remove_report_files
     end
 
-    def update_scan_reports(attempt)
-      merge_junit_reports if attempt != 1 && !parallel_running?
-    end
-
-    def update_scan_options
-      scan_options = @options.select { |key,  _|
-        FastlaneScanHelper.valid_scan_keys.include?(key)
-      }.merge(plugin_scan_options)
-      scan_options[:only_testing] = extract_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?
-
-        Scan.config.set(key, val) unless val.nil?
-        FastlaneCore::UI.verbose("\tSetting #{key.to_s} to #{val}")
-      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')
-      end
-      if xcargs.include?('-quiet')
-        FastlaneCore::UI.important('Disabling -quiet as failing tests cannot be found with it enabled.')
-        xcargs.gsub!('-quiet', '')
-      end
-      @options.select { |key, _| FastlaneScanHelper.valid_scan_keys.include?(key) }.merge({ xcargs: xcargs })
+    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},
+        title: "Test Results"
+      )
     end
 
-    def extract_failed_tests
-      if parallel_running?
-        extract_failed_tests_from_xcresult_report
+    def ordinalized_attempt
+      case @attempt
+      when 1
+        "#{@attempt}st"
+      when 2
+        "#{@attempt}nd"
+      when 3
+        "#{@attempt}rd"
       else
-        extract_failed_tests_from_junit_report
+        "#{@attempt}th"
       end
     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))
+    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
 
-    def extract_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?
-
-        test_class = test_case.xpath('@classname').to_s.split('.')[1]
-        test_name = test_case.xpath('@name')
-        only_testing << "#{suite_name}/#{test_class}/#{test_name}"
+    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
-      FastlaneCore::UI.verbose("Extracted tests to retry: #{only_testing}")
-      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) }
+      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
-      @cached_junit_report
-    end
 
-    def merge_junit_reports
-      old_junit_report = junit_report(cached: true)
-      new_junit_report = junit_report(cached: false)
+      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
 
-      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
+      if @options[:try_parallel] && !@options[:disable_concurrent_testing]
+        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}"
         end
+        @options[:xcargs] = "#{@options[:xcargs].to_s} #{xcargs.join(' ')}"
       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
+    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
 
-      File.open(@junit_report_path, "w+") { |f| f.write(old_junit_report.to_xml) }
+      Scan.cache.clear
+      scan_options.each do |key, val|
+        next if val.nil?
+
+        Scan.config.set(key, val)
+        FastlaneCore::UI.verbose("\tSetting #{key.to_s} to #{val}")
+      end
     end
 
     def parse_xcresult_report
@@ -169,16 +151,25 @@ module TryScanManager
       JSON.parse(`xcrun xcresulttool get --format json --path #{xcresult_report_files.first}`)
     end
 
-    def extract_failed_tests_from_xcresult_report
+    def failed_tests_from_xcresult_report
       only_testing = []
       parse_xcresult_report['issues']['testFailureSummaries']['_values'].each do |failed_test|
         suite_name = failed_test['producingTarget']['_value']
-        test_class = failed_test['testCaseName']['_value'].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 << "#{suite_name}/#{test_class}/#{test_name}"
       end
-      FastlaneCore::UI.verbose("Extracted tests to retry: #{only_testing}")
       only_testing
     end
+
+    def tests_count_from_xcresult_report
+      parse_xcresult_report['metrics']['testsCount']['_value']
+    end
   end
 end

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

@@ -1,5 +1,5 @@
 module Fastlane
   module TryScan
-    VERSION = "0.1.1"
+    VERSION = "0.5.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-try_scan
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Alexey Alter-Pesotskiy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-10 00:00:00.000000000 Z
+date: 2020-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -122,20 +122,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: nokogiri
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: fastlane
   requirement: !ruby/object:Gem::Requirement