fastlane 2.164.0 → 2.169.0

data/scan/lib/scan/options.rb

@@ -419,6 +419,15 @@ module Scan
                                      description: "Use only if you're a pro, use the other options instead",
                                      is_string: false,
                                      optional: true),
+        FastlaneCore::ConfigItem.new(key: :catalyst_platform,
+                                     env_name: "SCAN_CATALYST_PLATFORM",
+                                     description: "Platform to build when using a Catalyst enabled app. Valid values are: ios, macos",
+                                     type: String,
+                                     optional: true,
+                                     verify_block: proc do |value|
+                                       av = %w(ios macos)
+                                       UI.user_error!("Unsupported export_method '#{value}', must be: #{av}") unless av.include?(value)
+                                     end),
         FastlaneCore::ConfigItem.new(key: :custom_report_file_name,
                                      env_name: "SCAN_CUSTOM_REPORT_FILE_NAME",
                                      description: "Sets custom full report file name when generating a single report",
@@ -436,7 +445,13 @@ module Scan
                                     env_name: "SCAN_CLONED_SOURCE_PACKAGES_PATH",
                                     description: "Sets a custom path for Swift Package Manager dependencies",
                                     type: String,
-                                    optional: true)
+                                    optional: true),
+        FastlaneCore::ConfigItem.new(key: :use_system_scm,
+                                     env_name: "SCAN_USE_SYSTEM_SCM",
+                                     description: "Lets xcodebuild use system's scm configuration",
+                                     optional: true,
+                                     type: Boolean,
+                                     default_value: false)
 
       ]
     end

data/scan/lib/scan/runner.rb

@@ -83,6 +83,8 @@ module Scan
     end
 
     def handle_results(tests_exit_status)
+      return if Scan.config[:disable_xcpretty]
+
       result = TestResultParser.new.parse_result(test_results)
       SlackPoster.new.run(result)
 
@@ -144,8 +146,6 @@ module Scan
     end
 
     def test_results
-      return if Scan.config[:disable_xcpretty]
-
       temp_junit_report = Scan.cache[:temp_junit_report]
       return File.read(temp_junit_report) if temp_junit_report && File.file?(temp_junit_report)
 

data/scan/lib/scan/test_command_generator.rb

@@ -32,6 +32,7 @@ module Scan
 
       options = []
       options += project_path_array unless config[:xctestrun]
+      options << "-scmProvider system" if config[:use_system_scm]
       options << "-sdk '#{config[:sdk]}'" if config[:sdk]
       options << destination # generated in `detect_values`
       options << "-toolchain '#{config[:toolchain]}'" if config[:toolchain]

data/sigh/lib/sigh/runner.rb

@@ -303,7 +303,7 @@ module Sigh
         end
 
         if Sigh.config[:cert_owner_name]
-          next unless c.owner_name.strip == Sigh.config[:cert_owner_name].strip
+          next unless c.display_name.strip == Sigh.config[:cert_owner_name].strip
         end
 
         true
@@ -327,7 +327,7 @@ module Sigh
         UI.important("Found more than one code signing identity. Choosing the first one. Check out `fastlane sigh --help` to see all available options.")
         UI.important("Available Code Signing Identities for current filters:")
         certificates.each do |c|
-          str = ["\t- Name:", c.owner_name, "- ID:", c.id + " - Expires", c.expires.strftime("%d/%m/%Y")].join(" ")
+          str = ["\t- Name:", c.display_name, "- ID:", c.id + " - Expires", c.expires.strftime("%d/%m/%Y")].join(" ")
           UI.message(str.green)
         end
       end

data/snapshot/lib/assets/SnapshotHelper.swift

@@ -180,7 +180,11 @@ open class Snapshot: NSObject {
                 simulator = regex.stringByReplacingMatches(in: simulator, range: range, withTemplate: "")
 
                 let path = screenshotsDir.appendingPathComponent("\(simulator)-\(name).png")
-                try image.pngData()?.write(to: path, options: .atomic)
+                #if swift(<5.0)
+                    UIImagePNGRepresentation(image)?.write(to: path, options: .atomic)
+                #else
+                    try image.pngData()?.write(to: path, options: .atomic)
+                #endif
             } catch let error {
                 NSLog("Problem writing screenshot: \(name) to \(screenshotsDir)/\(simulator)-\(name).png")
                 NSLog(error.localizedDescription)

data/snapshot/lib/snapshot/test_command_generator.rb

@@ -13,7 +13,7 @@ module Snapshot
         parts << "xcodebuild"
         parts += options(language, locale)
         parts += destination(devices)
-        parts += build_settings
+        parts += build_settings(language, locale)
         parts += actions
         parts += suffix
         parts += pipe(log_path: log_path)

data/snapshot/lib/snapshot/test_command_generator_base.rb

@@ -40,11 +40,13 @@ module Snapshot
         return options
       end
 
-      def build_settings
+      def build_settings(language, locale)
         config = Snapshot.config
 
         build_settings = []
         build_settings << "FASTLANE_SNAPSHOT=YES"
+        build_settings << "FASTLANE_LANGUAGE=#{language}" if language
+        build_settings << "FASTLANE_LOCALE=#{locale}" if locale
         build_settings << "TEST_TARGET_NAME=#{config[:test_target_name].shellescape}" if config[:test_target_name]
 
         return build_settings

data/snapshot/lib/snapshot/test_command_generator_xcode_8.rb

@@ -14,7 +14,7 @@ module Snapshot
         parts << "xcodebuild"
         parts += options(language, locale)
         parts += destination(device_type)
-        parts += build_settings
+        parts += build_settings(language, locale)
         parts += actions
         parts += suffix
         parts += pipe(device_type, language, locale)

data/spaceship/lib/spaceship/client.rb

@@ -57,6 +57,7 @@ module Spaceship
     InternalServerError = Spaceship::InternalServerError
     BadGatewayError = Spaceship::BadGatewayError
     AccessForbiddenError = Spaceship::AccessForbiddenError
+    TooManyRequestsError = Spaceship::TooManyRequestsError
 
     def self.hostname
       raise "You must implement self.hostname"
@@ -645,6 +646,17 @@ module Spaceship
         retry
       end
       raise ex # re-raise the exception
+    rescue TooManyRequestsError => ex
+      tries -= 1
+      unless tries.zero?
+        msg = "Timeout received: '#{ex.class}', '#{ex.message}'. Retrying after #{ex.retry_after} seconds (remaining: #{tries})..."
+        puts(msg) if Spaceship::Globals.verbose?
+        logger.warn(msg)
+
+        sleep(ex.retry_after) unless Object.const_defined?("SpecHelper")
+        retry
+      end
+      raise ex # re-raise the exception
     rescue \
         Faraday::ParsingError, # <h2>Internal Server Error</h2> with content type json
         InternalServerError => ex
@@ -873,6 +885,8 @@ module Spaceship
           msg = "Access forbidden"
           logger.warn(msg)
           raise AccessForbiddenError.new, msg
+        elsif resp_hash[:status] == 429
+          raise TooManyRequestsError, resp_hash
         end
 
         return response

data/spaceship/lib/spaceship/connect_api.rb

@@ -31,6 +31,8 @@ require 'spaceship/connect_api/models/beta_tester_metric'
 require 'spaceship/connect_api/models/build'
 require 'spaceship/connect_api/models/build_delivery'
 require 'spaceship/connect_api/models/build_beta_detail'
+require 'spaceship/connect_api/models/custom_app_organization'
+require 'spaceship/connect_api/models/custom_app_user'
 require 'spaceship/connect_api/models/pre_release_version'
 
 require 'spaceship/connect_api/models/age_rating_declaration'

data/spaceship/lib/spaceship/connect_api/client.rb

@@ -13,20 +13,23 @@ module Spaceship
 
       # Initializes client with Apple's App Store Connect JWT auth key.
       #
-      # This method will automatically use the key id, issuer id, and filepath from environment
+      # This method will automatically use the arguments from environment
       # variables if not given.
       #
-      # All three parameters are needed to authenticate.
+      # The key_id, issuer_id and either filepath or key are needed to authenticate.
       #
       # @param key_id (String) (optional): The key id
       # @param issuer_id (String) (optional): The issuer id
       # @param filepath (String) (optional): The filepath
+      # @param key (String) (optional): The key
+      # @param duration (Integer) (optional): How long this session should last
+      # @param in_house (Boolean) (optional): Whether this session is an Enterprise one
       #
       # @raise InvalidUserCredentialsError: raised if authentication failed
       #
       # @return (Spaceship::ConnectAPI::Client) The client the login method was called for
-      def self.auth(key_id: nil, issuer_id: nil, filepath: nil)
-        token = Spaceship::ConnectAPI::Token.create(key_id: key_id, issuer_id: issuer_id, filepath: filepath)
+      def self.auth(key_id: nil, issuer_id: nil, filepath: nil, key: nil, duration: nil, in_house: nil)
+        token = Spaceship::ConnectAPI::Token.create(key_id: key_id, issuer_id: issuer_id, filepath: filepath, key: key, duration: duration, in_house: in_house)
         return ConnectAPI::Client.new(token: token)
       end
 

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

@@ -105,9 +105,10 @@ module Spaceship
       # API
       #
 
-      def update(attributes: nil)
+      def update(client: nil, attributes: nil)
+        client ||= Spaceship::ConnectAPI
         attributes = reverse_attr_mapping(attributes)
-        Spaceship::ConnectAPI.patch_age_rating_declaration(age_rating_declaration_id: id, attributes: attributes)
+        client.patch_age_rating_declaration(age_rating_declaration_id: id, attributes: attributes)
       end
     end
   end

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

@@ -18,11 +18,26 @@ module Spaceship
       attr_accessor :app_store_versions
       attr_accessor :prices
 
+      # Only available with Apple ID auth
+      attr_accessor :distribution_type
+      attr_accessor :educationDiscountType
+
       module ContentRightsDeclaration
         USES_THIRD_PARTY_CONTENT = "USES_THIRD_PARTY_CONTENT"
         DOES_NOT_USE_THIRD_PARTY_CONTENT = "DOES_NOT_USE_THIRD_PARTY_CONTENT"
       end
 
+      module DistributionType
+        APP_STORE = "APP_STORE"
+        CUSTOM = "CUSTOM"
+      end
+
+      module EducationDiscountType
+        DISCOUNTED = "DISCOUNTED"
+        NOT_APPLICABLE = "NOT_APPLICABLE"
+        NOT_DISCOUNTED = "NOT_DISCOUNTED"
+      end
+
       self.attr_mapping({
         "name" => "name",
         "bundleId" => "bundle_id",
@@ -32,6 +47,8 @@ module Spaceship
         "removed" => "removed",
         "isAAG" => "is_aag",
         "availableInNewTerritories" => "available_in_new_territories",
+        "distributionType" => "distribution_type",
+        "educationDiscountType" => "education_discount_type",
 
         "contentRightsDeclaration" => "content_rights_declaration",
 
@@ -52,19 +69,22 @@ module Spaceship
       # Apps
       #
 
-      def self.all(filter: {}, includes: ESSENTIAL_INCLUDES, limit: nil, sort: nil)
-        resps = Spaceship::ConnectAPI.get_apps(filter: filter, includes: includes, limit: limit, sort: sort).all_pages
+      def self.all(client: nil, filter: {}, includes: ESSENTIAL_INCLUDES, limit: nil, sort: nil)
+        client ||= Spaceship::ConnectAPI
+        resps = client.get_apps(filter: filter, includes: includes, limit: limit, sort: sort).all_pages
         return resps.flat_map(&:to_models)
       end
 
-      def self.find(bundle_id)
-        return all(filter: { bundleId: bundle_id }).find do |app|
+      def self.find(bundle_id, client: nil)
+        client ||= Spaceship::ConnectAPI
+        return all(client: client, filter: { bundleId: bundle_id }).find do |app|
           app.bundle_id == bundle_id
         end
       end
 
-      def self.create(name: nil, version_string: nil, sku: nil, primary_locale: nil, bundle_id: nil, platforms: nil, company_name: nil)
-        Spaceship::ConnectAPI.post_app(
+      def self.create(client: nil, name: nil, version_string: nil, sku: nil, primary_locale: nil, bundle_id: nil, platforms: nil, company_name: nil)
+        client ||= Spaceship::ConnectAPI
+        client.post_app(
           name: name,
           version_string: version_string,
           sku: sku,
@@ -75,35 +95,40 @@ module Spaceship
         )
       end
 
-      def self.get(app_id: nil, includes: "appStoreVersions")
-        return Spaceship::ConnectAPI.get_app(app_id: app_id, includes: includes).first
+      def self.get(client: nil, app_id: nil, includes: "appStoreVersions")
+        client ||= Spaceship::ConnectAPI
+        return client.get_app(app_id: app_id, includes: includes).first
       end
 
-      def update(attributes: nil, app_price_tier_id: nil, territory_ids: nil)
+      def update(client: nil, attributes: nil, app_price_tier_id: nil, territory_ids: nil)
+        client ||= Spaceship::ConnectAPI
         attributes = reverse_attr_mapping(attributes)
-        return Spaceship::ConnectAPI.patch_app(app_id: id, attributes: attributes, app_price_tier_id: app_price_tier_id, territory_ids: territory_ids)
+        return client.patch_app(app_id: id, attributes: attributes, app_price_tier_id: app_price_tier_id, territory_ids: territory_ids)
       end
 
       #
       # App Info
       #
 
-      def fetch_live_app_info(includes: Spaceship::ConnectAPI::AppInfo::ESSENTIAL_INCLUDES)
+      def fetch_live_app_info(client: nil, includes: Spaceship::ConnectAPI::AppInfo::ESSENTIAL_INCLUDES)
+        client ||= Spaceship::ConnectAPI
         states = [
           Spaceship::ConnectAPI::AppInfo::AppStoreState::READY_FOR_SALE,
           Spaceship::ConnectAPI::AppInfo::AppStoreState::PENDING_APPLE_RELEASE,
           Spaceship::ConnectAPI::AppInfo::AppStoreState::PENDING_DEVELOPER_RELEASE,
           Spaceship::ConnectAPI::AppInfo::AppStoreState::PROCESSING_FOR_APP_STORE,
-          Spaceship::ConnectAPI::AppInfo::AppStoreState::IN_REVIEW
+          Spaceship::ConnectAPI::AppInfo::AppStoreState::IN_REVIEW,
+          Spaceship::ConnectAPI::AppInfo::AppStoreState::DEVELOPER_REMOVED_FROM_SALE
         ]
 
-        resp = Spaceship::ConnectAPI.get_app_infos(app_id: id, includes: includes)
+        resp = client.get_app_infos(app_id: id, includes: includes)
         return resp.to_models.select do |model|
           states.include?(model.app_store_state)
         end.first
       end
 
-      def fetch_edit_app_info(includes: Spaceship::ConnectAPI::AppInfo::ESSENTIAL_INCLUDES)
+      def fetch_edit_app_info(client: nil, includes: Spaceship::ConnectAPI::AppInfo::ESSENTIAL_INCLUDES)
+        client ||= Spaceship::ConnectAPI
         states = [
           Spaceship::ConnectAPI::AppInfo::AppStoreState::PREPARE_FOR_SUBMISSION,
           Spaceship::ConnectAPI::AppInfo::AppStoreState::DEVELOPER_REJECTED,
@@ -113,7 +138,7 @@ module Spaceship
           Spaceship::ConnectAPI::AppInfo::AppStoreState::INVALID_BINARY
         ]
 
-        resp = Spaceship::ConnectAPI.get_app_infos(app_id: id, includes: includes)
+        resp = client.get_app_infos(app_id: id, includes: includes)
         return resp.to_models.select do |model|
           states.include?(model.app_store_state)
         end.first
@@ -123,9 +148,10 @@ module Spaceship
       # Available Territories
       #
 
-      def fetch_available_territories(filter: {}, includes: nil, limit: nil, sort: nil)
+      def fetch_available_territories(client: nil, filter: {}, includes: nil, limit: nil, sort: nil)
+        client ||= Spaceship::ConnectAPI
         filter ||= {}
-        resps = Spaceship::ConnectAPI.get_available_territories(app_id: id, filter: filter, includes: includes, limit: limit, sort: sort).all_pages
+        resps = client.get_available_territories(app_id: id, filter: filter, includes: includes, limit: limit, sort: sort).all_pages
         return resps.flat_map(&:to_models)
       end
 
@@ -133,8 +159,9 @@ module Spaceship
       # App Pricing
       #
 
-      def fetch_app_prices(filter: {}, includes: "priceTier", limit: nil, sort: nil)
-        resp = Spaceship::ConnectAPI.get_app_prices(app_id: id, filter: filter, includes: includes, limit: limit, sort: sort)
+      def fetch_app_prices(client: nil, filter: {}, includes: "priceTier", limit: nil, sort: nil)
+        client ||= Spaceship::ConnectAPI
+        resp = client.get_app_prices(app_id: id, filter: filter, includes: includes, limit: limit, sort: sort)
         return resp.to_models
       end
 
@@ -142,7 +169,8 @@ module Spaceship
       # App Store Versions
       #
 
-      def reject_version_if_possible!(platform: nil)
+      def reject_version_if_possible!(client: nil, platform: nil)
+        client ||= Spaceship::ConnectAPI
         platform ||= Spaceship::ConnectAPI::Platform::IOS
         filter = {
           appStoreState: [
@@ -155,7 +183,7 @@ module Spaceship
         }
 
         # Get the latest version
-        version = get_app_store_versions(filter: filter, includes: "appStoreVersionSubmission")
+        version = get_app_store_versions(client: client, filter: filter, includes: "appStoreVersionSubmission")
                   .sort_by { |v| Gem::Version.new(v.version_string) }
                   .last
 
@@ -167,46 +195,53 @@ module Spaceship
       # This will either create a new version or change the version number
       # from an existing version
       # @return (Bool) Was something changed?
-      def ensure_version!(version_string, platform: nil)
+      def ensure_version!(version_string, platform: nil, client: nil)
+        client ||= Spaceship::ConnectAPI
         app_store_version = get_edit_app_store_version(platform: platform)
 
         if app_store_version
           if version_string != app_store_version.version_string
             attributes = { versionString: version_string }
-            app_store_version.update(attributes: attributes)
+            app_store_version.update(client: client, attributes: attributes)
             return true
           end
           return false
         else
           attributes = { versionString: version_string, platform: platform }
-          Spaceship::ConnectAPI.post_app_store_version(app_id: id, attributes: attributes)
+          client.post_app_store_version(app_id: id, attributes: attributes)
 
           return true
         end
       end
 
-      def get_latest_app_store_version(platform: nil, includes: nil)
+      def get_latest_app_store_version(client: nil, platform: nil, includes: nil)
+        client ||= Spaceship::ConnectAPI
         platform ||= Spaceship::ConnectAPI::Platform::IOS
         filter = {
           platform: platform
         }
 
         # Get the latest version
-        return get_app_store_versions(filter: filter, includes: includes)
+        return get_app_store_versions(client: client, filter: filter, includes: includes)
                .sort_by { |v| Date.parse(v.created_date) }
                .last
       end
 
-      def get_live_app_store_version(platform: nil, includes: Spaceship::ConnectAPI::AppStoreVersion::ESSENTIAL_INCLUDES)
+      def get_live_app_store_version(client: nil, platform: nil, includes: Spaceship::ConnectAPI::AppStoreVersion::ESSENTIAL_INCLUDES)
+        client ||= Spaceship::ConnectAPI
         platform ||= Spaceship::ConnectAPI::Platform::IOS
         filter = {
-          appStoreState: Spaceship::ConnectAPI::AppStoreVersion::AppStoreState::READY_FOR_SALE,
+          appStoreState: [
+            Spaceship::ConnectAPI::AppStoreVersion::AppStoreState::READY_FOR_SALE,
+            Spaceship::ConnectAPI::AppStoreVersion::AppStoreState::DEVELOPER_REMOVED_FROM_SALE
+          ].join(","),
           platform: platform
         }
-        return get_app_store_versions(filter: filter, includes: includes).first
+        return get_app_store_versions(client: client, filter: filter, includes: includes).first
       end
 
-      def get_edit_app_store_version(platform: nil, includes: Spaceship::ConnectAPI::AppStoreVersion::ESSENTIAL_INCLUDES)
+      def get_edit_app_store_version(client: nil, platform: nil, includes: Spaceship::ConnectAPI::AppStoreVersion::ESSENTIAL_INCLUDES)
+        client ||= Spaceship::ConnectAPI
         platform ||= Spaceship::ConnectAPI::Platform::IOS
         filter = {
           appStoreState: [
@@ -221,21 +256,23 @@ module Spaceship
         }
 
         # Get the latest version
-        return get_app_store_versions(filter: filter, includes: includes)
+        return get_app_store_versions(client: client, filter: filter, includes: includes)
                .sort_by { |v| Gem::Version.new(v.version_string) }
                .last
       end
 
-      def get_in_review_app_store_version(platform: nil, includes: Spaceship::ConnectAPI::AppStoreVersion::ESSENTIAL_INCLUDES)
+      def get_in_review_app_store_version(client: nil, platform: nil, includes: Spaceship::ConnectAPI::AppStoreVersion::ESSENTIAL_INCLUDES)
+        client ||= Spaceship::ConnectAPI
         platform ||= Spaceship::ConnectAPI::Platform::IOS
         filter = {
           appStoreState: Spaceship::ConnectAPI::AppStoreVersion::AppStoreState::IN_REVIEW,
           platform: platform
         }
-        return get_app_store_versions(filter: filter, includes: includes).first
+        return get_app_store_versions(client: client, filter: filter, includes: includes).first
       end
 
-      def get_pending_release_app_store_version(platform: nil, includes: Spaceship::ConnectAPI::AppStoreVersion::ESSENTIAL_INCLUDES)
+      def get_pending_release_app_store_version(client: nil, platform: nil, includes: Spaceship::ConnectAPI::AppStoreVersion::ESSENTIAL_INCLUDES)
+        client ||= Spaceship::ConnectAPI
         platform ||= Spaceship::ConnectAPI::Platform::IOS
         filter = {
           appStoreState: [
@@ -244,23 +281,48 @@ module Spaceship
           ].join(','),
           platform: platform
         }
-        return get_app_store_versions(filter: filter, includes: includes).first
+        return get_app_store_versions(client: client, filter: filter, includes: includes).first
       end
 
-      def get_app_store_versions(filter: {}, includes: Spaceship::ConnectAPI::AppStoreVersion::ESSENTIAL_INCLUDES, limit: nil, sort: nil)
-        resps = Spaceship::ConnectAPI.get_app_store_versions(app_id: id, filter: filter, includes: includes, limit: limit, sort: sort).all_pages
-        return resps.flat_map(&:to_models)
+      def get_app_store_versions(client: nil, filter: {}, includes: Spaceship::ConnectAPI::AppStoreVersion::ESSENTIAL_INCLUDES, limit: nil, sort: nil)
+        client ||= Spaceship::ConnectAPI
+        if limit.nil?
+          resps = client.get_app_store_versions(app_id: id, filter: filter, includes: includes, limit: limit, sort: sort).all_pages
+          return resps.flat_map(&:to_models)
+        else
+          resp = client.get_app_store_versions(app_id: id, filter: filter, includes: includes, limit: limit, sort: sort)
+          return resp.to_models
+        end
+      end
+
+      #
+      # B2B
+      #
+
+      def disable_b2b
+        update(attributes: {
+          distributionType: DistributionType::APP_STORE,
+          education_discount_type: EducationDiscountType::NOT_DISCOUNTED
+        })
+      end
+
+      def enable_b2b
+        update(attributes: {
+          distributionType: App::DistributionType::CUSTOM,
+          education_discount_type: EducationDiscountType::NOT_APPLICABLE
+        })
       end
 
       #
       # Beta Feedback
       #
 
-      def get_beta_feedback(filter: {}, includes: "tester,build,screenshots", limit: nil, sort: nil)
+      def get_beta_feedback(client: nil, filter: {}, includes: "tester,build,screenshots", limit: nil, sort: nil)
+        client ||= Spaceship::ConnectAPI
         filter ||= {}
         filter["build.app"] = id
 
-        resps = Spaceship::ConnectAPI.get_beta_feedback(filter: filter, includes: includes, limit: limit, sort: sort).all_pages
+        resps = client.get_beta_feedback(filter: filter, includes: includes, limit: limit, sort: sort).all_pages
         return resps.flat_map(&:to_models)
       end
 
@@ -268,11 +330,12 @@ module Spaceship
       # Beta Testers
       #
 
-      def get_beta_testers(filter: {}, includes: nil, limit: nil, sort: nil)
+      def get_beta_testers(client: nil, filter: {}, includes: nil, limit: nil, sort: nil)
+        client ||= Spaceship::ConnectAPI
         filter ||= {}
         filter[:apps] = id
 
-        resps = Spaceship::ConnectAPI.get_beta_testers(filter: filter, includes: includes, limit: limit, sort: sort).all_pages
+        resps = client.get_beta_testers(filter: filter, includes: includes, limit: limit, sort: sort).all_pages
         return resps.flat_map(&:to_models)
       end
 
@@ -280,40 +343,45 @@ module Spaceship
       # Builds
       #
 
-      def get_builds(filter: {}, includes: nil, limit: nil, sort: nil)
+      def get_builds(client: nil, filter: {}, includes: nil, limit: nil, sort: nil)
+        client ||= Spaceship::ConnectAPI
         filter ||= {}
         filter[:app] = id
 
-        resps = Spaceship::ConnectAPI.get_builds(filter: filter, includes: includes, limit: limit, sort: sort).all_pages
+        resps = client.get_builds(filter: filter, includes: includes, limit: limit, sort: sort).all_pages
         return resps.flat_map(&:to_models)
       end
 
-      def get_build_deliveries(filter: {}, includes: nil, limit: nil, sort: nil)
+      def get_build_deliveries(client: nil, filter: {}, includes: nil, limit: nil, sort: nil)
+        client ||= Spaceship::ConnectAPI
         filter ||= {}
         filter[:app] = id
 
-        resps = Spaceship::ConnectAPI.get_build_deliveries(filter: filter, includes: includes, limit: limit, sort: sort).all_pages
+        resps = client.get_build_deliveries(filter: filter, includes: includes, limit: limit, sort: sort).all_pages
         return resps.flat_map(&:to_models)
       end
 
-      def get_beta_app_localizations(filter: {}, includes: nil, limit: nil, sort: nil)
+      def get_beta_app_localizations(client: nil, filter: {}, includes: nil, limit: nil, sort: nil)
+        client ||= Spaceship::ConnectAPI
         filter ||= {}
         filter[:app] = id
 
-        resps = Spaceship::ConnectAPI.get_beta_app_localizations(filter: filter, includes: includes, limit: limit, sort: sort).all_pages
+        resps = client.get_beta_app_localizations(filter: filter, includes: includes, limit: limit, sort: sort).all_pages
         return resps.flat_map(&:to_models)
       end
 
-      def get_beta_groups(filter: {}, includes: nil, limit: nil, sort: nil)
+      def get_beta_groups(client: nil, filter: {}, includes: nil, limit: nil, sort: nil)
+        client ||= Spaceship::ConnectAPI
         filter ||= {}
         filter[:app] = id
 
-        resps = Spaceship::ConnectAPI.get_beta_groups(filter: filter, includes: includes, limit: limit, sort: sort).all_pages
+        resps = client.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(
+      def create_beta_group(client: nil, group_name: nil, public_link_enabled: false, public_link_limit: 10_000, public_link_limit_enabled: false)
+        client ||= Spaceship::ConnectAPI
+        resps = client.create_beta_group(
           app_id: id,
           group_name: group_name,
           public_link_enabled: public_link_enabled,
@@ -323,13 +391,30 @@ module Spaceship
         return resps.flat_map(&:to_models).first
       end
 
+      #
+      # Education
+      #
+
+      def disable_educational_discount
+        update(attributes: {
+          education_discount_type: EducationDiscountType::NOT_DISCOUNTED
+        })
+      end
+
+      def enable_educational_discount
+        update(attributes: {
+          education_discount_type: EducationDiscountType::DISCOUNTED
+        })
+      end
+
       #
       # Users
       #
 
-      def add_users(user_ids: nil)
+      def add_users(client: nil, user_ids: nil)
+        client ||= Spaceship::ConnectAPI
         user_ids.each do |user_id|
-          Spaceship::ConnectAPI.add_user_visible_apps(user_id: user_id, app_ids: [id])
+          client.add_user_visible_apps(user_id: user_id, app_ids: [id])
         end
       end
     end