Added configurable upload timeout to firebase_app_distribution_action (#287)

* Added configurable upload timeout to firebase_app_distribution_action
* Bump version to 0.3.8.

Author: spatenotte

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

@@ -15,6 +15,8 @@ class FirebaseAppDistributionAction < Action
       extend Auth::FirebaseAppDistributionAuthClient
       extend Helper::FirebaseAppDistributionHelper
 
+      DEFAULT_UPLOAD_TIMEOUT_SECONDS = 300
+
       def self.run(params)
         params.values # to validate all inputs before looking for the ipa/apk/aab
 
@@ -42,7 +44,9 @@ def self.run(params)
           validate_aab_setup!(aab_info)
         end
 
-        release_name = fad_api_client.upload(app_name, binary_path, platform.to_s)
+        upload_timeout = get_upload_timeout(params)
+
+        release_name = fad_api_client.upload(app_name, binary_path, platform.to_s, upload_timeout)
 
         if binary_type == :AAB && aab_info && !aab_info.certs_provided?
           updated_aab_info = fad_api_client.get_aab_info(app_name)
@@ -135,6 +139,14 @@ def self.get_binary_path(platform, params)
         end
       end
 
+      def self.get_upload_timeout(params)
+        if params[:upload_timeout]
+          return params[:upload_timeout]
+        else
+          return DEFAULT_UPLOAD_TIMEOUT_SECONDS
+        end
+      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
           case aab_info.integration_state
@@ -242,7 +254,12 @@ def self.available_options
           FastlaneCore::ConfigItem.new(key: :service_credentials_file,
                                        description: "Path to Google service account json",
                                        optional: true,
-                                       type: String)
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :upload_timeout,
+                                       description: "The amount of seconds before the upload will timeout, if not completed",
+                                       optional: true,
+                                       default_value: DEFAULT_UPLOAD_TIMEOUT_SECONDS,
+                                       type: Integer)
         ]
       end
 

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

@@ -106,11 +106,12 @@ def get_aab_info(app_name)
       #   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_name, binary_path, platform)
+      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 = 300 # seconds
+          request.options.timeout = timeout # seconds
           request.headers[AUTHORIZATION] = "Bearer " + @auth_token
           request.headers[CONTENT_TYPE] = APPLICATION_OCTET_STREAM
           request.headers[CLIENT_VERSION] = client_version_header_value
@@ -130,16 +131,17 @@ def upload_binary(app_name, binary_path, platform)
       # args
       #   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 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(app_name, binary_path, platform)
+      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)
+        operation_name = upload_binary(app_name, binary_path, platform, timeout)
 
         upload_status_response = get_upload_status(operation_name)
         MAX_POLLING_RETRIES.times do

lib/fastlane/plugin/firebase_app_distribution/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module FirebaseAppDistribution
-    VERSION = "0.3.7"
+    VERSION = "0.3.8"
   end
 end

spec/firebase_app_distribution_api_client_spec.rb

@@ -7,6 +7,7 @@
   let(:fake_binary_contents) { "Hello World" }
   let(:fake_binary) { double("Binary") }
   let(:headers) { { 'Authorization' => 'Bearer auth_token' } }
+  let(:upload_timeout) { 300 }
 
   let(:api_client) { Fastlane::Client::FirebaseAppDistributionApiClient.new("auth_token") }
   let(:stubs) { Faraday::Adapter::Test::Stubs.new }
@@ -105,14 +106,14 @@
           }
         ]
       end
-      api_client.upload_binary(app_name, fake_binary_path, "android")
+      api_client.upload_binary(app_name, fake_binary_path, "android", upload_timeout)
     end
 
     it 'crashes when given an invalid binary_path' do
       expect(File).to receive(:open)
         .with("invalid_binary.apk", "rb")
         .and_raise(Errno::ENOENT.new("file not found"))
-      expect { api_client.upload_binary(app_name, "invalid_binary.apk", "android") }
+      expect { api_client.upload_binary(app_name, "invalid_binary.apk", "android", upload_timeout) }
         .to raise_error("#{ErrorMessage.binary_not_found('APK')}: invalid_binary.apk")
     end
   end
@@ -185,7 +186,7 @@
 
     it 'uploads the app binary then returns the release name' do
       expect(api_client).to receive(:upload_binary)
-        .with(app_name, fake_binary_path, "android")
+        .with(app_name, fake_binary_path, "android", upload_timeout)
         .and_return(operation_name)
         .at_most(:once)
       expect(api_client).to receive(:get_upload_status)
@@ -197,13 +198,13 @@
         .and_return(upload_status_response_success)
         .at_most(:once)
 
-      result = api_client.upload(app_name, fake_binary_path, "android")
+      result = api_client.upload(app_name, fake_binary_path, "android", upload_timeout)
       expect(result).to eq(release_name)
     end
 
     it 'uploads the app binary for an existing unmodified binary' do
       expect(api_client).to receive(:upload_binary)
-        .with(app_name, fake_binary_path, "android")
+        .with(app_name, fake_binary_path, "android", upload_timeout)
         .and_return(operation_name)
         .at_most(:once)
       expect(api_client).to receive(:get_upload_status)
@@ -215,13 +216,13 @@
         .and_return(upload_status_response_release_unmodified)
         .at_most(:once)
 
-      result = api_client.upload(app_name, fake_binary_path, "android")
+      result = api_client.upload(app_name, fake_binary_path, "android", upload_timeout)
       expect(result).to eq(release_name)
     end
 
     it 'uploads the app binary for an existing updated binary' do
       expect(api_client).to receive(:upload_binary)
-        .with(app_name, fake_binary_path, "android")
+        .with(app_name, fake_binary_path, "android", upload_timeout)
         .and_return(operation_name)
         .at_most(:once)
       expect(api_client).to receive(:get_upload_status)
@@ -233,7 +234,7 @@
         .and_return(upload_status_response_release_updated)
         .at_most(:once)
 
-      result = api_client.upload(app_name, fake_binary_path, "android")
+      result = api_client.upload(app_name, fake_binary_path, "android", upload_timeout)
       expect(result).to eq(release_name)
     end
 
@@ -242,15 +243,15 @@
       stub_const("Fastlane::Client::FirebaseAppDistributionApiClient::MAX_POLLING_RETRIES", max_polling_retries)
 
       expect(api_client).to receive(:upload_binary)
-        .with(app_name, fake_binary_path, "android")
+        .with(app_name, fake_binary_path, "android", upload_timeout)
         .and_return(operation_name)
       expect(api_client).to receive(:get_upload_status)
         .with(operation_name)
         .and_return(upload_status_response_in_progress)
         .exactly(max_polling_retries + 1).times # adding 1 for initial call
 
       expect do
-        api_client.upload(app_name, fake_binary_path, "android")
+        api_client.upload(app_name, fake_binary_path, "android", upload_timeout)
       end.to raise_error
     end
 
@@ -259,7 +260,7 @@
       stub_const("Fastlane::Client::FirebaseAppDistributionApiClient::MAX_POLLING_RETRIES", max_polling_retries)
 
       expect(api_client).to receive(:upload_binary)
-        .with(app_name, fake_binary_path, "android")
+        .with(app_name, fake_binary_path, "android", upload_timeout)
         .and_return(operation_name)
         .at_most(:once)
       # return in_progress for a couple polls
@@ -271,33 +272,33 @@
         .with(operation_name)
         .and_return(upload_status_response_success)
 
-      result = api_client.upload(app_name, fake_binary_path, "android")
+      result = api_client.upload(app_name, fake_binary_path, "android", upload_timeout)
       expect(result).to eq(release_name)
     end
 
     it 'crashes after failing to upload with status error' do
       expect(api_client).to receive(:upload_binary)
-        .with(app_name, fake_binary_path, "android")
+        .with(app_name, fake_binary_path, "android", upload_timeout)
         .and_return(operation_name)
       expect(api_client).to receive(:get_upload_status)
         .with(operation_name)
         .and_return(upload_status_response_error)
         .at_most(:once)
 
-      expect { api_client.upload(app_name, fake_binary_path, "android") }
+      expect { api_client.upload(app_name, fake_binary_path, "android", upload_timeout) }
         .to raise_error("#{ErrorMessage.upload_binary_error('APK')}: #{upload_status_response_error.error_message}")
     end
 
     it 'crashes after failing to upload with status unspecified' do
       expect(api_client).to receive(:upload_binary)
-        .with(app_name, fake_binary_path, "android")
+        .with(app_name, fake_binary_path, "android", upload_timeout)
         .and_return(operation_name)
       expect(api_client).to receive(:get_upload_status)
         .with(operation_name)
         .and_return(upload_status_response_status_unspecified)
         .at_most(:once)
 
-      expect { api_client.upload(app_name, fake_binary_path, "android") }
+      expect { api_client.upload(app_name, fake_binary_path, "android", upload_timeout) }
         .to raise_error(ErrorMessage.upload_binary_error("APK"))
     end
   end