bugsnag-maze-runner 7.22.1

data/lib/maze/option.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Provides the set of Maze Runner command line options
+module Maze
+  module Option
+    # Document server options
+    DS_BIND_ADDRESS = 'document-server-bind-address'
+    DS_PORT = 'document-server-port'
+    DS_ROOT = 'document-server-root'
+
+    # Server options
+    BIND_ADDRESS = 'bind-address'
+    NULL_PORT = 'null-port'
+    PORT = 'port'
+
+    # Appium options
+    A11Y_LOCATOR = 'a11y-locator'
+    APP = 'app'
+    CAPABILITIES = 'capabilities'
+    FARM = 'farm'
+
+    # Generic device farm options
+    ACCESS_KEY = 'access-key'
+    APP_BUNDLE_ID = 'app-bundle-id'
+    APPIUM_VERSION = 'appium-version'
+    BROWSER = 'browser'
+    DEVICE = 'device'
+    LIST_DEVICES = 'list-devices'
+    OS = 'os'
+    OS_VERSION = 'os-version'
+    TUNNEL = 'tunnel'
+    USERNAME = 'username'
+
+    # BitBar options
+    SB_LOCAL = 'sb-local'
+
+    # BrowserStack-only options
+    BS_LOCAL = 'bs-local'
+
+    # BitBar-only options
+    TMS_URI = 'tms-uri'
+    TMS_TOKEN = 'tms-token'
+
+    # Local-only options
+    APPIUM_LOGFILE = 'appium-logfile'
+    APPIUM_SERVER = 'appium-server'
+    APPLE_TEAM_ID = 'apple-team-id'
+    START_APPIUM = 'start-appium'
+    UDID = 'udid'
+
+    # Logging options
+    ALWAYS_LOG = 'always-log'
+    FILE_LOG = 'file-log'
+    LOG_REQUESTS = 'log-requests'
+
+    # General options
+    AWS_PUBLIC_IP = 'aws-public-ip'
+    REPEATER_API_KEY = 'repeater-api-key'
+    ENABLE_BUGSNAG = 'enable-bugsnag'
+    ENABLE_RETRIES = 'enable-retries'
+  end
+end

data/lib/maze/plugins/bugsnag_reporting_plugin.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'bugsnag'
+require 'cucumber/core/filter'
+
+# Required to access the options
+module Cucumber
+  class Configuration
+    attr_accessor :options
+  end
+end
+
+module Maze
+  module Plugins
+    class BugsnagReportingPlugin < Cucumber::Core::Filter.new(:configuration)
+
+      def test_case(test_case)
+        configuration.on_event(:test_step_finished) do |event|
+          @last_test_step = event.test_step if event.result.failed?
+        end
+
+        configuration.on_event(:test_case_finished) do |event|
+
+          # Ensure we're in the correct test case and that it's failed
+          next unless event.test_case.eql?(test_case) && event.result.failed?
+
+          Bugsnag.notify(event.result.exception) do |bsg_event|
+            unless @last_test_step.nil?
+              bsg_event.context = @last_test_step.location
+              bsg_event.grouping_hash = test_case.name + @last_test_step.location
+              bsg_event.add_metadata(:'scenario', {
+                'failing step': @last_test_step.to_s,
+                'failing step location': @last_test_step.location
+              })
+            end
+            bsg_event.add_metadata(:'scenario', {
+              'scenario name': test_case.name,
+              'scenario location': test_case.location,
+              'scenario tags': test_case.tags,
+              'scenario duration (mS)': event.result.duration.nanoseconds/1000000
+            })
+          end
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/maze/plugins/cucumber_report_plugin.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'bugsnag'
+require 'cucumber/core/filter'
+require 'json'
+
+# Required to access the options
+module Cucumber
+  class Configuration
+    attr_accessor :options
+  end
+end
+
+module Maze
+  module Plugins
+    class CucumberReportPlugin
+
+      def initialize
+        configured_data = {
+          driver_class: Maze.driver.class,
+          device_farm: Maze.config.farm,
+          device: Maze.config.device,
+          os: Maze.config.os,
+          os_version: Maze.config.os_version
+        }
+        buildkite_data = {
+          pipeline: ENV['BUILDKITE_PIPELINE_NAME'],
+          repo: ENV['BUILDKITE_REPO'],
+          build_url: ENV['BUILDKITE_BUILD_URL'],
+          branch: ENV['BUILDKITE_BRANCH'],
+          message: ENV['BUILDKITE_MESSAGE'],
+          step: ENV['BUILDKITE_LABEL'],
+          commit: ENV['BUILDKITE_COMMIT']
+        }
+        report['configuration'] = configured_data
+        report['build'] = buildkite_data
+      end
+
+      def install_plugin(cuc_config)
+        unless Maze.config.tms_uri && Maze.config.tms_token && ENV['BUILDKITE']
+          $logger.info 'No test report will be delivered for this run'
+          return
+        end
+        # Add installation hook
+        cuc_config.formats << ['json', {}, json_report_stream]
+
+        # Add exit hook
+        at_exit do
+          finish_report
+        end
+      end
+
+      def json_report_stream
+        @json_report_stream ||= StringIO.new
+      end
+
+      def report
+        @report ||= {}
+      end
+
+      private
+
+      def finish_report
+        session_hash = JSON.parse(json_report_stream.string)
+        report[:session] = session_hash
+        output_folder = File.join(Dir.pwd, 'maze_output')
+        filename = 'maze_report.json'
+        filepath = File.join(output_folder, filename)
+
+        begin
+          File.open(filepath, 'w') do |file|
+            file.puts JSON.pretty_generate(report)
+          end
+        rescue => e
+          $logger.warn 'Report could not be saved locally'
+          $logger.warn e.message
+        end
+
+        send_report
+      end
+
+      def send_report
+        uri = URI("#{Maze.config.tms_uri}/report")
+        request = Net::HTTP::Post.new(uri)
+        request['Content-Type'] = 'application/json'
+        request['Authorization'] = Maze.config.tms_token
+        request.body = JSON.generate(report)
+
+        begin
+          http = Net::HTTP.new(uri.hostname, uri.port)
+          http.request(request)
+        rescue => e
+          $logger.warn 'Report delivery attempt failed'
+          $logger.warn e.message
+        else
+          $logger.info 'Cucumber report delivered to test report server'
+        end
+      end
+    end
+  end
+end

data/lib/maze/plugins/error_code_plugin.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Maze
+  module Plugins
+    class ErrorCodePlugin < Cucumber::Core::Filter.new(:configuration)
+
+      def test_case(test_case)
+        configuration.on_event(:test_case_finished) do |event|
+
+          # Ensure we're in the correct test case, and the test failed
+          next unless event.test_case == test_case
+
+          error = event.result.failed? ? event.result.exception.class : nil
+          Maze::Hooks::ErrorCodeHook.last_test_error_class = error
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/maze/plugins/global_retry_plugin.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'cucumber/core/filter'
+
+# Required to access the options
+module Cucumber
+  class Configuration
+    attr_accessor :options
+  end
+end
+
+module Maze
+  module Plugins
+    class GlobalRetryPlugin < Cucumber::Core::Filter.new(:configuration)
+
+      def test_case(test_case)
+        configuration.on_event(:test_case_finished) do |event|
+
+          # Ensure we're in the correct test case
+          next unless event.test_case == test_case
+
+          # Set retry to 0
+          configuration.options[:retry] = 0
+
+          # Guard to check if the case should be retried
+          should_retry = event.result.failed? && Maze::RetryHandler.should_retry?(test_case, event)
+
+          next unless should_retry
+
+          # Set retry to 1
+          configuration.options[:retry] = 1
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/maze/proxy.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'singleton'
+require 'webrick'
+require 'webrick/https'
+require 'webrick/httpproxy'
+
+module Maze
+  # Provides the ability to run a proxy server, using the WEBrick proxy server.
+  # Note that for an HTTPS proxy a self-signed certificate will be used.  If using curl, for example, this
+  # means having to employ the --proxy-insecure option.
+  class Proxy
+    include Singleton
+
+    # There are some constraints on the port from driving remote browsers on BrowserStack.
+    # E.g. the ports/ranges that Safari will access on "localhost" urls are restricted to the following:
+    #   80, 3000, 4000, 5000, 8000, 8080 or 9000-9999 [ from https://stackoverflow.com/a/28678652 ]
+    PORT = 9000
+
+    def initialize
+      @hosts = []
+    end
+
+    # Whether the proxy handled a request for the given host
+    #
+    # @param host [String] The destination host to test for
+    def handled_host?(host)
+      @hosts.include? host
+    end
+
+    # Whether the proxy server thread is running
+    #
+    def running?
+      @thread&.alive?
+    end
+
+    # Starts the WEBrick proxy in a separate thread
+    # If authentication if requested, then the credentials used are simply 'user' with 'password'.
+    #
+    # @param protocol [Symbol] :Http or Https
+    # @param authenticated [Boolean] Whether basic authentication should be applied.
+    def start(protocol, authenticated = false)
+      @hosts.clear
+
+      attempts = 0
+      $logger.info 'Starting proxy server'
+      loop do
+        @thread = Thread.new do
+
+          handler = proc do |req, res|
+            req.header['host'].each { |host| @hosts.append(host) }
+          end
+          config = {
+            Logger: $logger,
+            Port: PORT,
+            ProxyContentHandler: handler
+          }
+
+          # Setup protocol
+          if protocol == :Http
+            $logger.info 'Starting HTTP proxy'
+          elsif protocol == :Https
+            $logger.info 'Starting HTTPS proxy'
+            cert_name = [
+              %w[CN localhost]
+            ]
+            config[:SSLCertName] = cert_name
+            config[:SSLEnable] = true
+          else
+            raise "Unsupported protocol #{protocol}: :Http and :Https are supported"
+          end
+
+          # Authentication required?
+          if authenticated
+            # Apache compatible Password manager
+            htpasswd = WEBrick::HTTPAuth::Htpasswd.new File.expand_path('htpasswd', __dir__)
+            htpasswd.set_passwd 'Proxy Realm', 'user', 'password'
+            htpasswd.flush
+            authenticator = WEBrick::HTTPAuth::ProxyBasicAuth.new Realm: 'Proxy Realm',
+                                                                  UserDB: htpasswd
+            config[:ProxyAuthProc] = authenticator.method(:authenticate).to_proc
+          end
+
+          # Crwate and start the proxy
+          proxy = WEBrick::HTTPProxyServer.new config
+          proxy.start
+        rescue StandardError => e
+          $logger.warn "Failed to start proxy server: #{e.message}"
+        ensure
+          proxy&.shutdown
+        end
+
+        # Need a short sleep here as a dying thread is still alive momentarily
+        sleep 1
+        break if running?
+
+        # Bail out after 3 attempts
+        attempts += 1
+        raise 'Too many failed attempts to start proxy server' if attempts == 3
+
+        # Failed to start - sleep before retrying
+        $logger.info 'Retrying in 5 seconds'
+        sleep 5
+      end
+    end
+
+    # Stops the WEBrick proxy thread if it's running
+    def stop
+      @thread&.kill if @thread&.alive?
+      @thread = nil
+    end
+  end
+end

data/lib/maze/request_list.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Maze
+  # An abstraction for storing a list of requests (e.g. Errors, Sessions),
+  # keeping track of the "current" request (i.e. the one being inspected).
+  class RequestList
+    def initialize
+      @requests = []
+      @current = 0
+      @count = 0
+    end
+
+    # The number of unprocessed/remaining requests in the list (not the total number actually held)
+    def size_remaining
+      @count
+    end
+
+    # The total number of requests received, including those already processed
+    def size_all
+      @requests.size
+    end
+
+    # Add a request to the list
+    #
+    # @param request The new request, from which a clone is made
+    def add(request)
+      @requests.append request.clone
+      @count += 1
+    end
+
+    # The current request
+    def current
+      @requests[@current] if @requests.size > @current
+    end
+
+    # Peek at requests yet to be processed - i.e. from current onwards.  All requests are left visible in the list.
+    # Returns an empty array if there are no requests outstanding.
+    def remaining
+      return [] if current.nil?
+
+      @requests[@current..@requests.size]
+    end
+
+    # Moves to the next request, if there is one
+    def next
+      return if @current >= @requests.size
+
+      @current += 1
+      @count -= 1
+    end
+
+    # A frozen clone of all requests held, including those already processed
+    def all
+      @requests.clone.freeze
+    end
+
+    # Clears the list
+    def clear
+      @requests.clear
+      @current = 0
+      @count = 0
+    end
+
+    # Sorts the first `count` elements of the list by the Bugsnag-Sent-At header, if present in all of those elements
+    def sort_by_sent_at!(count)
+      return unless count > 1
+
+      header = 'Bugsnag-Sent-At'
+      sub_list = @requests[@current...@current + count]
+
+      return if sub_list.any? { |r| r[:request][header].nil? }
+
+      # Sort sublist by Bugsnag-Sent-At and overwrite in the main list
+      sub_list.sort_by! { |r| DateTime.parse(r[:request][header]) }
+      sub_list.each_with_index { |r, i| @requests[@current + i] = r }
+    end
+
+    # Sorts the remaining elements of the list by the field given, if present in all of those elements
+    def sort_by!(key_path)
+      list = remaining
+
+      # Sort the list and overwrite in the main list
+      list.sort_by! { |r| Maze::Helper.read_key_path(r[:body], key_path) }
+      list.each_with_index { |r, i| @requests[@current + i] = r }
+    end
+  end
+end

data/lib/maze/request_repeater.rb

@@ -0,0 +1,49 @@
+module Maze
+  # Repeats POST requests
+  module RequestRepeater
+
+    def do_POST(request, response)
+      repeat(request) if enabled?
+
+      super(request, response)
+    end
+
+    private
+
+    def enabled?
+      # enabled if the config option is on and this request type should be repeated
+      Maze.config.repeater_api_key && url_for_request_type
+    end
+
+    # @param request [HTTPRequest] The request to be repeated
+    def repeat(request)
+
+      # TODO Forwarding of internal errors to be considered later
+      return if request.header.keys.any? { |key| key.downcase == 'bugsnag-internal-error' }
+
+      url = url_for_request_type
+      http = Net::HTTP.new(url.host)
+      bugsnag_request = Net::HTTP::Post.new(url.path)
+
+      # Set all headers that are present
+      bugsnag_request.body = request.body
+      request.header.each {|key,value| bugsnag_request[key] = value }
+      bugsnag_request['bugsnag-api-key'] = Maze.config.repeater_api_key
+
+      # TODO Also overwrite apiKey in the payload, if present, recalculate the integrity header (handling
+      #   compressed payloads if the content-encoding header is set accordingly)
+
+      http.request(bugsnag_request)
+    end
+
+    def url_for_request_type
+      url = case @request_type
+            when :errors then 'https://notify.bugsnag.com/'
+            when :sessions then 'https://sessions.bugsnag.com/'
+            when :traces then 'https://otlp.bugsnag.com/v1/traces'
+            else return nil
+            end
+      URI.parse(url)
+    end
+  end
+end

data/lib/maze/retry_handler.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'appium_lib'
+
+module Maze
+  # Handles the logic of when a test should be retried after a failure.
+  # Note: This class expects a failed test. For repeating a single test see RepeatHandler
+  class RetryHandler
+    class << self
+
+      # Acceptable tags to indicate a test should be restarted
+      RETRY_TAGS = %w[@retry @retryable @retriable].freeze
+
+      # Determines whether a failed test_case should be restarted
+      #
+      # @param test_case [Cucumber::RunningTestCase] The current test_case or scenario
+      # @param event [Cucumber::Core::Event] The triggering event
+      def should_retry?(test_case, event)
+        # Only retry if the option is set and we haven't already retried
+        return false if !Maze.config.enable_retries || retried_previously?(test_case)
+
+        if retry_on_driver_error?(event)
+          $logger.warn "Retrying #{test_case.name} due to driver error: #{event.result.exception}"
+          if Maze.driver.is_a?(Maze::Driver::Appium)
+            Maze.driver.restart
+          elsif Maze.driver.is_a?(Maze::Driver::Browser)
+            Maze.driver.refresh
+          end
+        elsif retry_on_tag?(test_case)
+          $logger.warn "Retrying #{test_case.name} due to retry tag"
+        elsif Maze.dynamic_retry
+          $logger.warn "Retrying #{test_case.name} due to dynamic retry set"
+        else
+          return false
+        end
+        increment_retry_count(test_case)
+        true
+      end
+
+      def retried_previously?(test_case)
+        global_retried[test_case] > 0
+      end
+
+      private
+
+      def increment_retry_count(test_case)
+        global_retried[test_case] += 1
+      end
+
+      def retry_on_driver_error?(event)
+        error_class = event.result.exception.class
+        maze_errors = Maze::Error::ERROR_CODES
+        Maze.driver && maze_errors.include?(error_class) && maze_errors[error_class][:retry]
+      end
+
+      def retry_on_tag?(test_case)
+        test_case.tags.any? do |tag|
+          RETRY_TAGS.include?(tag.name)
+        end
+      end
+
+      def global_retried
+        @global_retried ||= Hash.new { |h, k| h[k] = 0 }
+      end
+    end
+  end
+end