fastlane_hotfix 2.165.1 → 2.187.0

data/scan/lib/scan/commands_generator.rb

@@ -1,6 +1,7 @@
 require 'commander'
 
 require 'fastlane_core/configuration/configuration'
+require 'fastlane_core/ui/help_formatter'
 require_relative 'module'
 require_relative 'manager'
 require_relative 'options'
@@ -28,7 +29,7 @@ module Scan
       program :help, "Author", "Felix Krause <scan@krausefx.com>"
       program :help, "Website", "https://fastlane.tools"
       program :help, "Documentation", "https://docs.fastlane.tools/actions/scan/"
-      program :help_formatter, :compact
+      program :help_formatter, FastlaneCore::HelpFormatter
 
       global_option("--verbose") { FastlaneCore::Globals.verbose = true }
 

data/scan/lib/scan/detect_values.rb

@@ -162,7 +162,10 @@ module Scan
               filter_simulators(simulators, :equal, version).tap(&potential_emptiness_error).select(&selector)
             end
           ).tap do |array|
-            UI.error("Ignoring '#{device_string}', couldn’t find matching simulator") if array.empty?
+            if array.empty?
+              UI.test_failure!("No device found with name '#{device_string}'") if Scan.config[:ensure_devices_found]
+              UI.error("Ignoring '#{device_string}', couldn’t find matching simulator")
+            end
           end
         end
 
@@ -209,7 +212,9 @@ module Scan
       end
 
       # building up the destination now
-      if Scan.devices && Scan.devices.count > 0
+      if Scan.building_mac_catalyst_for_mac?
+        Scan.config[:destination] = ["platform=macOS,variant=Mac Catalyst"]
+      elsif Scan.devices && Scan.devices.count > 0
         Scan.config[:destination] = Scan.devices.map { |d| "platform=#{d.os_type} Simulator,id=#{d.udid}" }
       elsif Scan.project.mac_app?
         Scan.config[:destination] = min_xcode8? ? ["platform=macOS"] : ["platform=OS X"]

data/scan/lib/scan/module.rb

@@ -21,6 +21,10 @@ module Scan
     def scanfile_name
       "Scanfile"
     end
+
+    def building_mac_catalyst_for_mac?
+      Scan.project.supports_mac_catalyst? && Scan.config[:catalyst_platform] == "macos"
+    end
   end
 
   Helper = FastlaneCore::Helper # you gotta love Ruby: Helper.* should use the Helper class contained in FastlaneCore

data/scan/lib/scan/options.rb

@@ -69,6 +69,11 @@ module Scan
                                      default_value: false,
                                      type: Boolean,
                                      optional: true),
+        FastlaneCore::ConfigItem.new(key: :ensure_devices_found,
+                                     description: "Should fail if devices not found",
+                                     default_value: false,
+                                     type: Boolean,
+                                     optional: true),
 
         # simulator management
         FastlaneCore::ConfigItem.new(key: :force_quit_simulator,
@@ -269,6 +274,11 @@ module Scan
                                      optional: true,
                                      is_string: false,
                                      default_value: false),
+        FastlaneCore::ConfigItem.new(key: :output_xctestrun,
+                                     type: Boolean,
+                                     env_name: "SCAN_OUTPUT_XCTESTRUN",
+                                     description: "Should provide additional copy of .xctestrun file (settings.xctestrun) and place in output path?",
+                                     default_value: false),
         FastlaneCore::ConfigItem.new(key: :result_bundle,
                                      short_option: "-z",
                                      env_name: "SCAN_RESULT_BUNDLE",
@@ -411,6 +421,11 @@ module Scan
                                      description: "Only post on Slack if the tests fail",
                                      is_string: false,
                                      default_value: false),
+        FastlaneCore::ConfigItem.new(key: :slack_default_payloads,
+                                     env_name: "SCAN_SLACK_DEFAULT_PAYLOADS",
+                                     description: "Specifies default payloads to include in Slack messages. For more info visit https://docs.fastlane.tools/actions/slack",
+                                     optional: true,
+                                     type: Array),
 
         # misc
         FastlaneCore::ConfigItem.new(key: :destination,
@@ -419,6 +434,15 @@ module Scan
                                      description: "Use only if you're a pro, use the other options instead",
                                      is_string: false,
                                      optional: true),
+        FastlaneCore::ConfigItem.new(key: :catalyst_platform,
+                                     env_name: "SCAN_CATALYST_PLATFORM",
+                                     description: "Platform to build when using a Catalyst enabled app. Valid values are: ios, macos",
+                                     type: String,
+                                     optional: true,
+                                     verify_block: proc do |value|
+                                       av = %w(ios macos)
+                                       UI.user_error!("Unsupported export_method '#{value}', must be: #{av}") unless av.include?(value)
+                                     end),
         FastlaneCore::ConfigItem.new(key: :custom_report_file_name,
                                      env_name: "SCAN_CUSTOM_REPORT_FILE_NAME",
                                      description: "Sets custom full report file name when generating a single report",
@@ -436,7 +460,28 @@ module Scan
                                     env_name: "SCAN_CLONED_SOURCE_PACKAGES_PATH",
                                     description: "Sets a custom path for Swift Package Manager dependencies",
                                     type: String,
-                                    optional: true)
+                                    optional: true),
+        FastlaneCore::ConfigItem.new(key: :skip_package_dependencies_resolution,
+                                     env_name: "SCAN_SKIP_PACKAGE_DEPENDENCIES_RESOLUTION",
+                                     description: "Skips resolution of Swift Package Manager dependencies",
+                                     type: Boolean,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :disable_package_automatic_updates,
+                                     env_name: "SCAN_DISABLE_PACKAGE_AUTOMATIC_UPDATES",
+                                     description: "Prevents packages from automatically being resolved to versions other than those recorded in the `Package.resolved` file",
+                                     type: Boolean,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :use_system_scm,
+                                    env_name: "SCAN_USE_SYSTEM_SCM",
+                                    description: "Lets xcodebuild use system's scm configuration",
+                                    optional: true,
+                                    type: Boolean,
+                                    default_value: false),
+        FastlaneCore::ConfigItem.new(key: :number_of_retries,
+                                    env_name: 'SCAN_NUMBER_OF_RETRIES',
+                                    description: "The number of times a test can fail before scan should stop retrying",
+                                    type: Integer,
+                                    default_value: 0)
 
       ]
     end

data/scan/lib/scan/runner.rb

@@ -51,7 +51,14 @@ module Scan
         end
       end
 
+      execute(retries: Scan.config[:number_of_retries])
+    end
+
+    def execute(retries: 0)
+      Scan.cache[:retry_attempt] = Scan.config[:number_of_retries] - retries
+
       command = @test_command_generator.generate
+
       prefix_hash = [
         {
           prefix: "Running Tests: ",
@@ -71,7 +78,12 @@ module Scan
                                               error: proc do |error_output|
                                                 begin
                                                   exit_status = $?.exitstatus
-                                                  ErrorHandler.handle_build_error(error_output, @test_command_generator.xcodebuild_log_path)
+                                                  if retries > 0
+                                                    # If there are retries remaining, run the tests again
+                                                    return retry_execute(retries: retries, error_output: error_output)
+                                                  else
+                                                    ErrorHandler.handle_build_error(error_output, @test_command_generator.xcodebuild_log_path)
+                                                  end
                                                 rescue => ex
                                                   SlackPoster.new.run({
                                                     build_errors: 1
@@ -79,10 +91,58 @@ module Scan
                                                   raise ex
                                                 end
                                               end)
+
       exit_status
     end
 
+    def retry_execute(retries:, error_output: "")
+      tests = retryable_tests(error_output)
+
+      if tests.empty?
+        UI.crash!("Failed to find failed tests to retry (could not parse error output)")
+      end
+
+      Scan.config[:only_testing] = tests
+      UI.important("Retrying tests: #{Scan.config[:only_testing].join(', ')}")
+
+      retries -= 1
+      UI.important("Number of retries remaining: #{retries}")
+
+      return execute(retries: retries)
+    end
+
+    def retryable_tests(input)
+      input = Helper.strip_ansi_colors(input)
+
+      retryable_tests = []
+
+      failing_tests = input.split("Failing tests:\n").fetch(1, [])
+                           .split("\n\n").first
+
+      suites = failing_tests.split(/(?=\n\s+[\w\s]+:\n)/)
+
+      suites.each do |suite|
+        suite_name = suite.match(/\s*([\w\s\S]+):/).captures.first
+
+        test_cases = suite.split(":\n").fetch(1, []).split("\n").each
+                          .select { |line| line.match?(/^\s+/) }
+                          .map { |line| line.strip.gsub(".", "/").gsub("()", "") }
+                          .map { |line| suite_name + "/" + line }
+
+        retryable_tests += test_cases
+      end
+
+      return retryable_tests.uniq
+    end
+
     def handle_results(tests_exit_status)
+      if Scan.config[:disable_xcpretty]
+        unless tests_exit_status == 0
+          UI.test_failure!("Test execution failed. Exit status: #{tests_exit_status}")
+        end
+        return
+      end
+
       result = TestResultParser.new.parse_result(test_results)
       SlackPoster.new.run(result)
 
@@ -103,6 +163,7 @@ module Scan
 
       copy_simulator_logs
       zip_build_products
+      copy_xctestrun
 
       if result[:failures] > 0
         open_report
@@ -143,9 +204,33 @@ module Scan
       UI.message("Successfully zipped build products: #{output_path}")
     end
 
-    def test_results
-      return if Scan.config[:disable_xcpretty]
+    def copy_xctestrun
+      return unless Scan.config[:output_xctestrun]
+
+      # Gets :derived_data_path/Build/Products directory for coping .xctestrun file
+      derived_data_path = Scan.config[:derived_data_path]
+      path = File.join(derived_data_path, "Build", "Products")
 
+      # Gets absolute path of output directory
+      output_directory = File.absolute_path(Scan.config[:output_directory])
+      output_path = File.join(output_directory, "settings.xctestrun")
+
+      # Caching path for action to put into lane_context
+      Scan.cache[:output_xctestrun] = output_path
+
+      # Copy .xctestrun file and moves it to output directory
+      UI.message("Copying .xctestrun file")
+      xctestrun_file = Dir.glob("#{path}/*.xctestrun").first
+
+      if xctestrun_file
+        FileUtils.cp(xctestrun_file, output_path)
+        UI.message("Successfully copied xctestrun file: #{output_path}")
+      else
+        UI.user_error!("Could not find .xctextrun file to copy")
+      end
+    end
+
+    def test_results
       temp_junit_report = Scan.cache[:temp_junit_report]
       return File.read(temp_junit_report) if temp_junit_report && File.file?(temp_junit_report)
 

data/scan/lib/scan/slack_poster.rb

@@ -1,5 +1,6 @@
 require 'fastlane/action'
 require 'fastlane/actions/slack'
+require 'fastlane_core/configuration/configuration'
 
 require_relative 'module'
 
@@ -43,7 +44,7 @@ module Scan
         }
       end
 
-      Fastlane::Actions::SlackAction.run({
+      options = FastlaneCore::Configuration.create(Fastlane::Actions::SlackAction.available_options, {
         message: "#{Scan.config[:app_name] || Scan.project.app_name} Tests:\n#{Scan.config[:slack_message]}",
         channel: channel,
         slack_url: Scan.config[:slack_url].to_s,
@@ -51,10 +52,12 @@ module Scan
         username: username,
         icon_url: icon_url,
         payload: {},
+        default_payloads: Scan.config[:slack_default_payloads],
         attachment_properties: {
           fields: fields
         }
       })
+      Fastlane::Actions::SlackAction.run(options)
     end
   end
 end

data/scan/lib/scan/test_command_generator.rb

@@ -38,6 +38,9 @@ module Scan
       if config[:derived_data_path] && !options.include?("-derivedDataPath #{config[:derived_data_path].shellescape}")
         options << "-derivedDataPath #{config[:derived_data_path].shellescape}"
       end
+      if config[:use_system_scm] && !options.include?("-scmProvider system")
+        options << "-scmProvider system"
+      end
       options << "-resultBundlePath '#{result_bundle_path}'" if config[:result_bundle]
       if FastlaneCore::Helper.xcode_at_least?(10)
         options << "-parallel-testing-worker-count #{config[:concurrent_workers]}" if config[:concurrent_workers]
@@ -159,16 +162,18 @@ module Scan
       Scan.cache[:build_path]
     end
 
+    # The path to the result bundle
     def result_bundle_path
-      unless Scan.cache[:result_bundle_path]
-        ext = FastlaneCore::Helper.xcode_version.to_i >= 11 ? '.xcresult' : '.test_result'
-        path = File.join(Scan.config[:output_directory], Scan.config[:scheme]) + ext
-        if File.directory?(path)
-          FileUtils.remove_dir(path)
-        end
-        Scan.cache[:result_bundle_path] = path
+      retry_count = Scan.cache[:retry_attempt] || 0
+      attempt = retry_count > 0 ? "-#{retry_count}" : ""
+      ext = FastlaneCore::Helper.xcode_version.to_i >= 11 ? '.xcresult' : '.test_result'
+      path = File.join(Scan.config[:output_directory], Scan.config[:scheme]) + attempt + ext
+      if File.directory?(path)
+        FileUtils.remove_dir(path)
       end
-      return Scan.cache[:result_bundle_path]
+      Scan.cache[:result_bundle_path] = path
+
+      return path
     end
   end
 end

data/screengrab/lib/screengrab/android_environment.rb

@@ -4,86 +4,38 @@ require 'fastlane_core/command_executor'
 module Screengrab
   class AndroidEnvironment
     attr_reader :android_home
-    attr_reader :build_tools_version
 
     # android_home        - the String path to the install location of the Android SDK
-    # build_tools_version - the String version of the Android build tools that should be used
-    def initialize(android_home, build_tools_version)
+    # build_tools_version - the String version of the Android build tools that should be used, ignored
+    def initialize(android_home, build_tools_version = nil)
       @android_home = android_home
-      @build_tools_version = build_tools_version
     end
 
     def platform_tools_path
       @platform_tools_path ||= find_platform_tools(android_home)
     end
 
-    def build_tools_path
-      @build_tools_path ||= find_build_tools(android_home, build_tools_version)
-    end
-
     def adb_path
       @adb_path ||= find_adb(platform_tools_path)
     end
 
-    def aapt_path
-      @aapt_path ||= find_aapt(build_tools_path)
-    end
-
     private
 
     def find_platform_tools(android_home)
       return nil unless android_home
 
-      platform_tools_path = File.join(android_home, 'platform-tools')
+      platform_tools_path = Helper.localize_file_path(File.join(android_home, 'platform-tools'))
       File.directory?(platform_tools_path) ? platform_tools_path : nil
     end
 
-    def find_build_tools(android_home, build_tools_version)
-      return nil unless android_home
-
-      build_tools_dir = File.join(android_home, 'build-tools')
-
-      return nil unless build_tools_dir && File.directory?(build_tools_dir)
-
-      return File.join(build_tools_dir, build_tools_version) if build_tools_version
-
-      version = select_build_tools_version(build_tools_dir)
-
-      return version ? File.join(build_tools_dir, version) : nil
-    end
-
-    def select_build_tools_version(build_tools_dir)
-      # Collect the sub-directories of the build_tools_dir, rejecting any that start with '.' to remove . and ..
-      dir_names = Dir.entries(build_tools_dir).select { |e| !e.start_with?('.') && File.directory?(File.join(build_tools_dir, e)) }
-
-      # Collect a sorted array of Version objects from the directory names, handling the possibility that some
-      # entries may not be valid version names
-      versions = dir_names.map do |d|
-        begin
-          Gem::Version.new(d)
-        rescue
-          nil
-        end
-      end.reject(&:nil?).sort
-
-      # We'll take the last entry (highest version number) as the directory name we want
-      versions.last.to_s
-    end
-
     def find_adb(platform_tools_path)
       return FastlaneCore::CommandExecutor.which('adb') unless platform_tools_path
 
-      adb_path = File.join(platform_tools_path, 'adb')
+      adb_path = Helper.get_executable_path(File.join(platform_tools_path, 'adb'))
+      adb_path = Helper.localize_file_path(adb_path)
       return executable_command?(adb_path) ? adb_path : nil
     end
 
-    def find_aapt(build_tools_path)
-      return FastlaneCore::CommandExecutor.which('aapt') unless build_tools_path
-
-      aapt_path = File.join(build_tools_path, 'aapt')
-      return executable_command?(aapt_path) ? aapt_path : nil
-    end
-
     def executable_command?(cmd_path)
       Helper.executable?(cmd_path)
     end

data/screengrab/lib/screengrab/commands_generator.rb

@@ -1,6 +1,7 @@
 require 'commander'
 
 require 'fastlane/version'
+require 'fastlane_core/ui/help_formatter'
 require 'fastlane_core/fastlane_folder'
 require 'fastlane_core/configuration/configuration'
 require_relative 'android_environment'
@@ -26,7 +27,7 @@ module Screengrab
       program :help, 'Authors', 'Andrea Falcone <asfalcone@google.com>, Michael Furtak <mfurtak@google.com>'
       program :help, 'Website', 'https://fastlane.tools'
       program :help, 'Documentation', 'https://docs.fastlane.tools/actions/screengrab/'
-      program :help_formatter, :compact
+      program :help_formatter, FastlaneCore::HelpFormatter
 
       global_option('--verbose', 'Shows a more verbose output') { FastlaneCore::Globals.verbose = true }
 

data/screengrab/lib/screengrab/dependency_checker.rb

@@ -6,7 +6,6 @@ module Screengrab
       return if Helper.test?
 
       check_adb(android_env)
-      check_aapt(android_env)
     end
 
     def self.check_adb(android_env)
@@ -30,25 +29,6 @@ module Screengrab
       UI.user_error!('adb command not found')
     end
 
-    def self.check_aapt(android_env)
-      android_home = android_env.android_home
-      aapt_path = android_env.aapt_path
-
-      warn_if_command_path_not_relative_to_android_home('aapt', android_home, aapt_path)
-      # aapt is not required in order to function, so we'll only warn if we can't find it.
-      warn_missing_aapt(android_home) unless aapt_path
-    end
-
-    def self.warn_missing_aapt(android_home)
-      if android_home
-        UI.important("The `aapt` command could not be found relative to your provided ANDROID_HOME at #{android_home}")
-        UI.important("Please ensure that the Android SDK is installed and you have the build tools downloaded")
-      else
-        UI.important("The `aapt` command could not be found on your PATH")
-        UI.important("Please ensure that the Android SDK is installed and you have the build tools downloaded and present on your PATH")
-      end
-    end
-
     def self.warn_if_command_path_not_relative_to_android_home(cmd_name, android_home, cmd_path)
       if android_home && cmd_path && !cmd_path.start_with?(android_home)
         UI.important("Using `#{cmd_name}` found at #{cmd_path} which is not within the specified ANDROID_HOME at #{android_home}")