fastlane-plugin-firebase_test_lab 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0a8802e9a08e68e912d7c73f2c36bc68e97d27756f7495449bc076d2810c7381
+  data.tar.gz: ec28f88fd8eb81965dba501ce0e9cf8e11a24f7ddd7ddf4f82d3cb883397b768
+SHA512:
+  metadata.gz: 5e1230cffef6c6498779f9c6a41c93bf34b1144f068a3c0c8a1b7bc4fd1bb9485545640683c1fb2b26c90a4668e9d4fefe8250851eb9e7e9e7ac29877f5a33a7
+  data.tar.gz: 1760eccb32955a7451a2b70c1c4d2f870a3801db7db3f62547d7464d65dc9376cd96a75ff579efe75e5a2572fb8835f7b27f0cb0021a0d7fbca7dc2f1bc9c8e6

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-present the fastlane authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,99 @@
+# `Firebase Test Lab` Plugin for fastlane
+
+This project is a [fastlane](https://fastlane.tools) plugin. You can add it to your [fastlane](https://fastlane.tools) project by running
+
+```bash
+fastlane add_plugin firebase_test_lab
+```
+
+## About Firebase Test Lab plugin
+
+[Firebase Test Lab](https://firebase.google.com/docs/test-lab/) let you easily test your iOS and Android app on a variety of real or virtual devices and configurations with just one API call. This plugin allows you to submit your app to Firebase Test Lab by adding an action into Fastfile.
+
+## Getting started
+
+### If you are not current user of Firebase
+You need to set up Firebase first. These only needs to be done once for an organization.
+
+- If you have not used Google Cloud before, you need to [create a new Google Cloud project](https://cloud.google.com/resource-manager/docs/creating-managing-projects#Creating%20a%20Project) first.
+- Go to the [Firebase Console](https://console.firebase.google.com/). Add Firebase into your Google Cloud project by clicking on "Add project" and then choose your just-created project..
+
+### Configure Google credentials through service accounts
+To authenticate, Google Cloud credentials will need to be set for any machine where fastlane and this plugin runs on.
+
+If you are running this plugin on Google Cloud [Compute Engine](https://cloud.google.com/compute), [Kubernetes Engine](https://cloud.google.com/kubernetes-engine) or [App Engine flexible environment](https://cloud.google.com/appengine/docs/flexible/), a default service account is automatically provisioned. You will not need to create a service account. See [this](https://cloud.google.com/compute/docs/access/service-accounts#compute_engine_default_service_account) for more details.
+
+In all other cases, you would need to configure the service account manually. You can follow [this guide](https://cloud.google.com/docs/authentication/getting-started) on how to create a new service account and create a key for it. You will need to set the `GOOGLE_APPLICATION_CREDENTIALS` environment variable pointing to the service account key file according to the document.
+
+No matter you are a using an automatically provisioned service account or a manually created one, the service account must be configured to have project editor role.
+
+### Enable relevant Google APIs
+- You need to enable the following APIs on your [Google Cloud API library](https://console.cloud.google.com/apis/library) (see [this](https://support.google.com/cloud/answer/6158841) for how):
+  1. Cloud Testing API
+  2. Cloud Tool Results API
+
+### Find out the devices you want to test on
+If you have [gcloud tool](https://cloud.google.com/sdk/gcloud/), you can run
+
+```bash
+gcloud beta firebase test ios models list
+```
+This will return a list of supported devices and their identifiers.
+
+All available devices can also be seen [here](https://firebase.google.com/docs/test-lab/ios/available-testing-devices). 
+
+
+## Actions
+
+### firebase_test_lab_ios_xctest
+
+Submit your iOS app to Firebase Test Lab and run XCTest. Refer to [this document](https://firebase.google.com/docs/test-lab/ios/command-line) for more details about Firebase Test Lab specific arguments.
+```ruby
+scan(
+  scheme: 'YourApp',                  # XCTest scheme
+  clean: true,                        # Recommended: This would ensure the build would not include unnecessary files
+  skip_detect_devices: true,          # Required
+  build_for_testing: true,            # Required
+  sdk: 'iphoneos',                    # Required
+  should_zip_build_products: true     # Must be true to set the correct format for Firebase Test Lab
+)
+firebase_test_lab_ios_xctest(
+  gcp_project: 'your-google-project', # Your Google Cloud project name
+  devices: [                          # Device(s) to run tests on
+    {
+      ios_model_id: 'iphonex',        # Device model ID, see gcloud command above
+      ios_version_id: '11.2',         # iOS version ID, see gcloud command above
+      locale: 'en_US',                # Optional: default to en_US if not set
+      orientation: 'portrait'         # Optional: default to portrait if not set
+    }
+  ]
+)
+```
+
+Arguments available are:
+
+- `app_path` You may provide a different path in the local filesystem (e.g: `/path/to/app-bundle.zip`) or on Google Cloud Storage (`gs://your-bucket/path/to/app-bundle.zip`) that points to an app bundle as specified [here](https://firebase.google.com/docs/test-lab/ios/command-line#build_xctests_for_your_app). If a Google Cloud Storage path is used, the service account must have read access to such file.
+- `gcp_project` The Google Cloud project name for Firebase Test Lab to run on.
+- `oauth_key_file_path` The path to the Google Cloud service account key. If not set, the default credential will be used.
+- `devices` An array of devices for your app to be tested on. Each device is represented as a hash, with ios_model_id, ios_version_id, locale and orientation properties, the first two of which are required. If not set, it will be defaulted to iPhone X on iOS 11.2. This array cannot be empty.
+- `async` If set to true, the action will not wait for the test results but exit immediately.
+- `timeout_sec` After how long will the test be abandoned by Firebase Test Lab. Duration hould be given in seconds.
+- `result_storage` Designate which location on Google Cloud Storage to store the test results. This should be a directory (e.g: `gs://your-bucket/tests/`)
+
+## Issues and Feedback
+
+If you have any other issues and feedback about this plugin, we appreciate if you could submit an issue to this repository.
+
+You can also join the Firebase slack channel [here](https://firebase.community/).
+
+## Troubleshooting
+
+For some more detailed help with plugins problems, check out the [Plugins Troubleshooting](https://github.com/fastlane/fastlane/blob/master/fastlane/docs/PluginsTroubleshooting.md) doc in the main `fastlane` repo.
+
+## Using `fastlane` Plugins
+
+For more information about how the `fastlane` plugin system works, check out the [Plugins documentation](https://github.com/fastlane/fastlane/blob/master/fastlane/docs/Plugins.md) in the main `fastlane` repo.
+
+## About `fastlane`
+
+`fastlane` automates building, testing, and releasing your app for beta and app store distributions. To learn more about `fastlane`, check out [fastlane.tools](https://fastlane.tools).

data/lib/fastlane/plugin/firebase_test_lab.rb

@@ -0,0 +1,16 @@
+require 'fastlane/plugin/firebase_test_lab/module'
+
+module Fastlane
+  module FirebaseTestLab
+    # Return all .rb files inside the "actions" and "helper" directory
+    def self.all_classes
+      Dir[File.expand_path('*/{actions,helper}/*.rb', File.dirname(__FILE__))]
+    end
+  end
+end
+
+# By default we want to import all available actions and helpers
+# A plugin can contain any number of actions and plugins
+Fastlane::FirebaseTestLab.all_classes.each do |current|
+  require current
+end

data/lib/fastlane/plugin/firebase_test_lab/actions/firebase_test_lab_ios_xctest.rb

@@ -0,0 +1,268 @@
+require_relative '../helper/ftl_service'
+require_relative '../helper/ftl_message'
+require_relative '../helper/storage'
+require_relative '../helper/credential'
+require_relative '../helper/ios_validator'
+require_relative '../options'
+
+require 'json'
+require 'securerandom'
+require 'tty-spinner'
+
+module Fastlane
+  module Actions
+    class FirebaseTestLabIosXctestAction < Action
+      DEFAULT_APP_BUNDLE_NAME = "bundle"
+      PULL_RESULT_INTERVAL = 5
+
+      RUNNING_STATES = %w(VALIDATING PENDING RUNNING)
+
+      private_constant :DEFAULT_APP_BUNDLE_NAME
+      private_constant :PULL_RESULT_INTERVAL
+      private_constant :RUNNING_STATES
+
+      def self.run(params)
+        gcp_project = params[:gcp_project]
+        oauth_key_file_path = params[:oauth_key_file_path]
+        gcp_credential = Fastlane::FirebaseTestLab::Credential.new(key_file_path: oauth_key_file_path)
+
+        ftl_service = Fastlane::FirebaseTestLab::FirebaseTestLabService.new(gcp_credential)
+
+        # The default Google Cloud Storage path we store app bundle and test results
+        gcs_workfolder = generate_directory_name
+
+        # Firebase Test Lab requires an app bundle be already on Google Cloud Storage before starting the job
+        if params[:app_path].to_s.start_with?("gs://")
+          # gs:// is a path on Google Cloud Storage, we do not need to re-upload the app to a different bucket
+          app_gcs_link = params[:app_path]
+        else
+          FirebaseTestLab::IosValidator.validate_ios_app(params[:app_path])
+
+          # When given a local path, we upload the app bundle to Google Cloud Storage
+          upload_spinner = TTY::Spinner.new("[:spinner] Uploading the app to GCS...", format: :dots)
+          upload_spinner.auto_spin
+          upload_bucket_name = ftl_service.get_default_bucket(gcp_project)
+          app_gcs_link = upload_file(params[:app_path],
+                                     upload_bucket_name,
+                                     "#{gcs_workfolder}/#{DEFAULT_APP_BUNDLE_NAME}",
+                                     gcp_project,
+                                     gcp_credential)
+          upload_spinner.success("Done")
+        end
+
+        UI.message("Submitting job(s) to Firebase Test Lab")
+        result_storage = (params[:result_storage] ||
+          "gs://#{ftl_service.get_default_bucket(gcp_project)}/#{gcs_workfolder}")
+
+        # We have gathered all the information. Call Firebase Test Lab to start the job now
+        matrix_id = ftl_service.start_job(gcp_project,
+                                          app_gcs_link,
+                                          result_storage,
+                                          params[:devices],
+                                          params[:timeout_sec])
+
+        # In theory, matrix_id should be available. Keep it to catch unexpected Firebase Test Lab API response
+        if matrix_id.nil?
+          UI.abort_with_message!("No matrix ID received.")
+        end
+        UI.message("Matrix ID for this submission: #{matrix_id}")
+        wait_for_test_results(ftl_service, gcp_project, matrix_id, params[:async])
+      end
+
+      def self.upload_file(app_path, bucket_name, gcs_path, gcp_project, gcp_credential)
+        file_name = "gs://#{bucket_name}/#{gcs_path}"
+        storage = Fastlane::FirebaseTestLab::Storage.new(gcp_project, gcp_credential)
+        storage.upload_file(File.expand_path(app_path), bucket_name, gcs_path)
+        return file_name
+      end
+
+      def self.wait_for_test_results(ftl_service, gcp_project, matrix_id, async)
+        firebase_console_link = nil
+
+        spinner = TTY::Spinner.new("[:spinner] Starting tests...", format: :dots)
+        spinner.auto_spin
+
+        # Keep pulling test results until they are ready
+        loop do
+          results = ftl_service.get_matrix_results(gcp_project, matrix_id)
+
+          if firebase_console_link.nil?
+            history_id, execution_id = try_get_history_id_and_execution_id(results)
+            # Once we get the Firebase console link, we display that exactly once
+            unless history_id.nil? || execution_id.nil?
+              firebase_console_link = "https://console.firebase.google.com" \
+                "/project/#{gcp_project}/testlab/histories/#{history_id}/matrices/#{execution_id}"
+
+              spinner.success("Done")
+              UI.message("Go to #{firebase_console_link} for more information about this run")
+
+              if async
+                UI.success("Job(s) have been submitted to Firebase Test Lab")
+                return
+              end
+
+              spinner = TTY::Spinner.new("[:spinner] Waiting for results...", format: :dots)
+              spinner.auto_spin
+            end
+          end
+
+          state = results["state"]
+          # Handle all known error statuses
+          if FirebaseTestLab::ERROR_STATE_TO_MESSAGE.key?(state.to_sym)
+            spinner.error("Failed")
+            invalid_matrix_details = results["invalidMatrixDetails"]
+            if invalid_matrix_details &&
+               FirebaseTestLab::INVALID_MATRIX_DETAIL_TO_MESSAGE.key?(invalid_matrix_details.to_sym)
+              UI.error(FirebaseTestLab::INVALID_MATRIX_DETAIL_TO_MESSAGE[invalid_matrix_details.to_sym])
+            end
+            UI.user_error!(FirebaseTestLab::ERROR_STATE_TO_MESSAGE[state.to_sym])
+          end
+
+          if state == "FINISHED"
+            spinner.success("Done")
+            # Inspect the execution results: only contain info on whether each job finishes.
+            # Do not include whether tests fail
+            executions_completed = extract_execution_results(results)
+
+            if results["resultStorage"].nil? || results["resultStorage"]["toolResultsExecution"].nil?
+              UI.abort_with_message!("Unexpected response from Firebase test lab: Cannot retrieve result info")
+            end
+
+            # Now, look at the actual test result and see if they succeed
+            history_id, execution_id = try_get_history_id_and_execution_id(results)
+            if history_id.nil? || execution_id.nil?
+              UI.abort_with_message!("Unexpected response from Firebase test lab: No history or execution ID")
+            end
+            test_results = ftl_service.get_execution_steps(gcp_project, history_id, execution_id)
+            tests_successful = extract_test_results(test_results, gcp_project, history_id, execution_id)
+            unless executions_completed && tests_successful
+              UI.test_failure!("Tests failed")
+            end
+            return
+          end
+
+          # We should have caught all known states here. If the state is not one of them, this
+          # plugin should be modified to handle that
+          unless RUNNING_STATES.include?(state)
+            spinner.error("Failed")
+            UI.abort_with_message!("The test execution is in an unknown state: #{state}. " \
+              "We appreciate if you could notify us at " \
+              "https://github.com/fastlane/fastlane-plugin-firebase_test_lab/issues")
+          end
+          sleep(PULL_RESULT_INTERVAL)
+        end
+      end
+
+      def self.generate_directory_name
+        timestamp = Time.now.getutc.strftime("%Y%m%d-%H%M%SZ")
+        return "fastlane-#{timestamp}-#{SecureRandom.hex[0..5]}"
+      end
+
+      def self.try_get_history_id_and_execution_id(matrix_results)
+        if matrix_results["resultStorage"].nil? || matrix_results["resultStorage"]["toolResultsExecution"].nil?
+          return nil, nil
+        end
+
+        tool_results_execution = matrix_results["resultStorage"]["toolResultsExecution"]
+        history_id = tool_results_execution["historyId"]
+        execution_id = tool_results_execution["executionId"]
+        return history_id, execution_id
+      end
+
+      def self.extract_execution_results(execution_results)
+        UI.message("Test job(s) are finalized")
+        UI.message("-------------------------")
+        UI.message("|   EXECUTION RESULTS   |")
+        failures = 0
+        execution_results["testExecutions"].each do |execution|
+          UI.message("-------------------------")
+          execution_info = "#{execution['id']}: #{execution['state']}"
+          if execution["state"] != "FINISHED"
+            failures += 1
+            UI.error(execution_info)
+          else
+            UI.success(execution_info)
+          end
+
+          # Display build logs
+          if !execution["testDetails"].nil? && !execution["testDetails"]["progressMessages"].nil?
+            execution["testDetails"]["progressMessages"].each { |msg| UI.message(msg) }
+          end
+        end
+
+        UI.message("-------------------------")
+        if failures > 0
+          UI.error("😞  #{failures} execution(s) have failed to complete.")
+        else
+          UI.success("🎉  All jobs have ran and completed.")
+        end
+        return failures == 0
+      end
+
+      def self.extract_test_results(test_results, gcp_project, history_id, execution_id)
+        steps = test_results["steps"]
+        failures = 0
+        inconclusive_runs = 0
+
+        UI.message("-------------------------")
+        UI.message("|      TEST OUTCOME     |")
+        steps.each do |step|
+          UI.message("-------------------------")
+          step_id = step["stepId"]
+          UI.message("Test step: #{step_id}")
+
+          run_duration_sec = step["runDuration"]["seconds"] || 0
+          UI.message("Execution time: #{run_duration_sec} seconds")
+
+          outcome = step["outcome"]["summary"]
+          case outcome
+          when "success"
+            UI.success("Result: #{outcome}")
+          when "skipped"
+            UI.message("Result: #{outcome}")
+          when "inconclusive"
+            inconclusive_runs += 1
+            UI.error("Result: #{outcome}")
+          when "failure"
+            failures += 1
+            UI.error("Result: #{outcome}")
+          end
+          UI.message("For details, go to https://console.firebase.google.com/project/#{gcp_project}/testlab/" \
+            "histories/#{history_id}/matrices/#{execution_id}/executions/#{step_id}")
+        end
+
+        UI.message("-------------------------")
+        if failures == 0 && inconclusive_runs == 0
+          UI.success("🎉  Yay! All executions are completed successfully!")
+        end
+        if failures > 0
+          UI.error("😞  #{failures} step(s) have failed.")
+        end
+        if inconclusive_runs > 0
+          UI.error("😞  #{inconclusive_runs} step(s) yielded inconclusive outcomes.")
+        end
+        return failures == 0 && inconclusive_runs == 0
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Submit an iOS XCTest job to Firebase Test Lab"
+      end
+
+      def self.available_options
+        Fastlane::FirebaseTestLab::Options.available_options
+      end
+
+      def self.authors
+        ["powerivq"]
+      end
+
+      def self.is_supported?(platform)
+        return platform == :ios
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/firebase_test_lab/helper/credential.rb

@@ -0,0 +1,33 @@
+require 'googleauth'
+
+module Fastlane
+  module FirebaseTestLab
+    class Credential
+      def initialize(key_file_path: nil)
+        @key_file_path = key_file_path
+      end
+
+      def get_google_credential(scopes)
+        unless @key_file_path
+          begin
+            return Google::Auth.get_application_default(scopes)
+          rescue => ex
+            UI.abort_with_message!("Failed reading application default credential. Either the Oauth credential should be provided or Google Application Default Credential should be configured: #{ex.message}")
+          end
+        end
+
+        File.open(File.expand_path(@key_file_path), "r") do |file|
+          options = {
+            json_key_io: file,
+            scope: scopes
+          }
+          begin
+            return Google::Auth::ServiceAccountCredentials.make_creds(options)
+          rescue => ex
+            UI.abort_with_message!("Failed reading OAuth credential: #{ex.message}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/firebase_test_lab/helper/error_helper.rb

@@ -0,0 +1,21 @@
+require 'json'
+
+module Fastlane
+  module FirebaseTestLab
+    class ErrorHelper
+      def self.summarize_google_error(payload)
+        begin
+          response = JSON.parse(payload)
+        rescue JSON::ParserError => ex
+          FastlaneCore::UI.error("Unable to parse error message: #{ex.class}, message: #{ex.message}")
+          return payload
+        end
+
+        if response["error"]
+          return "#{response['error']['message']}\n#{payload}"
+        end
+        return payload
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/firebase_test_lab/helper/ftl_message.rb

@@ -0,0 +1,51 @@
+module Fastlane
+  module FirebaseTestLab
+    ERROR_STATE_TO_MESSAGE = {
+      ERROR: "The execution or matrix has stopped because it encountered an infrastructure failure.",
+      UNSUPPORTED_ENVIRONMENT: "The execution was not run because it corresponds to a unsupported environment.",
+      INCOMPATIBLE_ENVIRONMENT: "The execution was not run because the provided inputs are incompatible with the " \
+                                "requested environment",
+      INCOMPATIBLE_ARCHITECTURE: "The execution was not run because the provided inputs are incompatible with the " \
+                                 "requested architecture.",
+      CANCELLED: "The user cancelled the execution.",
+      INVALID: "The execution or matrix was not run because the provided inputs are not valid."
+    }
+
+    INVALID_MATRIX_DETAIL_TO_MESSAGE = {
+      MALFORMED_APK: "The app APK is not a valid Android application",
+      MALFORMED_TEST_APK: "The test APK is not a valid Android instrumentation test",
+      NO_MANIFEST: "The app APK is missing the manifest file",
+      NO_PACKAGE_NAME: "The APK manifest file is missing the package name",
+      TEST_SAME_AS_APP: "The test APK is the same as the app APK",
+      NO_INSTRUMENTATION: "The test APK declares no instrumentation tags in the manifest",
+      NO_SIGNATURE: "At least one supplied APK file has a missing or invalid signature",
+      INSTRUMENTATION_ORCHESTRATOR_INCOMPATIBLE: "The test runner class specified by the user or the test APK\"s " \
+                                                 "manifest file is not compatible with Android Test Orchestrator. " \
+                                                 "Please use AndroidJUnitRunner version 1.0 or higher",
+      NO_TEST_RUNNER_CLASS: "The test APK does not contain the test runner class specified by " \
+                            "the user or the manifest file. The test runner class name may be " \
+                            "incorrect, or the class may be mislocated in the app APK.",
+      NO_LAUNCHER_ACTIVITY: "The app APK does not specify a main launcher activity",
+      FORBIDDEN_PERMISSIONS: "The app declares one or more permissions that are not allowed",
+      INVALID_ROBO_DIRECTIVES: "Cannot have multiple robo-directives with the same resource name",
+      TEST_LOOP_INTENT_FILTER_NOT_FOUND: "The app does not have a correctly formatted game-loop intent filter",
+      SCENARIO_LABEL_NOT_DECLARED: "A scenario-label was not declared in the manifest file",
+      SCENARIO_LABEL_MALFORMED: "A scenario-label in the manifest includes invalid numbers or ranges",
+      SCENARIO_NOT_DECLARED: "A scenario-number was not declared in the manifest file",
+      DEVICE_ADMIN_RECEIVER: "Device administrator applications are not allowed",
+      MALFORMED_XC_TEST_ZIP: "The XCTest zip file was malformed. The zip did not contain a single " \
+                             ".xctestrun file and the contents of the DerivedData/Build/Products directory.",
+      BUILT_FOR_IOS_SIMULATOR: "The provided XCTest was built for the iOS simulator rather than for " \
+                               "a physical device",
+      NO_TESTS_IN_XC_TEST_ZIP: "The .xctestrun file did not specify any test targets to run",
+      USE_DESTINATION_ARTIFACTS: "One or more of the test targets defined in the .xctestrun file " \
+                                 "specifies \"UseDestinationArtifacts\", which is not allowed",
+      TEST_NOT_APP_HOSTED: "One or more of the test targets defined in the .xctestrun file " \
+                           "does not have a host binary to run on the physical iOS device, " \
+                           "which may cause errors when running xcodebuild",
+      NO_CODE_APK: "\"hasCode\" is false in the Manifest. Tested APKs must contain code",
+      INVALID_INPUT_APK: "Either the provided input APK path was malformed, the APK file does " \
+                         "not exist, or the user does not have permission to access the file"
+    }
+  end
+end

data/lib/fastlane/plugin/firebase_test_lab/helper/ftl_service.rb

@@ -0,0 +1,202 @@
+require 'googleauth'
+require 'json'
+
+require_relative './error_helper'
+require_relative '../module'
+
+module Fastlane
+  module FirebaseTestLab
+    class FirebaseTestLabService
+      APIARY_ENDPOINT = "https://www.googleapis.com"
+      TOOLRESULTS_GET_SETTINGS_API_V3 = "/toolresults/v1beta3/projects/{project}/settings"
+      TOOLRESULTS_INITIALIZE_SETTINGS_API_V3 = "/toolresults/v1beta3/projects/{project}:initializeSettings"
+      TOOLRESULTS_LIST_EXECUTION_STEP_API_V3 =
+        "/toolresults/v1beta3/projects/{project}/histories/{history_id}/executions/{execution_id}/steps"
+
+      FIREBASE_TEST_LAB_ENDPOINT = "https://testing.googleapis.com"
+      FTL_CREATE_API = "/v1/projects/{project}/testMatrices"
+      FTL_RESULTS_API = "/v1/projects/{project}/testMatrices/{matrix}"
+
+      TESTLAB_OAUTH_SCOPES = ["https://www.googleapis.com/auth/cloud-platform"]
+
+      private_constant :APIARY_ENDPOINT
+      private_constant :TOOLRESULTS_GET_SETTINGS_API_V3
+      private_constant :TOOLRESULTS_INITIALIZE_SETTINGS_API_V3
+      private_constant :TOOLRESULTS_LIST_EXECUTION_STEP_API_V3
+      private_constant :FIREBASE_TEST_LAB_ENDPOINT
+      private_constant :FTL_CREATE_API
+      private_constant :FTL_RESULTS_API
+      private_constant :TESTLAB_OAUTH_SCOPES
+
+      def initialize(credential)
+        @auth = credential.get_google_credential(TESTLAB_OAUTH_SCOPES)
+        @default_bucket = nil
+      end
+
+      def init_default_bucket(gcp_project)
+        conn = Faraday.new(APIARY_ENDPOINT)
+        begin
+          conn.post(TOOLRESULTS_INITIALIZE_SETTINGS_API_V3.gsub("{project}", gcp_project)) do |req|
+            req.headers = @auth.apply(req.headers)
+            req.options.timeout = 15
+            req.options.open_timeout = 5
+          end
+        rescue Faraday::Error => ex
+          UI.abort_with_message!("Network error when initializing Firebase Test Lab, " \
+            "type: #{ex.class}, message: #{ex.message}")
+        end
+      end
+
+      def get_default_bucket(gcp_project)
+        return @default_bucket unless @default_bucket.nil?
+
+        init_default_bucket(gcp_project)
+        conn = Faraday.new(APIARY_ENDPOINT)
+        begin
+          resp = conn.get(TOOLRESULTS_GET_SETTINGS_API_V3.gsub("{project}", gcp_project)) do |req|
+            req.headers = @auth.apply(req.headers)
+            req.options.timeout = 15
+            req.options.open_timeout = 5
+          end
+        rescue Faraday::Error => ex
+          UI.abort_with_message!("Network error when obtaining Firebase Test Lab default GCS bucket, " \
+            "type: #{ex.class}, message: #{ex.message}")
+        end
+
+        if resp.status != 200
+          FastlaneCore::UI.error("Failed to obtain default bucket for Firebase Test Lab.")
+          summarized_error = ErrorHelper.summarize_google_error(resp.body)
+          if summarized_error.include?("Not Authorized for project")
+            FastlaneCore::UI.error("Please make sure that the account associated with your Google credential is the " \
+                                   "project editor or owner. You can do this at the Google Developer Console " \
+                                   "https://console.cloud.google.com/iam-admin/iam?project=#{gcp_project}")
+          end
+          FastlaneCore::UI.abort_with_message!(summarized_error)
+          return nil
+        else
+          response_json = JSON.parse(resp.body)
+          @default_bucket = response_json["defaultBucket"]
+          return @default_bucket
+        end
+      end
+
+      def start_job(gcp_project, app_path, result_path, devices, timeout_sec)
+        body = {
+          projectId: gcp_project,
+          testSpecification: {
+            testTimeout: {
+              seconds: timeout_sec
+            },
+            iosTestSetup: {},
+            iosXcTest: {
+              testsZip: {
+                gcsPath: app_path
+              }
+            }
+          },
+          environmentMatrix: {
+            iosDeviceList: {
+              iosDevices: devices.map(&FirebaseTestLabService.method(:map_device_to_proto))
+            }
+          },
+          resultStorage: {
+            googleCloudStorage: {
+              gcsPath: result_path
+            }
+          },
+          clientInfo: {
+            name: PLUGIN_NAME,
+            clientInfoDetails: [
+              {
+                key: "version",
+                value: VERSION
+              }
+            ]
+          }
+        }
+
+        conn = Faraday.new(FIREBASE_TEST_LAB_ENDPOINT)
+        begin
+          resp = conn.post(FTL_CREATE_API.gsub("{project}", gcp_project)) do |req|
+            req.headers = @auth.apply(req.headers)
+            req.headers["Content-Type"] = "application/json"
+            req.headers["X-Goog-User-Project"] = gcp_project
+            req.body = body.to_json
+            req.options.timeout = 15
+            req.options.open_timeout = 5
+          end
+        rescue Faraday::Error => ex
+          UI.abort_with_message!("Network error when initializing Firebase Test Lab, " \
+            "type: #{ex.class}, message: #{ex.message}")
+        end
+
+        if resp.status != 200
+          FastlaneCore::UI.error("Failed to start Firebase Test Lab jobs.")
+          FastlaneCore::UI.abort_with_message!(ErrorHelper.summarize_google_error(resp.body))
+        else
+          response_json = JSON.parse(resp.body)
+          return response_json["testMatrixId"]
+        end
+      end
+
+      def get_matrix_results(gcp_project, matrix_id)
+        url = FTL_RESULTS_API
+              .gsub("{project}", gcp_project)
+              .gsub("{matrix}", matrix_id)
+
+        conn = Faraday.new(FIREBASE_TEST_LAB_ENDPOINT)
+        begin
+          resp = conn.get(url) do |req|
+            req.headers = @auth.apply(req.headers)
+            req.options.timeout = 15
+            req.options.open_timeout = 5
+          end
+        rescue Faraday::Error => ex
+          UI.abort_with_message!("Network error when attempting to get test results, " \
+            "type: #{ex.class}, message: #{ex.message}")
+        end
+
+        if resp.status != 200
+          FastlaneCore::UI.error("Failed to obtain test results.")
+          FastlaneCore::UI.abort_with_message!(ErrorHelper.summarize_google_error(resp.body))
+          return nil
+        else
+          return JSON.parse(resp.body)
+        end
+      end
+
+      def get_execution_steps(gcp_project, history_id, execution_id)
+        conn = Faraday.new(APIARY_ENDPOINT)
+        url = TOOLRESULTS_LIST_EXECUTION_STEP_API_V3
+              .gsub("{project}", gcp_project)
+              .gsub("{history_id}", history_id)
+              .gsub("{execution_id}", execution_id)
+        begin
+          resp = conn.get(url) do |req|
+            req.headers = @auth.apply(req.headers)
+            req.options.timeout = 15
+            req.options.open_timeout = 5
+          end
+        rescue Faraday::Error => ex
+          UI.abort_with_message!("Failed to obtain the metadata of test artifacts, " \
+            "type: #{ex.class}, message: #{ex.message}")
+        end
+
+        if resp.status != 200
+          FastlaneCore::UI.error("Failed to obtain the metadata of test artifacts.")
+          FastlaneCore::UI.abort_with_message!(ErrorHelper.summarize_google_error(resp.body))
+        end
+        return JSON.parse(resp.body)
+      end
+
+      def self.map_device_to_proto(device)
+        {
+          iosModelId: device[:ios_model_id],
+          iosVersionId: device[:ios_version_id],
+          locale: device[:locale],
+          orientation: device[:orientation]
+        }
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/firebase_test_lab/helper/ios_validator.rb

@@ -0,0 +1,35 @@
+require 'zip'
+require 'plist'
+
+module Fastlane
+  module FirebaseTestLab
+    class IosValidator
+      def self.validate_ios_app(file_path)
+        absolute_path = File.expand_path(file_path)
+        begin
+          Zip::File.open(absolute_path) do |zip_file|
+            xctestrun_files = zip_file.glob("*.xctestrun")
+            if xctestrun_files.size != 1
+              UI.user_error!("app verification failed: There must be only one .xctestrun files in the ZIP file.")
+            end
+
+            conf = Plist.parse_xml(xctestrun_files.first.get_input_stream)
+            unless conf.size == 1
+              UI.user_error!("The app bundle may contain only one scheme, #{conf.size} found")
+            end
+            _, scheme_conf = conf.first
+            unless scheme_conf["IsUITestBundle"]
+              UI.user_error!("The app bundle is not a UI test bundle. Did you build with build-for-testing argument?")
+            end
+            unless scheme_conf.key?("TestHostPath") || scheme_conf.key?("TestBundlePath")
+              UI.user_error!("Either TestHostPath or TestBundlePath must be in the app bundle. Please check your " \
+                            "xcodebuild arguments")
+            end
+          end
+        rescue Zip::Error => e
+          UI.user_error!("Failed to read the ZIP file #{file_path}: #{e.message}")
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/firebase_test_lab/helper/storage.rb

@@ -0,0 +1,23 @@
+require 'googleauth'
+require 'google/cloud/storage'
+
+module Fastlane
+  module FirebaseTestLab
+    class Storage
+      GCS_OAUTH_SCOPES = ["https://www.googleapis.com/auth/devstorage.full_control"]
+
+      private_constant :GCS_OAUTH_SCOPES
+
+      def initialize(gcp_project, credential)
+        credentials = credential.get_google_credential(GCS_OAUTH_SCOPES)
+        @client = Google::Cloud::Storage.new(project_id: gcp_project,
+                                             credentials: credentials)
+      end
+
+      def upload_file(source_path, destination_bucket, destination_path)
+        bucket = @client.bucket(destination_bucket)
+        bucket.create_file(source_path, destination_path)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/firebase_test_lab/module.rb

@@ -0,0 +1,6 @@
+module Fastlane
+  module FirebaseTestLab
+    VERSION = "0.9.0"
+    PLUGIN_NAME = "fastlane-plugin-firebase_test_lab"
+  end
+end

data/lib/fastlane/plugin/firebase_test_lab/options.rb

@@ -0,0 +1,90 @@
+require 'fastlane_core/configuration/config_item'
+
+module Fastlane
+  module FirebaseTestLab
+    class Options
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :gcp_project,
+                                       description: "Google Cloud Platform project name",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :app_path,
+                                       description: "Path to the app, either on the filesystem or GCS address (gs://)",
+                                       default_value:
+                                         Actions.lane_context[Actions::SharedValues::SCAN_ZIP_BUILD_PRODUCTS_PATH],
+                                       verify_block: proc do |value|
+                                         unless value.to_s.start_with?("gs://")
+                                           v = File.expand_path(value.to_s)
+                                           UI.user_error!("App file not found at path '#{v}'") unless File.exist?(v)
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :devices,
+                                       description: "Devices to test the app on",
+                                       type: Array,
+                                       default_value: [{
+                                         ios_model_id: "iphonex",
+                                         ios_version_id: "11.2",
+                                         locale: "en_US",
+                                         orientation: "portrait"
+                                       }],
+                                       verify_block: proc do |value|
+                                         if value.empty?
+                                           UI.user_error!("Devices cannot be empty")
+                                         end
+                                         value.each do |current|
+                                           if current.class != Hash
+                                             UI.user_error!("Each device must be represented by a Hash object, " \
+                                               "#{current.class} found")
+                                           end
+                                           check_has_property(current, :ios_model_id)
+                                           check_has_property(current, :ios_version_id)
+                                           set_default_property(current, :locale, "en_US")
+                                           set_default_property(current, :orientation, "portrait")
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :async,
+                                       description: "Do not wait for test results",
+                                       default_value: false,
+                                       type: Fastlane::Boolean),
+          FastlaneCore::ConfigItem.new(key: :timeout_sec,
+                                       description: "After how long, in seconds, should tests be terminated",
+                                       default_value: 180,
+                                       optional: true,
+                                       type: Integer,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Timeout must be less or equal to 45 minutes.") \
+                                           if value <= 0 || value > 45 * 60
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :result_storage,
+                                       description: "GCS path to store test results",
+                                       default_value: nil,
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Invalid GCS path: '#{value}'") \
+                                           unless value.to_s.start_with?("gs://")
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :oauth_key_file_path,
+                                       description: "Use the given Google cloud service key file." \
+                                                    "If not set, application default credential will be used " \
+                                                    "(see https://cloud.google.com/docs/authentication/production)",
+                                       default_value: nil,
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         v = File.expand_path(value.to_s)
+                                         UI.user_error!("Key file not found at path '#{v}'") unless File.exist?(v)
+                                       end)
+        ]
+      end
+
+      def self.check_has_property(hash_obj, property)
+        UI.user_error!("Each device must have #{property} property") unless hash_obj.key?(property)
+      end
+
+      def self.set_default_property(hash_obj, property, default)
+        unless hash_obj.key?(property)
+          hash_obj[property] = default
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,187 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-firebase_test_lab
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Shihua Zheng
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-09-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: googleauth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: plist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: google-cloud-storage
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.13.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.13.0
+- !ruby/object:Gem::Dependency
+  name: tty-spinner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fastlane
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.102.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.102.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 0.50.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 0.50.0
+description: 
+email: shihuaz@google.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/firebase_test_lab.rb
+- lib/fastlane/plugin/firebase_test_lab/actions/firebase_test_lab_ios_xctest.rb
+- lib/fastlane/plugin/firebase_test_lab/helper/credential.rb
+- lib/fastlane/plugin/firebase_test_lab/helper/error_helper.rb
+- lib/fastlane/plugin/firebase_test_lab/helper/ftl_message.rb
+- lib/fastlane/plugin/firebase_test_lab/helper/ftl_service.rb
+- lib/fastlane/plugin/firebase_test_lab/helper/ios_validator.rb
+- lib/fastlane/plugin/firebase_test_lab/helper/storage.rb
+- lib/fastlane/plugin/firebase_test_lab/module.rb
+- lib/fastlane/plugin/firebase_test_lab/options.rb
+homepage: https://github.com/fastlane/fastlane-plugin-firebase_test_lab
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Firebase Test Lab for fastlane
+test_files: []