[GCSI-567] feat: handle android build app to track build time and build path and + specs

Author: Yousif-Ahmed

lib/fastlane/plugin/instabug_stores_upload/actions/instabug_build_android_app_action.rb

@@ -6,47 +6,67 @@ module Actions
     class InstabugBuildAndroidAppAction < Action
       def self.run(params)
         UI.message("Starting Instabug Android build...")
-        
+
         # Extract Instabug-specific parameters
         branch_name = params.delete(:branch_name)
         instabug_api_key = params.delete(:instabug_api_key)
-        
+
         # Validate required parameters
         if branch_name.nil? || branch_name.empty?
           UI.user_error!("branch_name is required for Instabug reporting")
         end
-        
+
         begin
           # Report build start to Instabug
           Helper::InstabugStoresUploadHelper.report_status(
-            branch_name: branch_name,
+            branch_name:,
             api_key: instabug_api_key,
             status: "inprogress",
             step: "build_app"
           )
 
+          # Start timing the build
+          build_start_time = Time.now
+
           # Execute the actual Android build using gradle
           result = Actions::GradleAction.run(params)
 
+          # Calculate build time in seconds
+          build_time = (Time.now - build_start_time).round
+
+          # Extract Android build path (APK or AAB)
+          build_path = Helper::InstabugStoresUploadHelper.fetch_android_build_path(Actions.lane_context)
+
+          if build_path.nil? || build_path.empty?
+            UI.user_error!("Could not find any generated APK or AAB. Please check your gradle settings.")
+          else
+            UI.success("Successfully found build artifact(s) at: #{build_path}")
+          end
+
           # Report build success to Instabug
           Helper::InstabugStoresUploadHelper.report_status(
-            branch_name: branch_name,
+            branch_name:,
             api_key: instabug_api_key,
             status: "success",
-            step: "build_app"
+            step: "build_app",
+            extras: {
+              build_time:,
+              build_path:
+            }
           )
 
           UI.success("Android build completed successfully!")
           result
-        rescue => e
+        rescue StandardError => e
           UI.error("Android build failed: #{e.message}")
 
           # Report build failure to Instabug
           Helper::InstabugStoresUploadHelper.report_status(
-            branch_name: branch_name,
+            branch_name:,
             api_key: instabug_api_key,
             status: "failure",
-            step: "build_app"
+            step: "build_app",
+            error_message: e.message
           )
           raise e
         end
@@ -71,7 +91,7 @@ def self.details
       def self.available_options
         # Start with the original gradle options
         options = Actions::GradleAction.available_options
-        
+
         # Add Instabug-specific options
         instabug_options = [
           FastlaneCore::ConfigItem.new(
@@ -88,9 +108,17 @@ def self.available_options
             optional: false,
             type: String,
             sensitive: true
-          ) 
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :instabug_api_base_url,
+            env_name: "INSTABUG_API_BASE_URL",
+            description: "Instabug API base URL (defaults to https://api.instabug.com)",
+            optional: true,
+            type: String,
+            skip_type_validation: true # Since we don't extract this param
+          )
         ]
-        
+
         # Combine both sets of options
         options + instabug_options
       end
@@ -121,4 +149,4 @@ def self.category
       end
     end
   end
-end 
+end

lib/fastlane/plugin/instabug_stores_upload/helper/instabug_stores_upload_helper.rb

@@ -8,60 +8,82 @@ module Fastlane
 
   module Helper
     class InstabugStoresUploadHelper
-      # Base URL for Instabug API we will need to adjust it for STs
-      INSTABUG_API_BASE_URL = "https://api.instabug.com".freeze
+      # Default Base URL for Instabug API
+      DEFAULT_INSTABUG_API_BASE_URL = "https://api.instabug.com".freeze
 
       def self.show_message
         UI.message("Hello from the instabug_stores_upload plugin helper!")
       end
 
-      def self.report_status(branch_name:, api_key:, status:, step:)
+      def self.report_status(branch_name:, api_key:, status:, step:, extras: {}, error_message: nil)
         return unless branch_name.start_with?('crash-fix/instabug-crash-')
-        
+
         UI.message("📡 Reporting #{step} status to Instabug for #{branch_name}/#{status}")
-        
+
         make_api_request(
-          branch_name: branch_name,
-          status: status,
-          api_key: api_key,
-          step: step
+          branch_name:,
+          status:,
+          api_key:,
+          step:,
+          extras:,
+          error_message:
         )
       end
 
-      private
+      # This helper method provides a clean and prioritized way to get the Android build output.
+      # It checks for the most common output types in a specific order.
+      # This is used to get the build path for the Android build artifact.
+      def self.fetch_android_build_path(lane_context)
+        all_aab_paths = lane_context[Actions::SharedValues::GRADLE_ALL_AAB_OUTPUT_PATHS]
+        return all_aab_paths if all_aab_paths && !all_aab_paths.empty?
+
+        aab_path = lane_context[Actions::SharedValues::GRADLE_AAB_OUTPUT_PATH]
+        return aab_path if aab_path && !aab_path.empty?
+
+        all_apk_paths = lane_context[Actions::SharedValues::GRADLE_ALL_APK_OUTPUT_PATHS]
+        return all_apk_paths if all_apk_paths && !all_apk_paths.empty?
+
+        apk_path = lane_context[Actions::SharedValues::GRADLE_APK_OUTPUT_PATH]
+        return apk_path if apk_path && !apk_path.empty?
+
+        return nil
+      end
 
-      def self.make_api_request(branch_name:, status:, api_key:, step:)
+      def self.make_api_request(branch_name:, status:, api_key:, step:, extras: {}, error_message: nil)
         return unless api_key
 
-        uri = URI.parse("#{INSTABUG_API_BASE_URL}/api/web/public/agent_fastlane/status") 
-        
+        # Determine API base URL from env var or default
+        base_url = ENV['INSTABUG_API_BASE_URL'] || DEFAULT_INSTABUG_API_BASE_URL
+        uri = URI.parse("#{base_url}/api/web/public/agent_fastlane/status")
+
         payload = {
-          branch_name: branch_name,
-          status: status,
-          step: step
+          branch_name:,
+          status:,
+          step:,
+          extras:,
+          error_message:
         }
-        
+
         begin
           http = Net::HTTP.new(uri.host, uri.port)
           http.use_ssl = true
           http.read_timeout = 30
           http.open_timeout = 30
-          
+
           request = Net::HTTP::Patch.new(uri.path)
           request['Content-Type'] = 'application/json'
           request['Authorization'] = "Bearer #{api_key}"
           request['User-Agent'] = "fastlane-plugin-instabug-stores-upload"
           request.body = payload.to_json
-          
+
           response = http.request(request)
-          
+
           case response.code.to_i
           when 200..299
             UI.success("✅ Successfully reported to Instabug")
           else
             UI.error("❌ Unknown error reporting to Instabug: #{response.code} #{response.message}")
           end
-          
         rescue Net::TimeoutError
           UI.error("❌ Timeout while reporting to Instabug")
         rescue Net::OpenTimeout

spec/instabug_build_android_app_action_spec.rb

@@ -23,7 +23,12 @@
 
   describe '#run' do
     context 'when build succeeds' do
-      it 'reports inprogress, calls build action, and reports success' do
+      it 'reports inprogress, calls build action, and reports success with timing and path' do
+        # Mock the lane context to return a build path
+        allow(Fastlane::Actions).to receive(:lane_context).and_return({
+          Fastlane::Actions::SharedValues::GRADLE_APK_OUTPUT_PATH => '/path/to/app.apk'
+        })
+
         expect(Fastlane::Actions::GradleAction).to receive(:run)
           .with(hash_including(task: 'assembleRelease', project_dir: 'android/'))
           .and_return('build_result')
@@ -36,7 +41,9 @@
             body: {
               branch_name: 'crash-fix/instabug-crash-456',
               status: 'inprogress',
-              step: 'build_app'
+              step: 'build_app',
+              extras: {},
+              error_message: nil
             }.to_json,
             headers: {
               'Content-Type' => 'application/json',
@@ -46,18 +53,26 @@
           ).once
 
         expect(WebMock).to have_requested(:patch, api_endpoint)
-          .with(
-            body: {
-              branch_name: 'crash-fix/instabug-crash-456',
-              status: 'success',
-              step: 'build_app'
-            }.to_json,
-            headers: {
-              'Content-Type' => 'application/json',
-              'Authorization' => 'Bearer test-api-key',
-              'User-Agent' => 'fastlane-plugin-instabug-stores-upload'
-            }
-          ).once
+          .with { |req|
+            body = JSON.parse(req.body)
+            body['status'] == 'success' &&
+              body['branch_name'] == 'crash-fix/instabug-crash-456' &&
+              body['step'] == 'build_app' &&
+              body['extras']['build_path'] == '/path/to/app.apk' &&
+              body['extras']['build_time'].kind_of?(Integer)
+          }.once
+      end
+
+      it 'fails when no build artifact is found' do
+        # Mock empty lane context
+        allow(Fastlane::Actions).to receive(:lane_context).and_return({})
+
+        expect(Fastlane::Actions::GradleAction).to receive(:run)
+          .and_return('build_result')
+
+        expect do
+          described_class.run(valid_params)
+        end.to raise_error(FastlaneCore::Interface::FastlaneError, /Could not find any generated APK or AAB/)
       end
     end
 
@@ -67,16 +82,18 @@
         expect(Fastlane::Actions::GradleAction).to receive(:run)
           .and_raise(error)
 
-        expect {
+        expect do
           described_class.run(valid_params)
-        }.to raise_error(StandardError, 'Build failed')
+        end.to raise_error(StandardError, 'Build failed')
 
         expect(WebMock).to have_requested(:patch, api_endpoint)
           .with(
             body: {
               branch_name: 'crash-fix/instabug-crash-456',
               status: 'failure',
-              step: 'build_app'
+              step: 'build_app',
+              extras: {},
+              error_message: 'Build failed'
             }.to_json
           )
       end
@@ -86,26 +103,31 @@
       it 'raises user error' do
         params = valid_params.merge(branch_name: nil)
 
-        expect {
+        expect do
           described_class.run(params)
-        }.to raise_error(FastlaneCore::Interface::FastlaneError, 'branch_name is required for Instabug reporting')
+        end.to raise_error(FastlaneCore::Interface::FastlaneError, 'branch_name is required for Instabug reporting')
       end
     end
 
     context 'when branch_name is empty' do
       it 'raises user error' do
         params = valid_params.merge(branch_name: '')
 
-        expect {
+        expect do
           described_class.run(params)
-        }.to raise_error(FastlaneCore::Interface::FastlaneError, 'branch_name is required for Instabug reporting')
+        end.to raise_error(FastlaneCore::Interface::FastlaneError, 'branch_name is required for Instabug reporting')
       end
     end
 
     context 'when branch name does not match instabug pattern' do
       it 'does not make API calls but still runs build' do
         params = valid_params.merge(branch_name: 'feature/new-feature')
-        
+
+        # Mock successful build with a valid build path to avoid validation error
+        allow(Fastlane::Actions).to receive(:lane_context).and_return({
+          Fastlane::Actions::SharedValues::GRADLE_APK_OUTPUT_PATH => '/path/to/app.apk'
+        })
+
         expect(Fastlane::Actions::GradleAction).to receive(:run)
           .and_return('build_result')
 
@@ -132,4 +154,4 @@
       expect(described_class.category).to eq(:building)
     end
   end
-end 
+end