fastlane-plugin-wpmreleasetoolkit 4.0.0 → 5.0.0

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/app_size_metrics_helper.rb

@@ -0,0 +1,95 @@
+require 'json'
+require 'net/http'
+require 'zlib'
+
+module Fastlane
+  module Helper
+    # A helper class to build an App Size Metrics payload and send it to a server (or write it to disk)
+    #
+    # The payload generated (and sent) by this helper conforms to the API for grouped metrics described in
+    # https://github.com/Automattic/apps-metrics
+    #
+    class AppSizeMetricsHelper
+      # @param [Hash] metadata Metadata common to all the metrics. Can be any arbitrary set of key/value pairs.
+      #
+      def initialize(metadata = {})
+        self.metadata = metadata
+        @metrics = []
+      end
+
+      # Sets the metadata common to the whole group of metrics in the payload being built by this helper instance
+      #
+      # @param [Hash] hash The metadata common to all the metrics of the payload built by that helper instance. Can be any arbitrary set of key/value pairs
+      #
+      def metadata=(hash)
+        @metadata = (hash.compact || {}).map { |key, value| { name: key.to_s, value: value } }
+      end
+
+      # Adds a single metric to the group of metrics
+      #
+      # @param [String] name The metric name
+      # @param [Integer] value The metric value
+      # @param [Hash] metadata The arbitrary dictionary of metadata to associate to that metric entry
+      #
+      def add_metric(name:, value:, metadata: nil)
+        metric = { name: name, value: value }
+        metadata = metadata&.compact || {} # Remove nil values if any (and use empty Hash if nil was provided)
+        metric[:meta] = metadata.map { |meta_key, meta_value| { name: meta_key.to_s, value: meta_value } } unless metadata.empty?
+        @metrics.append(metric)
+      end
+
+      def to_h
+        {
+          meta: @metadata,
+          metrics: @metrics
+        }
+      end
+
+      # Send the metrics to the given App Metrics endpoint.
+      #
+      # Must conform to the API described in https://github.com/Automattic/apps-metrics/wiki/Queue-Group-of-Metrics
+      #
+      # @param [String,URI] to The URL of the App Metrics service, or a `file://` URL to write the payload to disk
+      # @param [String] api_token The API bearer token to use to register the metric.
+      # @return [Integer] the HTTP response code
+      #
+      def send_metrics(to:, api_token:, use_gzip: true)
+        uri = URI(to)
+        json_payload = use_gzip ? Zlib.gzip(to_h.to_json) : to_h.to_json
+
+        # Allow using a `file:` URI for debugging
+        if uri.is_a?(URI::File)
+          UI.message("Writing metrics payload to file #{uri.path} (instead of sending it to a remote API endpoint)")
+          File.write(uri.path, json_payload)
+          return 201 # To make it easy at call site to check for pseudo-status code 201 even in non-HTTP cases
+        end
+
+        UI.message("Sending metrics to #{uri}...")
+        headers = {
+          Authorization: "Bearer #{api_token}",
+          Accept: 'application/json',
+          'Content-Type': 'application/json'
+        }
+        headers[:'Content-Encoding'] = 'gzip' if use_gzip
+
+        request = Net::HTTP::Post.new(uri, headers)
+        request.body = json_payload
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+          http.request(request)
+        end
+
+        if response.is_a?(Net::HTTPSuccess)
+          UI.success("Metrics sent. (#{response.code} #{response.message})")
+        else
+          UI.error("Metrics failed to send. Received: #{response.code} #{response.message}")
+          UI.message("Request was #{request.method} to #{request.uri}")
+          UI.message("Request headers were: #{headers}")
+          UI.message("Request body was #{request.body.length} bytes")
+          UI.message("Response was #{response.body}")
+        end
+        response.code.to_i
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/git_helper.rb

@@ -8,14 +8,11 @@ module Fastlane
       # Fallback default branch of the client repository.
       DEFAULT_GIT_BRANCH = 'trunk'.freeze
 
-      # Checks if the given path, or current directory if no path is given, is
-      # inside a Git repository
+      # Checks if the given path, or current directory if no path is given, is inside a Git repository
       #
-      # @param [String] path An optional path where to check if a Git repo
-      #        exists.
+      # @param [String] path An optional path where to check if a Git repo exists.
       #
-      # @return [Bool] True if the current directory is the root of a git repo
-      #         (i.e. a local working copy) or a subdirectory of one.
+      # @return [Bool] True if the current directory is the root of a git repo (i.e. a local working copy) or a subdirectory of one.
       #
       def self.is_git_repo?(path: Dir.pwd)
         # If the path doesn't exist, find its first ancestor.
@@ -23,23 +20,19 @@ module Fastlane
         # Get the path's directory, so we can look in it for the Git folder
         dir = path.directory? ? path : path.dirname
 
-        # Recursively look for the Git folder until it's found or we read the
-        # the file system root
+        # Recursively look for the Git folder until it's found or we read the the file system root
         dir = dir.parent until Dir.entries(dir).include?('.git') || dir.root?
 
-        # If we reached the root, we haven't found a repo. (Technically, there
-        # could be a repo in the root of the system, but that's a usecase that
-        # we don't need to support at this time)
+        # If we reached the root, we haven't found a repo.
+        # (Technically, there could be a repo in the root of the system, but that's a usecase that we don't need to support at this time)
         return dir.root? == false
       end
 
-      # Travels back the hierarchy of the given path until it finds an existing
-      # ancestor, or it reaches the root of the file system.
+      # Travels back the hierarchy of the given path until it finds an existing ancestor, or it reaches the root of the file system.
       #
       # @param [String] path The path to inspect
       #
-      # @return [Pathname] The first existing ancestor, or `path` itself if it
-      #         exists
+      # @return [Pathname] The first existing ancestor, or `path` itself if it exists
       #
       def self.first_existing_ancestor_of(path:)
         p = Pathname(path).expand_path
@@ -106,7 +99,7 @@ module Fastlane
       #
       # @param [String] message The commit message to use
       # @param [String|Array<String>] files A file or array of files to git-add before creating the commit.
-      #        use `nil` or `[]` if you already added the files in a separate step and don't wan't this method to add any new file before commit.
+      #        Use `nil` or `[]` if you already added the files in a separate step and don't wan't this method to add any new file before commit.
       #        Also accepts the special symbol `:all` to add all the files (`git commit -a -m …`).
       # @param [Bool] push If true, will `git push` to `origin` after the commit has been created. Defaults to `false`.
       #
@@ -209,8 +202,7 @@ module Fastlane
         UI.user_error!("This command works only on #{branch_name} branch") unless current_branch_name.include?(branch_name)
       end
 
-      # Checks whether a given path is ignored by Git, relying on Git's
-      # `check-ignore` under the hood.
+      # Checks whether a given path is ignored by Git, relying on Git's `check-ignore` under the hood.
       #
       # @param [String] path The path to check against `.gitignore`
       #

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/ios/ios_l10n_helper.rb

@@ -143,11 +143,15 @@ module Fastlane
         #
         def self.download_glotpress_export_file(project_url:, locale:, filters:, destination:)
           query_params = (filters || {}).transform_keys { |k| "filters[#{k}]" }.merge(format: 'strings')
-          uri = URI.parse("#{project_url.chomp('/')}/#{locale}/default/export-translations?#{URI.encode_www_form(query_params)}")
+          uri = URI.parse("#{project_url.chomp('/')}/#{locale}/default/export-translations/?#{URI.encode_www_form(query_params)}")
+
+          # Set an unambiguous User Agent so GlotPress won't rate-limit us
+          options = { 'User-Agent' => Wpmreleasetoolkit::USER_AGENT }
+
           begin
-            IO.copy_stream(uri.open, destination)
+            IO.copy_stream(uri.open(options), destination)
           rescue StandardError => e
-            UI.error "Error downloading locale `#{locale}` — #{e.message}"
+            UI.error "Error downloading locale `#{locale}` — #{e.message} (#{uri})"
             return nil
           end
         end

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/ios/ios_l10n_linter_helper.rb

@@ -58,8 +58,7 @@ module Fastlane
         #
         # @param [String] input_dir The path (ideally absolute) to the directory containing the `.lproj` folders to parse
         # @param [String] base_lang The code name (i.e the basename of one of the `.lproj` folders) of the locale to use as the baseline
-        # @return [Hash<String, String>] A hash whose keys are the language codes (basename of `.lproj` folders) for which violations were found,
-        #         and the values are the output of the `diff` showing these violations.
+        # @return [Hash<String, Array<String>>] A hash of violations, keyed by language code, whose values are the list of violation messages for that language
         #
         def run(input_dir:, base_lang: DEFAULT_BASE_LANG, only_langs: nil)
           check_swiftgen_installed || install_swiftgen!
@@ -87,7 +86,7 @@ module Fastlane
           <<~TEMPLATE
             {% macro recursiveBlock table item %}
               {% for string in item.strings %}
-            "{{string.key}}" => [{{string.types|join:","}}]
+            {{string.key}} ==> [{{string.types|join:","}}]
               {% endfor %}
               {% for child in item.children %}
               {% call recursiveBlock table child %}
@@ -139,20 +138,19 @@ module Fastlane
           return [config_file, langs]
         end
 
-        # Because we use English copy verbatim as key names, some keys are the same except for the upper/lowercase.
-        # We need to sort the output again because SwiftGen only sort case-insensitively so that means keys that are
-        # the same except case might be in swapped order for different outputs
+        # Returns a Hash mapping the list of expected parameter types for each of the keys based in the %… placeholders found in their `.strings` files
         #
         # @param [String] dir The temporary directory in which the file to sort lines for is located
         # @param [String] lang The code for the locale we need to sort the output lines for
+        # @return [Hash<String, String>] A hash whose keys are the strings keys, and corresponding value is a String describing the types expected as parameters.
         #
-        def sort_file_lines!(dir, lang)
+        def placeholder_types_for_keys(dir, lang)
           file = File.join(dir, output_filename(lang))
           return nil unless File.exist?(file)
 
-          sorted_lines = File.readlines(file).sort
-          File.write(file, sorted_lines.join)
-          return file
+          File.readlines(file).map do |line|
+            line.match(/^(.*) ==> (\[[A-Za-z,]*\])$/)&.captures
+          end.compact.to_h
         end
 
         # Prepares the template and config files, then run SwiftGen, run `diff` on each generated output against the baseline, and returns a Hash of the violations found.
@@ -160,7 +158,7 @@ module Fastlane
         # @param [String] input_dir The directory where the `.lproj` folders to scan are located
         # @param [String] base_lang The base language used as source of truth that all other languages will be compared against
         # @param [Array<String>] only_langs The list of languages to limit the generation for. Useful to focus only on a couple of issues or just one language
-        # @return [Hash<String, String>] A hash of violations, keyed by language code, whose values are the diff output.
+        # @return [Hash<String, Array<String>>] A hash of violations, keyed by language code, whose values are the list of violation messages for that language
         #
         # @note The returned Hash contains keys only for locales with violations. Locales parsed but without any violations found will not appear in the resulting hash.
         #
@@ -172,34 +170,22 @@ module Fastlane
             Action.sh(swiftgen_bin, 'config', 'run', '--config', config_file)
 
             # Run diffs
-            base_file = sort_file_lines!(tmpdir, base_lang)
+            params_for_base_lang = placeholder_types_for_keys(tmpdir, base_lang)
             langs.delete(base_lang)
             return langs.map do |lang|
-              file = sort_file_lines!(tmpdir, lang)
+              params_for_lang = placeholder_types_for_keys(tmpdir, lang)
+
               # If the lang ends up not having any translation at all (e.g. a `.lproj` without any `.strings` file in it but maybe just a storyboard or assets catalog), ignore it
-              next nil if file.nil? || only_empty_lines?(file)
-
-              # Compute the diff
-              diff = `diff -U0 "#{base_file}" "#{file}"`
-              # Remove the lines starting with `---`/`+++` which contains the file names (which are temp files we don't want to expose in the final diff to users)
-              # Note: We still keep the `@@ from-file-line-numbers to-file-line-numbers @@` lines to help the user know the index of the key to find it faster,
-              #       and also to serve as a clear visual separator between diff entries in the output.
-              #       Those numbers won't be matching the original `.strings` file line numbers because they are line numbers in the SwiftGen-generated intermediate
-              #       file instead, but they can still give an indication at the index in the list of keys at which this difference is located.
-              diff.gsub!(/^(---|\+\+\+).*\n/, '')
-              diff.empty? ? nil : [lang, diff]
-            end.compact.to_h
-          end
-        end
+              next nil if params_for_lang.nil? || params_for_lang.empty?
 
-        # Returns true if the file only contains empty lines, i.e. lines that only contains whitespace (space, tab, CR, LF)
-        def only_empty_lines?(file)
-          File.open(file) do |f|
-            while (line = f.gets)
-              return false unless line.strip.empty?
-            end
+              violations = params_for_lang.map do |key, param_types|
+                next "`#{key}` was unexpected, as it is not present in the base locale." if params_for_base_lang[key].nil?
+                next "`#{key}` expected placeholders for #{params_for_base_lang[key]} but found #{param_types} instead." if params_for_base_lang[key] != param_types
+              end.compact
+
+              [lang, violations] unless violations.empty?
+            end.compact.to_h
           end
-          return true
         end
       end
     end

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/ios/ios_strings_file_validation_helper.rb

@@ -0,0 +1,107 @@
+module Fastlane
+  module Helper
+    module Ios
+      class StringsFileValidationHelper
+        # context can be one of:
+        #   :root, :maybe_comment_start, :in_line_comment, :in_block_comment,
+        #   :maybe_block_comment_end, :in_quoted_key,
+        #   :after_quoted_key_before_eq, :after_quoted_key_and_equal,
+        #   :in_quoted_value, :after_quoted_value
+        State = Struct.new(:context, :buffer, :in_escaped_ctx, :found_key, keyword_init: true)
+
+        TRANSITIONS = {
+          root: {
+            /\s/ => :root,
+            '/' => :maybe_comment_start,
+            '"' => :in_quoted_key
+          },
+          maybe_comment_start: {
+            '/' => :in_line_comment,
+            /\*/ => :in_block_comment
+          },
+          in_line_comment: {
+            "\n" => :root,
+            /./ => :in_line_comment
+          },
+          in_block_comment: {
+            /\*/ => :maybe_block_comment_end,
+            /./m => :in_block_comment
+          },
+          maybe_block_comment_end: {
+            '/' => :root,
+            /./m => :in_block_comment
+          },
+          in_quoted_key: {
+            '"' => lambda do |state, _|
+              state.found_key = state.buffer.string.dup
+              state.buffer.string = ''
+              :after_quoted_key_before_eq
+            end,
+            /./ => lambda do |state, c|
+              state.buffer.write(c)
+              :in_quoted_key
+            end
+          },
+          after_quoted_key_before_eq: {
+            /\s/ => :after_quoted_key_before_eq,
+            '=' => :after_quoted_key_and_eq
+          },
+          after_quoted_key_and_eq: {
+            /\s/ => :after_quoted_key_and_eq,
+            '"' => :in_quoted_value
+          },
+          in_quoted_value: {
+            '"' => :after_quoted_value,
+            /./m => :in_quoted_value
+          },
+          after_quoted_value: {
+            /\s/ => :after_quoted_value,
+            ';' => :root
+          }
+        }.freeze
+
+        # Inspects the given `.strings` file for duplicated keys, returning them if any.
+        #
+        # @param [String] file The path to the file to inspect.
+        # @return [Hash<String, Array<Int>] Hash with the dublipcated keys.
+        #         Each element has the duplicated key (from the `.strings`) as key and an array of line numbers where the key occurs as value.
+        def self.find_duplicated_keys(file:)
+          keys_with_lines = Hash.new([])
+
+          state = State.new(context: :root, buffer: StringIO.new, in_escaped_ctx: false, found_key: nil)
+
+          File.readlines(file).each_with_index do |line, line_no|
+            line.chars.each_with_index do |c, col_no|
+              # Handle escaped characters at a global level.
+              # This is more straightforward than having to account for it in the `TRANSITIONS` table.
+              if state.in_escaped_ctx || c == '\\'
+                # Just because we check for escaped characters at the global level, it doesn't mean we allow them in every context.
+                allowed_contexts_for_escaped_characters = %i[in_quoted_key in_quoted_value in_block_comment in_line_comment]
+                raise "Found escaped character outside of allowed contexts on line #{line_no + 1} (current context: #{state.context})" unless allowed_contexts_for_escaped_characters.include?(state.context)
+
+                state.buffer.write(c) if state.context == :in_quoted_key
+                state.in_escaped_ctx = !state.in_escaped_ctx
+                next
+              end
+
+              # Look at the transitions table for the current context, and find the first transition matching the current character
+              (_, next_context) = TRANSITIONS[state.context].find { |regex, _| c.match?(regex) } || [nil, nil]
+              raise "Invalid character `#{c}` found on line #{line_no + 1}, col #{col_no + 1}" if next_context.nil?
+
+              state.context = next_context.is_a?(Proc) ? next_context.call(state, c) : next_context
+              next unless state.found_key
+
+              # If we just exited the :in_quoted_key context and thus have found a new key, process it
+              key = state.found_key.dup
+              state.found_key = nil
+
+              keys_with_lines[key] += [line_no + 1]
+            end
+          end
+
+          keys_with_lines.keep_if { |_, lines| lines.count > 1 }
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/metadata_download_helper.rb

@@ -12,8 +12,7 @@ module Fastlane
         @alternates = {}
       end
 
-      # Downloads data from GlotPress,
-      # in JSON format
+      # Downloads data from GlotPress, in JSON format
       def download(target_locale, glotpress_url, is_source)
         uri = URI(glotpress_url)
         response = Net::HTTP.get_response(uri)
@@ -73,15 +72,14 @@ module Fastlane
             UI.message("#{target_locale} translation for #{key} exceeds maximum length (#{message_len}). Switching to the alternate translation.")
             @alternates[data[:alternate_key]] = { desc: data[:desc], max_size: 0 }
           else
-            UI.message("Rejecting #{target_locale} traslation for #{key}: translation length: #{message_len} - max allowed length: #{data[:max_size]}")
+            UI.message("Rejecting #{target_locale} translation for #{key}: translation length: #{message_len} - max allowed length: #{data[:max_size]}")
           end
         else
           save_metadata(target_locale, file[1][:desc], msg)
         end
       end
 
-      # Writes the downloaded content
-      # to the target file
+      # Writes the downloaded content to the target file
       def save_metadata(locale, file_name, content)
         file_path = get_target_file_path(locale, file_name)
 

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/promo_screenshots_helper.rb

@@ -117,8 +117,7 @@ module Fastlane
       end
 
       def draw_screenshot_to_canvas(entry, canvas, device)
-        # Don't require a screenshot to be present – we can just skip
-        # this function if one doesn't exist.
+        # Don't require a screenshot to be present – we can just skip this function if one doesn't exist.
         return canvas if entry['screenshot'].nil?
 
         device_mask = device['screenshot_mask']
@@ -235,7 +234,7 @@ module Fastlane
         begin
           tempTextFile = Tempfile.new()
 
-          sh('drawText', "html=\"#{text}\"", "maxWidth=#{width}", "maxHeight=#{height}", "output=\"#{tempTextFile.path}\"", "fontSize=#{font_size}", "stylesheet=\"#{stylesheet_path}\"", "alignment=\"#{position}\"")
+          Action.sh('drawText', "html=#{text}", "maxWidth=#{width}", "maxHeight=#{height}", "output=#{tempTextFile.path}", "fontSize=#{font_size}", "stylesheet=#{stylesheet_path}", "alignment=#{position}")
 
           text_content = open_image(tempTextFile.path).trim
           text_frame = create_image(width, height)

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/release_notes_helper.rb

@@ -9,9 +9,11 @@ module Fastlane
       def self.add_new_section(path:, section_title:)
         lines = File.readlines(path)
 
-        # Find the index of the first non-empty line that is also NOT a comment. That way we keep commment headers as the very top of the file
+        # Find the index of the first non-empty line that is also NOT a comment.
+        # That way we keep commment headers as the very top of the file
         line_idx = lines.find_index { |l| !l.start_with?('***') && !l.start_with?('//') && !l.chomp.empty? }
-        # Put back the header, then the new entry, then the rest (note: '...' excludes the higher bound of the range, unlike '..')
+        # Put back the header, then the new entry, then the rest
+        # (note: '...' excludes the higher bound of the range, unlike '..')
         new_lines = lines[0...line_idx] + ["#{section_title}\n", "-----\n", "\n", "\n"] + lines[line_idx..]
 
         File.write(path, new_lines.join)

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/user_agent.rb

@@ -0,0 +1,5 @@
+module Fastlane
+  module Wpmreleasetoolkit
+    USER_AGENT = 'Automattic App Release Automator; https://github.com/wordpress-mobile/release-toolkit/'.freeze
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/models/file_reference.rb

@@ -40,11 +40,9 @@ module Fastlane
       end
 
       # "Applies" the instruction described in the instance to the file system.
-      # That is, copies the content of the source `file` to the `destination`
-      # path.
+      # That is, copies the content of the source `file` to the `destination` path.
       #
-      # @raise [StandardError] For security reasons, it will raise if
-      # `destination` is not ignored under Git.
+      # @raise [StandardError] For security reasons, it will raise if `destination` is not ignored under Git.
       def apply
         # Only decrypt the file if the destination is ignored in Git
         unless Fastlane::Helper::GitHelper.is_ignored?(path: destination_file_path)

data/lib/fastlane/plugin/wpmreleasetoolkit/models/firebase_account.rb

@@ -0,0 +1,19 @@
+module Fastlane
+  class FirebaseAccount
+    def self.activate_service_account_with_key_file(key_file_path)
+      Fastlane::Actions.sh('gcloud', 'auth', 'activate-service-account', '--key-file', key_file_path)
+    end
+
+    def self.authenticated?
+      auth_status = JSON.parse(auth_status_data)
+      auth_status.any? do |account|
+        account['status'] == 'ACTIVE'
+      end
+    end
+
+    # Lookup the current account authentication status
+    def self.auth_status_data
+      Fastlane::Actions.sh('gcloud', 'auth', 'list', '--format', 'json', log: false)
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module Fastlane
+  class FirebaseDevice
+    attr_reader :model, :version, :locale, :orientation
+
+    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
+
+    class << self
+      @locale_data = nil
+      @model_data = nil
+      @version_data = nil
+
+      def valid_model_names
+        JSON.parse(model_data).map { |device| device['codename'] }
+      end
+
+      def valid_version_numbers
+        JSON.parse(version_data).map { |version| version['apiLevel'].to_i }
+      end
+
+      def valid_locales
+        JSON.parse(locale_data).map { |locale| locale['id'] }
+      end
+
+      def valid_orientations
+        %w[portrait landscape]
+      end
+
+      def locale_data
+        FirebaseDevice.verify_logged_in!
+        @locale_data ||= Fastlane::Actions.sh('gcloud', 'firebase', 'test', 'android', 'locales', 'list', '--format="json"', log: false)
+      end
+
+      def model_data
+        FirebaseDevice.verify_logged_in!
+        @model_data ||= Fastlane::Actions.sh('gcloud', 'firebase', 'test', 'android', 'models', 'list', '--format="json"', log: false)
+      end
+
+      def version_data
+        FirebaseDevice.verify_logged_in!
+        @version_data ||= Fastlane::Actions.sh('gcloud', 'firebase', 'test', 'android', 'versions', 'list', '--format="json"', log: false)
+      end
+
+      def verify_logged_in!
+        UI.user_error!('You must call `firebase_login` before creating a FirebaseDevice object') unless FirebaseAccount.authenticated?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+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 no test cases failed
+    def success?
+      File.readlines(@path).any? { |line| line.include?('Passed') && line.include?('test cases passed') }
+    end
+
+    # Parse the log for the "More details are available..." URL
+    def more_details_url
+      File.readlines(@path)
+          .flat_map { |line| URI.extract(line) }
+          .find { |url| URI(url).host == 'console.firebase.google.com' && url.include?('/matrices/') }
+    end
+
+    # Parse the log for the Google Cloud Storage Bucket URL
+    def raw_results_paths
+      uri = File.readlines(@path)
+                .flat_map { |line| URI.extract(line) }
+                .map { |string| URI(string) }
+                .find { |u| u.scheme == 'gs' }
+
+      return nil if uri.nil?
+
+      return {
+        bucket: uri.host,
+        prefix: uri.path.delete_prefix('/').chomp('/')
+      }
+    end
+  end
+end