fastlane-plugin-firebase_app_distribution 0.6.1 → 0.7.0.pre.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e7f18a8f8eafbf185e2668199992945f10c594eb0905a7f44dacc19d896dec7
-  data.tar.gz: 8d04a88db55901df3e117bd620d3db5b05080f7ba381b9a26cd7fd857c863bb2
+  metadata.gz: b34d6851b746d0df4a985fed4cbd775767b1278bb236c67cf5753c85e7168950
+  data.tar.gz: 0f8ef74f5659bb7a0057e6c3e4c2a015c7aef49eca8f541ef09ee9a11fb3c4d6
 SHA512:
-  metadata.gz: 144d169438dbefce6a18448ef9b64012e29d2675487f638b11aeb99ccbb9b075391bb77d57bac106718d1510a791e70fa31d4ddcf6a3b757854e6b93f0e18fde
-  data.tar.gz: 114836ed3247cd167071a10ec5d1868da3c090c3f37c792913529438dce1a9ff7ce3d3f4ee3b9c67d2d5f9dae1ab8769872f7cd6992dc6210b0b651a3ab30739
+  metadata.gz: 11be0d646292c1ee160b1d704c5af1f051dfb1e90f9f6761d5347b03c92ed6ca8bcaf4249cd518aea979efa496f38eae2fc8d923a5c679ba84b979fa8bd3e5d2
+  data.tar.gz: 1f9093a5593ed7c862cd96391549800f20bcb50e5c257065210ecba3c210df1a43d4fbc8d2c79565ecf83c347baff767d7eff35a556340d962c2a8e7aa04c348

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

@@ -2,10 +2,8 @@ require 'fastlane/action'
 require 'open3'
 require 'shellwords'
 require 'googleauth'
-require_relative '../helper/upload_status_response'
 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'
 
 ## How should we document the usage of release notes?
@@ -15,19 +13,18 @@ module Fastlane
       FIREBASE_APP_DISTRO_RELEASE ||= :FIREBASE_APP_DISTRO_RELEASE
     end
 
+    # rubocop:disable Metrics/ClassLength
     class FirebaseAppDistributionAction < Action
       extend Auth::FirebaseAppDistributionAuthClient
       extend Helper::FirebaseAppDistributionHelper
 
       DEFAULT_UPLOAD_TIMEOUT_SECONDS = 300
+      MAX_POLLING_RETRIES = 60
+      POLLING_INTERVAL_SECONDS = 5
 
       def self.run(params)
         params.values # to validate all inputs before looking for the ipa/apk/aab
 
-        if params[:debug]
-          UI.important("Warning: Debug logging enabled. Output may include sensitive information.")
-        end
-
         app_id = app_id_from_params(params)
         app_name = app_name_from_app_id(app_id)
         platform = lane_platform || platform_from_app_id(app_id)
@@ -37,33 +34,31 @@ module Fastlane
         UI.user_error!("Couldn't find binary at path #{binary_path}") unless File.exist?(binary_path)
         binary_type = binary_type_from_path(binary_path)
 
-        auth_token = fetch_auth_token(
-          params[:service_credentials_file], params[:firebase_cli_token], params[:debug]
-        )
-        fad_api_client = Client::FirebaseAppDistributionApiClient.new(auth_token, params[:debug])
+        client = init_client(params[:service_credentials_file], params[:firebase_cli_token], params[:debug])
 
         # 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 = fad_api_client.get_aab_info(app_name)
+          aab_info = get_aab_info(client, app_name)
           validate_aab_setup!(aab_info)
         end
 
-        upload_timeout = get_upload_timeout(params)
+        binary_type = binary_type_from_path(binary_path)
+        UI.message("⌛ Uploading the #{binary_type}.")
 
-        upload_status_response = fad_api_client.upload(app_name, binary_path, platform.to_s, upload_timeout)
-        release_name = upload_status_response.release_name
-        release = upload_status_response.release
+        timeout = get_upload_timeout(params)
+        operation = upload_binary(app_name, binary_path, client, timeout)
+        release = poll_upload_release_operation(client, operation, binary_type)
 
-        if binary_type == :AAB && aab_info && !aab_info.certs_provided?
-          updated_aab_info = fad_api_client.get_aab_info(app_name)
-          if updated_aab_info.certs_provided?
+        if binary_type == :AAB && aab_info && !aab_certs_included?(aab_info.test_certificate)
+          updated_aab_info = get_aab_info(client, app_name)
+          if aab_certs_included?(updated_aab_info.test_certificate)
             UI.message("After you upload an AAB for the first time, App Distribution " \
               "generates a new test certificate. All AAB uploads are re-signed with this test " \
               "certificate. Use the certificate fingerprints below to register your app " \
               "signing key with API providers, such as Google Sign-In and Google Maps.\n" \
-              "MD-1 certificate fingerprint: #{updated_aab_info.md5_certificate_hash}\n" \
-              "SHA-1 certificate fingerprint: #{updated_aab_info.sha1_certificate_hash}\n" \
-              "SHA-256 certificate fingerprint: #{updated_aab_info.sha256_certificate_hash}")
+              "MD-1 certificate fingerprint: #{updated_aab_info.test_certificate.hash_md5}\n" \
+              "SHA-1 certificate fingerprint: #{updated_aab_info.test_certificate.hash_sha1}\n" \
+              "SHA-256 certificate fingerprint: #{updated_aab_info.test_certificate.hash_sha256}")
           end
         end
 
@@ -71,30 +66,35 @@ module Fastlane
         if release_notes.nil? || release_notes.empty?
           UI.message("⏩ No release notes passed in. Skipping this step.")
         else
-          release = fad_api_client.update_release_notes(release_name, release_notes)
+          release.release_notes = Google::Apis::FirebaseappdistributionV1::GoogleFirebaseAppdistroV1ReleaseNotes.new(
+            text: release_notes
+          )
+          release = update_release(client, release)
         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)
         group_aliases = string_to_array(groups)
-        fad_api_client.distribute(release_name, emails, group_aliases)
-        UI.success("🎉 App Distribution upload finished successfully. Setting Actions.lane_context[SharedValues::FIREBASE_APP_DISTRO_RELEASE] to the uploaded release.")
-
-        if upload_status_response.firebase_console_uri
-          UI.message("🔗 View this release in the Firebase console: #{upload_status_response.firebase_console_uri}")
+        if present?(emails) || present?(group_aliases)
+          request = Google::Apis::FirebaseappdistributionV1::GoogleFirebaseAppdistroV1DistributeReleaseRequest.new(
+            tester_emails: emails,
+            group_aliases: group_aliases
+          )
+          distribute_release(client, release, request)
+        else
+          UI.message("⏩ No testers or groups passed in. Skipping this step.")
         end
 
-        if upload_status_response.testing_uri
-          UI.message("🔗 Share this release with testers who have access: #{upload_status_response.testing_uri}")
-        end
+        UI.success("🎉 App Distribution upload finished successfully. Setting Actions.lane_context[SharedValues::FIREBASE_APP_DISTRO_RELEASE] to the uploaded release.")
 
-        if upload_status_response.binary_download_uri
-          UI.message("🔗 Download the release binary (link expires in 1 hour): #{upload_status_response.binary_download_uri}")
-        end
+        UI.message("🔗 View this release in the Firebase console: #{release.firebase_console_uri}") if release.firebase_console_uri
+        UI.message("🔗 Share this release with testers who have access: #{release.testing_uri}") if release.testing_uri
+        UI.message("🔗 Download the release binary (link expires in 1 hour): #{release.binary_download_uri}") if release.binary_download_uri
 
-        Actions.lane_context[SharedValues::FIREBASE_APP_DISTRO_RELEASE] = release
-        release
+        release_hash = deep_symbolize_keys(JSON.parse(release.to_json))
+        Actions.lane_context[SharedValues::FIREBASE_APP_DISTRO_RELEASE] = release_hash
+        release_hash
       end
 
       def self.description
@@ -174,15 +174,15 @@ module Fastlane
       end
 
       def self.validate_aab_setup!(aab_info)
-        if aab_info && aab_info.integration_state != AabInfo::AabState::INTEGRATED && aab_info.integration_state != AabInfo::AabState::UNAVAILABLE
+        if aab_info && aab_info.integration_state != 'INTEGRATED' && aab_info.integration_state != 'AAB_STATE_UNAVAILABLE'
           case aab_info.integration_state
-          when AabInfo::AabState::PLAY_ACCOUNT_NOT_LINKED
+          when 'PLAY_ACCOUNT_NOT_LINKED'
             UI.user_error!(ErrorMessage::PLAY_ACCOUNT_NOT_LINKED)
-          when AabInfo::AabState::APP_NOT_PUBLISHED
+          when 'APP_NOT_PUBLISHED'
             UI.user_error!(ErrorMessage::APP_NOT_PUBLISHED)
-          when AabInfo::AabState::NO_APP_WITH_GIVEN_BUNDLE_ID_IN_PLAY_ACCOUNT
+          when 'NO_APP_WITH_GIVEN_BUNDLE_ID_IN_PLAY_ACCOUNT'
             UI.user_error!(ErrorMessage::NO_APP_WITH_GIVEN_BUNDLE_ID_IN_PLAY_ACCOUNT)
-          when AabInfo::AabState::PLAY_IAS_TERMS_NOT_ACCEPTED
+          when 'PLAY_IAS_TERMS_NOT_ACCEPTED'
             UI.user_error!(ErrorMessage::PLAY_IAS_TERMS_NOT_ACCEPTED)
           else
             UI.user_error!(ErrorMessage.aab_upload_error(aab_info.integration_state))
@@ -190,12 +190,126 @@ module Fastlane
         end
       end
 
+      def self.aab_certs_included?(test_certificate)
+        present?(test_certificate.hash_md5) && present?(test_certificate.hash_sha1) &&
+          present?(test_certificate.hash_sha256)
+      end
+
+      def self.aab_info_name(app_name)
+        "#{app_name}/aabInfo"
+      end
+
       def self.release_notes(params)
         release_notes_param =
           get_value_from_value_or_file(params[:release_notes], params[:release_notes_file])
         release_notes_param || Actions.lane_context[SharedValues::FL_CHANGELOG]
       end
 
+      def self.poll_upload_release_operation(client, operation, binary_type)
+        operation = client.get_project_app_release_operation(operation.name)
+        MAX_POLLING_RETRIES.times do
+          if operation.done && operation.response && operation.response['release']
+            release = extract_release(operation)
+            result = operation.response['result']
+            if result == 'RELEASE_UPDATED'
+              UI.success("✅ Uploaded #{binary_type} successfully; updated provisioning profile of existing release #{release_version(release)}.")
+              break
+            elsif result == '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)
+          else
+            if operation.error && operation.error.message
+              UI.user_error!("#{ErrorMessage.upload_binary_error(binary_type)}: #{operation.error.message}")
+            else
+              UI.user_error!(ErrorMessage.upload_binary_error(binary_type))
+            end
+          end
+        end
+
+        unless operation.done && operation.response && operation.response['release']
+          UI.crash!("It took longer than expected to process your #{binary_type}, please try again.")
+        end
+
+        extract_release(operation)
+      end
+
+      def self.upload_binary(app_name, binary_path, client, timeout)
+        options = Google::Apis::RequestOptions.new
+        options.max_elapsed_time = timeout
+        options.header = {
+          'Content-Type' => 'application/octet-stream',
+          'X-Goog-Upload-File-Name' => 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').read,
+          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
+
+      def self.release_version(release)
+        if release.display_version && release.build_version
+          "#{release.display_version} (#{release.build_version})"
+        elsif release.display_version
+          release.display_version
+        else
+          release.build_version
+        end
+      end
+
+      def self.get_aab_info(client, app_name)
+        client.get_project_app_aab_info(aab_info_name(app_name))
+      rescue Google::Apis::Error => err
+        case err.status_code.to_i
+        when 404
+          UI.user_error!(ErrorMessage::INVALID_APP_ID)
+        else
+          UI.crash!(err)
+        end
+      end
+
+      def self.update_release(client, release)
+        client.patch_project_app_release(release.name, release)
+      rescue Google::Apis::Error => err
+        case err.status_code.to_i
+        when 400
+          UI.user_error!("#{ErrorMessage::INVALID_RELEASE_NOTES}: #{err.body}")
+        else
+          UI.crash!(err)
+        end
+      end
+
+      def self.distribute_release(client, release, request)
+        client.distribute_project_app_release(release.name, request)
+      rescue Google::Apis::Error => err
+        case err.status_code.to_i
+        when 400
+          UI.user_error!("#{ErrorMessage::INVALID_TESTERS}\nEmails: #{request.tester_emails} \nGroup Aliases: #{request.group_aliases}")
+        else
+          UI.crash!(err)
+        end
+      end
+
       def self.available_options
         [
           # iOS Specific
@@ -314,5 +428,6 @@ module Fastlane
         ]
       end
     end
+    # rubocop:enable Metrics/ClassLength
   end
 end

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

@@ -11,14 +11,15 @@ module Fastlane
       extend Helper::FirebaseAppDistributionHelper
 
       def self.run(params)
-        auth_token = fetch_auth_token(params[:service_credentials_file], params[:firebase_cli_token])
-        fad_api_client = Client::FirebaseAppDistributionApiClient.new(auth_token, params[:debug])
+        client = init_client(params[:service_credentials_file], params[:firebase_cli_token], params[:debug])
 
         if blank?(params[:emails]) && blank?(params[:file])
           UI.user_error!("Must specify `emails` or `file`.")
         end
 
         emails = string_to_array(get_value_from_value_or_file(params[:emails], params[:file]))
+        project_number = params[:project_number]
+        group_alias = params[:group_alias]
 
         UI.user_error!("Must pass at least one email") if blank?(emails)
 
@@ -26,13 +27,10 @@ module Fastlane
           UI.user_error!("A maximum of 1000 testers can be added at a time.")
         end
 
-        UI.message("⏳ Adding #{emails.count} testers to project #{params[:project_number]}...")
-
-        fad_api_client.add_testers(params[:project_number], emails)
-
-        unless blank?(params[:group_alias])
-          UI.message("⏳ Adding testers to group #{params[:group_alias]}...")
-          fad_api_client.add_testers_to_group(params[:project_number], params[:group_alias], emails)
+        if present?(group_alias)
+          add_testers_to_group(client, project_number, emails, group_alias)
+        else
+          add_testers_to_project(client, emails, project_number)
         end
 
         # The add_testers response lists all the testers from the request
@@ -95,6 +93,51 @@ module Fastlane
       def self.is_supported?(platform)
         true
       end
+
+      def self.add_testers_to_project(client, emails, project_number)
+        UI.message("⏳ Adding #{emails.count} testers to project #{project_number}...")
+        request = Google::Apis::FirebaseappdistributionV1::GoogleFirebaseAppdistroV1BatchAddTestersRequest.new(
+          emails: emails
+        )
+
+        begin
+          client.batch_project_tester_add(project_name(project_number), request)
+        rescue Google::Apis::Error => err
+          case err.status_code.to_i
+          when 400
+            UI.user_error!(ErrorMessage::INVALID_EMAIL_ADDRESS)
+          when 404
+            UI.user_error!(ErrorMessage::INVALID_PROJECT)
+          when 429
+            UI.user_error!(ErrorMessage::TESTER_LIMIT_VIOLATION)
+          else
+            UI.crash!(err)
+          end
+        end
+      end
+
+      def self.add_testers_to_group(client, project_number, emails, group_alias)
+        UI.message("⏳ Adding testers to group #{group_alias}...")
+        request = Google::Apis::FirebaseappdistributionV1::GoogleFirebaseAppdistroV1BatchJoinGroupRequest.new(
+          emails: emails,
+          create_missing_testers: true
+        )
+
+        begin
+          client.batch_project_group_join(group_name(project_number, group_alias), request)
+        rescue Google::Apis::Error => err
+          case err.status_code.to_i
+          when 400
+            UI.user_error!(ErrorMessage::INVALID_EMAIL_ADDRESS)
+          when 404
+            UI.user_error!(ErrorMessage::INVALID_TESTER_GROUP)
+          when 429
+            UI.user_error!(ErrorMessage::TESTER_LIMIT_VIOLATION)
+          else
+            UI.crash!(err)
+          end
+        end
+      end
     end
   end
 end

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

@@ -1,5 +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'
@@ -10,10 +11,9 @@ module Fastlane
       extend Auth::FirebaseAppDistributionAuthClient
       extend Helper::FirebaseAppDistributionHelper
 
-      def self.run(params)
-        auth_token = fetch_auth_token(params[:service_credentials_file], params[:firebase_cli_token])
-        fad_api_client = Client::FirebaseAppDistributionApiClient.new(auth_token, params[:debug])
+      FirebaseAppDistributionV1 = Google::Apis::FirebaseappdistributionV1
 
+      def self.run(params)
         if blank?(params[:alias])
           UI.user_error!("Must specify `alias`.")
         end
@@ -22,13 +22,34 @@ module Fastlane
           UI.user_error!("Must specify `display_name`.")
         end
 
+        client = init_client(params[:service_credentials_file], params[:firebase_cli_token], params[:debug])
+
         project_number = params[:project_number]
         group_alias = params[:alias]
         display_name = params[:display_name]
 
         UI.message("⏳ Creating tester group '#{group_alias} (#{display_name})' in project #{project_number}...")
 
-        fad_api_client.create_group(project_number, group_alias, display_name)
+        parent = project_name(project_number)
+        group = FirebaseAppDistributionV1::GoogleFirebaseAppdistroV1Group.new(
+          name: group_name(project_number, group_alias),
+          display_name: display_name
+        )
+
+        begin
+          client.create_project_group(parent, group, group_id: group_alias)
+        rescue Google::Apis::Error => err
+          case err.status_code.to_i
+          when 400
+            UI.user_error!(ErrorMessage::INVALID_TESTER_GROUP_NAME)
+          when 404
+            UI.user_error!(ErrorMessage::INVALID_PROJECT)
+          when 409
+            UI.important("Tester group #{group_alias} already exists.")
+          else
+            UI.crash!(err)
+          end
+        end
 
         UI.success("✅ Group created successfully.")
       end

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

@@ -11,8 +11,7 @@ module Fastlane
       extend Helper::FirebaseAppDistributionHelper
 
       def self.run(params)
-        auth_token = fetch_auth_token(params[:service_credentials_file], params[:firebase_cli_token])
-        fad_api_client = Client::FirebaseAppDistributionApiClient.new(auth_token, params[:debug])
+        client = init_client(params[:service_credentials_file], params[:firebase_cli_token], params[:debug])
 
         if blank?(params[:alias])
           UI.user_error!("Must specify `alias`.")
@@ -23,7 +22,16 @@ module Fastlane
 
         UI.message("⏳ Deleting tester group '#{group_alias}' in project #{project_number}...")
 
-        fad_api_client.delete_group(project_number, group_alias)
+        begin
+          client.delete_project_group(group_name(project_number, group_alias))
+        rescue Google::Apis::Error => err
+          case err.status_code.to_i
+          when 404
+            UI.user_error!(ErrorMessage::INVALID_TESTER_GROUP)
+          else
+            UI.crash!(err)
+          end
+        end
 
         UI.success("✅ Group deleted successfully.")
       end

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

@@ -1,5 +1,5 @@
 require 'fastlane/action'
-require_relative '../client/firebase_app_distribution_api_client'
+require 'google/apis/firebaseappdistribution_v1'
 require_relative '../helper/firebase_app_distribution_auth_client'
 require_relative '../helper/firebase_app_distribution_helper'
 
@@ -13,23 +13,53 @@ module Fastlane
       extend Helper::FirebaseAppDistributionHelper
 
       def self.run(params)
-        auth_token = fetch_auth_token(params[:service_credentials_file], params[:firebase_cli_token])
-        fad_api_client = Client::FirebaseAppDistributionApiClient.new(auth_token, params[:debug])
+        client = init_client(params[:service_credentials_file], params[:firebase_cli_token], params[:debug])
 
         UI.message("⏳ Fetching latest release for app #{params[:app]}...")
 
-        releases = fad_api_client.list_releases(app_name_from_app_id(params[:app]), 1)[:releases] || []
-        if releases.empty?
+        parent = app_name_from_app_id(params[:app])
+
+        begin
+          releases = client.list_project_app_releases(parent, page_size: 1).releases
+        rescue Google::Apis::Error => err
+          if err.status_code.to_i == 404
+            UI.user_error!("#{ErrorMessage::INVALID_APP_ID}: #{params[:app]}")
+          else
+            UI.crash!(err)
+          end
+        end
+
+        if releases.nil? || releases.empty?
           latest_release = nil
           UI.important("No releases for app #{params[:app]} found in App Distribution. Returning nil and setting Actions.lane_context[SharedValues::FIREBASE_APP_DISTRO_LATEST_RELEASE].")
         else
-          latest_release = releases[0]
+          # latest_release = append_json_style_fields(response.releases[0].to_h)
+          latest_release = map_release_hash(releases[0])
           UI.success("✅ Latest release fetched successfully. Returning release and setting Actions.lane_context[SharedValues::FIREBASE_APP_DISTRO_LATEST_RELEASE].")
         end
         Actions.lane_context[SharedValues::FIREBASE_APP_DISTRO_LATEST_RELEASE] = latest_release
         return latest_release
       end
 
+      def self.map_release_hash(release)
+        {
+          name: release.name,
+          releaseNotes: map_release_notes_hash(release.release_notes),
+          displayVersion: release.display_version,
+          buildVersion: release.build_version,
+          binaryDownloadUri: release.binary_download_uri,
+          firebaseConsoleUri: release.firebase_console_uri,
+          testingUri: release.testing_uri,
+          createTime: release.create_time
+        }
+      end
+
+      def self.map_release_notes_hash(release_notes)
+        return nil if release_notes.nil?
+
+        { text: release_notes.text }
+      end
+
       #####################################################
       # @!group Documentation
       #####################################################
@@ -106,6 +136,9 @@ module Fastlane
           },
           displayVersion: "1.2.3",
           buildVersion: "10",
+          binaryDownloadUri: "<URI>",
+          firebaseConsoleUri: "<URI>",
+          testingUri: "<URI>",
           createTime: "2021-10-06T15:01:23Z"
         }
       end

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

@@ -14,8 +14,8 @@ module Fastlane
       extend Helper::FirebaseAppDistributionHelper
 
       def self.run(params)
-        auth_token = fetch_auth_token(params[:service_credentials_file], params[:firebase_cli_token])
-        fad_api_client = Client::FirebaseAppDistributionApiClient.new(auth_token, params[:debug])
+        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])
 
         app_id = params[:app]
         udids = fad_api_client.get_udids(app_id)

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

@@ -11,14 +11,15 @@ module Fastlane
       extend Helper::FirebaseAppDistributionHelper
 
       def self.run(params)
-        auth_token = fetch_auth_token(params[:service_credentials_file], params[:firebase_cli_token])
-        fad_api_client = Client::FirebaseAppDistributionApiClient.new(auth_token, params[:debug])
+        client = init_client(params[:service_credentials_file], params[:firebase_cli_token], params[:debug])
 
         if blank?(params[:emails]) && blank?(params[:file])
           UI.user_error!("Must specify `emails` or `file`.")
         end
 
         emails = string_to_array(get_value_from_value_or_file(params[:emails], params[:file]))
+        project_number = params[:project_number]
+        group_alias = params[:group_alias]
 
         UI.user_error!("Must pass at least one email") if blank?(emails)
 
@@ -26,14 +27,10 @@ module Fastlane
           UI.user_error!("A maximum of 1000 testers can be removed at a time.")
         end
 
-        if blank?(params[:group_alias])
-          UI.message("⏳ Removing #{emails.count} testers from project #{params[:project_number]}...")
-          count = fad_api_client.remove_testers(params[:project_number], emails)
-          UI.success("✅ #{count} tester(s) removed successfully.")
+        if present?(group_alias)
+          remove_testers_from_group(client, project_number, group_alias, emails)
         else
-          UI.message("⏳ Removing #{emails.count} testers from group #{params[:group_alias]}...")
-          fad_api_client.remove_testers_from_group(params[:project_number], params[:group_alias], emails)
-          UI.success("✅ Tester(s) removed successfully.")
+          remove_testers_from_project(client, project_number, emails)
         end
       end
 
@@ -92,6 +89,48 @@ module Fastlane
       def self.is_supported?(platform)
         true
       end
+
+      def self.remove_testers_from_project(client, project_number, emails)
+        UI.message("⏳ Removing #{emails.count} testers from project #{project_number}...")
+        request = Google::Apis::FirebaseappdistributionV1::GoogleFirebaseAppdistroV1BatchRemoveTestersRequest.new(
+          emails: emails
+        )
+
+        begin
+          response = client.batch_project_tester_remove(project_name(project_number), request)
+        rescue Google::Apis::Error => err
+          case err.status_code.to_i
+          when 404
+            UI.user_error!(ErrorMessage::INVALID_PROJECT)
+          else
+            UI.crash!(err)
+          end
+        end
+
+        UI.success("✅ #{response.emails.count} tester(s) removed successfully.")
+      end
+
+      def self.remove_testers_from_group(client, project_number, group_alias, emails)
+        UI.message("⏳ Removing #{emails.count} testers from group #group_alias}...")
+        request = Google::Apis::FirebaseappdistributionV1::GoogleFirebaseAppdistroV1BatchLeaveGroupRequest.new(
+          emails: emails
+        )
+
+        begin
+          client.batch_project_group_leave(group_name(project_number, group_alias), request)
+        rescue Google::Apis::Error => err
+          case err.status_code.to_i
+          when 400
+            UI.user_error!(ErrorMessage::INVALID_EMAIL_ADDRESS)
+          when 404
+            UI.user_error!(ErrorMessage::INVALID_TESTER_GROUP)
+          else
+            UI.crash!(err)
+          end
+        end
+
+        UI.success("✅ Tester(s) removed successfully.")
+      end
     end
   end
 end