fastlane-plugin-firebase_app_distribution 0.2.5 → 0.5.0

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 generated using the Firebase CLI's login:ci command",
+                                       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,218 +1,325 @@
 require 'fastlane_core/ui/ui'
-require_relative '../actions/firebase_app_distribution_login'
 require_relative '../client/error_response'
+require_relative '../client/aab_info'
+require_relative '../helper/firebase_app_distribution_helper'
 
 module Fastlane
   module Client
     class FirebaseAppDistributionApiClient
+      include Helper::FirebaseAppDistributionHelper
+
       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, platform, debug = false)
+      def initialize(auth_token, debug = false)
         @auth_token = auth_token
         @debug = debug
-
-        if platform.nil?
-          @binary_type = "IPA/APK"
-        elsif platform == :ios
-          @binary_type = "IPA"
-        else
-          @binary_type = "APK"
-        end
       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
+            request.headers[CLIENT_VERSION] = client_version_header_value
           end
         rescue Faraday::ClientError
-          UI.user_error!("#{ErrorMessage::INVALID_TESTERS} \nEmails: #{emails} \nGroups: #{group_ids}")
+          UI.user_error!("#{ErrorMessage::INVALID_TESTERS} \nEmails: #{emails} \nGroup Aliases: #{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
       #
+      # Returns a hash of the 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 } }
-        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|
-            request.headers[AUTHORIZATION] = "Bearer " + @auth_token
-            request.headers[CONTENT_TYPE] = APPLICATION_JSON
-          end
-        rescue Faraday::ClientError => e
-          error = ErrorResponse.new(e.response)
-          UI.user_error!("#{ErrorMessage::INVALID_RELEASE_NOTES}: #{error.message}")
+      def update_release_notes(release_name, release_notes)
+        payload = {
+          name: release_name,
+          releaseNotes: {
+            text: release_notes
+          }
+        }
+        response = 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
+          request.headers[CLIENT_VERSION] = client_version_header_value
         end
         UI.success("✅ Posted release notes.")
+        response.body
+      rescue Faraday::ClientError => e
+        error = ErrorResponse.new(e.response)
+        UI.user_error!("#{ErrorMessage::INVALID_RELEASE_NOTES}: #{error.message}")
       end
 
-      # Returns the url encoded upload token used for get_upload_status calls:
-      # projects/<project-number>/apps/<app-id>/releases/-/binaries/<binary-hash>
+      # Get AAB info (Android apps only)
       #
       # args
-      #   app_id - Firebase App ID
-      #   binary_path - Absolute path to your app's apk/ipa file
-      #
-      # Throws a user_error if an invalid app id is passed in, the binary file does
-      # not exist, or invalid auth credentials are used (e.g. wrong project permissions)
-      def get_upload_token(app_id, binary_path)
-        if binary_path.nil? || !File.exist?(binary_path)
-          UI.crash!("#{ErrorMessage.binary_not_found(@binary_type)}: #{binary_path}")
-        end
-        binary_hash = Digest::SHA256.hexdigest(read_binary(binary_path))
-
+      #   app_name - Firebase App resource name
+      #
+      # Throws a user_error if the app hasn't been onboarded to App Distribution
+      def get_aab_info(app_name)
         begin
-          response = connection.get(v1_apps_url(app_id)) do |request|
+          response = connection.get(aab_info_url(app_name)) 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}")
+          UI.user_error!("#{ErrorMessage::INVALID_APP_ID}: #{app_name}")
         end
-        contact_email = response.body[:contactEmail]
-        if contact_email.nil? || contact_email.strip.empty?
-          UI.user_error!(ErrorMessage::GET_APP_NO_CONTACT_EMAIL_ERROR)
-        end
-        return upload_token_format(response.body[:appId], response.body[:projectNumber], binary_hash)
+
+        AabInfo.new(response.body)
       end
 
       # Uploads the app binary to the Firebase API
       #
       # args
-      #   app_id - Firebase App ID
-      #   binary_path - Absolute path to your app's apk/ipa file
+      #   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
       #
       # 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, 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["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[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
-        UI.user_error!("#{ErrorMessage.binary_not_found(@binary_type)}: #{binary_path}")
+        binary_type = binary_type_from_path(binary_path)
+        UI.user_error!("#{ErrorMessage.binary_not_found(binary_type)}: #{binary_path}")
       end
 
       # Uploads the binary file if it has not already been uploaded
       # Takes at least POLLING_INTERVAL_SECONDS between polling get_upload_status
       #
       # args
-      #   app_id - Firebase App ID
-      #   binary_path - Absolute path to your app's apk/ipa file
-      #
-      # Returns the release_id on a successful release, otherwise returns nil.
-      #
-      # Throws a UI error if the number of polling retries exceeds MAX_POLLING_RETRIES
-      # Crashes if not able to upload the binary
-      def upload(app_id, binary_path, platform)
-        upload_token = get_upload_token(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}.")
+      #   app_name - Firebase App resource name
+      #   binary_path - Absolute path to your app's aab/apk/ipa file
+      #   timeout - The amount of seconds before the upload will timeout, if not completed
+      #
+      # Returns a `UploadStatusResponse` with the upload is complete.
+      #
+      # Crashes if the number of polling retries exceeds MAX_POLLING_RETRIES or if the binary cannot
+      # be uploaded.
+      def upload(app_name, binary_path, platform, timeout)
+        binary_type = binary_type_from_path(binary_path)
+
+        UI.message("⌛ Uploading the #{binary_type}.")
+        operation_name = upload_binary(app_name, binary_path, platform, timeout)
+
+        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.error("It took longer than expected to process your #{@binary_type}, please try again.")
-            return nil
           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
       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
+          request.headers[CLIENT_VERSION] = client_version_header_value
         end
-        return UploadStatusResponse.new(response.body)
+        UploadStatusResponse.new(response.body)
+      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
+
+      # 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
+
+      # List releases
+      #
+      # args
+      #   app_name - Firebase App resource name
+      #   page_size - The number of releases to return in the page
+      #   page_token - A page token, received from a previous call
+      #
+      # Returns the response body. Throws a user_error if the app hasn't been onboarded to App Distribution.
+      def list_releases(app_name, page_size = 100, page_token = nil)
+        begin
+          response = connection.get(list_releases_url(app_name), { pageSize: page_size.to_s, pageToken: page_token }) 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_name}")
+        end
+
+        return response.body
       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 update_release_notes_url(release_name)
+        "/v1/#{release_name}?updateMask=release_notes.text"
+      end
+
+      def distribute_url(release_name)
+        "/v1/#{release_name}:distribute"
+      end
+
+      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 enable_access_url(app_id, release_id)
-        "#{v1_apps_url(app_id)}/releases/#{release_id}/enable_access"
+      def list_releases_url(app_name)
+        "#{v1_apps_url(app_name)}/releases"
       end
 
-      def binary_upload_url(app_id)
-        "/app-binary-uploads?app_id=#{app_id}"
+      def get_udids_url(app_id)
+        "#{v1alpha_apps_url(app_id)}/testers:getTesterUdids"
       end
 
-      def upload_status_url(app_id, app_token)
-        "#{v1_apps_url(app_id)}/upload_status/#{app_token}"
+      def add_testers_url(project_number)
+        "/v1/projects/#{project_number}/testers:batchAdd"
       end
 
-      def upload_token_format(app_id, project_number, binary_hash)
-        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