fastlane-plugin-firebase_app_distribution 0.7.3 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31b34bdb303bcc029291767ec3396329550ed6ac8f038774b37d78fb5121f1dc
-  data.tar.gz: 220323bd4dab4e6cd20fca8a863aa184d4b88fdf261549ecb115d8ef4aaf0b6b
+  metadata.gz: 1ed146d48ff09a46b608e01e483f207ce62a2809d9a8ded675c56d0b22802ba7
+  data.tar.gz: 18b893dc6b1a79a339fb7aeb8c432c13bd419d04df78dc4c5606dbfd24db64a6
 SHA512:
-  metadata.gz: 7256d3eb6e7ac59dd8bffbd3ce3d1fda8b98d1284c6576ad556e1f43d46d7adc0b86a59fc5a30577438a525fea8f46b76027b28278a2c3a025d98b3c6e8636e7
-  data.tar.gz: a4469ffccd6a38a78dfaf3729433ab5961ade3fc251f97c791123f76632c8142f25544afd6ece4c961310d45d0277be0212782ababbc8418eceb08c4d568dec3
+  metadata.gz: afa135119953bc3ee405aa868e1f5012b0e1dc9ac1240b02a895f437125b142b5e58a9930e4dc137fcfac92e3711db9ac364d07c98f33e61a6de652e878bdf46
+  data.tar.gz: c263365d7d45466c43486fb78548c7b0191b3f502e4e207f83b4674180badb457cb35e0f14e927f3a7c82841b6544ff5d44e0e05f99837f6ae45331dda9dbd92

data/lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_action.rb

@@ -2,6 +2,7 @@ require 'fastlane/action'
 require 'open3'
 require 'shellwords'
 require 'googleauth'
+require 'google/apis/firebaseappdistribution_v1'
 require_relative '../helper/firebase_app_distribution_helper'
 require_relative '../helper/firebase_app_distribution_error_message'
 require_relative '../helper/firebase_app_distribution_auth_client'
@@ -19,8 +20,10 @@ module Fastlane
       extend Helper::FirebaseAppDistributionHelper
 
       DEFAULT_UPLOAD_TIMEOUT_SECONDS = 300
-      MAX_POLLING_RETRIES = 60
-      POLLING_INTERVAL_SECONDS = 5
+      UPLOAD_MAX_POLLING_RETRIES = 60
+      UPLOAD_POLLING_INTERVAL_SECONDS = 5
+      TEST_MAX_POLLING_RETRIES = 40
+      TEST_POLLING_INTERVAL_SECONDS = 30
 
       def self.run(params)
         params.values # to validate all inputs before looking for the ipa/apk/aab
@@ -31,40 +34,31 @@ module Fastlane
         timeout = get_upload_timeout(params)
 
         binary_path = get_binary_path(platform, params)
-        UI.user_error!("Couldn't find binary") if binary_path.nil?
-        UI.user_error!("Couldn't find binary at path #{binary_path}") unless File.exist?(binary_path)
+        UI.user_error!("Couldn't find binary.") if binary_path.nil?
+        UI.user_error!("Couldn't find binary at path #{binary_path}.") unless File.exist?(binary_path)
         binary_type = binary_type_from_path(binary_path)
 
         # TODO(lkellogg): This sets the send timeout for all POST requests made by the client, but
-        # ideally the timeout should only apply to the binary upload
-        client = init_client(params[:service_credentials_file],
-                             params[:firebase_cli_token],
-                             params[:debug],
-                             timeout)
-
-        # If binary is an AAB, get the AAB info for this app, which includes the integration state and certificate data
+        #     ideally the timeout should only apply to the binary upload
+        init_google_api_client(params[:debug], timeout)
+        authorization = get_authorization(params[:service_credentials_file], params[:firebase_cli_token], params[:service_credentials_json_data], params[:debug])
+        client = Google::Apis::FirebaseappdistributionV1::FirebaseAppDistributionService.new
+        client.authorization = authorization
+        alpha_client = Google::Apis::FirebaseappdistributionV1alpha::FirebaseAppDistributionService.new
+        alpha_client.authorization = authorization
+
+        # If binary is an AAB, get the AAB info for this app, which includes the integration state
+        # and certificate data
         if binary_type == :AAB
           aab_info = get_aab_info(client, app_name)
           validate_aab_setup!(aab_info)
         end
 
         binary_type = binary_type_from_path(binary_path)
-        UI.message("⌛ Uploading the #{binary_type}.")
-
-        # For some reason calling the client.upload_medium returns nil when
-        # it should return a long running operation object
-        # (https://github.com/googleapis/google-api-ruby-client/blob/main/generated/google-apis-firebaseappdistribution_v1/lib/google/apis/firebaseappdistribution_v1/service.rb#L79).
-        # We could use client.http, but is much slower
-        # (https://github.com/firebase/fastlane-plugin-firebase_app_distribution/issues/330),
-        # so we still use the old client for now.
-        # TODO(kbolay) Prefer client.upload_medium, assuming it is sufficiently fast
-        fad_api_client = Client::FirebaseAppDistributionApiClient.new(client.authorization.access_token, params[:debug])
-        operation_name = fad_api_client.upload_binary(app_name,
-                                                      binary_path,
-                                                      platform.to_s,
-                                                      get_upload_timeout(params))
-
-        release = poll_upload_release_operation(client, operation_name, binary_type)
+        UI.message("📡 Uploading the #{binary_type}.")
+        operation = upload_binary(app_name, binary_path, client, timeout)
+        UI.message("🕵️ Validating upload…")
+        release = poll_upload_release_operation(client, operation, binary_type)
 
         if binary_type == :AAB && aab_info && !aab_certs_included?(aab_info.test_certificate)
           updated_aab_info = get_aab_info(client, app_name)
@@ -86,9 +80,21 @@ module Fastlane
           release.release_notes = Google::Apis::FirebaseappdistributionV1::GoogleFirebaseAppdistroV1ReleaseNotes.new(
             text: release_notes
           )
+          UI.message("📜 Setting release notes.")
           release = update_release(client, release)
         end
 
+        test_devices =
+          get_value_from_value_or_file(params[:test_devices], params[:test_devices_file])
+        if present?(test_devices)
+          UI.message("🤖 Starting automated tests. Note: This feature is in beta.")
+          test_password = test_password_from_params(params)
+          release_test = test_release(alpha_client, release, test_devices, params[:test_username], test_password, params[:test_username_resource], params[:test_password_resource])
+          unless params[:test_non_blocking]
+            poll_test_finished(alpha_client, release_test.name)
+          end
+        end
+
         testers = get_value_from_value_or_file(params[:testers], params[:testers_file])
         groups = get_value_from_value_or_file(params[:groups], params[:groups_file])
         emails = string_to_array(testers)
@@ -98,6 +104,7 @@ module Fastlane
             tester_emails: emails,
             group_aliases: group_aliases
           )
+          UI.message("📦 Distributing release.")
           distribute_release(client, release, request)
         else
           UI.message("⏩ No testers or groups passed in. Skipping this step.")
@@ -127,6 +134,12 @@ module Fastlane
         "Release your beta builds with Firebase App Distribution"
       end
 
+      def self.test_password_from_params(params)
+        test_password = get_value_from_value_or_file(params[:test_password], params[:test_password_file])
+        # Remove trailing newline if present
+        test_password && test_password.sub(/\r?\n$/, "")
+      end
+
       def self.app_id_from_params(params)
         if params[:app]
           app_id = params[:app]
@@ -222,25 +235,23 @@ module Fastlane
         release_notes_param || Actions.lane_context[SharedValues::FL_CHANGELOG]
       end
 
-      def self.poll_upload_release_operation(client, operation_name, binary_type)
-        operation = client.get_project_app_release_operation(operation_name)
-        MAX_POLLING_RETRIES.times do
+      def self.poll_upload_release_operation(client, operation, binary_type)
+        UPLOAD_MAX_POLLING_RETRIES.times do
+          sleep(UPLOAD_POLLING_INTERVAL_SECONDS)
+          operation = client.get_project_app_release_operation(operation.name)
           if operation.done && operation.response && operation.response['release']
             release = extract_release(operation)
-            result = operation.response['result']
-            if result == 'RELEASE_UPDATED'
+            case operation.response['result']
+            when 'RELEASE_UPDATED'
               UI.success("✅ Uploaded #{binary_type} successfully; updated provisioning profile of existing release #{release_version(release)}.")
-              break
-            elsif result == 'RELEASE_UNMODIFIED'
+            when 'RELEASE_UNMODIFIED'
               UI.success("✅ The same #{binary_type} was found in release #{release_version(release)} with no changes, skipping.")
-              break
             else
               UI.success("✅ Uploaded #{binary_type} successfully and created release #{release_version(release)}.")
             end
             break
           elsif !operation.done
-            sleep(POLLING_INTERVAL_SECONDS)
-            operation = client.get_project_app_release_operation(operation.name)
+            next
           else
             if operation.error && operation.error.message
               UI.user_error!("#{ErrorMessage.upload_binary_error(binary_type)}: #{operation.error.message}")
@@ -257,6 +268,30 @@ module Fastlane
         extract_release(operation)
       end
 
+      def self.upload_binary(app_name, binary_path, client, timeout)
+        options = Google::Apis::RequestOptions.new
+        options.max_elapsed_time = timeout # includes retries (default = no retries)
+        options.header = {
+          'Content-Type' => 'application/octet-stream',
+          'X-Goog-Upload-File-Name' => CGI.escape(File.basename(binary_path)),
+          'X-Goog-Upload-Protocol' => 'raw'
+        }
+
+        # For some reason calling the client.upload_medium returns nil when
+        # it should return a long running operation object, so we make a
+        # standard http call instead and convert it to a long running object
+        # https://github.com/googleapis/google-api-ruby-client/blob/main/generated/google-apis-firebaseappdistribution_v1/lib/google/apis/firebaseappdistribution_v1/service.rb#L79
+        # TODO(kbolay): Prefer client.upload_medium
+        response = client.http(
+          :post,
+          "https://firebaseappdistribution.googleapis.com/upload/v1/#{app_name}/releases:upload",
+          body: File.open(binary_path, 'rb'),
+          options: options
+        )
+
+        Google::Apis::FirebaseappdistributionV1::GoogleLongrunningOperation.from_json(response)
+      end
+
       def self.extract_release(operation)
         Google::Apis::FirebaseappdistributionV1::GoogleFirebaseAppdistroV1Release.from_json(operation.response['release'].to_json)
       end
@@ -304,6 +339,99 @@ module Fastlane
         end
       end
 
+      def self.test_release(alpha_client, release, test_devices, username = nil, password = nil, username_resource = nil, password_resource = nil)
+        if username_resource.nil? ^ password_resource.nil?
+          UI.user_error!("Username and password resource names for automated tests need to be specified together.")
+        end
+        field_hints = nil
+        if !username_resource.nil? && !password_resource.nil?
+          field_hints =
+            Google::Apis::FirebaseappdistributionV1alpha::GoogleFirebaseAppdistroV1alphaLoginCredentialFieldHints.new(
+              username_resource_name: username_resource,
+              password_resource_name: password_resource
+            )
+        end
+
+        if username.nil? ^ password.nil?
+          UI.user_error!("Username and password for automated tests need to be specified together.")
+        end
+        login_credential = nil
+        if !username.nil? && !password.nil?
+          login_credential =
+            Google::Apis::FirebaseappdistributionV1alpha::GoogleFirebaseAppdistroV1alphaLoginCredential.new(
+              username: username,
+              password: password,
+              field_hints: field_hints
+            )
+        else
+          unless field_hints.nil?
+            UI.user_error!("Must specify username and password for automated tests if resource names are set.")
+          end
+        end
+
+        device_executions = string_to_array(test_devices, ';').map do |td_string|
+          td_hash = parse_test_device_string(td_string)
+          Google::Apis::FirebaseappdistributionV1alpha::GoogleFirebaseAppdistroV1alphaDeviceExecution.new(
+            device: Google::Apis::FirebaseappdistributionV1alpha::GoogleFirebaseAppdistroV1alphaTestDevice.new(
+              model: td_hash['model'],
+              version: td_hash['version'],
+              orientation: td_hash['orientation'],
+              locale: td_hash['locale']
+            )
+          )
+        end
+
+        release_test =
+          Google::Apis::FirebaseappdistributionV1alpha::GoogleFirebaseAppdistroV1alphaReleaseTest.new(
+            login_credential: login_credential,
+            device_executions: device_executions
+          )
+        alpha_client.create_project_app_release_test(release.name, release_test)
+      rescue Google::Apis::Error => err
+        UI.crash!(err)
+      end
+
+      def self.poll_test_finished(alpha_client, release_test_name)
+        TEST_MAX_POLLING_RETRIES.times do
+          UI.message("⏳ The automated test results are pending.")
+          sleep(TEST_POLLING_INTERVAL_SECONDS)
+          release_test = alpha_client.get_project_app_release_test(release_test_name)
+          if release_test.device_executions.all? { |e| e.state == 'PASSED' }
+            UI.success("✅ Passed automated test(s).")
+            return
+          end
+          release_test.device_executions.each do |de|
+            case de.state
+            when 'PASSED', 'IN_PROGRESS'
+              next
+            when 'FAILED'
+              UI.test_failure!("Automated test failed for #{device_to_s(de.device)}: #{de.failed_reason}.")
+            when 'INCONCLUSIVE'
+              UI.test_failure!("Automated test inconclusive for #{device_to_s(de.device)}: #{de.inconclusive_reason}.")
+            else
+              UI.test_failure!("Unsupported automated test state for #{device_to_s(de.device)}: #{de.state}.")
+            end
+          end
+        end
+        UI.test_failure!("It took longer than expected to process your test, please try again.")
+      end
+
+      def self.parse_test_device_string(td_string)
+        allowed_keys = %w[model version locale orientation]
+        key_value_pairs = td_string.split(',').map do |key_value_string|
+          key, value = key_value_string.split('=')
+          unless allowed_keys.include?(key)
+            UI.user_error!("Unrecognized key in test_devices. Can only contain keys #{allowed_keys.join(', ')}.")
+          end
+          [key, value]
+        end
+        Hash[key_value_pairs]
+      end
+
+      def self.device_to_s(device)
+        "#{device.model} (#{device.version}/#{device.orientation}/#{device.locale})"
+      end
+
       def self.available_options
         [
           # iOS Specific
@@ -335,7 +463,7 @@ module Fastlane
                                        verify_block: proc do |value|
                                          UI.user_error!("firebase_app_distribution: '#{value}' is not a valid value for android_artifact_type. Should be 'APK' or 'AAB'") unless ['APK', 'AAB'].include?(value)
                                        end),
-          # Generic
+          # General
           FastlaneCore::ConfigItem.new(key: :app,
                                        env_name: "FIREBASEAPPDISTRO_APP",
                                        description: "Your app's Firebase App ID. You can find the App ID in the Firebase console, on the General Settings page",
@@ -344,26 +472,38 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :firebase_cli_path,
                                        deprecated: "This plugin no longer uses the Firebase CLI",
                                        env_name: "FIREBASEAPPDISTRO_FIREBASE_CLI_PATH",
-                                       description: "The absolute path of the firebase cli command",
+                                       description: "Absolute path of the Firebase CLI command",
                                        type: String),
+          FastlaneCore::ConfigItem.new(key: :debug,
+                                      description: "Print verbose debug output",
+                                      optional: true,
+                                      default_value: false,
+                                      type: Boolean),
+
+          # Release Distribution
+          FastlaneCore::ConfigItem.new(key: :upload_timeout,
+                                       description: "Amount of seconds before the upload will  timeout, if not completed",
+                                       optional: true,
+                                       default_value: DEFAULT_UPLOAD_TIMEOUT_SECONDS,
+                                       type: Integer),
           FastlaneCore::ConfigItem.new(key: :groups,
                                        env_name: "FIREBASEAPPDISTRO_GROUPS",
-                                       description: "The group aliases used for distribution, separated by commas",
+                                       description: "Group aliases used for distribution, separated by commas",
                                        optional: true,
                                        type: String),
           FastlaneCore::ConfigItem.new(key: :groups_file,
                                        env_name: "FIREBASEAPPDISTRO_GROUPS_FILE",
-                                       description: "The group aliases used for distribution, separated by commas",
+                                       description: "Path to file containing group aliases used for distribution, separated by commas",
                                        optional: true,
                                        type: String),
           FastlaneCore::ConfigItem.new(key: :testers,
                                        env_name: "FIREBASEAPPDISTRO_TESTERS",
-                                       description: "Pass email addresses of testers, separated by commas",
+                                       description: "Email addresses of testers, separated by commas",
                                        optional: true,
                                        type: String),
           FastlaneCore::ConfigItem.new(key: :testers_file,
                                        env_name: "FIREBASEAPPDISTRO_TESTERS_FILE",
-                                       description: "Pass email addresses of testers, separated by commas",
+                                       description: "Path to file containing email addresses of testers, separated by commas",
                                        optional: true,
                                        type: String),
           FastlaneCore::ConfigItem.new(key: :release_notes,
@@ -373,27 +513,66 @@ module Fastlane
                                        type: String),
           FastlaneCore::ConfigItem.new(key: :release_notes_file,
                                        env_name: "FIREBASEAPPDISTRO_RELEASE_NOTES_FILE",
-                                       description: "Release notes file for this build",
+                                       description: "Path to file containing release notes for this build",
                                        optional: true,
                                        type: String),
-          FastlaneCore::ConfigItem.new(key: :firebase_cli_token,
-                                       description: "Auth token generated using the Firebase CLI's login:ci command",
+
+          # Release Testing
+          FastlaneCore::ConfigItem.new(key: :test_devices,
+                                       env_name: "FIREBASEAPPDISTRO_TEST_DEVICES",
+                                       description: "List of devices to run automated tests on, in the format 'model=<model-id>,version=<os-version-id>,locale=<locale>,orientation=<orientation>;model=<model-id>,...'. Run 'gcloud firebase test android|ios models list' to see available devices. Note: This feature is in beta",
                                        optional: true,
                                        type: String),
-          FastlaneCore::ConfigItem.new(key: :debug,
-                                       description: "Print verbose debug output",
+          FastlaneCore::ConfigItem.new(key: :test_devices_file,
+                                       env_name: "FIREBASEAPPDISTRO_TEST_DEVICES_FILE",
+                                       description: "Path to file containing a list of devices to run automated tests on, in the format 'model=<model-id>,version=<os-version-id>,locale=<locale>,orientation=<orientation>;model=<model-id>,...'. Run 'gcloud firebase test android|ios models list' to see available devices. Note: This feature is in beta",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :test_username,
+                                       env_name: "FIREBASEAPPDISTRO_TEST_USERNAME",
+                                       description: "Username for automatic login",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :test_password,
+                                       env_name: "FIREBASEAPPDISTRO_TEST_PASSWORD",
+                                       description: "Password for automatic login. If using a real password consider using test_password_file or setting FIREBASEAPPDISTRO_TEST_PASSWORD to avoid exposing sensitive info",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :test_password_file,
+                                       env_name: "FIREBASEAPPDISTRO_TEST_PASSWORD_FILE",
+                                      description: "Path to file containing password for automatic login",
+                                      optional: true,
+                                      type: String),
+          FastlaneCore::ConfigItem.new(key: :test_username_resource,
+                                       env_name: "FIREBASEAPPDISTRO_TEST_USERNAME_RESOURCE",
+                                       description: "Resource name for the username field for automatic login",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :test_password_resource,
+                                       env_name: "FIREBASEAPPDISTRO_TEST_PASSWORD_RESOURCE",
+                                       description: "Resource name for the password field for automatic login",
                                        optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :test_non_blocking,
+                                       env_name: "FIREBASEAPPDISTRO_TEST_NON_BLOCKING",
+                                       description: "Run automated tests without waiting for them to finish. Visit the Firebase console for the test results",
+                                       optional: false,
                                        default_value: false,
-                                       is_string: false),
+                                       type: Boolean),
+
+          # Auth
+          FastlaneCore::ConfigItem.new(key: :firebase_cli_token,
+                                       description: "Auth token generated using the Firebase CLI's login:ci command",
+                                       optional: true,
+                                       type: String),
           FastlaneCore::ConfigItem.new(key: :service_credentials_file,
-                                       description: "Path to Google service account json",
+                                       description: "Path to Google service account json file",
                                        optional: true,
                                        type: String),
-          FastlaneCore::ConfigItem.new(key: :upload_timeout,
-                                       description: "The amount of seconds before the upload will timeout, if not completed",
+          FastlaneCore::ConfigItem.new(key: :service_credentials_json_data,
+                                       description: "Google service account json file content",
                                        optional: true,
-                                       default_value: DEFAULT_UPLOAD_TIMEOUT_SECONDS,
-                                       type: Integer)
+                                       type: String)
         ]
       end
 
@@ -410,7 +589,8 @@ module Fastlane
           <<-CODE
             firebase_app_distribution(
               app: "<your Firebase app ID>",
-              testers: "snatchev@google.com, rebeccahe@google.com"
+              testers: "snatchev@google.com, rebeccahe@google.com",
+              test_devices: "model=shiba,version=34,locale=en,orientation=portrait;model=b0q,version=33,locale=en,orientation=portrait",
             )
           CODE
         ]

data/lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_add_testers_action.rb

@@ -1,6 +1,6 @@
 require 'fastlane/action'
 require 'fastlane_core/ui/ui'
-
+require 'google/apis/firebaseappdistribution_v1'
 require_relative '../helper/firebase_app_distribution_helper'
 require_relative '../helper/firebase_app_distribution_auth_client'
 
@@ -11,7 +11,9 @@ module Fastlane
       extend Helper::FirebaseAppDistributionHelper
 
       def self.run(params)
-        client = init_client(params[:service_credentials_file], params[:firebase_cli_token], params[:debug])
+        init_google_api_client(params[:debug])
+        client = Google::Apis::FirebaseappdistributionV1::FirebaseAppDistributionService.new
+        client.authorization = get_authorization(params[:service_credentials_file], params[:firebase_cli_token], params[:service_credentials_json_data], params[:debug])
 
         if blank?(params[:emails]) && blank?(params[:file])
           UI.user_error!("Must specify `emails` or `file`.")
@@ -78,6 +80,10 @@ module Fastlane
                                       description: "Path to Google service credentials file",
                                       optional: true,
                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :service_credentials_json_data,
+                                      description: "Google service account json file content",
+                                      optional: true,
+                                      type: String),
           FastlaneCore::ConfigItem.new(key: :firebase_cli_token,
                                        description: "Auth token generated using the Firebase CLI's login:ci command",
                                        optional: true,

data/lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_create_group_action.rb

@@ -1,7 +1,6 @@
 require 'fastlane/action'
 require 'fastlane_core/ui/ui'
 require 'google/apis/firebaseappdistribution_v1'
-
 require_relative '../helper/firebase_app_distribution_helper'
 require_relative '../helper/firebase_app_distribution_auth_client'
 
@@ -11,8 +10,6 @@ module Fastlane
       extend Auth::FirebaseAppDistributionAuthClient
       extend Helper::FirebaseAppDistributionHelper
 
-      FirebaseAppDistributionV1 = Google::Apis::FirebaseappdistributionV1
-
       def self.run(params)
         if blank?(params[:alias])
           UI.user_error!("Must specify `alias`.")
@@ -22,7 +19,9 @@ module Fastlane
           UI.user_error!("Must specify `display_name`.")
         end
 
-        client = init_client(params[:service_credentials_file], params[:firebase_cli_token], params[:debug])
+        init_google_api_client(params[:debug])
+        client = Google::Apis::FirebaseappdistributionV1::FirebaseAppDistributionService.new
+        client.authorization = get_authorization(params[:service_credentials_file], params[:firebase_cli_token], params[:service_credentials_json_data], params[:debug])
 
         project_number = params[:project_number]
         group_alias = params[:alias]
@@ -31,7 +30,7 @@ module Fastlane
         UI.message("⏳ Creating tester group '#{group_alias} (#{display_name})' in project #{project_number}...")
 
         parent = project_name(project_number)
-        group = FirebaseAppDistributionV1::GoogleFirebaseAppdistroV1Group.new(
+        group = Google::Apis::FirebaseappdistributionV1::GoogleFirebaseAppdistroV1Group.new(
           name: group_name(project_number, group_alias),
           display_name: display_name
         )
@@ -88,6 +87,10 @@ module Fastlane
                                        description: "Path to Google service credentials file",
                                        optional: true,
                                        type: String),
+          FastlaneCore::ConfigItem.new(key: :service_credentials_json_data,
+                                       description: "Google service account json file content",
+                                       optional: true,
+                                       type: String),
           FastlaneCore::ConfigItem.new(key: :firebase_cli_token,
                                        description: "Auth token generated using the Firebase CLI's login:ci command",
                                        optional: true,

data/lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_delete_group_action.rb

@@ -1,6 +1,6 @@
 require 'fastlane/action'
 require 'fastlane_core/ui/ui'
-
+require 'google/apis/firebaseappdistribution_v1'
 require_relative '../helper/firebase_app_distribution_helper'
 require_relative '../helper/firebase_app_distribution_auth_client'
 
@@ -11,7 +11,9 @@ module Fastlane
       extend Helper::FirebaseAppDistributionHelper
 
       def self.run(params)
-        client = init_client(params[:service_credentials_file], params[:firebase_cli_token], params[:debug])
+        init_google_api_client(params[:debug])
+        client = Google::Apis::FirebaseappdistributionV1::FirebaseAppDistributionService.new
+        client.authorization = get_authorization(params[:service_credentials_file], params[:firebase_cli_token], params[:service_credentials_json_data], params[:debug])
 
         if blank?(params[:alias])
           UI.user_error!("Must specify `alias`.")
@@ -65,6 +67,10 @@ module Fastlane
                                        description: "Path to Google service credentials file",
                                        optional: true,
                                        type: String),
+          FastlaneCore::ConfigItem.new(key: :service_credentials_json_data,
+                                       description: "Google service account json file content",
+                                       optional: true,
+                                       type: String),
           FastlaneCore::ConfigItem.new(key: :firebase_cli_token,
                                        description: "Auth token generated using the Firebase CLI's login:ci command",
                                        optional: true,

data/lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_get_latest_release.rb

@@ -13,7 +13,9 @@ module Fastlane
       extend Helper::FirebaseAppDistributionHelper
 
       def self.run(params)
-        client = init_client(params[:service_credentials_file], params[:firebase_cli_token], params[:debug])
+        init_google_api_client(params[:debug])
+        client = Google::Apis::FirebaseappdistributionV1::FirebaseAppDistributionService.new
+        client.authorization = get_authorization(params[:service_credentials_file], params[:firebase_cli_token], params[:service_credentials_json_data], params[:debug])
 
         UI.message("⏳ Fetching latest release for app #{params[:app]}...")
 
@@ -89,6 +91,10 @@ module Fastlane
                                        description: "Path to Google service account json",
                                        optional: true,
                                        type: String),
+          FastlaneCore::ConfigItem.new(key: :service_credentials_json_data,
+                                       description: "Google service account json file content",
+                                       optional: true,
+                                       type: String),
           FastlaneCore::ConfigItem.new(key: :debug,
                                        description: "Print verbose debug output",
                                        optional: true,

data/lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_get_udids.rb

@@ -2,9 +2,9 @@ require 'fastlane/action'
 require 'open3'
 require 'shellwords'
 require 'googleauth'
+require 'google/apis/firebaseappdistribution_v1alpha'
 require_relative '../helper/firebase_app_distribution_helper'
 require_relative '../helper/firebase_app_distribution_error_message'
-require_relative '../client/firebase_app_distribution_api_client'
 require_relative '../helper/firebase_app_distribution_auth_client'
 
 module Fastlane
@@ -14,14 +14,23 @@ module Fastlane
       extend Helper::FirebaseAppDistributionHelper
 
       def self.run(params)
-        client = init_client(params[:service_credentials_file], params[:firebase_cli_token], params[:debug])
-        fad_api_client = Client::FirebaseAppDistributionApiClient.new(client.authorization.access_token, params[:debug])
+        init_google_api_client(params[:debug])
+        client = Google::Apis::FirebaseappdistributionV1alpha::FirebaseAppDistributionService.new
+        client.authorization = get_authorization(params[:service_credentials_file], params[:firebase_cli_token], params[:service_credentials_json_data], params[:debug])
 
-        app_id = params[:app]
-        udids = fad_api_client.get_udids(app_id)
+        project_number = params[:project_number]
+        if blank?(project_number)
+          app_id = params[:app]
+          if blank?(app_id)
+            UI.user_error!("Must specify `project_number`.")
+          end
+          project_number = project_number_from_app_id(app_id)
+        end
+        udids = client.get_project_tester_udids(project_name(project_number)).tester_udids
 
-        if udids.empty?
-          UI.important("App Distribution fetched 0 tester UDIDs. Nothing written to output file.")
+        if udids.to_a.empty?
+          File.delete(params[:output_file]) if File.exist?(params[:output_file])
+          UI.important("App Distribution fetched 0 tester UDIDs. Removed output file.")
         else
           write_udids_to_file(udids, params[:output_file])
           UI.success("🎉 App Distribution tester UDIDs written to: #{params[:output_file]}")
@@ -32,7 +41,7 @@ module Fastlane
         File.open(output_file, 'w') do |f|
           f.write("Device ID\tDevice Name\tDevice Platform\n")
           udids.each do |tester_udid|
-            f.write("#{tester_udid[:udid]}\t#{tester_udid[:name]}\t#{tester_udid[:platform]}\n")
+            f.write("#{tester_udid.udid}\t#{tester_udid.name}\t#{tester_udid.platform}\n")
           end
         end
       end
@@ -52,10 +61,18 @@ module Fastlane
 
       def self.available_options
         [
+          FastlaneCore::ConfigItem.new(key: :project_number,
+                                       conflicting_options: [:app],
+                                       env_name: "FIREBASEAPPDISTRO_PROJECT_NUMBER",
+                                       description: "Your Firebase project number. You can find the project number in the Firebase console, on the General Settings page",
+                                       type: Integer,
+                                       optional: true),
           FastlaneCore::ConfigItem.new(key: :app,
+                                       conflicting_options: [:project_number],
                                        env_name: "FIREBASEAPPDISTRO_APP",
                                        description: "Your app's Firebase App ID. You can find the App ID in the Firebase console, on the General Settings page",
-                                       optional: false,
+                                       optional: true,
+                                       deprecated: "Use project_number (FIREBASEAPPDISTRO_PROJECT_NUMBER) instead",
                                        type: String),
           FastlaneCore::ConfigItem.new(key: :output_file,
                                        env_name: "FIREBASEAPPDISTRO_OUTPUT_FILE",
@@ -70,6 +87,10 @@ module Fastlane
                                        description: "Path to Google service account json",
                                        optional: true,
                                        type: String),
+          FastlaneCore::ConfigItem.new(key: :service_credentials_json_data,
+                                       description: "Google service account json file content",
+                                       optional: true,
+                                       type: String),
           FastlaneCore::ConfigItem.new(key: :debug,
                                        description: "Print verbose debug output",
                                        optional: true,

data/lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_remove_testers_action.rb

@@ -1,6 +1,6 @@
 require 'fastlane/action'
 require 'fastlane_core/ui/ui'
-
+require 'google/apis/firebaseappdistribution_v1'
 require_relative '../helper/firebase_app_distribution_helper'
 require_relative '../helper/firebase_app_distribution_auth_client'
 
@@ -11,7 +11,9 @@ module Fastlane
       extend Helper::FirebaseAppDistributionHelper
 
       def self.run(params)
-        client = init_client(params[:service_credentials_file], params[:firebase_cli_token], params[:debug])
+        init_google_api_client(params[:debug])
+        client = Google::Apis::FirebaseappdistributionV1::FirebaseAppDistributionService.new
+        client.authorization = get_authorization(params[:service_credentials_file], params[:firebase_cli_token], params[:service_credentials_json_data], params[:debug])
 
         if blank?(params[:emails]) && blank?(params[:file])
           UI.user_error!("Must specify `emails` or `file`.")
@@ -73,6 +75,10 @@ module Fastlane
                                       description: "Path to Google service credentials file",
                                       optional: true,
                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :service_credentials_json_data,
+                                       description: "Google service account json file content",
+                                       optional: true,
+                                       type: String),
           FastlaneCore::ConfigItem.new(key: :firebase_cli_token,
                                        description: "Auth token generated using the Firebase CLI's login:ci command",
                                        optional: true,

data/lib/fastlane/plugin/firebase_app_distribution/helper/firebase_app_distribution_auth_client.rb

@@ -20,6 +20,7 @@ module Fastlane
       # auth method is used, unset all other auth variables/parameters to nil/empty
       #
       # args
+      #   google_service_json_data - Google service account json file content as a string
       #   google_service_path - Absolute path to the Google service account file
       #   firebase_cli_token - Refresh token
       #   debug - Whether to enable debug-level logging
@@ -28,26 +29,25 @@ module Fastlane
       #   FIREBASE_TOKEN - see firebase_cli_token
       #
       # Crashes if given invalid or missing credentials
-      def get_authorization(google_service_path, firebase_cli_token, debug = false)
+      def get_authorization(google_service_path, firebase_cli_token, google_service_json_data, debug = false)
         if !google_service_path.nil? && !google_service_path.empty?
           UI.message("🔐 Authenticating with --service_credentials_file path parameter: #{google_service_path}")
-          service_account(google_service_path, debug)
+          service_account_from_file(google_service_path, debug)
+        elsif !google_service_json_data.nil? && !google_service_json_data.empty?
+          UI.message("🔐 Authenticating with --service_credentials_json content parameter")
+          service_account_from_json(google_service_json_data, debug)
         elsif !firebase_cli_token.nil? && !firebase_cli_token.empty?
           UI.message("🔐 Authenticating with --firebase_cli_token parameter")
           firebase_token(firebase_cli_token, debug)
         elsif !ENV["FIREBASE_TOKEN"].nil? && !ENV["FIREBASE_TOKEN"].empty?
           UI.message("🔐 Authenticating with FIREBASE_TOKEN environment variable")
           firebase_token(ENV["FIREBASE_TOKEN"], debug)
-        # TODO(lkellogg): Not using Google::Auth.get_application_default yet while we are still
-        # using the old client for uploads. ADC also does not work for the get_udids action:
-        # https://cloud.google.com/docs/authentication/troubleshoot-adc#user-creds-client-based
-        # For now go back to just using the environment variable:
-        elsif !ENV["GOOGLE_APPLICATION_CREDENTIALS"].nil? && !ENV["GOOGLE_APPLICATION_CREDENTIALS"].empty?
-          UI.message("🔐 Authenticating with GOOGLE_APPLICATION_CREDENTIALS environment variable: #{ENV['GOOGLE_APPLICATION_CREDENTIALS']}")
-          service_account(ENV["GOOGLE_APPLICATION_CREDENTIALS"], debug)
         elsif (refresh_token = refresh_token_from_firebase_tools)
-          UI.message("🔐 No authentication method found. Using cached Firebase CLI credentials.")
+          UI.message("🔐 Authenticating with cached Firebase CLI credentials")
           firebase_token(refresh_token, debug)
+        elsif !application_default_creds.nil?
+          UI.message("🔐 Authenticating with Application Default Credentials")
+          application_default_creds
         else
           UI.user_error!(ErrorMessage::MISSING_CREDENTIALS)
           nil
@@ -56,6 +56,12 @@ module Fastlane
 
       private
 
+      def application_default_creds
+        Google::Auth.get_application_default([SCOPE])
+      rescue
+        nil
+      end
+
       def refresh_token_from_firebase_tools
         config_path = format_config_path
         if File.exist?(config_path)
@@ -98,21 +104,32 @@ module Fastlane
         UI.user_error!(error_message)
       end
 
-      def service_account(google_service_path, debug)
-        service_account_credentials = Google::Auth::ServiceAccountCredentials.make_creds(
-          json_key_io: File.open(google_service_path),
+      def service_account_from_json(google_service_json_data, debug)
+        get_service_account_credentials(google_service_json_data, debug)
+      end
+
+      def service_account_from_file(google_service_path, debug)
+        get_service_account_credentials(File.read(google_service_path), debug)
+      rescue Errno::ENOENT
+        UI.user_error!("#{ErrorMessage::SERVICE_CREDENTIALS_NOT_FOUND}: #{google_service_path}")
+      end
+
+      def get_service_account_credentials(json_data, debug)
+        json_file = JSON.parse(json_data)
+        # check if it's an external account or service account
+        auth = json_file["type"] == "external_account" ? Google::Auth::ExternalAccount::Credentials : Google::Auth::ServiceAccountCredentials
+        service_account_credentials = auth.make_creds(
+          json_key_io: StringIO.new(json_data),
           scope: SCOPE
         )
         service_account_credentials.fetch_access_token!
         service_account_credentials
-      rescue Errno::ENOENT
-        UI.user_error!("#{ErrorMessage::SERVICE_CREDENTIALS_NOT_FOUND}: #{google_service_path}")
       rescue Signet::AuthorizationError => error
-        error_message = "#{ErrorMessage::SERVICE_CREDENTIALS_ERROR}: \"#{google_service_path}\""
+        error_message = "#{ErrorMessage::SERVICE_CREDENTIALS_ERROR}: "
         if debug
           error_message += "\n#{error_details(error)}"
         else
-          error_message += ". #{debug_instructions}"
+          error_message += debug_instructions.to_s
         end
         UI.user_error!(error_message)
       end

data/lib/fastlane/plugin/firebase_app_distribution/helper/firebase_app_distribution_error_message.rb

@@ -1,46 +1,46 @@
 module ErrorMessage
   MISSING_CREDENTIALS = "Missing authentication credentials. Set up Application Default Credentials, your Firebase refresh token, or sign in with the Firebase CLI, and try again."
-  MISSING_APP_ID = "Missing app id. Please check that the app parameter is set and try again"
-  SERVICE_CREDENTIALS_NOT_FOUND = "Service credentials file does not exist. Please check the service credentials path and try again"
-  PARSE_SERVICE_CREDENTIALS_ERROR = "Failed to extract service account information from the service credentials file"
-  PARSE_FIREBASE_TOOLS_JSON_ERROR = "Encountered error parsing json file. Ensure the firebase-tools.json file is formatted correctly"
-  UPLOAD_RELEASE_NOTES_ERROR = "App Distribution halted because it had a problem uploading release notes"
-  UPLOAD_TESTERS_ERROR = "App Distribution halted because it had a problem adding testers/groups"
-  GET_RELEASE_TIMEOUT = "App Distribution failed to fetch release information"
+  MISSING_APP_ID = "Missing app id. Please check that the app parameter is set and try again."
+  SERVICE_CREDENTIALS_NOT_FOUND = "Service credentials file does not exist. Please check the service credentials path and try again."
+  PARSE_SERVICE_CREDENTIALS_ERROR = "Failed to extract service account information from the service credentials file."
+  PARSE_FIREBASE_TOOLS_JSON_ERROR = "Encountered error parsing json file. Ensure the firebase-tools.json file is formatted correctly."
+  UPLOAD_RELEASE_NOTES_ERROR = "App Distribution halted because it had a problem uploading release notes."
+  UPLOAD_TESTERS_ERROR = "App Distribution halted because it had a problem adding testers/groups."
+  GET_RELEASE_TIMEOUT = "App Distribution failed to fetch release information."
   REFRESH_TOKEN_ERROR = "App Distribution could not generate credentials from the refresh token specified."
-  APP_NOT_ONBOARDED_ERROR = "App Distribution not onboarded"
+  APP_NOT_ONBOARDED_ERROR = "App Distribution not onboarded."
   INVALID_APP_ID = "App Distribution could not find your app. Make sure to onboard your app by pressing the \"Get started\" button on the App Distribution page in the Firebase console: https://console.firebase.google.com/project/_/appdistribution. App ID"
   INVALID_PROJECT = "App Distribution could not find your Firebase project. Make sure to onboard an app in your project by pressing the \"Get started\" button on the App Distribution page in the Firebase console: https://console.firebase.google.com/project/_/appdistribution."
   INVALID_PATH = "Could not read content from"
   INVALID_TESTERS = "Could not enable access for testers. Check that the tester emails are formatted correctly, the groups exist and you are using group aliases (not group names) for specifying groups."
   INVALID_TESTER_GROUP = "App Distribution could not find your tester group. Make sure that it exists before trying to add testers, and that the group alias is specified correctly."
   INVALID_TESTER_GROUP_NAME = "The tester group name should be 4-63 characters, and valid characters are /[a-z][0-9]-/."
-  INVALID_RELEASE_NOTES = "Failed to set release notes"
-  SERVICE_CREDENTIALS_ERROR = "App Distribution could not generate credentials from the service credentials file specified"
+  INVALID_RELEASE_NOTES = "Failed to set release notes."
+  SERVICE_CREDENTIALS_ERROR = "App Distribution could not generate credentials from the service credentials file specified."
   PLAY_ACCOUNT_NOT_LINKED = "This project is not linked to a Google Play account."
   APP_NOT_PUBLISHED = "This app is not published in the Google Play console."
   NO_APP_WITH_GIVEN_BUNDLE_ID_IN_PLAY_ACCOUNT = "App with matching package name does not exist in Google Play."
   PLAY_IAS_TERMS_NOT_ACCEPTED = "You must accept the Play Internal App Sharing (IAS) terms to upload AABs."
   INVALID_EMAIL_ADDRESS = "You passed an invalid email address."
-  TESTER_LIMIT_VIOLATION = "Creating testers would exceed tester limit"
+  TESTER_LIMIT_VIOLATION = "Creating testers would exceed tester limit."
 
   def self.aab_upload_error(aab_state)
     "Failed to process the AAB: #{aab_state}"
   end
 
   def self.binary_not_found(binary_type)
-    "Could not find the #{binary_type}. Make sure you set the #{binary_type} path parameter to point to your #{binary_type}"
+    "Could not find the #{binary_type}. Make sure you set the #{binary_type} path parameter to point to your #{binary_type}."
   end
 
   def self.parse_binary_metadata_error(binary_type)
-    "Failed to extract #{binary_type} metadata from the #{binary_type} path"
+    "Failed to extract #{binary_type} metadata from the #{binary_type} path."
   end
 
   def self.upload_binary_error(binary_type)
-    "App Distribution halted because it had a problem uploading the #{binary_type}"
+    "App Distribution halted because it had a problem uploading the #{binary_type}."
   end
 
   def self.binary_processing_error(binary_type)
-    "App Distribution failed to process the #{binary_type}"
+    "App Distribution failed to process the #{binary_type}."
   end
 end

data/lib/fastlane/plugin/firebase_app_distribution/helper/firebase_app_distribution_helper.rb

@@ -1,5 +1,6 @@
 require 'fastlane_core/ui/ui'
 require 'cfpropertylist'
+
 module Fastlane
   UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
   module Helper
@@ -26,10 +27,10 @@ module Fastlane
 
       # Returns the array representation of a string with trimmed comma
       # seperated values.
-      def string_to_array(string)
+      def string_to_array(string, delimiter = ",")
         return [] if string.nil?
         # Strip string and then strip individual values
-        string.strip.split(",").map(&:strip)
+        string.strip.split(delimiter).map(&:strip)
       end
 
       def parse_plist(path)
@@ -53,8 +54,12 @@ module Fastlane
         !blank?(value)
       end
 
+      def project_number_from_app_id(app_id)
+        app_id.split(':')[1]
+      end
+
       def app_name_from_app_id(app_id)
-        "#{project_name(app_id.split(':')[1])}/apps/#{app_id}"
+        "#{project_name(project_number_from_app_id(app_id))}/apps/#{app_id}"
       end
 
       def project_name(project_number)
@@ -65,7 +70,7 @@ module Fastlane
         "#{project_name(project_number)}/groups/#{group_alias}"
       end
 
-      def init_client(service_credentials_file, firebase_cli_token, debug, timeout = nil)
+      def init_google_api_client(debug, timeout = nil)
         if debug
           UI.important("Warning: Debug logging enabled. Output may include sensitive information.")
           Google::Apis.logger.level = Logger::DEBUG
@@ -76,10 +81,6 @@ module Fastlane
         unless timeout.nil?
           Google::Apis::ClientOptions.default.send_timeout_sec = timeout
         end
-
-        client = Google::Apis::FirebaseappdistributionV1::FirebaseAppDistributionService.new
-        client.authorization = get_authorization(service_credentials_file, firebase_cli_token, debug)
-        client
       end
 
       def deep_symbolize_keys(hash)

data/lib/fastlane/plugin/firebase_app_distribution/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module FirebaseAppDistribution
-    VERSION = "0.7.3"
+    VERSION = "0.9.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-firebase_app_distribution
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.9.0
 platform: ruby
 authors:
 - Stefan Natchev
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-09-07 00:00:00.000000000 Z
+date: 2024-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-apis-firebaseappdistribution_v1
@@ -26,6 +26,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: google-apis-firebaseappdistribution_v1alpha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -172,7 +186,6 @@ files:
 - lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_get_latest_release.rb
 - lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_get_udids.rb
 - lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_remove_testers_action.rb
-- lib/fastlane/plugin/firebase_app_distribution/client/firebase_app_distribution_api_client.rb
 - lib/fastlane/plugin/firebase_app_distribution/helper/firebase_app_distribution_auth_client.rb
 - lib/fastlane/plugin/firebase_app_distribution/helper/firebase_app_distribution_error_message.rb
 - lib/fastlane/plugin/firebase_app_distribution/helper/firebase_app_distribution_helper.rb
@@ -196,7 +209,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.3
 signing_key: 
 specification_version: 4
 summary: Release your beta builds to Firebase App Distribution. https://firebase.google.com/docs/app-distribution

data/lib/fastlane/plugin/firebase_app_distribution/client/firebase_app_distribution_api_client.rb

@@ -1,97 +0,0 @@
-require 'fastlane_core/ui/ui'
-require_relative '../helper/firebase_app_distribution_helper'
-
-module Fastlane
-  module Client
-    class FirebaseAppDistributionApiClient
-      include Helper::FirebaseAppDistributionHelper
-
-      BASE_URL = "https://firebaseappdistribution.googleapis.com"
-      MAX_POLLING_RETRIES = 60
-      POLLING_INTERVAL_SECONDS = 5
-
-      AUTHORIZATION = "Authorization"
-      CONTENT_TYPE = "Content-Type"
-      APPLICATION_OCTET_STREAM = "application/octet-stream"
-      CLIENT_VERSION = "X-Client-Version"
-
-      def initialize(auth_token, debug = false)
-        @auth_token = auth_token
-        @debug = debug
-      end
-
-      # Uploads the app binary to the Firebase API
-      #
-      # args
-      #   app_name - Firebase App resource name
-      #   binary_path - Absolute path to your app's aab/apk/ipa file
-      #   platform - 'android' or 'ios'
-      #   timeout - The amount of seconds before the upload will timeout, if not completed
-      #
-      # Returns the long-running operation name.
-      #
-      # Throws a user_error if the binary file does not exist
-      def upload_binary(app_name, binary_path, platform, timeout)
-        response = connection.post(binary_upload_url(app_name), read_binary(binary_path)) do |request|
-          request.options.timeout = timeout # seconds
-          request.headers[AUTHORIZATION] = "Bearer " + @auth_token
-          request.headers[CONTENT_TYPE] = APPLICATION_OCTET_STREAM
-          request.headers[CLIENT_VERSION] = client_version_header_value
-          request.headers["X-Goog-Upload-File-Name"] = File.basename(binary_path)
-          request.headers["X-Goog-Upload-Protocol"] = "raw"
-        end
-
-        response.body[:name] || ''
-      rescue Errno::ENOENT # Raised when binary_path file does not exist
-        binary_type = binary_type_from_path(binary_path)
-        UI.user_error!("#{ErrorMessage.binary_not_found(binary_type)}: #{binary_path}")
-      end
-
-      # Get tester UDIDs
-      #
-      # args
-      #   app_name - Firebase App resource name
-      #
-      # Returns a list of hashes containing tester device info
-      def get_udids(app_id)
-        begin
-          response = connection.get(get_udids_url(app_id)) do |request|
-            request.headers[AUTHORIZATION] = "Bearer " + @auth_token
-            request.headers[CLIENT_VERSION] = client_version_header_value
-          end
-        rescue Faraday::ResourceNotFound
-          UI.user_error!("#{ErrorMessage::INVALID_APP_ID}: #{app_id}")
-        end
-        response.body[:testerUdids] || []
-      end
-
-      private
-
-      def client_version_header_value
-        "fastlane/#{Fastlane::FirebaseAppDistribution::VERSION}"
-      end
-
-      def binary_upload_url(app_name)
-        "/upload/v1/#{app_name}/releases:upload"
-      end
-
-      def get_udids_url(app_id)
-        "/v1alpha/apps/#{app_id}/testers:getTesterUdids"
-      end
-
-      def connection
-        @connection ||= Faraday.new(url: BASE_URL) do |conn|
-          conn.response(:json, parser_options: { symbolize_names: true })
-          conn.response(:raise_error) # raise_error middleware will run before the json middleware
-          conn.response(:logger, nil, { headers: false, bodies: { response: true }, log_level: :debug }) if @debug
-          conn.adapter(Faraday.default_adapter)
-        end
-      end
-
-      def read_binary(path)
-        # File must be read in binary mode to work on Windows
-        File.open(path, 'rb').read
-      end
-    end
-  end
-end