fastlane 2.159.0 → 2.164.0

data/deliver/lib/deliver/app_screenshot_iterator.rb

@@ -52,10 +52,10 @@ module Deliver
       end
     end
 
-    # Iterate given local app_screenshot over localizations and app_screenshot_sets with index within each app_screenshot_set
+    # Iterate given local app_screenshot over localizations and app_screenshot_sets
     #
     # @param screenshots_per_language [Hash<String, Array<Deliver::AppScreenshot>]
-    # @yield [localization, app_screenshot_set, app_screenshot, index]
+    # @yield [localization, app_screenshot_set, app_screenshot]
     # @yieldparam [optional, Spaceship::ConnectAPI::AppStoreVersionLocalization] localization
     # @yieldparam [optional, Spaceship::ConnectAPI::AppStoreScreenshotSet] app_screenshot_set
     # @yieldparam [optional, Deliver::AppScreenshot] screenshot
@@ -85,8 +85,8 @@ module Deliver
           app_screenshot_set ||= localization.create_app_screenshot_set(attributes: { screenshotDisplayType: display_type })
 
           # iterate over screenshots per display size with index
-          screenshots.each.with_index do |screenshot, index|
-            yield(localization, app_screenshot_set, screenshot, index)
+          screenshots.each do |screenshot|
+            yield(localization, app_screenshot_set, screenshot)
           end
         end
       end

data/deliver/lib/deliver/module.rb

@@ -1,5 +1,6 @@
 require 'fastlane_core/helper'
 require 'fastlane_core/ui/ui'
+require 'fastlane/boolean'
 
 module Deliver
   class << self
@@ -7,6 +8,7 @@ module Deliver
 
   Helper = FastlaneCore::Helper # you gotta love Ruby: Helper.* should use the Helper class contained in FastlaneCore
   UI = FastlaneCore::UI
+  Boolean = Fastlane::Boolean
 
   # Constant that captures the root Pathname for the project. Should be used for building paths to assets or other
   # resources that code needs to locate locally

data/deliver/lib/deliver/options.rb

@@ -12,6 +12,22 @@ module Deliver
       user ||= ENV["DELIVER_USER"]
 
       [
+        FastlaneCore::ConfigItem.new(key: :api_key_path,
+                                     env_name: "DELIVER_API_KEY_PATH",
+                                     description: "Path to your App Store Connect API Key JSON file (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-json-file)",
+                                     optional: true,
+                                     conflicting_options: [:api_key],
+                                     verify_block: proc do |value|
+                                       UI.user_error!("Couldn't find API key JSON file at path '#{value}'") unless File.exist?(value)
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :api_key,
+                                     env_name: "DELIVER_API_KEY",
+                                     description: "Your App Store Connect API Key information (https://docs.fastlane.tools/app-store-connect-api/#use-return-value-and-pass-in-as-an-option)",
+                                     type: Hash,
+                                     optional: true,
+                                     sensitive: true,
+                                     conflicting_options: [:api_key_path]),
+
         FastlaneCore::ConfigItem.new(key: :username,
                                      short_option: "-u",
                                      env_name: "DELIVER_USERNAME",
@@ -129,7 +145,7 @@ module Deliver
                                      default_value: false),
         FastlaneCore::ConfigItem.new(key: :skip_app_version_update,
                                      env_name: "DELIVER_SKIP_APP_VERSION_UPDATE",
-                                     description: "Don't update app version for submission",
+                                     description: "Don’t create or update the app version that is being prepared for submission",
                                      is_string: false,
                                      default_value: false),
 
@@ -137,7 +153,7 @@ module Deliver
         FastlaneCore::ConfigItem.new(key: :force,
                                      short_option: "-f",
                                      env_name: "DELIVER_FORCE",
-                                     description: "Skip the HTML report file verification",
+                                     description: "Skip verification of HTML preview file",
                                      is_string: false,
                                      default_value: false),
         FastlaneCore::ConfigItem.new(key: :overwrite_screenshots,
@@ -160,8 +176,8 @@ module Deliver
         FastlaneCore::ConfigItem.new(key: :automatic_release,
                                      env_name: "DELIVER_AUTOMATIC_RELEASE",
                                      description: "Should the app be automatically released once it's approved? (Can not be used together with `auto_release_date`)",
-                                     is_string: false,
-                                     default_value: false),
+                                     type: Boolean,
+                                     optional: true),
         FastlaneCore::ConfigItem.new(key: :auto_release_date,
                                      env_name: "DELIVER_AUTO_RELEASE_DATE",
                                      description: "Date in milliseconds for automatically releasing on pending approval (Can not be used together with `automatic_release`)",

data/deliver/lib/deliver/queue_worker.rb

@@ -6,9 +6,11 @@ module Deliver
   # Use this when you have all the items that you'll process in advance.
   # Simply enqueue them to this and call `QueueWorker#start`.
   class QueueWorker
+    NUMBER_OF_THREADS = Helper.test? ? 1 : [ENV.fetch("DELIVER_NUMBER_OF_THREADS", 10).to_i, 10].min
+
     # @param concurrency (Numeric) - A number of threads to be created
     # @param block (Proc) - A task you want to execute with enqueued items
-    def initialize(concurrency, &block)
+    def initialize(concurrency = NUMBER_OF_THREADS, &block)
       @concurrency = concurrency
       @block = block
       @queue = Queue.new
@@ -19,46 +21,29 @@ module Deliver
       @queue.push(job)
     end
 
+    # @param jobs (Array<Object>) - An array of arbitary object that keeps parameters
+    def batch_enqueue(jobs)
+      raise(ArgumentError, "Enqueue Array instead of #{jobs.class}") unless jobs.kind_of?(Array)
+      jobs.each { |job| enqueue(job) }
+    end
+
     # Call this after you enqueuned all the jobs you want to process
     # This method blocks current thread until all the enqueued jobs are processed
     def start
+      @queue.close
+
       threads = []
       @concurrency.times do
         threads << Thread.new do
-          while running? && !empty?
+          job = @queue.pop
+          while job
+            @block.call(job)
             job = @queue.pop
-            @block.call(job) if job
           end
         end
       end
 
-      wait_for_complete
       threads.each(&:join)
     end
-
-    private
-
-    def running?
-      !@queue.closed?
-    end
-
-    def empty?
-      @queue.empty?
-    end
-
-    def wait_for_complete
-      wait_thread = Thread.new do
-        loop do
-          if @queue.empty?
-            @queue.close
-            break
-          end
-
-          sleep(1)
-        end
-      end
-
-      wait_thread.join
-    end
   end
 end

data/deliver/lib/deliver/runner.rb

@@ -26,11 +26,22 @@ module Deliver
     end
 
     def login
-      # Team selection passed though FASTLANE_TEAM_ID and FASTLANE_TEAM_NAME environment variables
-      # Prompts select team if multiple teams and none specified
-      UI.message("Login to App Store Connect (#{options[:username]})")
-      Spaceship::ConnectAPI.login(options[:username], nil, use_portal: false, use_tunes: true)
-      UI.message("Login successful")
+      if api_token
+        UI.message("Creating authorization token for App Store Connect API")
+        Spaceship::ConnectAPI.token = api_token
+      else
+        # Team selection passed though FASTLANE_TEAM_ID and FASTLANE_TEAM_NAME environment variables
+        # Prompts select team if multiple teams and none specified
+        UI.message("Login to App Store Connect (#{options[:username]})")
+        Spaceship::ConnectAPI.login(options[:username], nil, use_portal: false, use_tunes: true)
+        UI.message("Login successful")
+      end
+    end
+
+    def api_token
+      @api_token ||= Spaceship::ConnectAPI::Token.create(options[:api_key]) if options[:api_key]
+      @api_token ||= Spaceship::ConnectAPI::Token.from_json_file(options[:api_key_path]) if options[:api_key_path]
+      return @api_token
     end
 
     def run
@@ -67,11 +78,21 @@ module Deliver
       precheck_options = {
         default_rule_level: options[:precheck_default_rule_level],
         include_in_app_purchases: options[:precheck_include_in_app_purchases],
-        app_identifier: options[:app_identifier],
-        username: options[:username],
-        platform: options[:platform]
+        app_identifier: options[:app_identifier]
       }
 
+      if options[:api_key] || options[:api_key_path]
+        if options[:precheck_include_in_app_purchases]
+          UI.user_error!("Precheck cannot check In-app purchases with the App Store Connect API Key (yet). Exclude In-app purchases from precheck or use Apple ID login")
+        end
+
+        precheck_options[:api_key] = options[:api_key]
+        precheck_options[:api_key_path] = options[:api_key_path]
+      else
+        precheck_options[:username] = options[:username]
+        precheck_options[:platform] = options[:platform]
+      end
+
       precheck_config = FastlaneCore::Configuration.create(Precheck::Options.available_options, precheck_options)
       Precheck.config = precheck_config
 
@@ -175,10 +196,17 @@ module Deliver
 
     private
 
+    # If App Store Connect API token, use token.
     # If itc_provider was explicitly specified, use it.
     # If there are multiple teams, infer the provider from the selected team name.
     # If there are fewer than two teams, don't infer the provider.
     def transporter_for_selected_team
+      # Use JWT auth
+      unless api_token.nil?
+        api_token.refresh! if api_token.expired?
+        return FastlaneCore::ItunesTransporter.new(nil, nil, false, nil, api_token.text)
+      end
+
       tunes_client = Spaceship::ConnectAPI.client.tunes_client
 
       generic_transporter = FastlaneCore::ItunesTransporter.new(options[:username], nil, false, options[:itc_provider])

data/deliver/lib/deliver/upload_metadata.rb

@@ -1,4 +1,5 @@
 require_relative 'module'
+require_relative 'queue_worker'
 
 module Deliver
   # upload description, rating, etc.
@@ -96,7 +97,7 @@ module Deliver
 
         if v.nil?
           UI.message("Couldn't find live version, editing the current version on App Store Connect instead")
-          version = app.get_edit_app_store_version(platform: platform)
+          version = fetch_edit_app_store_version(app, platform)
           # we don't want to update the localised_options and non_localised_options
           # as we also check for `options[:edit_live]` at other areas in the code
           # by not touching those 2 variables, deliver is more consistent with what the option says
@@ -105,7 +106,7 @@ module Deliver
           UI.message("Found live version")
         end
       else
-        version = app.get_edit_app_store_version(platform: platform)
+        version = fetch_edit_app_store_version(app, platform)
         localised_options = (LOCALISED_VERSION_VALUES.keys + LOCALISED_APP_VALUES.keys)
         non_localised_options = NON_LOCALISED_VERSION_VALUES.keys
       end
@@ -175,38 +176,51 @@ module Deliver
 
                        non_localized_version_attributes['earliestReleaseDate'] = date
                        Spaceship::ConnectAPI::AppStoreVersion::ReleaseType::SCHEDULED
-                     elsif options[:automatic_release]
+                     elsif options[:automatic_release] == true
                        Spaceship::ConnectAPI::AppStoreVersion::ReleaseType::AFTER_APPROVAL
-                     else
+                     elsif options[:automatic_release] == false
                        Spaceship::ConnectAPI::AppStoreVersion::ReleaseType::MANUAL
                      end
-      non_localized_version_attributes['releaseType'] = release_type
+      if release_type.nil?
+        UI.important("Release type will not be set because neither `automatic_release` nor `auto_release_date` were provided. Please explicitly set one of these options if you need a release type set")
+      else
+        non_localized_version_attributes['releaseType'] = release_type
+      end
 
       # Update app store version
       # This needs to happen before updating localizations (https://openradar.appspot.com/radar?id=4925914991296512)
+      #
+      # Adding some sleeps because the API will sometimes be in a state where releaseType can't be modified
+      #   https://github.com/fastlane/fastlane/issues/16911
       UI.message("Uploading metadata to App Store Connect for version")
+      sleep(2)
       version.update(attributes: non_localized_version_attributes)
+      sleep(1)
 
       # Update app store version localizations
-      app_store_version_localizations.each do |app_store_version_localization|
+      store_version_worker = Deliver::QueueWorker.new do |app_store_version_localization|
         attributes = localized_version_attributes_by_locale[app_store_version_localization.locale]
         if attributes
           UI.message("Uploading metadata to App Store Connect for localized version '#{app_store_version_localization.locale}'")
           app_store_version_localization.update(attributes: attributes)
         end
       end
+      store_version_worker.batch_enqueue(app_store_version_localizations)
+      store_version_worker.start
 
       # Update app info localizations
-      app_info_localizations.each do |app_info_localization|
+      app_info_worker = Deliver::QueueWorker.new do |app_info_localization|
         attributes = localized_info_attributes_by_locale[app_info_localization.locale]
         if attributes
           UI.message("Uploading metadata to App Store Connect for localized info '#{app_info_localization.locale}'")
           app_info_localization.update(attributes: attributes)
         end
       end
+      app_info_worker.batch_enqueue(app_info_localizations)
+      app_info_worker.start
 
       # Update categories
-      app_info = app.fetch_edit_app_info
+      app_info = fetch_edit_app_info(app)
       if app_info
         category_id_map = {}
 
@@ -414,9 +428,35 @@ module Deliver
         .uniq
     end
 
+    def fetch_edit_app_store_version(app, platform, wait_time: 10)
+      retry_if_nil("Cannot find edit app store version", wait_time: wait_time) do
+        app.get_edit_app_store_version(platform: platform)
+      end
+    end
+
+    def fetch_edit_app_info(app, wait_time: 10)
+      retry_if_nil("Cannot find edit app info", wait_time: wait_time) do
+        app.fetch_edit_app_info
+      end
+    end
+
+    def retry_if_nil(message, tries: 5, wait_time: 10)
+      loop do
+        tries -= 1
+
+        value = yield
+        return value if value
+
+        UI.message("#{message}... Retrying after #{wait_time} seconds (remaining: #{tries})")
+        sleep(wait_time)
+
+        return nil if tries.zero?
+      end
+    end
+
     # Finding languages to enable
     def verify_available_info_languages!(options, app, languages)
-      app_info = app.fetch_edit_app_info
+      app_info = fetch_edit_app_info(app)
 
       unless app_info
         UI.user_error!("Cannot update languages - could not find an editable info")
@@ -451,7 +491,7 @@ module Deliver
     # Finding languages to enable
     def verify_available_version_languages!(options, app, languages)
       platform = Spaceship::ConnectAPI::Platform.map(options[:platform])
-      version = app.get_edit_app_store_version(platform: platform)
+      version = fetch_edit_app_store_version(app, platform)
 
       unless version
         UI.user_error!("Cannot update languages - could not find an editable version for '#{platform}'")
@@ -558,6 +598,7 @@ module Deliver
     def set_review_information(version, options)
       return unless options[:app_review_information]
       info = options[:app_review_information]
+      info = info.collect { |k, v| [k.to_sym, v] }.to_h
       UI.user_error!("`app_review_information` must be a hash", show_github_issues: true) unless info.kind_of?(Hash)
 
       attributes = {}

data/deliver/lib/deliver/upload_price_tier.rb

@@ -14,9 +14,14 @@ module Deliver
       attributes = {}
       territory_ids = []
 
-      app_prices = app.fetch_app_prices
+      # As of 2020-09-14:
+      # Official App Store Connect does not have an endpoint to get app prices for an app
+      # Need to get prices from the app's relationships
+      # Prices from app's relationship doess not have price tier so need to fetch app price with price tier relationship
+      app_prices = app.prices
       if app_prices.first
-        old_price = app_prices.first.price_tier.id
+        app_price = Spaceship::ConnectAPI.get_app_price(app_price_id: app_prices.first.id, includes: "priceTier").first
+        old_price = app_price.price_tier.id
       else
         UI.message("App has no prices yet... Enabling all countries in App Store Connect")
         territory_ids = Spaceship::ConnectAPI::Territory.all.map(&:id)

data/deliver/lib/deliver/upload_screenshots.rb

@@ -13,8 +13,6 @@ module Deliver
     DeleteScreenshotJob = Struct.new(:app_screenshot, :localization, :app_screenshot_set)
     UploadScreenshotJob = Struct.new(:app_screenshot_set, :path)
 
-    NUMBER_OF_THREADS = Helper.test? ? 1 : [ENV.fetch("DELIVER_NUMBER_OF_THREADS", 10).to_i, 10].min
-
     def upload(options, screenshots)
       return if options[:skip_screenshots]
       return if options[:edit_live]
@@ -69,7 +67,7 @@ module Deliver
     def delete_screenshots(localizations, screenshots_per_language, tries: 5)
       tries -= 1
 
-      worker = QueueWorker.new(NUMBER_OF_THREADS) do |job|
+      worker = QueueWorker.new do |job|
         start_time = Time.now
         target = "#{job.localization.locale} #{job.app_screenshot_set.screenshot_display_type} #{job.app_screenshot.id}"
         begin
@@ -115,7 +113,7 @@ module Deliver
       tries -= 1
 
       # Upload screenshots
-      worker = QueueWorker.new(NUMBER_OF_THREADS) do |job|
+      worker = QueueWorker.new do |job|
         begin
           UI.verbose("Uploading '#{job.path}'...")
           start_time = Time.now
@@ -126,10 +124,16 @@ module Deliver
         end
       end
 
-      number_of_screenshots = 0
+      # Each app_screenshot_set can have only 10 images
+      number_of_screenshots_per_set = {}
+      total_number_of_screenshots = 0
+
       iterator = AppScreenshotIterator.new(localizations)
-      iterator.each_local_screenshot(screenshots_per_language) do |localization, app_screenshot_set, screenshot, index|
-        if index >= 10
+      iterator.each_local_screenshot(screenshots_per_language) do |localization, app_screenshot_set, screenshot|
+        # Initialize counter on each app screenshot set
+        number_of_screenshots_per_set[app_screenshot_set] ||= (app_screenshot_set.app_screenshots || []).count
+
+        if number_of_screenshots_per_set[app_screenshot_set] >= 10
           UI.error("Too many screenshots found for device '#{screenshot.device_type}' in '#{screenshot.language}', skipping this one (#{screenshot.path})")
           next
         end
@@ -141,10 +145,12 @@ module Deliver
         if duplicate
           UI.message("Previous uploaded. Skipping '#{screenshot.path}'...")
         else
+          UI.verbose("Queued uplaod sceeenshot job for #{localization.locale} #{app_screenshot_set.screenshot_display_type} #{screenshot.path}")
           worker.enqueue(UploadScreenshotJob.new(app_screenshot_set, screenshot.path))
+          number_of_screenshots_per_set[app_screenshot_set] += 1
         end
 
-        number_of_screenshots += 1
+        total_number_of_screenshots += 1
       end
 
       worker.start
@@ -154,7 +160,7 @@ module Deliver
       Helper.show_loading_indicator("Waiting for all the screenshots processed...")
       states = wait_for_complete(iterator)
       Helper.hide_loading_indicator
-      retry_upload_screenshots_if_needed(iterator, states, number_of_screenshots, tries, localizations, screenshots_per_language)
+      retry_upload_screenshots_if_needed(iterator, states, total_number_of_screenshots, tries, localizations, screenshots_per_language)
 
       UI.message("Successfully uploaded all screenshots")
     end
@@ -203,12 +209,21 @@ module Deliver
       # Check if local screenshots' checksum exist on App Store Connect
       checksum_to_app_screenshot = iterator.each_app_screenshot.map { |_, _, app_screenshot| [app_screenshot.source_file_checksum, app_screenshot] }.to_h
 
-      missing_local_screenshots = iterator.each_local_screenshot(screenshots_per_language).select do |_, _, local_screenshot, index|
+      number_of_screenshots_per_set = {}
+      missing_local_screenshots = iterator.each_local_screenshot(screenshots_per_language).select do |_, app_screenshot_set, local_screenshot|
+        number_of_screenshots_per_set[app_screenshot_set] ||= (app_screenshot_set.app_screenshots || []).count
         checksum = UploadScreenshots.calculate_checksum(local_screenshot.path)
-        checksum_to_app_screenshot[checksum].nil? && index < 10 # if index is more than 10, it's skipped
+
+        if checksum_to_app_screenshot[checksum]
+          next(false)
+        else
+          is_missing = number_of_screenshots_per_set[app_screenshot_set] < 10 # if it's more than 10, it's skipped
+          number_of_screenshots_per_set[app_screenshot_set] += 1
+          next(is_missing)
+        end
       end
 
-      missing_local_screenshots.each do |_, _, screenshot, _|
+      missing_local_screenshots.each do |_, _, screenshot|
         UI.error("#{screenshot.path} is missing on App Store Connect.")
       end
 
@@ -219,7 +234,7 @@ module Deliver
       iterator = AppScreenshotIterator.new(localizations)
 
       # Re-order screenshots within app_screenshot_set
-      worker = QueueWorker.new(NUMBER_OF_THREADS) do |app_screenshot_set|
+      worker = QueueWorker.new do |app_screenshot_set|
         original_ids = app_screenshot_set.app_screenshots.map(&:id)
         sorted_ids = app_screenshot_set.app_screenshots.sort_by(&:file_name).map(&:id)
         if original_ids != sorted_ids