fastlane 2.200.0 → 2.201.0

data/scan/lib/scan/runner.rb

@@ -51,11 +51,18 @@ module Scan
         end
       end
 
-      execute(retries: Scan.config[:number_of_retries])
+      retries = Scan.config[:number_of_retries]
+      execute(retries: retries)
     end
 
     def execute(retries: 0)
-      Scan.cache[:retry_attempt] = Scan.config[:number_of_retries] - retries
+      # Set retries to 0 if Xcode 13 because TestCommandGenerator will set '-retry-tests-on-failure -test-iterations'
+      if Helper.xcode_at_least?(13)
+        retries = 0
+        Scan.cache[:retry_attempt] = 0
+      else
+        Scan.cache[:retry_attempt] = Scan.config[:number_of_retries] - retries
+      end
 
       command = @test_command_generator.generate
 
@@ -135,27 +142,127 @@ module Scan
       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}")
+    def find_filename(type)
+      index = Scan.config[:output_types].split(',').index(type)
+      return nil if index.nil?
+      return (Scan.config[:output_files] || "").split(',')[index]
+    end
+
+    def output_html?
+      return Scan.config[:output_types].split(',').include?('html')
+    end
+
+    def output_junit?
+      return Scan.config[:output_types].split(',').include?('junit')
+    end
+
+    def output_json_compilation_database?
+      return Scan.config[:output_types].split(',').include?('json-compilation-database')
+    end
+
+    def output_html_filename
+      return find_filename('html')
+    end
+
+    def output_junit_filename
+      return find_filename('junit')
+    end
+
+    def output_json_compilation_database_filename
+      return find_filename('json-compilation-database')
+    end
+
+    def trainer_test_results
+      require "trainer"
+
+      results = {
+        number_of_tests: 0,
+        number_of_failures: 0,
+        number_of_retries: 0
+      }
+
+      result_bundle_path = Scan.cache[:result_bundle_path]
+
+      output_path = Scan.config[:output_directory] || Dir.mktmpdir
+      output_path = File.absolute_path(output_path)
+
+      UI.crash!("A -resultBundlePath is needed to parse the test results. This should not have happened. Please file an issue.") unless result_bundle_path
+
+      params = {
+        path: result_bundle_path,
+        output_remove_retry_attempts: Scan.config[:output_remove_retry_attempts],
+        silent: !FastlaneCore::Globals.verbose?
+      }
+
+      formatter = Scan.config[:xcodebuild_formatter].chomp
+      show_output_types_tip = false
+      if output_html? && formatter != 'xcpretty'
+        UI.important("Skipping HTML... only available with `xcodebuild_formatter: 'xcpretty'` right now")
+        show_output_types_tip = true
+      end
+
+      if output_json_compilation_database? && formatter != 'xcpretty'
+        UI.important("Skipping JSON Compilation Database... only available with `xcodebuild_formatter: 'xcpretty'` right now")
+        show_output_types_tip = true
+      end
+
+      if show_output_types_tip
+        UI.important("Your 'xcodebuild_formatter' doesn't support these 'output_types'. Change your 'output_types' to prevent these warnings from showing...")
+      end
+
+      if output_junit?
+        if formatter == 'xcpretty'
+          UI.verbose("Generating junit report with xcpretty")
+        else
+          UI.verbose("Generating junit report with trainer")
+          params[:output_filename] = output_junit_filename || "report.junit"
+          params[:output_directory] = output_path
         end
-        return
       end
 
-      result = TestResultParser.new.parse_result(test_results)
-      SlackPoster.new.run(result)
+      resulting_paths = Trainer::TestParser.auto_convert(params)
+      resulting_paths.each do |path, data|
+        results[:number_of_tests] += data[:number_of_tests_excluding_retries]
+        results[:number_of_failures] += data[:number_of_failures_excluding_retries]
+        results[:number_of_retries] += data[:number_of_retries]
+      end
+
+      return results
+    end
+
+    def handle_results(tests_exit_status)
+      return if Scan.config[:build_for_testing]
 
-      if result[:failures] > 0
-        failures_str = result[:failures].to_s.red
+      results = trainer_test_results
+
+      number_of_retries = results[:number_of_retries]
+      number_of_tests = results[:number_of_tests]
+      number_of_failures = results[:number_of_failures]
+
+      SlackPoster.new.run({
+        tests: number_of_tests,
+        failures: number_of_failures
+      })
+
+      if number_of_failures > 0
+        failures_str = number_of_failures.to_s.red
       else
-        failures_str = result[:failures].to_s.green
+        failures_str = number_of_failures.to_s.green
       end
 
+      retries_str = case number_of_retries
+                    when 0
+                      ""
+                    when 1
+                      " (and 1 retry)"
+                    else
+                      " (and #{number_of_retries} retries)"
+                    end
+
       puts(Terminal::Table.new({
         title: "Test Results",
         rows: [
-          ["Number of tests", result[:tests]],
+          ["Number of tests", "#{number_of_tests}#{retries_str}"],
           ["Number of failures", failures_str]
         ]
       }))
@@ -165,7 +272,7 @@ module Scan
       zip_build_products
       copy_xctestrun
 
-      if result[:failures] > 0
+      if number_of_failures > 0
         open_report
 
         UI.test_failure!("Tests have failed")

data/scan/lib/scan/test_command_generator.rb

@@ -53,7 +53,7 @@ module Scan
       if config[:use_system_scm] && !options.include?("-scmProvider system")
         options << "-scmProvider system"
       end
-      options << "-resultBundlePath '#{result_bundle_path}'" if config[:result_bundle]
+      options << "-resultBundlePath '#{result_bundle_path(config[:result_bundle])}'"
       if FastlaneCore::Helper.xcode_at_least?(10)
         options << "-parallel-testing-worker-count #{config[:concurrent_workers]}" if config[:concurrent_workers]
         options << "-maximum-concurrent-test-simulator-destinations #{config[:max_concurrent_simulators]}" if config[:max_concurrent_simulators]
@@ -72,6 +72,10 @@ module Scan
       end
       options << "-xctestrun '#{config[:xctestrun]}'" if config[:xctestrun]
       options << config[:xcargs] if config[:xcargs]
+      if config[:number_of_retries] >= 1 && FastlaneCore::Helper.xcode_at_least?(13)
+        options << "-retry-tests-on-failure"
+        options << "-test-iterations #{config[:number_of_retries]}"
+      end
 
       # detect_values will ensure that these values are present as Arrays if
       # they are present at all
@@ -107,12 +111,56 @@ module Scan
     def pipe
       pipe = ["| tee '#{xcodebuild_log_path}'"]
 
+      # disable_xcpretty is now deprecated and directs to use output_style of raw
       if Scan.config[:disable_xcpretty] || Scan.config[:output_style] == 'raw'
         return pipe
       end
 
+      formatter = Scan.config[:xcodebuild_formatter].chomp
+      options = legacy_xcpretty_options
+
+      if formatter == ''
+        UI.verbose("Not using an xcodebuild formatter")
+      elsif !options.empty?
+        UI.important("Detected legacy xcpretty being used so formatting wth xcpretty")
+        UI.important("Option(s) used: #{options.join(', ')}")
+        pipe << pipe_xcpretty
+      elsif formatter == 'xcpretty'
+        pipe << pipe_xcpretty
+      elsif formatter == 'xcbeautify'
+        pipe << pipe_xcbeautify
+      else
+        pipe << "| #{formatter}"
+      end
+
+      return pipe
+    end
+
+    def pipe_xcbeautify
+      formatter = ['| xcbeautify']
+
+      if FastlaneCore::Helper.colors_disabled?
+        formatter << '--disable-colored-output'
+      end
+
+      return formatter.join(' ')
+    end
+
+    def legacy_xcpretty_options
+      options = []
+
+      options << "formatter" if Scan.config[:formatter]
+      options << "xcpretty_formatter" if Scan.config[:xcpretty_formatter]
+      options << "output_style" if Scan.config[:output_style]
+      options << "output_types" if (Scan.config[:output_types] || "").include?("json-compilation-database")
+      options << "custom_report_file_name" if Scan.config[:custom_report_file_name]
+
+      return options
+    end
+
+    def pipe_xcpretty
       formatter = []
-      if (custom_formatter = Scan.config[:formatter])
+      if (custom_formatter = Scan.config[:xcpretty_formatter] || Scan.config[:formatter])
         if custom_formatter.end_with?(".rb")
           formatter << "-f '#{custom_formatter}'"
         else
@@ -143,7 +191,7 @@ module Scan
                                                                          Scan.config[:xcpretty_args])
       reporter_options = @reporter_options_generator.generate_reporter_options
       reporter_xcpretty_args = @reporter_options_generator.generate_xcpretty_args_options
-      return pipe << "| xcpretty #{formatter.join(' ')} #{reporter_options.join(' ')} #{reporter_xcpretty_args}"
+      return "| xcpretty #{formatter.join(' ')} #{reporter_options.join(' ')} #{reporter_xcpretty_args}"
     end
 
     # Store the raw file
@@ -183,11 +231,13 @@ module Scan
     end
 
     # The path to the result bundle
-    def result_bundle_path
+    def result_bundle_path(use_output_directory)
+      root_dir = use_output_directory ? Scan.config[:output_directory] : Dir.mktmpdir
+
       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
+      path = File.join([root_dir, Scan.config[:scheme]].compact) + attempt + ext
 
       Scan.cache[:result_bundle_path] = path
 

data/snapshot/lib/snapshot/options.rb

@@ -1,5 +1,6 @@
 require 'fastlane_core/configuration/config_item'
 require 'fastlane_core/device_manager'
+require 'fastlane/helper/xcodebuild_formatter_helper'
 require 'credentials_manager/appfile_config'
 require_relative 'module'
 
@@ -11,9 +12,13 @@ module Snapshot
     end
 
     def self.available_options
+      @options ||= plain_options
+    end
+
+    def self.plain_options
       output_directory = (File.directory?("fastlane") ? "fastlane/screenshots" : "screenshots")
 
-      @options ||= [
+      [
         FastlaneCore::ConfigItem.new(key: :workspace,
                                      short_option: "-w",
                                      env_name: "SNAPSHOT_WORKSPACE",
@@ -194,12 +199,6 @@ module Snapshot
                                      description: "The configuration to use when building the app. Defaults to 'Release'",
                                      default_value_dynamic: true,
                                      optional: true),
-        FastlaneCore::ConfigItem.new(key: :xcpretty_args,
-                                     short_option: "-x",
-                                     env_name: "SNAPSHOT_XCPRETTY_ARGS",
-                                     description: "Additional xcpretty arguments",
-                                     is_string: true,
-                                     optional: true),
         FastlaneCore::ConfigItem.new(key: :sdk,
                                      short_option: "-k",
                                      env_name: "SNAPSHOT_SDK",
@@ -289,11 +288,28 @@ module Snapshot
                                      verify_block: proc do |value|
                                        verify_type('skip_testing', [Array, String], value)
                                      end),
+
+        FastlaneCore::ConfigItem.new(key: :xcodebuild_formatter,
+                                     env_names: ["SNAPSHOT_XCODEBUILD_FORMATTER", "FASTLANE_XCODEBUILD_FORMATTER"],
+                                     description: "xcodebuild formatter to use (ex: 'xcbeautify', 'xcbeautify --quieter', 'xcpretty', 'xcpretty -test'). Use empty string (ex: '') to disable any formatter (More information: https://docs.fastlane.tools/best-practices/xcodebuild-formatters/)",
+                                     type: String,
+                                     default_value: Fastlane::Helper::XcodebuildFormatterHelper.xcbeautify_installed? ? 'xcbeautify' : 'xcpretty',
+                                     default_value_dynamic: true),
+
+        # xcpretty
+        FastlaneCore::ConfigItem.new(key: :xcpretty_args,
+                                     short_option: "-x",
+                                     env_name: "SNAPSHOT_XCPRETTY_ARGS",
+                                     deprecated: "Use `xcodebuild_formatter: ''` instead",
+                                     description: "Additional xcpretty arguments",
+                                     is_string: true,
+                                     optional: true),
         FastlaneCore::ConfigItem.new(key: :disable_xcpretty,
                                      env_name: "SNAPSHOT_DISABLE_XCPRETTY",
                                      description: "Disable xcpretty formatting of build",
                                      type: Boolean,
                                      optional: true),
+
         FastlaneCore::ConfigItem.new(key: :suppress_xcode_output,
                                      env_name: "SNAPSHOT_SUPPRESS_XCODE_OUTPUT",
                                      description: "Suppress the output of xcodebuild to stdout. Output is still saved in buildlog_path",

data/snapshot/lib/snapshot/test_command_generator.rb

@@ -27,10 +27,45 @@ module Snapshot
         tee_command << log_path.shellescape if log_path
 
         pipe = ["| #{tee_command.join(' ')}"]
-        if Snapshot.config[:disable_xcpretty]
-          return pipe
+
+        formatter = Snapshot.config[:xcodebuild_formatter].chomp
+        options = legacy_xcpretty_options
+
+        if Snapshot.config[:disable_xcpretty] || formatter == ''
+          UI.verbose("Not using an xcodebuild formatter")
+        elsif !options.empty?
+          UI.important("Detected legacy xcpretty being used so formatting wth xcpretty")
+          UI.important("Option(s) used: #{options.join(', ')}")
+          pipe += pipe_xcpretty
+        elsif formatter == 'xcpretty'
+          pipe += pipe_xcpretty
+        elsif formatter == 'xcbeautify'
+          pipe += pipe_xcbeautify
+        else
+          pipe << "| #{formatter}"
+        end
+
+        pipe
+      end
+
+      def pipe_xcbeautify
+        pipe = ['| xcbeautify']
+
+        if FastlaneCore::Helper.colors_disabled?
+          pipe << '--disable-colored-output'
         end
 
+        return pipe
+      end
+
+      def legacy_xcpretty_options
+        options = []
+        options << "xcpretty_args" if Snapshot.config[:xcpretty_args]
+        return options
+      end
+
+      def pipe_xcpretty
+        pipe = []
         xcpretty = "xcpretty #{Snapshot.config[:xcpretty_args]}"
         xcpretty << "--no-color" if Helper.colors_disabled?
         pipe << "| #{xcpretty}"

data/trainer/lib/assets/junit.xml.erb

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<% number_of_tests = 0 %>
+<% number_of_failures = 0 %>
+<% @results.each { |a| number_of_tests += a[:number_of_tests_excluding_retries] } %>
+<% @results.each { |a| number_of_failures += a[:number_of_failures_excluding_retries] } %>
+
+<testsuites tests="<%= number_of_tests %>" failures="<%= number_of_failures %>">
+  <% @results.each do |testsuite| %>
+    <testsuite name=<%= (testsuite[:target_name].nil? ? testsuite[:test_name] : testsuite[:target_name]).encode(:xml => :attr) %> tests="<%= testsuite[:number_of_tests_excluding_retries] %>" failures="<%= testsuite[:number_of_failures_excluding_retries] %>" time="<%= testsuite[:duration] %>">
+      <% testsuite[:tests].each do |test| %>
+        <testcase classname=<%= test[:test_group].encode(:xml => :attr) %> name=<%= test[:name].encode(:xml => :attr) %> time="<%= test[:duration] %>">
+          <% (test[:failures] || []).each do |failure| %>
+            <failure message=<%= failure[:failure_message].encode(:xml => :attr) %>>
+            </failure>
+          <% end %>
+        </testcase>
+      <% end %>
+    </testsuite>
+  <% end %>
+</testsuites>

data/trainer/lib/trainer/commands_generator.rb

@@ -0,0 +1,51 @@
+require 'commander'
+
+require 'fastlane_core/configuration/configuration'
+require 'fastlane_core/ui/help_formatter'
+
+require_relative 'options'
+require_relative 'test_parser'
+
+require_relative 'module'
+
+HighLine.track_eof = false
+
+module Trainer
+  class CommandsGenerator
+    include Commander::Methods
+
+    def self.start
+      self.new.run
+    end
+
+    def run
+      program :version, Fastlane::VERSION
+      program :description, Trainer::DESCRIPTION
+      program :help, 'Author', 'Felix Krause <trainer@krausefx.com>'
+      program :help, 'Website', 'https://fastlane.tools'
+      program :help, 'GitHub', 'https://github.com/KrauseFx/trainer'
+      program :help_formatter, :compact
+
+      global_option('--verbose', 'Shows a more verbose output') { $verbose = true }
+
+      always_trace!
+
+      FastlaneCore::CommanderGenerator.new.generate(Trainer::Options.available_options)
+
+      command :run do |c|
+        c.syntax = 'trainer'
+        c.description = Trainer::DESCRIPTION
+
+        c.action do |args, options|
+          options = FastlaneCore::Configuration.create(Trainer::Options.available_options, options.__hash__)
+          FastlaneCore::PrintTable.print_values(config: options, title: "Summary for trainer #{Fastlane::VERSION}") if $verbose
+          Trainer::TestParser.auto_convert(options)
+        end
+      end
+
+      default_command(:run)
+
+      run!
+    end
+  end
+end

data/trainer/lib/trainer/junit_generator.rb

@@ -0,0 +1,31 @@
+require_relative 'module'
+
+module Trainer
+  class JunitGenerator
+    attr_accessor :results
+
+    def initialize(results)
+      self.results = results
+    end
+
+    def generate
+      # JUnit file documentation: http://llg.cubic.org/docs/junit/
+      # And http://nelsonwells.net/2012/09/how-jenkins-ci-parses-and-displays-junit-output/
+      # And http://windyroad.com.au/dl/Open%20Source/JUnit.xsd
+
+      lib_path = Trainer::ROOT
+      xml_path = File.join(lib_path, "lib/assets/junit.xml.erb")
+      xml = ERB.new(File.read(xml_path), nil, '<>').result(binding) # http://www.rrn.dk/rubys-erb-templating-system
+
+      xml = xml.gsub('system_', 'system-').delete("\e") # Jenkins can not parse 'ESC' symbol
+
+      # We have to manuall clear empty lines
+      # They may contain white spaces
+      clean_xml = []
+      xml.each_line do |row|
+        clean_xml << row.delete("\n") if row.strip.to_s.length > 0
+      end
+      return clean_xml.join("\n")
+    end
+  end
+end

data/trainer/lib/trainer/module.rb

@@ -0,0 +1,10 @@
+require 'fastlane_core/helper'
+require 'fastlane/boolean'
+
+module Trainer
+  Helper = FastlaneCore::Helper # you gotta love Ruby: Helper.* should use the Helper class contained in FastlaneCore
+  UI = FastlaneCore::UI
+  Boolean = Fastlane::Boolean
+  ROOT = Pathname.new(File.expand_path('../../..', __FILE__))
+  DESCRIPTION = "Convert xcodebuild plist and xcresult files to JUnit reports"
+end

data/trainer/lib/trainer/options.rb

@@ -0,0 +1,55 @@
+require 'fastlane_core/configuration/config_item'
+
+require_relative 'module'
+
+module Trainer
+  class Options
+    def self.available_options
+      @options ||= [
+        FastlaneCore::ConfigItem.new(key: :path,
+                                     short_option: "-p",
+                                     env_name: "TRAINER_PATH",
+                                     default_value: ".",
+                                     description: "Path to the directory that should be converted",
+                                     verify_block: proc do |value|
+                                       v = File.expand_path(value.to_s)
+                                       if v.end_with?(".plist")
+                                         UI.user_error!("Can't find file at path #{v}") unless File.exist?(v)
+                                       else
+                                         UI.user_error!("Path '#{v}' is not a directory or can't be found") unless File.directory?(v)
+                                       end
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :extension,
+                                     short_option: "-e",
+                                     env_name: "TRAINER_EXTENSION",
+                                     default_value: ".xml",
+                                     description: "The extension for the newly created file. Usually .xml or .junit",
+                                     verify_block: proc do |value|
+                                       UI.user_error!("extension must contain a `.`") unless value.include?(".")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :output_directory,
+                                     short_option: "-o",
+                                     env_name: "TRAINER_OUTPUT_DIRECTORY",
+                                     default_value: nil,
+                                     optional: true,
+                                     description: "Directoy in which the xml files should be written to. Same directory as source by default"),
+        FastlaneCore::ConfigItem.new(key: :fail_build,
+                                     env_name: "TRAINER_FAIL_BUILD",
+                                     description: "Should this step stop the build if the tests fail? Set this to false if you're handling this with a test reporter",
+                                     is_string: false,
+                                     default_value: true),
+        FastlaneCore::ConfigItem.new(key: :xcpretty_naming,
+                                     short_option: "-x",
+                                     env_name: "TRAINER_XCPRETTY_NAMING",
+                                     description: "Produces class name and test name identical to xcpretty naming in junit file",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :silent,
+                                     env_name: "TRAINER_SILENT",
+                                     description: "Silences all output",
+                                     is_string: false,
+                                     default_value: false)
+      ]
+    end
+  end
+end