Move log file parsing out of the FirebaseHelper

The Firebase Helper had a lot of pieces doing a variety of things – splitting this into model objects makes it easier to change and test.

Author: jkmassel

lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_firebase_test.rb

@@ -2,23 +2,20 @@
 
 module Fastlane
   module Actions
-    require_relative '../../helper/android/android_firebase_helper'
-
     module SharedValues
-      FIREBASE_PROJECT_ID = :FIREBASE_PROJECT_ID
-      FIREBASE_CREDENTIALS = :FIREBASE_CREDENTIALS
       FIREBASE_TEST_RESULT = :FIREBASE_TEST_ACTION_RESULT
+      FIREBASE_TEST_LOG_FILE = :FIREBASE_TEST_LOG_FILE
       FIREBASE_TEST_LOG_FILE_PATH = :FIREBASE_TEST_LOG_FILE_PATH
       FIREBASE_TEST_RESULTS_FILE_PATH = :FIREBASE_TEST_LOG_FILE_PATH
     end
 
     class AndroidFirebaseTestAction < Action
       def self.run(params)
         # Preflight – ensure the system is set up correctly
-        Fastlane::Helper::Android::FirebaseHelper.verify_has_gcloud_binary
+        Fastlane::FirebaseTestRunner.verify_has_gcloud_binary
 
         # Log in to Firebase (and validate credentials)
-        Fastlane::Helper::Android::FirebaseHelper.setup(key_file: params[:key_file])
+        test_runner = Fastlane::FirebaseTestRunner.new(key_file: params[:key_file])
 
         # Set up the log file and output directory
         Fastlane::Actions.lane_context[:FIREBASE_TEST_RESULTS_FILE_PATH] = params[:results_output_dir]
@@ -31,23 +28,23 @@ def self.run(params)
           orientation: params[:orientation]
         )
 
-        result = Fastlane::Helper::Android::FirebaseHelper.run_tests(
+        result = test_runner.run_tests(
           apk_path: params[:apk_path],
           test_apk_path: params[:test_apk_path],
           device: device,
           type: params[:type]
         )
 
         # Download all of the outputs from the job to the local machine
-        Fastlane::Helper::Android::FirebaseHelper.download_raw_results
+        test_runner.download_raw_results(params[:results_output_dir])
 
         if result == true
           UI.success 'Firebase Tests Complete'
           return
         end
 
-        more_details_url = Fastlane::Helper::Android::FirebaseHelper.more_details_url
-        FastlaneCore::UI.test_failure! "Firebase Tests failed – more information can be found at #{more_details_url}"
+        log_file = Fastlane::Actions.lane_context[:FIREBASE_TEST_LOG_FILE]
+        FastlaneCore::UI.test_failure! "Firebase Tests failed – more information can be found at #{log_file.more_details_url}"
       end
 
       #####################################################
@@ -155,7 +152,7 @@ def self.available_options
             type: String,
             default_value: 'instrumentation',
             verify_block: proc do |value|
-              types = Fastlane::Helper::Android::FirebaseHelper.valid_test_types
+              types = Fastlane::FirebaseTestRunner::VALID_TEST_TYPES
               next if types.include? value
 
               UI.user_error!("Invalid Test Type: #{value}. Valid Types: #{types}")

lib/fastlane/plugin/wpmreleasetoolkit/helper/android/android_firebase_helper.rb

@@ -0,0 +1,42 @@
+module Fastlane
+  class FirebaseTestLabLogFile
+    def initialize(path:)
+      raise "No log file found at path #{path}" unless File.file? path
+
+      @path = path
+    end
+
+    # Scan the log file to for indications that the Test Run failed
+    def indicates_failure
+      File.readlines(@path).any? { |line| !line.include? 'Failed' }
+    end
+
+    # Parse the log for the "More details are available..." URL
+    def more_details_url
+      File.readlines(@path)
+          .map { |line| URI.extract(line) }
+          .flatten
+          .compact
+          .filter { |string| string.include? 'matrices' }
+          .first
+    end
+
+    # Parse the log for the Google Cloud Storage Bucket URL
+    def raw_results_paths
+      uri = File.readlines(@path)
+                .map { |line| URI.extract(line) }
+                .flatten
+                .compact
+                .map { |string| URI(string) }
+                .filter { |u| u.scheme == 'gs' }
+                .first
+
+      return nil if uri.nil?
+
+      return {
+        bucket: uri.host,
+        prefix: uri.path.delete_prefix('/').chomp('/')
+      }
+    end
+  end
+end

lib/fastlane/plugin/wpmreleasetoolkit/models/firebase_test_lab_log_file.rb

@@ -0,0 +1,87 @@
+require 'json'
+require 'uri'
+
+module Fastlane
+  class FirebaseTestRunner
+    VALID_TEST_TYPES = %w[instrumentation robo].freeze
+
+    def initialize(key_file:, automatic_login: true)
+      raise "Unable to find key file: #{key_file}" unless File.file? key_file
+
+      @key_file = key_file
+      authenticate if automatic_login
+    end
+
+    def authenticate
+      Action.sh(
+        'gcloud', 'auth', 'activate-service-account',
+        '--key-file', @key_file
+      )
+    end
+
+    def run_tests(apk_path:, test_apk_path:, device:, type: 'instrumentation')
+      raise "Unable to find apk: #{apk_path}" unless File.file? apk_path
+      raise "Unable to find apk: #{test_apk_path}" unless File.file? test_apk_path
+      raise "Invalid Type: #{type}" unless VALID_TEST_TYPES.include? type
+
+      command = [
+        'gcloud', 'firebase', 'test', 'android', 'run',
+        '--type', Shellwords.escape(type),
+        '--app', Shellwords.escape(apk_path),
+        '--test', Shellwords.escape(test_apk_path),
+        '--device', Shellwords.escape(device.to_s),
+        '--verbosity', 'info',
+      ].join(' ')
+
+      log_file_path = Fastlane::Actions.lane_context[:FIREBASE_TEST_LOG_FILE_PATH]
+      UI.message "Streaming log output to #{log_file_path}"
+      Action.sh("#{command} 2>&1 | tee #{log_file_path}")
+
+      # Make the file object available to other tasks
+      file = FirebaseTestLabLogFile.new(path: log_file_path)
+      Fastlane::Actions.lane_context[:FIREBASE_TEST_LOG_FILE] = file
+
+      # Return `true` if it looks like the test passed
+      !file.indicates_failure
+    end
+
+    def download_raw_results(log_file:, destination:)
+      raise unless log_file.is_a? Fastlane::FirebaseTestLabLogFile
+
+      paths = log_file.raw_results_paths
+      raise "Log File doesn't contain a raw results URL" if paths.nil?
+
+      FileUtils.mkdir_p(destination) unless File.directory? destination
+
+      require 'google/cloud/storage'
+      storage = Google::Cloud::Storage.new(
+        project_id: Fastlane::Actions.lane_context[:FIREBASE_PROJECT_ID],
+        credentials: Fastlane::Actions.lane_context[:FIREBASE_CREDENTIALS]
+      )
+
+      # Set up the download
+      bucket = storage.bucket(paths[:bucket])
+      files_to_download = bucket.files(prefix: paths[:prefix])
+
+      # Download the files
+      UI.header "Downloading Results Files to #{destination}"
+      files_to_download.each { |file| download_file(file: file, destination: destination) }
+    end
+
+    def download_file(file:, destination:)
+      destination = File.join(destination, file.name)
+      FileUtils.mkdir_p(File.dirname(destination))
+
+      # Print our progress
+      UI.message(file.name)
+
+      file.download(destination)
+    end
+
+    def self.verify_has_gcloud_binary
+      Action.sh('command -v gcloud > /dev/null')
+    rescue StandardError
+      UI.user_error!("The `gcloud` binary isn't available on this machine. Unable to continue.")
+    end
+  end
+end