Add Firebase Test Lab Support

.rubocop.yml

@@ -73,7 +73,7 @@ Metrics/ClassLength:
   Max: 300
 
 Metrics/MethodLength:
-  Max: 100
+  Max: 150
 
 Metrics/ModuleLength:
   Max: 300

CHANGELOG.md

@@ -28,6 +28,7 @@ _None_
   If provided, that identifier will be added as an `a8c-src-lib` XML attribute to the `<string>` nodes being updated with strings from said library.
   This can be useful to help identify where each string come from in the resulting, merged `strings.xml`. [#351]
 * Add the option for `an_localize_libs` to set the `tools:ignore="UnusedResources"` XML attribute for each string being merged from a library. [#354]
+* Add the ability to run Firebase Test Lab tests [#355]
 
 ### Bug Fixes
 

Gemfile.lock

@@ -8,6 +8,7 @@ PATH
       chroma (= 0.2.0)
       diffy (~> 3.3)
       git (~> 1.3)
+      google-cloud-storage (~> 1)
       jsonlint (~> 0.3)
       nokogiri (~> 1.11)
       octokit (~> 4.18)
@@ -427,4 +428,4 @@ DEPENDENCIES
   yard
 
 BUNDLED WITH
-   2.2.33
+   2.3.8

fastlane-plugin-wpmreleasetoolkit.gemspec

@@ -37,6 +37,10 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'parallel', '~> 1.14'
   spec.add_dependency 'chroma', '0.2.0'
   spec.add_dependency 'activesupport', '~> 5'
+
+  # `google-cloud-storage` is required by fastlane, but we pin it in case it's not in the future
+  spec.add_dependency 'google-cloud-storage', '~> 1'
+
   # Some of the upstream code uses `BigDecimal.new` which version 2.0 of the
   # `bigdecimal` gem removed. Until we'll find the time to identify the
   # dependencies and see if we can move them to something compatible with

lib/fastlane/plugin/wpmreleasetoolkit.rb

@@ -4,7 +4,7 @@ module Fastlane
   module Wpmreleasetoolkit
     # Return all .rb files inside the "actions" and "helper" directory
     def self.all_classes
-      Dir[File.expand_path('**/{actions,helper}/**/*.rb', File.dirname(__FILE__))]
+      Dir[File.expand_path('**/{actions,helper,models}/**/*.rb', File.dirname(__FILE__))]
     end
   end
 end

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

@@ -0,0 +1,186 @@
+require 'securerandom'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      FIREBASE_TEST_RESULT = :FIREBASE_TEST_LOG_FILE
+      FIREBASE_TEST_LOG_FILE_PATH = :FIREBASE_TEST_LOG_FILE_PATH
+    end
+
+    class AndroidFirebaseTestAction < Action
+      def self.run(params)
+        # Preflight – ensure the system is set up correctly
+        Fastlane::FirebaseTestRunner.verify_has_gcloud_binary
+
+        # Log in to Firebase (and validate credentials)
+        test_runner = Fastlane::FirebaseTestRunner.new(key_file: params[:key_file])
+
+        # Set up the log file and output directory
+        FileUtils.mkdir_p(params[:results_output_dir])
+        Fastlane::Actions.lane_context[:FIREBASE_TEST_LOG_FILE_PATH] = File.join(params[:results_output_dir], 'output.log')
+
+        device = Fastlane::FirebaseDevice.new(
+          model: params[:model],
+          version: params[:version],
+          locale: params[:locale],
+          orientation: params[:orientation]
+        )
+
+        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
+        test_runner.download_result_files(
+          result: result,
+          destination: params[:results_output_dir],
+          project_id: params[:project_id],
+          key_file_path: params[:key_file]
+        )
+
+        FastlaneCore::UI.test_failure! "Firebase Tests failed – more information can be found at #{result.more_details_url}" unless result.success?
+
+        UI.success 'Firebase Tests Complete'
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        'Runs the specified tests in Firebase Test Lab'
+      end
+
+      def self.details
+        description
+      end
+
+      def self.available_options
+        run_uuid = SecureRandom.uuid
+
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :project_id,
+            env_name: 'GCP_PROJECT',
+            description: 'The Project ID to test in',
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :key_file,
+            env_name: 'GOOGLE_APPLICATION_CREDENTIALS',
+            description: 'The key file used to authorize with Google Cloud',
+            type: String,
+            verify_block: proc do |value|
+              next if File.file? value
+
+              UI.user_error!("Invalid key file path: #{value}")
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :apk_path,
+            description: 'The application APK',
+            type: String,
+            verify_block: proc do |value|
+              next if File.file? value
+
+              UI.user_error!("Invalid application APK: #{value}")
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :test_apk_path,
+            description: 'The test APK',
+            type: String,
+            verify_block: proc do |value|
+              next if File.file? value
+
+              UI.user_error!("Invalid test APK: #{value}")
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :model,
+            description: 'The device model to run',
+            type: String,
+            verify_block: proc do |value|
+              model_names = Fastlane::FirebaseDevice.valid_model_names
+              next if model_names.include? value
+
+              UI.user_error!("Invalid Model Name: #{value}. Valid Model Names: #{model_names}")
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :version,
+            description: 'The device version to run',
+            type: Integer,
+            verify_block: proc do |value|
+              version_numbers = Fastlane::FirebaseDevice.valid_version_numbers
+              next if version_numbers.include? value
+
+              UI.user_error!("Invalid Version Number: #{value}. Valid Verison Numbers: #{version_numbers}")
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :locale,
+            description: 'The locale code to run in',
+            type: String,
+            default_value: 'en',
+            verify_block: proc do |value|
+              locale_codes = Fastlane::FirebaseDevice.valid_locales
+              next if locale_codes.include? value
+
+              UI.user_error!("Invalid Locale: #{value}. Valid Locales: #{locale_codes}")
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :orientation,
+            description: 'Which orientation to run the device in',
+            type: String,
+            default_value: 'portrait',
+            verify_block: proc do |value|
+              orientations = Fastlane::FirebaseDevice.valid_orientations
+              next if orientations.include? value
+
+              UI.user_error!("Invalid Orientation: #{value}. Valid Orientations: #{orientations}")
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :type,
+            description: 'Which type of test are we running?',
+            type: String,
+            default_value: 'instrumentation',
+            verify_block: proc do |value|
+              types = Fastlane::FirebaseTestRunner::VALID_TEST_TYPES
+              next if types.include? value
+
+              UI.user_error!("Invalid Test Type: #{value}. Valid Types: #{types}")
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :test_run_id,
+            description: 'A unique ID used to identify this test run',
+            type: String,
+            default_value: run_uuid,
+            default_value_dynamic: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :results_output_dir,
+            description: 'Where should we store the results of this test run?',
+            type: String,
+            default_value: File.join(Dir.tmpdir(), run_uuid),
+            default_value_dynamic: true
+          ),
+        ]
+      end
+
+      def self.authors
+        ['Automattic']
+      end
+
+      def self.is_supported?(platform)
+        platform == :android
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Fastlane
+  class FirebaseDevice
+    attr_reader :model, :version, :locale, :orientation
+
+    @@locale_data = nil
+    @@model_data = nil
+    @@version_data = nil
+
+    def initialize(model:, version:, orientation:, locale: 'en')
+      raise 'Invalid Model' unless FirebaseDevice.valid_model_names.include? model
+      raise 'Invalid Version' unless FirebaseDevice.valid_version_numbers.include? version
+      raise 'Invalid Locale' unless FirebaseDevice.valid_locales.include? locale
+      raise 'Invalid Orientation' unless FirebaseDevice.valid_orientations.include? orientation
+
+      @model = model
+      @version = version
+      @locale = locale
+      @orientation = orientation
+    end
+
+    def to_s
+      "model=#{@model},version=#{@version},locale=#{@locale},orientation=#{@orientation}"
+    end
+
+    def self.valid_model_names
+      JSON.parse(model_data).map { |device| device['codename'] }
+    end
+
+    def self.valid_version_numbers
+      JSON.parse(version_data).map { |version| version['apiLevel'].to_i }
+    end
+
+    def self.valid_locales
+      JSON.parse(locale_data).map { |locale| locale['id'] }
+    end
+
+    def self.valid_orientations
+      %w[portrait landscape]
+    end
+
+    def self.locale_data
+      @@locale_data || Fastlane::Actions.sh('gcloud firebase test android locales list --format="json"', log: false)
+    end
+
+    def self.model_data
+      @@model_data || Fastlane::Actions.sh('gcloud firebase test android models list --format="json"', log: false)
+    end
+
+    def self.version_data
+      @@version_data || Fastlane::Actions.sh('gcloud firebase test android versions list --format="json"', log: false)
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Fastlane
+  class FirebaseTestLabResult
+    def initialize(log_file_path:)
+      raise "No log file found at path #{log_file_path}" unless File.file? log_file_path
+
+      @path = log_file_path
+    end
+
+    # Scan the log file to for indications that the Test Run failed
+    def success?
+      File.readlines(@path).none? { |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