fastlane-plugin-firebase_app_distribution 0.2.9 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6396f055da2f0d98f6f8d675cf08af13e80d66a3a0d421cb905f5af075c6544
-  data.tar.gz: 6c81776db0daf3eef997d090cb6d1a51c62a44d69080e7f7efde05523d2e4c2e
+  metadata.gz: cf7cfe204f09a005063f099ef379887cda33351ed6f1dfd1bb84773b1c989a4f
+  data.tar.gz: 3fc3e7c82e6506a670ab6b137ab8a4a55d968ba5f89ff0f20bcb0448ca0d2f76
 SHA512:
-  metadata.gz: 675c0c9c0452e0dad1ad47edb31caa1d374869eb03a414adec8ffc3276b6e959b97016481fcf9fb66f416020f870341436de8a579480de35d30d9906107a93e2
-  data.tar.gz: 9177cc9fefed5010d2e5aa2395fda013235f4621f330a2615e617377028d20da292577b6d38f3a9d9f59c2363669086e03eb6f66ae29f8245b006341721207aa
+  metadata.gz: c25cb0b20720cd286c3665d8496b7c66e90121f34c2802fa7e63e52835a54aff81cc7fe2c91313af45a9e69ded27560b495917da498d0ea13a34712ae323dbbf
+  data.tar.gz: 1b45cb5e6657fac457d9bf34bbe4e5a624a8f912b193eaf58138d964cdb3d793aac0bf5036cd56dd997dee1b25e57ab2d30602a122e2c9f24d7171c8f7b25ccc

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

@@ -19,6 +19,7 @@ module Fastlane
         params.values # to validate all inputs before looking for the ipa/apk/aab
 
         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)
 
         binary_path = get_binary_path(platform, params)
@@ -26,35 +27,39 @@ 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])
+        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])
 
-        # If binary is an AAB get FULL view of app which includes the aab_state
-        app_view = binary_type == :AAB ? 'FULL' : 'BASIC'
-        app = fad_api_client.get_app(app_id, app_view)
-        validate_app!(app, binary_type)
-        release_id = fad_api_client.upload(app.project_number, app_id, binary_path, platform.to_s)
+        # 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)
+          validate_aab_setup!(aab_info)
+        end
+
+        release_name = fad_api_client.upload(app_name, binary_path, platform.to_s)
 
-        if binary_type == :AAB && app.aab_certificate.empty?
-          updated_app = fad_api_client.get_app(app_id)
-          unless updated_app.aab_certificate.empty?
+        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?
             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_app.aab_certificate.md5_certificate_hash}\n" \
-              "SHA-1 certificate fingerprint: #{updated_app.aab_certificate.sha1_certificate_hash}\n" \
-              "SHA-256 certificate fingerprint: #{updated_app.aab_certificate.sha256_certificate_hash}")
+              "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}")
           end
         end
 
-        fad_api_client.post_notes(app_id, release_id, release_notes(params))
+        fad_api_client.update_release_notes(release_name, release_notes(params))
 
         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_ids = string_to_array(groups)
-        fad_api_client.enable_access(app_id, release_id, emails, group_ids)
+        group_aliases = string_to_array(groups)
+        fad_api_client.distribute(release_name, emails, group_aliases)
         UI.success("🎉 App Distribution upload finished successfully.")
       end
 
@@ -84,6 +89,10 @@ module Fastlane
         app_id
       end
 
+      def self.app_name_from_app_id(app_id)
+        "projects/#{app_id.split(':')[1]}/apps/#{app_id}"
+      end
+
       def self.xcode_archive_path
         # prevents issues on cross-platform build environments where an XCode build happens within
         # the same lane
@@ -126,23 +135,19 @@ module Fastlane
         end
       end
 
-      def self.validate_app!(app, binary_type)
-        if app.contact_email.nil? || app.contact_email.strip.empty?
-          UI.user_error!(ErrorMessage::GET_APP_NO_CONTACT_EMAIL_ERROR)
-        end
-
-        if binary_type == :AAB && app.aab_state != App::AabState::ACTIVE && app.aab_state != App::AabState::UNAVAILABLE
-          case app.aab_state
-          when App::AabState::PLAY_ACCOUNT_NOT_LINKED
+      def self.validate_aab_setup!(aab_info)
+        if aab_info && aab_info.integration_state != AabInfo::AabState::INTEGRATED && aab_info.integration_state != AabInfo::AabState::UNAVAILABLE
+          case aab_info.integration_state
+          when AabInfo::AabState::PLAY_ACCOUNT_NOT_LINKED
             UI.user_error!(ErrorMessage::PLAY_ACCOUNT_NOT_LINKED)
-          when App::AabState::APP_NOT_PUBLISHED
+          when AabInfo::AabState::APP_NOT_PUBLISHED
             UI.user_error!(ErrorMessage::APP_NOT_PUBLISHED)
-          when App::AabState::NO_APP_WITH_GIVEN_BUNDLE_ID_IN_PLAY_ACCOUNT
+          when AabInfo::AabState::NO_APP_WITH_GIVEN_BUNDLE_ID_IN_PLAY_ACCOUNT
             UI.user_error!(ErrorMessage::NO_APP_WITH_GIVEN_BUNDLE_ID_IN_PLAY_ACCOUNT)
-          when App::AabState::PLAY_IAS_TERMS_NOT_ACCEPTED
+          when AabInfo::AabState::PLAY_IAS_TERMS_NOT_ACCEPTED
             UI.user_error!(ErrorMessage::PLAY_IAS_TERMS_NOT_ACCEPTED)
           else
-            UI.user_error!(ErrorMessage.aab_upload_error(app.aab_state))
+            UI.user_error!(ErrorMessage.aab_upload_error(aab_info.integration_state))
           end
         end
       end

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

@@ -0,0 +1,90 @@
+require 'fastlane/action'
+require 'fastlane_core/ui/ui'
+
+require_relative '../helper/firebase_app_distribution_helper'
+require_relative '../helper/firebase_app_distribution_auth_client'
+
+module Fastlane
+  module Actions
+    class FirebaseAppDistributionAddTestersAction < Action
+      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])
+
+        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]))
+
+        UI.user_error!("Must pass at least one email") if blank?(emails)
+
+        if emails.count > 1000
+          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)
+
+        # The add_testers response lists all the testers from the request
+        # regardless of whether or not they were created or if they already
+        # exists so can't get an accurate count of the number of newly created testers
+        UI.success("✅ Tester(s) successfully added.")
+      end
+
+      def self.description
+        "Create testers in bulk from a comma-separated list or a file"
+      end
+
+      def self.authors
+        ["Tunde Agboola"]
+      end
+
+      # supports markdown.
+      def self.details
+        "Create testers in bulk from a comma-separated list or a file"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :project_number,
+                                      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: false),
+          FastlaneCore::ConfigItem.new(key: :emails,
+                                      env_name: "FIREBASEAPPDISTRO_ADD_TESTERS_EMAILS",
+                                      description: "Comma separated list of tester emails to be created. A maximum of 1000 testers can be created at a time",
+                                      optional: true,
+                                      type: String),
+          FastlaneCore::ConfigItem.new(key: :file,
+                                      env_name: "FIREBASEAPPDISTRO_ADD_TESTERS_FILE",
+                                      description: "Path to a file containing a comma separated list of tester emails to be created. A maximum of 1000 testers can be deleted at a time",
+                                      optional: true,
+                                      type: String),
+          FastlaneCore::ConfigItem.new(key: :service_credentials_file,
+                                      description: "Path to Google service credentials file",
+                                      optional: true,
+                                      type: String),
+          FastlaneCore::ConfigItem.new(key: :firebase_cli_token,
+                                       description: "Auth token for firebase cli",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :debug,
+                                       description: "Print verbose debug output",
+                                       optional: true,
+                                       default_value: false,
+                                       is_string: false)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+require 'fastlane/action'
+require 'fastlane_core/ui/ui'
+
+require_relative '../helper/firebase_app_distribution_helper'
+require_relative '../helper/firebase_app_distribution_auth_client'
+
+module Fastlane
+  module Actions
+    class FirebaseAppDistributionRemoveTestersAction < Action
+      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])
+
+        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]))
+
+        UI.user_error!("Must pass at least one email") if blank?(emails)
+
+        if emails.count > 1000
+          UI.user_error!("A maximum of 1000 testers can be removed at a time.")
+        end
+
+        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.")
+      end
+
+      def self.description
+        "Delete testers in bulk from a comma-separated list or a file"
+      end
+
+      def self.authors
+        ["Tunde Agboola"]
+      end
+
+      # supports markdown.
+      def self.details
+        "Delete testers in bulk from a comma-separated list or a file"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :project_number,
+                                      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: false),
+          FastlaneCore::ConfigItem.new(key: :emails,
+                                      env_name: "FIREBASEAPPDISTRO_REMOVE_TESTERS_EMAILS",
+                                      description: "Comma separated list of tester emails to be deleted. A maximum of 1000 testers can be deleted at a time",
+                                      optional: true,
+                                      type: String),
+          FastlaneCore::ConfigItem.new(key: :file,
+                                      env_name: "FIREBASEAPPDISTRO_REMOVE_TESTERS_FILE",
+                                      description: "Path to a file containing a comma separated list of tester emails to be deleted. A maximum of 1000 testers can be deleted at a time",
+                                      optional: true,
+                                      type: String),
+          FastlaneCore::ConfigItem.new(key: :service_credentials_file,
+                                      description: "Path to Google service credentials file",
+                                      optional: true,
+                                      type: String),
+          FastlaneCore::ConfigItem.new(key: :firebase_cli_token,
+                                       description: "Auth token for firebase cli",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :debug,
+                                       description: "Print verbose debug output",
+                                       optional: true,
+                                       default_value: false,
+                                       is_string: false)
+
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+class AabInfo
+  # AAB states
+  class AabState
+    UNSPECIFIED = 'AAB_STATE_UNSPECIFIED'
+    PLAY_ACCOUNT_NOT_LINKED = 'PLAY_ACCOUNT_NOT_LINKED'
+    NO_APP_WITH_GIVEN_BUNDLE_ID_IN_PLAY_ACCOUNT = 'NO_APP_WITH_GIVEN_BUNDLE_ID_IN_PLAY_ACCOUNT'
+    APP_NOT_PUBLISHED = 'APP_NOT_PUBLISHED'
+    PLAY_IAS_TERMS_NOT_ACCEPTED = 'PLAY_IAS_TERMS_NOT_ACCEPTED'
+    INTEGRATED = 'INTEGRATED'
+    UNAVAILABLE = 'AAB_STATE_UNAVAILABLE'
+  end
+
+  def initialize(response)
+    @response = response || {}
+  end
+
+  def integration_state
+    @response[:integrationState]
+  end
+
+  def test_certificate
+    @response[:testCertificate] || {}
+  end
+
+  def md5_certificate_hash
+    test_certificate[:hashMd5]
+  end
+
+  def sha1_certificate_hash
+    test_certificate[:hashSha1]
+  end
+
+  def sha256_certificate_hash
+    test_certificate[:hashSha256]
+  end
+
+  def certs_provided?
+    (!md5_certificate_hash.nil? && !md5_certificate_hash.empty?) &&
+      (!sha1_certificate_hash.nil? && !sha1_certificate_hash.empty?) &&
+      (!sha256_certificate_hash.nil? && !sha256_certificate_hash.empty?)
+  end
+end

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

@@ -1,7 +1,7 @@
 require 'fastlane_core/ui/ui'
 require_relative '../actions/firebase_app_distribution_login'
 require_relative '../client/error_response'
-require_relative '../client/app'
+require_relative '../client/aab_info'
 require_relative '../helper/firebase_app_distribution_helper'
 
 module Fastlane
@@ -12,12 +12,13 @@ module Fastlane
       BASE_URL = "https://firebaseappdistribution.googleapis.com"
       TOKEN_CREDENTIAL_URI = "https://oauth2.googleapis.com/token"
       MAX_POLLING_RETRIES = 60
-      POLLING_INTERVAL_SECONDS = 2
+      POLLING_INTERVAL_SECONDS = 5
 
       AUTHORIZATION = "Authorization"
       CONTENT_TYPE = "Content-Type"
       APPLICATION_JSON = "application/json"
       APPLICATION_OCTET_STREAM = "application/octet-stream"
+      CLIENT_VERSION = "X-Client-Version"
 
       def initialize(auth_token, debug = false)
         @auth_token = auth_token
@@ -25,49 +26,52 @@ module Fastlane
       end
 
       # Enables tester access to the specified app release. Skips this
-      # step if no testers are passed in (emails and group_ids are nil/empty).
+      # step if no testers are passed in (emails and group_aliases are nil/empty).
       #
       # args
-      #   app_id - Firebase App ID
-      #   release_id - App release ID, returned by upload_status endpoint
+      #   release_name - App release resource name, returned by upload_status endpoint
       #   emails - String array of app testers' email addresses
-      #   group_ids - String array of Firebase tester group IDs
+      #   group_aliases - String array of Firebase tester group aliases
       #
-      # Throws a user_error if emails or group_ids are invalid
-      def enable_access(app_id, release_id, emails, group_ids)
-        if (emails.nil? || emails.empty?) && (group_ids.nil? || group_ids.empty?)
+      # Throws a user_error if emails or group_aliases are invalid
+      def distribute(release_name, emails, group_aliases)
+        if (emails.nil? || emails.empty?) && (group_aliases.nil? || group_aliases.empty?)
           UI.success("✅ No testers passed in. Skipping this step.")
           return
         end
-        payload = { emails: emails, groupIds: group_ids }
+        payload = { testerEmails: emails, groupAliases: group_aliases }
         begin
-          connection.post(enable_access_url(app_id, release_id), payload.to_json) do |request|
+          connection.post(distribute_url(release_name), payload.to_json) do |request|
             request.headers[AUTHORIZATION] = "Bearer " + @auth_token
             request.headers[CONTENT_TYPE] = APPLICATION_JSON
           end
         rescue Faraday::ClientError
-          UI.user_error!("#{ErrorMessage::INVALID_TESTERS} \nEmails: #{emails} \nGroups: #{group_ids}")
+          UI.user_error!("#{ErrorMessage::INVALID_TESTERS} \nEmails: #{emails} \nGroups: #{group_aliases}")
         end
         UI.success("✅ Added testers/groups.")
       end
 
-      # Posts notes for the specified app release. Skips this
+      # Update release notes for the specified app release. Skips this
       # step if no notes are passed in (release_notes is nil/empty).
       #
       # args
-      #   app_id - Firebase App ID
-      #   release_id - App release ID, returned by upload_status endpoint
+      #   release_name - App release resource name, returned by upload_status endpoint
       #   release_notes - String of notes for this release
       #
       # Throws a user_error if the release_notes are invalid
-      def post_notes(app_id, release_id, release_notes)
-        payload = { releaseNotes: { releaseNotes: release_notes } }
+      def update_release_notes(release_name, release_notes)
         if release_notes.nil? || release_notes.empty?
           UI.success("✅ No release notes passed in. Skipping this step.")
           return
         end
         begin
-          connection.post(release_notes_create_url(app_id, release_id), payload.to_json) do |request|
+          payload = {
+            name: release_name,
+            releaseNotes: {
+              text: release_notes
+            }
+          }
+          connection.patch(update_release_notes_url(release_name), payload.to_json) do |request|
             request.headers[AUTHORIZATION] = "Bearer " + @auth_token
             request.headers[CONTENT_TYPE] = APPLICATION_JSON
           end
@@ -78,42 +82,42 @@ module Fastlane
         UI.success("✅ Posted release notes.")
       end
 
-      # Get app
+      # Get AAB info (Android apps only)
       #
       # args
-      #   app_id - Firebase App ID
+      #   app_name - Firebase App resource name
       #
       # Throws a user_error if the app hasn't been onboarded to App Distribution
-      def get_app(app_id, app_view = 'BASIC')
+      def get_aab_info(app_name)
         begin
-          response = connection.get("#{v1_apps_url(app_id)}?appView=#{app_view}") do |request|
+          response = connection.get(aab_info_url(app_name)) do |request|
             request.headers[AUTHORIZATION] = "Bearer " + @auth_token
           end
         rescue Faraday::ResourceNotFound
-          UI.user_error!("#{ErrorMessage::INVALID_APP_ID}: #{app_id}")
+          UI.user_error!("#{ErrorMessage::INVALID_APP_ID}: #{app_name}")
         end
 
-        App.new(response.body)
+        AabInfo.new(response.body)
       end
 
       # Uploads the app binary to the Firebase API
       #
       # args
-      #   app_id - Firebase App ID
+      #   app_name - Firebase App resource name
       #   binary_path - Absolute path to your app's aab/apk/ipa file
       #   platform - 'android' or 'ios'
       #
       # Throws a user_error if the binary file does not exist
-      def upload_binary(app_id, binary_path, platform)
-        connection.post(binary_upload_url(app_id), read_binary(binary_path)) do |request|
+      def upload_binary(app_name, binary_path, platform)
+        response = connection.post(binary_upload_url(app_name), read_binary(binary_path)) do |request|
           request.headers[AUTHORIZATION] = "Bearer " + @auth_token
           request.headers[CONTENT_TYPE] = APPLICATION_OCTET_STREAM
-          request.headers["X-APP-DISTRO-API-CLIENT-ID"] = "fastlane"
-          request.headers["X-APP-DISTRO-API-CLIENT-TYPE"] =  platform
-          request.headers["X-APP-DISTRO-API-CLIENT-VERSION"] = Fastlane::FirebaseAppDistribution::VERSION
-          request.headers["X-GOOG-UPLOAD-FILE-NAME"] = File.basename(binary_path)
-          request.headers["X-GOOG-UPLOAD-PROTOCOL"] = "raw"
+          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}")
@@ -123,66 +127,67 @@ module Fastlane
       # Takes at least POLLING_INTERVAL_SECONDS between polling get_upload_status
       #
       # args
-      #   project_number - Firebase project number
-      #   app_id - Firebase app ID
+      #   app_name - Firebase App resource name
       #   binary_path - Absolute path to your app's aab/apk/ipa file
       #
-      # Returns the release_id of the uploaded release.
+      # Returns the release_name of the uploaded release.
       #
       # Crashes if the number of polling retries exceeds MAX_POLLING_RETRIES or if the binary cannot
       # be uploaded.
-      def upload(project_number, app_id, binary_path, platform)
+      def upload(app_name, binary_path, platform)
         binary_type = binary_type_from_path(binary_path)
 
-        upload_token = get_upload_token(project_number, app_id, binary_path)
-        upload_status_response = get_upload_status(app_id, upload_token)
-        if upload_status_response.success? || upload_status_response.already_uploaded?
-          UI.success("✅ This #{binary_type} has been uploaded before. Skipping upload step.")
-        else
-          unless upload_status_response.in_progress?
-            UI.message("⌛ Uploading the #{binary_type}.")
-            upload_binary(app_id, binary_path, platform)
-          end
-          MAX_POLLING_RETRIES.times do
-            upload_status_response = get_upload_status(app_id, upload_token)
-            if upload_status_response.success? || upload_status_response.already_uploaded?
-              UI.success("✅ Uploaded the #{binary_type}.")
+        UI.message("⌛ Uploading the #{binary_type}.")
+        operation_name = upload_binary(app_name, binary_path, platform)
+
+        upload_status_response = get_upload_status(operation_name)
+        MAX_POLLING_RETRIES.times do
+          if upload_status_response.success?
+            if upload_status_response.release_updated?
+              UI.success("✅ Uploaded #{binary_type} successfully; updated provisioning profile of existing release #{upload_status_response.release_version}.")
+              break
+            elsif upload_status_response.release_unmodified?
+              UI.success("✅ The same #{binary_type} was found in release #{upload_status_response.release_version} with no changes, skipping.")
               break
-            elsif upload_status_response.in_progress?
-              sleep(POLLING_INTERVAL_SECONDS)
             else
-              if !upload_status_response.message.nil?
-                UI.user_error!("#{ErrorMessage.upload_binary_error(binary_type)}: #{upload_status_response.message}")
-              else
-                UI.user_error!(ErrorMessage.upload_binary_error(binary_type))
-              end
+              UI.success("✅ Uploaded #{binary_type} successfully and created release #{upload_status_response.release_version}.")
+            end
+            break
+          elsif upload_status_response.in_progress?
+            sleep(POLLING_INTERVAL_SECONDS)
+            upload_status_response = get_upload_status(operation_name)
+          else
+            if !upload_status_response.error_message.nil?
+              UI.user_error!("#{ErrorMessage.upload_binary_error(binary_type)}: #{upload_status_response.error_message}")
+            else
+              UI.user_error!(ErrorMessage.upload_binary_error(binary_type))
             end
-          end
-          unless upload_status_response.success?
-            UI.crash!("It took longer than expected to process your #{binary_type}, please try again.")
           end
         end
-        upload_status_response.release_id
+        unless upload_status_response.success?
+          UI.crash!("It took longer than expected to process your #{binary_type}, please try again.")
+        end
+
+        upload_status_response.release_name
       end
 
       # Fetches the status of an uploaded binary
       #
       # args
-      #   app_id - Firebase App ID
-      #   upload_token - URL encoded upload token
+      #   operation_name - Upload operation name (with binary hash)
       #
-      # Returns the release ID on a successful release, otherwise returns nil.
-      def get_upload_status(app_id, upload_token)
-        response = connection.get(upload_status_url(app_id, upload_token)) do |request|
+      # Returns the `done` status, as well as a release, error, or nil
+      def get_upload_status(operation_name)
+        response = connection.get(upload_status_url(operation_name)) do |request|
           request.headers[AUTHORIZATION] = "Bearer " + @auth_token
         end
-        return UploadStatusResponse.new(response.body)
+        UploadStatusResponse.new(response.body)
       end
 
       # Get tester UDIDs
       #
       # args
-      #   app_id - Firebase App ID
+      #   app_name - Firebase App resource name
       #
       # Returns a list of hashes containing tester device info
       def get_udids(app_id)
@@ -196,35 +201,96 @@ module Fastlane
         response.body[:testerUdids] || []
       end
 
+      # Create testers
+      #
+      # args
+      #   project_number - Firebase project number
+      #   emails - An array of emails to be created as testers. A maximum of
+      #            1000 testers can be created at a time.
+      #
+      def add_testers(project_number, emails)
+        payload = { emails: emails }
+        connection.post(add_testers_url(project_number), payload.to_json) do |request|
+          request.headers[AUTHORIZATION] = "Bearer " + @auth_token
+          request.headers[CONTENT_TYPE] = APPLICATION_JSON
+          request.headers[CLIENT_VERSION] = client_version_header_value
+        end
+      rescue Faraday::BadRequestError
+        UI.user_error!(ErrorMessage::INVALID_EMAIL_ADDRESS)
+      rescue Faraday::ResourceNotFound
+        UI.user_error!(ErrorMessage::INVALID_PROJECT)
+      rescue Faraday::ClientError => e
+        if e.response_status == 429
+          UI.user_error!(ErrorMessage::TESTER_LIMIT_VIOLATION)
+        else
+          raise e
+        end
+      end
+
+      # Delete testers
+      #
+      # args
+      #   project_number - Firebase project number
+      #   emails - An array of emails to be deleted as testers. A maximum of
+      #            1000 testers can be deleted at a time.
+      #
+      # Returns the number of testers that were deleted
+      def remove_testers(project_number, emails)
+        payload = { emails: emails }
+        response = connection.post(remove_testers_url(project_number), payload.to_json) do |request|
+          request.headers[AUTHORIZATION] = "Bearer " + @auth_token
+          request.headers[CONTENT_TYPE] = APPLICATION_JSON
+          request.headers[CLIENT_VERSION] = client_version_header_value
+        end
+        response.body[:emails] ? response.body[:emails].count : 0
+      rescue Faraday::ResourceNotFound
+        UI.user_error!(ErrorMessage::INVALID_PROJECT)
+      end
+
       private
 
-      def v1_apps_url(app_id)
+      def client_version_header_value
+        "fastlane/#{Fastlane::FirebaseAppDistribution::VERSION}"
+      end
+
+      def v1alpha_apps_url(app_id)
         "/v1alpha/apps/#{app_id}"
       end
 
-      def release_notes_create_url(app_id, release_id)
-        "#{v1_apps_url(app_id)}/releases/#{release_id}/notes"
+      def v1_apps_url(app_name)
+        "/v1/#{app_name}"
+      end
+
+      def aab_info_url(app_name)
+        "#{v1_apps_url(app_name)}/aabInfo"
       end
 
-      def enable_access_url(app_id, release_id)
-        "#{v1_apps_url(app_id)}/releases/#{release_id}/enable_access"
+      def update_release_notes_url(release_name)
+        "/v1/#{release_name}?updateMask=release_notes.text"
       end
 
-      def binary_upload_url(app_id)
-        "/app-binary-uploads?app_id=#{app_id}"
+      def distribute_url(release_name)
+        "/v1/#{release_name}:distribute"
       end
 
-      def upload_status_url(app_id, app_token)
-        "#{v1_apps_url(app_id)}/upload_status/#{app_token}"
+      def binary_upload_url(app_name)
+        "/upload#{v1_apps_url(app_name)}/releases:upload"
+      end
+
+      def upload_status_url(operation_name)
+        "/v1/#{operation_name}"
       end
 
       def get_udids_url(app_id)
-        "#{v1_apps_url(app_id)}/testers:getTesterUdids"
+        "#{v1alpha_apps_url(app_id)}/testers:getTesterUdids"
+      end
+
+      def add_testers_url(project_number)
+        "/v1/projects/#{project_number}/testers:batchAdd"
       end
 
-      def get_upload_token(project_number, app_id, binary_path)
-        binary_hash = Digest::SHA256.hexdigest(read_binary(binary_path))
-        CGI.escape("projects/#{project_number}/apps/#{app_id}/releases/-/binaries/#{binary_hash}")
+      def remove_testers_url(project_number)
+        "/v1/projects/#{project_number}/testers:batchRemove"
       end
 
       def connection

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

@@ -13,28 +13,29 @@ module Fastlane
       #   google_service_path - Absolute path to the Google service account file
       #   firebase_cli_token - Firebase CLI refresh token from login action or
       #                        CI environment
+      #   debug - Whether to enable debug-level logging
       #
       # env variables
       #   GOOGLE_APPLICATION_CREDENTIALS - see google_service_path
       #   FIREBASE_TOKEN - see firebase_cli_token
       #
       # Crashes if given invalid or missing credentials
-      def fetch_auth_token(google_service_path, firebase_cli_token)
+      def fetch_auth_token(google_service_path, firebase_cli_token, debug = false)
         if !google_service_path.nil? && !google_service_path.empty?
           UI.message("Authenticating with --service_credentials_file path parameter: #{google_service_path}")
-          token = service_account(google_service_path)
+          token = service_account(google_service_path, debug)
         elsif !firebase_cli_token.nil? && !firebase_cli_token.empty?
           UI.message("Authenticating with --firebase_cli_token parameter")
-          token = firebase_token(firebase_cli_token)
+          token = firebase_token(firebase_cli_token, debug)
         elsif !ENV["FIREBASE_TOKEN"].nil? && !ENV["FIREBASE_TOKEN"].empty?
           UI.message("Authenticating with FIREBASE_TOKEN environment variable")
-          token = firebase_token(ENV["FIREBASE_TOKEN"])
+          token = firebase_token(ENV["FIREBASE_TOKEN"], debug)
         elsif !ENV["GOOGLE_APPLICATION_CREDENTIALS"].nil? && !ENV["GOOGLE_APPLICATION_CREDENTIALS"].empty?
           UI.message("Authenticating with GOOGLE_APPLICATION_CREDENTIALS environment variable: #{ENV['GOOGLE_APPLICATION_CREDENTIALS']}")
-          token = service_account(ENV["GOOGLE_APPLICATION_CREDENTIALS"])
+          token = service_account(ENV["GOOGLE_APPLICATION_CREDENTIALS"], debug)
         elsif (refresh_token = refresh_token_from_firebase_tools)
           UI.message("No authentication method specified. Using cached Firebase CLI credentials.")
-          token = firebase_token(refresh_token)
+          token = firebase_token(refresh_token, debug)
         else
           UI.user_error!(ErrorMessage::MISSING_CREDENTIALS)
         end
@@ -62,7 +63,7 @@ module Fastlane
         end
       end
 
-      def firebase_token(refresh_token)
+      def firebase_token(refresh_token, debug)
         client = Signet::OAuth2::Client.new(
           token_credential_uri: TOKEN_CREDENTIAL_URI,
           client_id: Fastlane::Actions::FirebaseAppDistributionLoginAction::CLIENT_ID,
@@ -71,11 +72,12 @@ module Fastlane
         )
         client.fetch_access_token!
         client.access_token
-      rescue Signet::AuthorizationError
+      rescue Signet::AuthorizationError => error
+        log_authorization_error_details(error) if debug
         UI.user_error!(ErrorMessage::REFRESH_TOKEN_ERROR)
       end
 
-      def service_account(google_service_path)
+      def service_account(google_service_path, debug)
         service_account_credentials = Google::Auth::ServiceAccountCredentials.make_creds(
           json_key_io: File.open(google_service_path),
           scope: Fastlane::Actions::FirebaseAppDistributionLoginAction::SCOPE
@@ -83,9 +85,16 @@ module Fastlane
         service_account_credentials.fetch_access_token!["access_token"]
       rescue Errno::ENOENT
         UI.user_error!("#{ErrorMessage::SERVICE_CREDENTIALS_NOT_FOUND}: #{google_service_path}")
-      rescue Signet::AuthorizationError
+      rescue Signet::AuthorizationError => error
+        log_authorization_error_details(error) if debug
         UI.user_error!("#{ErrorMessage::SERVICE_CREDENTIALS_ERROR}: #{google_service_path}")
       end
+
+      def log_authorization_error_details(error)
+        UI.error("Error fetching access token:")
+        UI.error(error.message)
+        UI.error("Response status: #{error.response.status}")
+      end
     end
   end
 end

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

@@ -7,19 +7,19 @@ module ErrorMessage
   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."
-  GET_APP_ERROR = "App Distribution failed to fetch app information"
   APP_NOT_ONBOARDED_ERROR = "App Distribution not onboarded"
-  GET_APP_NO_CONTACT_EMAIL_ERROR = "App Distribution could not find a contact email associated with this app. Contact Email"
   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 groups exist and the tester emails are formatted correctly"
-  INVALID_RELEASE_ID = "App distribution failed to fetch release with id"
   INVALID_RELEASE_NOTES = "Failed to add release notes"
   SERVICE_CREDENTIALS_ERROR = "App Distribution could not generate credentials from the service credentials file specified. Service Account Path"
   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"
 
   def self.aab_upload_error(aab_state)
     "Failed to process the AAB: #{aab_state}"

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

@@ -44,6 +44,15 @@ module Fastlane
         UI.shell_error!("can't extract GOOGLE_APP_ID") if identifier.empty?
         return identifier
       end
+
+      def blank?(value)
+        # Taken from https://apidock.com/rails/Object/blank%3F
+        value.respond_to?(:empty?) ? value.empty? : !value
+      end
+
+      def present?(value)
+        !blank?(value)
+      end
     end
   end
 end

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

@@ -3,35 +3,63 @@ class UploadStatusResponse
     @response_json_hash = response_json_hash
   end
 
+  def done
+    !!@response_json_hash[:done]
+  end
+
+  def response
+    @response_json_hash[:response]
+  end
+
+  def release
+    response ? response[:release] : nil
+  end
+
+  def release_name
+    release ? release[:name] : nil
+  end
+
+  def release_version
+    if release
+      if release[:displayVersion] && release[:buildVersion]
+        "#{release[:displayVersion]} (#{release[:buildVersion]})"
+      elsif release[:displayVersion]
+        release[:displayVersion]
+      else
+        release[:buildVersion]
+      end
+    end
+  end
+
   def status
-    @response_json_hash[:status]
+    response ? response[:result] : nil
   end
 
-  def success?
-    status == 'SUCCESS'
+  def error
+    @response_json_hash[:error]
   end
 
-  def in_progress?
-    status == 'IN_PROGRESS'
+  def error_message
+    error ? error[:message] : nil
   end
 
-  def error?
-    status == 'ERROR'
+  def success?
+    done && !!release
   end
 
-  def already_uploaded?
-    status == 'ALREADY_UPLOADED'
+  def in_progress?
+    !done
   end
 
-  def release_hash
-    @response_json_hash[:release]
+  def error?
+    done && message
   end
 
-  def release_id
-    release_hash ? release_hash[:id] : nil
+  def release_updated?
+    done && status == 'RELEASE_UPDATED'
   end
 
-  def message
-    @response_json_hash[:message]
+  def release_unmodified?
+    done && status == 'RELEASE_UNMODIFIED'
   end
 end

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

@@ -1,5 +1,5 @@
 module Fastlane
   module FirebaseAppDistribution
-    VERSION = "0.2.9"
+    VERSION = "0.3.1"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-firebase_app_distribution
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.3.1
 platform: ruby
 authors:
 - Stefan Natchev
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-14 00:00:00.000000000 Z
+date: 2021-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -151,10 +151,11 @@ files:
 - README.md
 - lib/fastlane/plugin/firebase_app_distribution.rb
 - lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_action.rb
+- lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_add_testers_action.rb
 - lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_get_udids.rb
 - lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_login.rb
-- lib/fastlane/plugin/firebase_app_distribution/client/aab_certificate.rb
-- lib/fastlane/plugin/firebase_app_distribution/client/app.rb
+- lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_remove_testers_action.rb
+- lib/fastlane/plugin/firebase_app_distribution/client/aab_info.rb
 - lib/fastlane/plugin/firebase_app_distribution/client/error_response.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

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

@@ -1,23 +0,0 @@
-class AabCertificate
-  def initialize(response)
-    @response = response || {}
-  end
-
-  def md5_certificate_hash
-    @response[:certificateHashMd5]
-  end
-
-  def sha1_certificate_hash
-    @response[:certificateHashSha1]
-  end
-
-  def sha256_certificate_hash
-    @response[:certificateHashSha256]
-  end
-
-  def empty?
-    (md5_certificate_hash.nil? || md5_certificate_hash.empty?) &&
-      (sha1_certificate_hash.nil? || sha1_certificate_hash.empty?) &&
-      (sha256_certificate_hash.nil? || sha256_certificate_hash.empty?)
-  end
-end

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

@@ -1,37 +0,0 @@
-require_relative 'aab_certificate'
-
-class App
-  # AAB states
-  class AabState
-    UNSPECIFIED = "AAB_STATE_UNSPECIFIED"
-    PLAY_ACCOUNT_NOT_LINKED = "PLAY_ACCOUNT_NOT_LINKED"
-    NO_APP_WITH_GIVEN_BUNDLE_ID_IN_PLAY_ACCOUNT = "NO_APP_WITH_GIVEN_BUNDLE_ID_IN_PLAY_ACCOUNT"
-    APP_NOT_PUBLISHED = "APP_NOT_PUBLISHED"
-    PLAY_IAS_TERMS_NOT_ACCEPTED = "PLAY_IAS_TERMS_NOT_ACCEPTED"
-    ACTIVE = "ACTIVE"
-    UNAVAILABLE = "AAB_STATE_UNAVAILABLE"
-  end
-
-  attr_reader :aab_certificate
-
-  def initialize(response)
-    @response = response
-    @aab_certificate = AabCertificate.new(response[:aabCertificate])
-  end
-
-  def app_id
-    @response[:appId]
-  end
-
-  def project_number
-    @response[:projectNumber]
-  end
-
-  def contact_email
-    @response[:contactEmail]
-  end
-
-  def aab_state
-    @response[:aabState]
-  end
-end