fastlane 2.141.0 → 2.146.0

data/pilot/lib/pilot/build_manager.rb

@@ -118,9 +118,17 @@ module Pilot
 
       # Get latest uploaded build if no build specified
       if build.nil?
-        UI.important("No build specified - fetching latest build")
+        app_version = config[:app_version]
+        build_number = config[:build_number]
+        if build_number.nil?
+          if app_version.nil?
+            UI.important("No build specified - fetching latest build")
+          else
+            UI.important("No build specified - fetching latest build for version #{app_version}")
+          end
+        end
         platform = Spaceship::ConnectAPI::Platform.map(fetch_app_platform)
-        build ||= Spaceship::ConnectAPI::Build.all(app_id: app.id, sort: "-uploadedDate", platform: platform, limit: 1).first
+        build ||= Spaceship::ConnectAPI::Build.all(app_id: app.id, version: app_version, build_number: build_number, sort: "-uploadedDate", platform: platform, limit: 1).first
       end
 
       # Verify the build has all the includes that we need
@@ -207,8 +215,11 @@ module Pilot
     end
 
     def update_beta_app_meta(options, build)
-      # Setting account required wth AppStore Connect API
-      update_review_detail(build, { demo_account_required: options[:demo_account_required] })
+      # If demo_account_required is a parameter, it should added into beta_app_review_info
+      unless options[:demo_account_required].nil?
+        options[:beta_app_review_info] = {} if options[:beta_app_review_info].nil?
+        options[:beta_app_review_info][:demo_account_required] = options[:demo_account_required]
+      end
 
       if should_update_beta_app_review_info(options)
         update_review_detail(build, options[:beta_app_review_info])
@@ -481,12 +492,18 @@ module Pilot
     end
 
     def update_build_beta_details(build, info)
-      build_beta_detail = build.build_beta_detail
-
       attributes = {}
       attributes[:autoNotifyEnabled] = info[:auto_notify_enabled] if info.key?(:auto_notify_enabled)
+      build_beta_detail = build.build_beta_detail
 
-      Spaceship::ConnectAPI.patch_build_beta_details(build_beta_details_id: build_beta_detail.id, attributes: attributes)
+      # https://github.com/fastlane/fastlane/pull/16006
+      if build_beta_detail
+        Spaceship::ConnectAPI.patch_build_beta_details(build_beta_details_id: build_beta_detail.id, attributes: attributes)
+      else
+        if attributes[:autoNotifyEnabled]
+          UI.important("Unable to auto notify testers as the build did not include beta detail information - this is likely a temporary issue on TestFlight.")
+        end
+      end
     end
   end
   # rubocop:enable Metrics/ClassLength

data/pilot/lib/pilot/options.rb

@@ -162,6 +162,14 @@ module Pilot
                                     env_name: "PILOT_NOTIFY_EXTERNAL_TESTERS",
                                     description: "Should notify external testers?",
                                     default_value: true),
+        FastlaneCore::ConfigItem.new(key: :app_version,
+                                     env_name: "PILOT_APP_VERSION",
+                                     description: "The version number of the application build to distribute. If the version number is not specified, then the most recent build uploaded to TestFlight will be distributed. If specified, the most recent build for the version number will be distributed",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :build_number,
+                                     env_name: "PILOT_BUILD_NUMBER",
+                                     description: "The build number of the application build to distribute. If the build number is not specified, the most recent build is distributed",
+                                     optional: true),
 
         # testers
         FastlaneCore::ConfigItem.new(key: :first_name,

data/produce/lib/produce/developer_center.rb

@@ -59,7 +59,7 @@ module Produce
         app = Spaceship.app.create!(bundle_id: app_identifier,
                                          name: app_name,
                                          enable_services: enable_services,
-                                         mac: Produce.config[:platform] == "osx")
+                                         mac: platform == "osx")
 
         if app.name != Produce.config[:app_name]
           UI.important("Your app name includes non-ASCII characters, which are not supported by the Apple Developer Portal.")
@@ -122,8 +122,17 @@ module Produce
 
     private
 
+    def platform
+      # This was added to support creation of multiple platforms
+      # Produce::ItunesConnect can take an array of platforms to create for App Store Connect
+      # but the Developer Center is now platform agnostic so we choose any platform here
+      #
+      # Platform won't be needed at all in the future when this is change over to use Spaceship::ConnectAPI
+      (Produce.config[:platforms] || []).first || Produce.config[:platform]
+    end
+
     def app_exists?
-      Spaceship.app.find(app_identifier, mac: Produce.config[:platform] == "osx") != nil
+      Spaceship.app.find(app_identifier, mac: platform == "osx") != nil
     end
 
     def login

data/produce/lib/produce/itunes_connect.rb

@@ -23,6 +23,8 @@ module Produce
       else
         UI.success("Creating new app '#{Produce.config[:app_name]}' on App Store Connect")
 
+        platforms = Produce.config[:platforms] || [Produce.config[:platform]]
+
         Produce.config[:bundle_identifier_suffix] = '' unless wildcard_bundle?
         generated_app = Spaceship::Tunes::Application.create!(name: Produce.config[:app_name],
                                                               primary_language: language,
@@ -30,7 +32,7 @@ module Produce
                                                               bundle_id: app_identifier,
                                                               bundle_id_suffix: Produce.config[:bundle_identifier_suffix],
                                                               company_name: Produce.config[:company_name],
-                                                              platform: Produce.config[:platform],
+                                                              platforms: platforms,
                                                               itunes_connect_users: Produce.config[:itc_users])
 
         UI.crash!("Something went wrong when creating the new app on iTC") if generated_app["adamId"].to_s.empty?
@@ -51,16 +53,22 @@ module Produce
         UI.crash!("Something went wrong when creating the new app - it's not listed in the App's list") unless application
 
         UI.message("Ensuring version number")
-        application.ensure_version!(Produce.config[:app_version], platform: Produce.config[:platform]) if Produce.config[:app_version]
+        platforms.each do |platform|
+          application.ensure_version!(Produce.config[:app_version], platform: platform) if Produce.config[:app_version]
+        end
 
         UI.success("Successfully created new app '#{Produce.config[:app_name]}' on App Store Connect with ID #{application.apple_id}")
       end
 
-      return Spaceship::Tunes::Application.find(@full_bundle_identifier, mac: Produce.config[:platform] == "osx").apple_id
+      return Spaceship::Tunes::Application.find(@full_bundle_identifier, mac: platform == "osx").apple_id
     end
 
     private
 
+    def platform
+      (Produce.config[:platforms] || []).first || Produce.config[:platform]
+    end
+
     def fetch_application
       Spaceship::Tunes::Application.find(@full_bundle_identifier)
     end

data/produce/lib/produce/options.rb

@@ -50,11 +50,23 @@ module Produce
                                      short_option: "-j",
                                      env_name: "PRODUCE_PLATFORM",
                                      description: "The platform to use (optional)",
+                                     conflicting_options: [:platforms],
                                      optional: true,
                                      default_value: "ios",
                                      verify_block: proc do |value|
                                                      UI.user_error!("The platform can only be ios or osx") unless %('ios', 'osx').include?(value)
                                                    end),
+        FastlaneCore::ConfigItem.new(key: :platforms,
+                                     short_option: "-J",
+                                     env_name: "PRODUCE_PLATFORMS",
+                                     description: "The platforms to use (optional)",
+                                     conflicting_options: [:platform],
+                                     optional: true,
+                                     type: Array,
+                                     verify_block: proc do |values|
+                                                     types = %w(ios osx)
+                                                     UI.user_error!("The platform can only be #{types}") unless (values - types).empty?
+                                                   end),
         FastlaneCore::ConfigItem.new(key: :language,
                                      short_option: "-m",
                                      env_name: "PRODUCE_LANGUAGE",

data/scan/lib/scan/options.rb

@@ -124,6 +124,11 @@ module Scan
                                      end),
 
         # other test options
+        FastlaneCore::ConfigItem.new(key: :testplan,
+                                     env_name: "SCAN_TESTPLAN",
+                                     description: "The testplan associated with the scheme that should be used for testing",
+                                     is_string: true,
+                                     optional: true),
         FastlaneCore::ConfigItem.new(key: :xctestrun,
                                      short_option: "-X",
                                      env_name: "SCAN_XCTESTRUN",
@@ -254,6 +259,11 @@ module Scan
                                      default_value: false),
 
         # concurrency
+        FastlaneCore::ConfigItem.new(key: :concurrent_workers,
+                                     type: Integer,
+                                     env_name: "SCAN_CONCURRENT_WORKERS",
+                                     description: "Specify the exact number of test runners that will be spawned during parallel testing. Equivalent to -parallel-testing-worker-count",
+                                     optional: true),
         FastlaneCore::ConfigItem.new(key: :max_concurrent_simulators,
                                      type: Integer,
                                      env_name: "SCAN_MAX_CONCURRENT_SIMULATORS",

data/scan/lib/scan/runner.rb

@@ -25,15 +25,17 @@ module Scan
     def test_app
       force_quit_simulator_processes if Scan.config[:force_quit_simulator]
 
-      if Scan.config[:reset_simulator]
-        Scan.devices.each do |device|
-          FastlaneCore::Simulator.reset(udid: device.udid)
+      if Scan.devices
+        if Scan.config[:reset_simulator]
+          Scan.devices.each do |device|
+            FastlaneCore::Simulator.reset(udid: device.udid)
+          end
         end
-      end
 
-      if Scan.config[:disable_slide_to_type]
-        Scan.devices.each do |device|
-          FastlaneCore::Simulator.disable_slide_to_type(udid: device.udid)
+        if Scan.config[:disable_slide_to_type]
+          Scan.devices.each do |device|
+            FastlaneCore::Simulator.disable_slide_to_type(udid: device.udid)
+          end
         end
       end
 

data/scan/lib/scan/test_command_generator.rb

@@ -27,7 +27,7 @@ module Scan
       UI.user_error!("No project/workspace found")
     end
 
-    def options
+    def options # rubocop:disable Metrics/PerceivedComplexity
       config = Scan.config
 
       options = []
@@ -37,11 +37,17 @@ module Scan
       options << "-toolchain '#{config[:toolchain]}'" if config[:toolchain]
       options << "-derivedDataPath '#{config[:derived_data_path]}'" if config[:derived_data_path]
       options << "-resultBundlePath '#{result_bundle_path}'" if config[:result_bundle]
-      options << "-maximum-concurrent-test-simulator-destinations #{config[:max_concurrent_simulators]}" if config[:max_concurrent_simulators]
-      options << "-disable-concurrent-testing" if config[:disable_concurrent_testing]
+      options << "-parallel-testing-worker-count #{config[:concurrent_workers]}" if config[:concurrent_workers]
+      if FastlaneCore::Helper.xcode_at_least?(10)
+        options << "-maximum-concurrent-test-simulator-destinations #{config[:max_concurrent_simulators]}" if config[:max_concurrent_simulators]
+        options << "-disable-concurrent-testing" if config[:disable_concurrent_testing]
+      end
       options << "-enableCodeCoverage #{config[:code_coverage] ? 'YES' : 'NO'}" unless config[:code_coverage].nil?
       options << "-enableAddressSanitizer #{config[:address_sanitizer] ? 'YES' : 'NO'}" unless config[:address_sanitizer].nil?
       options << "-enableThreadSanitizer #{config[:thread_sanitizer] ? 'YES' : 'NO'}" unless config[:thread_sanitizer].nil?
+      if FastlaneCore::Helper.xcode_at_least?(11)
+        options << "-testPlan '#{config[:testplan]}'" if config[:testplan]
+      end
       options << "-xctestrun '#{config[:xctestrun]}'" if config[:xctestrun]
       options << config[:xcargs] if config[:xcargs]
 
@@ -148,7 +154,8 @@ module Scan
 
     def result_bundle_path
       unless Scan.cache[:result_bundle_path]
-        path = File.join(Scan.config[:output_directory], Scan.config[:scheme]) + ".test_result"
+        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

data/screengrab/lib/screengrab/runner.rb

@@ -63,7 +63,7 @@ module Screengrab
 
       # Root is needed to access device paths at /data
       if @config[:use_adb_root]
-        run_adb_command("root", print_all: false, print_command: true)
+        run_adb_command("-s #{device_serial} root", print_all: false, print_command: true)
       end
 
       clear_device_previous_screenshots(device_serial, device_screenshots_paths)
@@ -73,15 +73,11 @@ module Screengrab
 
       validate_apk(app_apk_path)
 
-      enable_clean_status_bar(device_serial, app_apk_path)
-
-      run_tests(device_serial, app_apk_path, tests_apk_path, test_classes_to_use, test_packages_to_use, @config[:launch_arguments])
-
-      number_of_screenshots = pull_screenshots_from_device(device_serial, device_screenshots_paths, device_type_dir_name)
+      number_of_screenshots = run_tests(device_type_dir_name, device_screenshots_paths, device_serial, app_apk_path, tests_apk_path, test_classes_to_use, test_packages_to_use, @config[:launch_arguments])
 
       ReportsGenerator.new.generate
 
-      UI.success("Captured #{number_of_screenshots} screenshots! 📷✨")
+      UI.success("Captured #{number_of_screenshots} new screenshots! 📷✨")
     end
 
     def select_device
@@ -147,10 +143,17 @@ module Screengrab
 
     def determine_internal_screenshots_paths(app_package_name, locales)
       locale_paths = locales.map do |locale|
-        "/data/user/0/#{app_package_name}/files/#{app_package_name}/screengrab/#{locale}/images/screenshots"
-      end
+        [
+          "/data/user/0/#{app_package_name}/files/#{app_package_name}/screengrab/#{locale}/images/screenshots",
+
+          # https://github.com/fastlane/fastlane/issues/15653#issuecomment-578541663
+          "/data/data/#{app_package_name}/files/#{app_package_name}/screengrab/#{locale}/images/screenshots"
+        ]
+      end.flatten
 
-      return ["/data/data/#{app_package_name}/app_screengrab"] + locale_paths
+      return ["/data/data/#{app_package_name}/app_screengrab"] +
+             ["/data/data/#{app_package_name}/screengrab"] +
+             locale_paths
     end
 
     def clear_device_previous_screenshots(device_serial, device_screenshots_paths)
@@ -232,23 +235,29 @@ module Screengrab
       end
     end
 
-    def run_tests(device_serial, app_apk_path, tests_apk_path, test_classes_to_use, test_packages_to_use, launch_arguments)
+    def run_tests(device_type_dir_name, device_screenshots_paths, device_serial, app_apk_path, tests_apk_path, test_classes_to_use, test_packages_to_use, launch_arguments)
       unless @config[:reinstall_app]
         install_apks(device_serial, app_apk_path, tests_apk_path)
         grant_permissions(device_serial)
+        enable_clean_status_bar(device_serial, app_apk_path)
       end
 
+      number_of_screenshots = 0
+
       @config[:locales].each do |locale|
         if @config[:reinstall_app]
           uninstall_apks(device_serial, @config[:app_package_name], @config[:tests_package_name])
           install_apks(device_serial, app_apk_path, tests_apk_path)
           grant_permissions(device_serial)
+          enable_clean_status_bar(device_serial, app_apk_path)
         end
-        run_tests_for_locale(locale, device_serial, test_classes_to_use, test_packages_to_use, launch_arguments)
+        number_of_screenshots += run_tests_for_locale(device_type_dir_name, device_screenshots_paths, locale, device_serial, test_classes_to_use, test_packages_to_use, launch_arguments)
       end
+
+      number_of_screenshots
     end
 
-    def run_tests_for_locale(locale, device_serial, test_classes_to_use, test_packages_to_use, launch_arguments)
+    def run_tests_for_locale(device_type_dir_name, device_screenshots_paths, locale, device_serial, test_classes_to_use, test_packages_to_use, launch_arguments)
       UI.message("Running tests for locale: #{locale}")
 
       instrument_command = ["-s #{device_serial} shell am instrument --no-window-animation -w",
@@ -271,10 +280,12 @@ module Screengrab
           UI.error("Tests failed")
         end
       end
+
+      pull_screenshots_from_device(locale, device_serial, device_screenshots_paths, device_type_dir_name)
     end
 
-    def pull_screenshots_from_device(device_serial, device_screenshots_paths, device_type_dir_name)
-      UI.message("Pulling captured screenshots from the device")
+    def pull_screenshots_from_device(locale, device_serial, device_screenshots_paths, device_type_dir_name)
+      UI.message("Pulling captured screenshots for locale #{locale} from the device")
       starting_screenshot_count = screenshot_file_names_in(@config[:output_directory], device_type_dir_name).length
 
       UI.verbose("Starting screenshot count is: #{starting_screenshot_count}")
@@ -285,6 +296,7 @@ module Screengrab
       Dir.mktmpdir do |tempdir|
         device_screenshots_paths.each do |device_path|
           if_device_path_exists(device_serial, device_path) do |path|
+            next unless path.include?(locale)
             run_adb_command("-s #{device_serial} pull #{path} #{tempdir}",
                             print_all: false,
                             print_command: true)
@@ -296,7 +308,7 @@ module Screengrab
         #
         # Therefore, we'll move the pulled screenshots from their genericly named folder to one named by the
         # user provided device_type option value to match the directory structure that supply expects
-        move_pulled_screenshots(tempdir, device_type_dir_name)
+        move_pulled_screenshots(locale, tempdir, device_type_dir_name)
       end
 
       ending_screenshot_count = screenshot_file_names_in(@config[:output_directory], device_type_dir_name).length
@@ -305,7 +317,8 @@ module Screengrab
 
       # Because we can't guarantee the screenshot output directory will be empty when we pull, we determine
       # success based on whether there are more screenshots there than when we started.
-      if starting_screenshot_count == ending_screenshot_count
+      # This is only applicable though when `clear_previous_screenshots` is set to `true`.
+      if starting_screenshot_count == ending_screenshot_count && @config[:clear_previous_screenshots]
         UI.error("Make sure you've used Screengrab.screenshot() in your tests and that your expected tests are being run.")
         UI.abort_with_message!("No screenshots were detected 📷❌")
       end
@@ -313,7 +326,7 @@ module Screengrab
       ending_screenshot_count - starting_screenshot_count
     end
 
-    def move_pulled_screenshots(pull_dir, device_type_dir_name)
+    def move_pulled_screenshots(locale, pull_dir, device_type_dir_name)
       # Glob pattern that finds the pulled screenshots directory for each locale
       # Possible matches:
       #   [pull_dir]/en-US/images/screenshots
@@ -337,7 +350,7 @@ module Screengrab
         # specific name, as expected by supply
         #
         # (Moved to: fastlane/metadata/android/en-US/images/phoneScreenshots)
-        dest_dir = File.join(File.dirname(dest_dir), device_type_dir_name)
+        dest_dir = File.join(File.dirname(dest_dir), locale, 'images', device_type_dir_name)
 
         FileUtils.mkdir_p(dest_dir)
         FileUtils.cp_r(src_screenshots, dest_dir)

data/snapshot/lib/snapshot/fixes/simulator_shared_pasteboard.rb

@@ -0,0 +1,16 @@
+require_relative '../module'
+
+module Snapshot
+  module Fixes
+    # Becoming first responder can trigger Pasteboard sync, which can stall and crash the simulator
+    # See https://twitter.com/steipete/status/1227551552317140992
+
+    class SharedPasteboardFix
+      def self.patch
+        UI.verbose("Patching simulator to disable Pasteboard automatic sync")
+
+        Helper.backticks("defaults write com.apple.iphonesimulator PasteboardAutomaticSync -bool false", print: FastlaneCore::Globals.verbose?)
+      end
+    end
+  end
+end

data/snapshot/lib/snapshot/reports_generator.rb

@@ -97,13 +97,17 @@ module Snapshot
         'iPhone SE' => "iPhone SE",
         'iPhone 4s' => "iPhone 4s (3.5-Inch)",
         'iPad 2' => 'iPad 2',
+        'iPad Air (3rd generation)' => 'iPad Air (3rd generation)',
         'iPad Air 2' => 'iPad Air 2',
         'iPad Air' => 'iPad Air',
         'iPad (5th generation)' => 'iPad (5th generation)',
+        'iPad (7th generation)' => 'iPad (7th generation)',
         'iPad Pro (9.7-inch)' => 'iPad Pro (9.7-inch)',
         'iPad Pro (9.7 inch)' => 'iPad Pro (9.7-inch)', # iOS 10.3.1 simulator
         'iPad Pro (10.5-inch)' => 'iPad Pro (10.5-inch)',
+        'iPad Pro (11-inch) (2nd generation)' => 'iPad Pro (11-inch) (2nd generation)',
         'iPad Pro (11-inch)' => 'iPad Pro (11-inch)',
+        'iPad Pro (12.9-inch) (4th generation)' => 'iPad Pro (12.9-inch) (4th generation)',
         'iPad Pro (12.9-inch) (3rd generation)' => 'iPad Pro (12.9-inch) (3rd generation)',
         'iPad Pro (12.9-inch) (2nd generation)' => 'iPad Pro (12.9-inch) (2nd generation)',
         'iPad Pro (12.9-inch)' => 'iPad Pro (12.9-inch)',

data/snapshot/lib/snapshot/simulator_launchers/simulator_launcher_base.rb

@@ -5,6 +5,7 @@ require_relative '../test_command_generator'
 require_relative '../collector'
 require_relative '../fixes/hardware_keyboard_fix'
 require_relative '../fixes/simulator_zoom_fix'
+require_relative '../fixes/simulator_shared_pasteboard'
 
 module Snapshot
   class SimulatorLauncherBase
@@ -53,6 +54,7 @@ module Snapshot
 
       Fixes::SimulatorZoomFix.patch
       Fixes::HardwareKeyboardFix.patch
+      Fixes::SharedPasteboardFix.patch
 
       device_types.each do |type|
         if launcher_config.erase_simulator || launcher_config.localize_simulator || !launcher_config.dark_mode.nil?

data/spaceship/lib/spaceship/connect_api/models/app.rb

@@ -103,6 +103,17 @@ module Spaceship
         resps = Spaceship::ConnectAPI.get_beta_groups(filter: filter, includes: includes, limit: limit, sort: sort).all_pages
         return resps.flat_map(&:to_models)
       end
+
+      def create_beta_group(group_name: nil, public_link_enabled: false, public_link_limit: 10_000, public_link_limit_enabled: false)
+        resps = Spaceship::ConnectAPI.create_beta_group(
+          app_id: id,
+          group_name: group_name,
+          public_link_enabled: public_link_enabled,
+          public_link_limit: public_link_limit,
+          public_link_limit_enabled: public_link_limit_enabled
+        ).all_pages
+        return resps.flat_map(&:to_models).first
+      end
     end
   end
 end