fastlane 2.155.3 → 2.157.2

data/fastlane_core/lib/fastlane_core/project.rb

@@ -320,6 +320,7 @@ module FastlaneCore
       proj << "-scheme #{options[:scheme].shellescape}" if options[:scheme]
       proj << "-project #{options[:project].shellescape}" if options[:project]
       proj << "-configuration #{options[:configuration].shellescape}" if options[:configuration]
+      proj << "-derivedDataPath #{options[:derived_data_path].shellescape}" if options[:derived_data_path]
       proj << "-xcconfig #{options[:xcconfig].shellescape}" if options[:xcconfig]
 
       if FastlaneCore::Helper.xcode_at_least?('11.0') && options[:cloned_source_packages_path]

data/gym/lib/gym/error_handler.rb

@@ -143,7 +143,7 @@ module Gym
         # `xcodebuild` doesn't properly mark lines as failure reason or important information
         # so we assume that the last few lines show the error message that's relevant
         # (at least that's what was correct during testing)
-        log_content = File.read(log_path).split("\n")[-5..-1]
+        log_content = File.read(log_path).split("\n").last(5)
         log_content.each do |row|
           UI.command_output(row)
         end

data/gym/lib/gym/generators/build_command_generator.rb

@@ -38,7 +38,6 @@ module Gym
         options << "-toolchain '#{config[:toolchain]}'" if config[:toolchain]
         options << "-destination '#{config[:destination]}'" if config[:destination]
         options << "-archivePath #{archive_path.shellescape}" unless config[:skip_archive]
-        options << "-derivedDataPath '#{config[:derived_data_path]}'" if config[:derived_data_path]
         options << "-resultBundlePath '#{result_bundle_path}'" if config[:result_bundle]
         options << config[:xcargs] if config[:xcargs]
         options << "OTHER_SWIFT_FLAGS=\"-Xfrontend -debug-time-function-bodies\"" if config[:analyze_build_time]

data/pilot/lib/pilot/build_manager.rb

@@ -343,22 +343,36 @@ module Pilot
       builds_to_expire.each(&:expire!)
     end
 
+    # 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(options)
+      # 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
+
+      # Otherwise use username and password
+      tunes_client = Spaceship::ConnectAPI.client ? Spaceship::ConnectAPI.client.tunes_client : nil
+
       generic_transporter = FastlaneCore::ItunesTransporter.new(options[:username], nil, false, options[:itc_provider])
-      return generic_transporter if options[:itc_provider] || Spaceship::Tunes.client.nil?
-      return generic_transporter unless Spaceship::Tunes.client.teams.count > 1
+      return generic_transporter if options[:itc_provider] || tunes_client.nil?
+      return generic_transporter unless tunes_client.teams.count > 1
 
       begin
-        team = Spaceship::Tunes.client.teams.find { |t| t['contentProvider']['contentProviderId'].to_s == Spaceship::Tunes.client.team_id }
+        team = tunes_client.teams.find { |t| t['contentProvider']['contentProviderId'].to_s == tunes_client.team_id }
         name = team['contentProvider']['name']
+        STDERR.puts("name: #{name}")
+        STDERR.puts("id: #{generic_transporter.provider_ids}")
         provider_id = generic_transporter.provider_ids[name]
+        STDERR.puts("provider_id: #{provider_id}")
         UI.verbose("Inferred provider id #{provider_id} for team #{name}.")
         return FastlaneCore::ItunesTransporter.new(options[:username], nil, false, provider_id)
       rescue => ex
-        UI.verbose("Couldn't infer a provider short name for team with id #{Spaceship::Tunes.client.team_id} automatically: #{ex}. Proceeding without provider short name.")
+        STDERR.puts(ex.to_s)
+        UI.verbose("Couldn't infer a provider short name for team with id #{tunes_client.team_id} automatically: #{ex}. Proceeding without provider short name.")
         return generic_transporter
       end
     end

data/pilot/lib/pilot/manager.rb

@@ -17,12 +17,23 @@ module Pilot
     end
 
     def login
-      config[:username] ||= CredentialsManager::AppfileConfig.try_fetch_value(:apple_id)
+      if api_token
+        UI.message("Creating authorization token for App Store Connect API")
+        Spaceship::ConnectAPI.token = api_token
+      else
+        config[:username] ||= CredentialsManager::AppfileConfig.try_fetch_value(:apple_id)
 
-      UI.message("Login to App Store Connect (#{config[:username]})")
-      Spaceship::Tunes.login(config[:username])
-      Spaceship::Tunes.select_team(team_id: config[:team_id], team_name: config[:team_name])
-      UI.message("Login successful")
+        UI.message("Login to App Store Connect (#{config[:username]})")
+        Spaceship::ConnectAPI.login(config[:username], use_portal: false, use_tunes: true)
+        Spaceship::ConnectAPI.select_team(tunes_team_id: config[:team_id], team_name: config[:team_name])
+        UI.message("Login successful")
+      end
+    end
+
+    def api_token
+      @api_token ||= Spaceship::ConnectAPI::Token.create(config[:api_key]) if config[:api_key]
+      @api_token ||= Spaceship::ConnectAPI::Token.from_json_file(config[:api_key_path]) if config[:api_key_path]
+      return @api_token
     end
 
     # The app object we're currently using

data/pilot/lib/pilot/options.rb

@@ -10,6 +10,22 @@ module Pilot
       user ||= CredentialsManager::AppfileConfig.try_fetch_value(:apple_id)
 
       [
+        FastlaneCore::ConfigItem.new(key: :api_key_path,
+                                     env_name: "PILOT_API_KEY_PATH",
+                                     description: "Path to your App Store Connect API key JSON file",
+                                     optional: true,
+                                     conflicting_options: [:username],
+                                     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: "PILOT_API_KEY",
+                                     description: "Path to your App Store Connect API key JSON file",
+                                     type: Hash,
+                                     optional: true,
+                                     sensitive: true,
+                                     conflicting_options: [:api_key_path, :username]),
+
         # app upload info
         FastlaneCore::ConfigItem.new(key: :username,
                                      short_option: "-u",

data/produce/lib/produce/itunes_connect.rb

@@ -9,8 +9,8 @@ module Produce
       @full_bundle_identifier = app_identifier
       @full_bundle_identifier.gsub!('*', Produce.config[:bundle_identifier_suffix].to_s) if wildcard_bundle?
 
-      Spaceship::Tunes.login(Produce.config[:username], nil)
-      Spaceship::Tunes.client.select_team
+      Spaceship::ConnectAPI.login(Produce.config[:username], nil, use_portal: false, use_tunes: true)
+      Spaceship::ConnectAPI.client.select_team
 
       create_new_app
     end

data/scan/lib/scan/test_command_generator.rb

@@ -35,7 +35,9 @@ module Scan
       options << "-sdk '#{config[:sdk]}'" if config[:sdk]
       options << destination # generated in `detect_values`
       options << "-toolchain '#{config[:toolchain]}'" if config[:toolchain]
-      options << "-derivedDataPath '#{config[:derived_data_path]}'" if config[:derived_data_path]
+      if config[:derived_data_path] && !options.include?("-derivedDataPath #{config[:derived_data_path].shellescape}")
+        options << "-derivedDataPath #{config[:derived_data_path].shellescape}"
+      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]

data/screengrab/lib/screengrab/runner.rb

@@ -64,9 +64,10 @@ module Screengrab
       # Root is needed to access device paths at /data
       if @config[:use_adb_root]
         run_adb_command("-s #{device_serial} root", print_all: false, print_command: true)
+        run_adb_command("-s #{device_serial} wait-for-device", print_all: false, print_command: true)
       end
 
-      clear_device_previous_screenshots(device_serial, device_screenshots_paths)
+      clear_device_previous_screenshots(@config[:app_package_name], device_serial, device_screenshots_paths)
 
       app_apk_path ||= select_app_apk(discovered_apk_paths)
       tests_apk_path ||= select_tests_apk(discovered_apk_paths)
@@ -81,7 +82,7 @@ module Screengrab
     end
 
     def select_device
-      adb = Fastlane::Helper::AdbHelper.new(adb_host: @config[:adb_host])
+      adb = Fastlane::Helper::AdbHelper.new(adb_path: @android_env.adb_path, adb_host: @config[:adb_host])
       devices = adb.load_all_devices
 
       UI.user_error!('There are no connected and authorized devices or emulators') if devices.empty?
@@ -157,12 +158,12 @@ module Screengrab
       end.flatten
     end
 
-    def clear_device_previous_screenshots(device_serial, device_screenshots_paths)
+    def clear_device_previous_screenshots(app_package_name, device_serial, device_screenshots_paths)
       UI.message('Cleaning screenshots on device')
 
       device_screenshots_paths.each do |device_path|
-        if_device_path_exists(device_serial, device_path) do |path|
-          run_adb_command("-s #{device_serial} shell rm -rf #{path}",
+        if_device_path_exists(app_package_name, device_serial, device_path) do |path|
+          run_adb_command("-s #{device_serial} shell run-as #{app_package_name} rm -rf #{path}",
                           print_all: true,
                           print_command: true)
         end
@@ -296,11 +297,19 @@ module Screengrab
 
       Dir.mktmpdir do |tempdir|
         device_screenshots_paths.each do |device_path|
-          if_device_path_exists(device_serial, device_path) do |path|
+          if_device_path_exists(@config[:app_package_name], 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)
+            out = run_adb_command("-s #{device_serial} pull #{path} #{tempdir}",
+                                  print_all: false,
+                                  print_command: true,
+                                  raise_errors: false)
+            if out =~ /Permission denied/
+              dir = File.dirname(path)
+              base = File.basename(path)
+              run_adb_command("-s #{device_serial} shell run-as #{@config[:app_package_name]} 'tar -cC #{dir} #{base}' | tar -xvC #{tempdir}",
+                              print_all: false,
+                              print_command: true)
+            end
           end
         end
 
@@ -361,8 +370,8 @@ module Screengrab
 
     # Some device commands fail if executed against a device path that does not exist, so this helper method
     # provides a way to conditionally execute a block only if the provided path exists on the device.
-    def if_device_path_exists(device_serial, device_path)
-      return if run_adb_command("-s #{device_serial} shell ls #{device_path}",
+    def if_device_path_exists(app_package_name, device_serial, device_path)
+      return if run_adb_command("-s #{device_serial} shell run-as #{app_package_name} ls #{device_path}",
                                 print_all: false,
                                 print_command: false).include?('No such file')
 
@@ -380,16 +389,26 @@ module Screengrab
       packages.split("\n").map { |package| package.gsub("package:", "") }
     end
 
-    def run_adb_command(command, print_all: false, print_command: false)
+    def run_adb_command(command, print_all: false, print_command: false, raise_errors: true)
       adb_path = @android_env.adb_path.chomp("adb")
       adb_host = @config[:adb_host]
       host = adb_host.nil? ? '' : "-H #{adb_host} "
-      output = @executor.execute(command: adb_path + "adb " + host + command,
-                                 print_all: print_all,
-                                 print_command: print_command) || ''
+      output = ''
+      begin
+        errout = nil
+        cmdout = @executor.execute(command: adb_path + "adb " + host + command,
+                                  print_all: print_all,
+                                  print_command: print_command,
+                                  error: raise_errors ? nil : proc { |out, status| errout = out }) || ''
+        output = errout || cmdout
+      rescue => ex
+        if raise_errors
+          raise ex
+        end
+      end
       output.lines.reject do |line|
-        # Debug/Warning output from ADB}
-        line.start_with?('adb: ')
+        # Debug/Warning output from ADB
+        line.start_with?('adb: ') && !line.start_with?('adb: error: ')
       end.join('') # Lines retain their newline chars
     end
 

data/sigh/lib/sigh/runner.rb

@@ -18,8 +18,8 @@ module Sigh
                                              title: "Summary for sigh #{Fastlane::VERSION}")
 
       UI.message("Starting login with user '#{Sigh.config[:username]}'")
-      Spaceship.login(Sigh.config[:username], nil)
-      Spaceship.select_team
+      Spaceship::ConnectAPI.login(Sigh.config[:username], nil, use_portal: true, use_tunes: false)
+      Spaceship::ConnectAPI.select_team
       UI.message("Successfully logged in")
 
       profiles = [] if Sigh.config[:skip_fetch_profiles]
@@ -60,12 +60,12 @@ module Sigh
       case Sigh.config[:platform]
       when "ios"
         @profile_type = Spaceship::ConnectAPI::Profile::ProfileType::IOS_APP_STORE
-        @profile_type = Spaceship::ConnectAPI::Profile::ProfileType::IOS_APP_INHOUSE if Spaceship.client.in_house?
+        @profile_type = Spaceship::ConnectAPI::Profile::ProfileType::IOS_APP_INHOUSE if Spaceship::ConnectAPI.client.in_house?
         @profile_type = Spaceship::ConnectAPI::Profile::ProfileType::IOS_APP_ADHOC if Sigh.config[:adhoc]
         @profile_type = Spaceship::ConnectAPI::Profile::ProfileType::IOS_APP_DEVELOPMENT if Sigh.config[:development]
       when "tvos"
         @profile_type = Spaceship::ConnectAPI::Profile::ProfileType::TVOS_APP_STORE
-        @profile_type = Spaceship::ConnectAPI::Profile::ProfileType::TVOS_APP_INHOUSE if Spaceship.client.in_house?
+        @profile_type = Spaceship::ConnectAPI::Profile::ProfileType::TVOS_APP_INHOUSE if Spaceship::ConnectAPI.client.in_house?
         @profile_type = Spaceship::ConnectAPI::Profile::ProfileType::TVOS_APP_ADHOC if Sigh.config[:adhoc]
         @profile_type = Spaceship::ConnectAPI::Profile::ProfileType::TVOS_APP_DEVELOPMENT if Sigh.config[:development]
       when "macos"

data/snapshot/lib/snapshot/test_command_generator_base.rb

@@ -24,7 +24,9 @@ module Snapshot
         options = []
         options += project_path_array
         options << "-sdk '#{config[:sdk]}'" if config[:sdk]
-        options << "-derivedDataPath '#{derived_data_path}'"
+        if derived_data_path && !options.include?("-derivedDataPath #{derived_data_path.shellescape}")
+          options << "-derivedDataPath #{derived_data_path.shellescape}"
+        end
         options << "-resultBundlePath '#{result_bundle_path}'" if result_bundle_path
         if FastlaneCore::Helper.xcode_at_least?(11)
           options << "-testPlan '#{config[:testplan]}'" if config[:testplan]

data/spaceship/lib/spaceship.rb

@@ -4,6 +4,9 @@ require_relative 'spaceship/client'
 require_relative 'spaceship/provider'
 require_relative 'spaceship/launcher'
 
+# Middleware
+require_relative 'spaceship/stats_middleware'
+
 # Dev Portal
 require_relative 'spaceship/portal/portal'
 require_relative 'spaceship/portal/spaceship'
@@ -13,6 +16,7 @@ require_relative 'spaceship/tunes/tunes'
 require_relative 'spaceship/tunes/spaceship'
 require_relative 'spaceship/test_flight'
 require_relative 'spaceship/connect_api'
+require_relative 'spaceship/connect_api/spaceship'
 require_relative 'spaceship/spaceauth_runner'
 
 require_relative 'spaceship/module'

data/spaceship/lib/spaceship/client.rb

@@ -16,6 +16,7 @@ require_relative 'errors'
 require_relative 'tunes/errors'
 require_relative 'globals'
 require_relative 'provider'
+require_relative 'stats_middleware'
 
 Faraday::Utils.default_params_encoder = Faraday::FlatParamsEncoder
 
@@ -209,6 +210,7 @@ module Spaceship
         c.response(:plist, content_type: /\bplist$/)
         c.use(:cookie_jar, jar: @cookie)
         c.use(FaradayMiddleware::RelsMiddleware)
+        c.use(Spaceship::StatsMiddleware)
         c.adapter(Faraday.default_adapter)
 
         if ENV['SPACESHIP_DEBUG']

data/spaceship/lib/spaceship/connect_api.rb

@@ -56,21 +56,6 @@ require 'spaceship/connect_api/models/territory'
 
 module Spaceship
   class ConnectAPI
-    extend Spaceship::ConnectAPI::Provisioning
-    extend Spaceship::ConnectAPI::TestFlight
-    extend Spaceship::ConnectAPI::Users
-    extend Spaceship::ConnectAPI::Tunes
-
-    @token = nil
-
-    class << self
-      attr_writer(:token)
-    end
-
-    class << self
-      attr_reader :token
-    end
-
     # Defined in the App Store Connect API docs:
     # https://developer.apple.com/documentation/appstoreconnectapi/platform
     #

data/spaceship/lib/spaceship/connect_api/api_client.rb

@@ -0,0 +1,270 @@
+
+require_relative '../client'
+require_relative './response'
+require_relative '../client'
+require_relative './response'
+require_relative './token_refresh_middleware'
+
+require_relative '../stats_middleware'
+
+module Spaceship
+  class ConnectAPI
+    class APIClient < Spaceship::Client
+      attr_accessor :token
+
+      #####################################################
+      # @!group Client Init
+      #####################################################
+
+      # Instantiates a client with cookie session or a JWT token.
+      def initialize(cookie: nil, current_team_id: nil, token: nil, another_client: nil)
+        params_count = [cookie, token, another_client].compact.size
+        if params_count != 1
+          raise "Must initialize with one of :cookie, :token, or :another_client"
+        end
+
+        if token.nil?
+          if another_client.nil?
+            super(cookie: cookie, current_team_id: current_team_id, timeout: 1200)
+            return
+          end
+          super(cookie: another_client.instance_variable_get(:@cookie), current_team_id: another_client.team_id)
+        else
+          options = {
+            request: {
+              timeout:       (ENV["SPACESHIP_TIMEOUT"] || 300).to_i,
+              open_timeout:  (ENV["SPACESHIP_TIMEOUT"] || 300).to_i
+            }
+          }
+          @token = token
+          @current_team_id = current_team_id
+
+          @client = Faraday.new(hostname, options) do |c|
+            c.response(:json, content_type: /\bjson$/)
+            c.response(:plist, content_type: /\bplist$/)
+            c.use(FaradayMiddleware::RelsMiddleware)
+            c.use(Spaceship::StatsMiddleware)
+            c.use(Spaceship::TokenRefreshMiddleware, token)
+            c.adapter(Faraday.default_adapter)
+
+            if ENV['SPACESHIP_DEBUG']
+              # for debugging only
+              # This enables tracking of networking requests using Charles Web Proxy
+              c.proxy = "https://127.0.0.1:8888"
+              c.ssl[:verify_mode] = OpenSSL::SSL::VERIFY_NONE
+            elsif ENV["SPACESHIP_PROXY"]
+              c.proxy = ENV["SPACESHIP_PROXY"]
+              c.ssl[:verify_mode] = OpenSSL::SSL::VERIFY_NONE if ENV["SPACESHIP_PROXY_SSL_VERIFY_NONE"]
+            end
+
+            if ENV["DEBUG"]
+              puts("To run spaceship through a local proxy, use SPACESHIP_DEBUG")
+            end
+          end
+        end
+      end
+
+      # Instance level hostname only used when creating
+      # App Store Connect API Farady client.
+      # Forwarding to class level if using web session.
+      def hostname
+        if @token
+          return "https://api.appstoreconnect.apple.com/v1/"
+        end
+        return self.class.hostname
+      end
+
+      def self.hostname
+        # Implemented in subclass
+        not_implemented(__method__)
+      end
+
+      #
+      # Helpers
+      #
+
+      def web_session?
+        return @token.nil?
+      end
+
+      def build_params(filter: nil, includes: nil, limit: nil, sort: nil, cursor: nil)
+        params = {}
+
+        filter = filter.delete_if { |k, v| v.nil? } if filter
+
+        params[:filter] = filter if filter && !filter.empty?
+        params[:include] = includes if includes
+        params[:limit] = limit if limit
+        params[:sort] = sort if sort
+        params[:cursor] = cursor if cursor
+
+        return params
+      end
+
+      def get(url_or_path, params = nil)
+        response = with_asc_retry do
+          request(:get) do |req|
+            req.url(url_or_path)
+            req.options.params_encoder = Faraday::NestedParamsEncoder
+            req.params = params if params
+            req.headers['Content-Type'] = 'application/json'
+          end
+        end
+        handle_response(response)
+      end
+
+      def post(url_or_path, body, tries: 5)
+        response = with_asc_retry(tries) do
+          request(:post) do |req|
+            req.url(url_or_path)
+            req.body = body.to_json
+            req.headers['Content-Type'] = 'application/json'
+          end
+        end
+        handle_response(response)
+      end
+
+      def patch(url_or_path, body)
+        response = with_asc_retry do
+          request(:patch) do |req|
+            req.url(url_or_path)
+            req.body = body.to_json
+            req.headers['Content-Type'] = 'application/json'
+          end
+        end
+        handle_response(response)
+      end
+
+      def delete(url_or_path, params = nil, body = nil)
+        response = with_asc_retry do
+          request(:delete) do |req|
+            req.url(url_or_path)
+            req.options.params_encoder = Faraday::NestedParamsEncoder if params
+            req.params = params if params
+            req.body = body.to_json if body
+            req.headers['Content-Type'] = 'application/json' if body
+          end
+        end
+        handle_response(response)
+      end
+
+      protected
+
+      def with_asc_retry(tries = 5, &_block)
+        tries = 1 if Object.const_defined?("SpecHelper")
+        response = yield
+
+        status = response.status if response
+
+        if [500, 504].include?(status)
+          msg = "Timeout received! Retrying after 3 seconds (remaining: #{tries})..."
+          raise msg
+        end
+
+        return response
+      rescue => error
+        tries -= 1
+        puts(error) if Spaceship::Globals.verbose?
+        if tries.zero?
+          return response
+        else
+          retry
+        end
+      end
+
+      def handle_response(response)
+        if (200...300).cover?(response.status) && (response.body.nil? || response.body.empty?)
+          return
+        end
+
+        raise InternalServerError, "Server error got #{response.status}" if (500...600).cover?(response.status)
+
+        unless response.body.kind_of?(Hash)
+          raise UnexpectedResponse, response.body
+        end
+
+        raise UnexpectedResponse, response.body['error'] if response.body['error']
+
+        raise UnexpectedResponse, handle_errors(response) if response.body['errors']
+
+        raise UnexpectedResponse, "Temporary App Store Connect error: #{response.body}" if response.body['statusCode'] == 'ERROR'
+
+        store_csrf_tokens(response)
+
+        return Spaceship::ConnectAPI::Response.new(body: response.body, status: response.status, client: self)
+      end
+
+      def handle_errors(response)
+        # Example error format
+        # {
+        # "errors":[
+        #     {
+        #       "id":"cbfd8674-4802-4857-bfe8-444e1ea36e32",
+        #       "status":"409",
+        #       "code":"STATE_ERROR",
+        #       "title":"The request cannot be fulfilled because of the state of another resource.",
+        #       "detail":"Submit for review errors found.",
+        #       "meta":{
+        #           "associatedErrors":{
+        #             "/v1/appScreenshots/":[
+        #                 {
+        #                   "id":"23d1734f-b81f-411a-98e4-6d3e763d54ed",
+        #                   "status":"409",
+        #                   "code":"STATE_ERROR.SCREENSHOT_REQUIRED.APP_WATCH_SERIES_4",
+        #                   "title":"App screenshot missing (APP_WATCH_SERIES_4)."
+        #                 },
+        #                 {
+        #                   "id":"db993030-0a93-48e9-9fd7-7e5676633431",
+        #                   "status":"409",
+        #                   "code":"STATE_ERROR.SCREENSHOT_REQUIRED.APP_WATCH_SERIES_4",
+        #                   "title":"App screenshot missing (APP_WATCH_SERIES_4)."
+        #                 }
+        #             ],
+        #             "/v1/builds/d710b6fa-5235-4fe4-b791-2b80d6818db0":[
+        #                 {
+        #                   "id":"e421fe6f-0e3b-464b-89dc-ba437e7bb77d",
+        #                   "status":"409",
+        #                   "code":"ENTITY_ERROR.ATTRIBUTE.REQUIRED",
+        #                   "title":"The provided entity is missing a required attribute",
+        #                   "detail":"You must provide a value for the attribute 'usesNonExemptEncryption' with this request",
+        #                   "source":{
+        #                       "pointer":"/data/attributes/usesNonExemptEncryption"
+        #                   }
+        #                 }
+        #             ]
+        #           }
+        #       }
+        #     }
+        # ]
+        # }
+
+        return response.body['errors'].map do |error|
+          messages = [[error['title'], error['detail']].compact.join(" - ")]
+
+          meta = error["meta"] || {}
+          associated_errors = meta["associatedErrors"] || {}
+
+          messages + associated_errors.values.flatten.map do |associated_error|
+            [[associated_error["title"], associated_error["detail"]].compact.join(" - ")]
+          end
+        end.flatten.join("\n")
+      end
+
+      private
+
+      def local_variable_get(binding, name)
+        if binding.respond_to?(:local_variable_get)
+          binding.local_variable_get(name)
+        else
+          binding.eval(name.to_s)
+        end
+      end
+
+      def provider_id
+        return team_id if self.provider.nil?
+        self.provider.provider_id
+      end
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end