bugsnag-maze-runner 6.27.0

data/lib/maze/retry_handler.rb

@@ -0,0 +1,76 @@
+# 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
+
+      # Errors which indicate a selenium/appium driver has crashed and needs to be restarted
+      DRIVER_ERRORS = [
+        Maze::Error::AppiumElementNotFoundError,
+
+        Selenium::WebDriver::Error::NoSuchElementError,
+        Selenium::WebDriver::Error::StaleElementReferenceError,
+        Selenium::WebDriver::Error::TimeoutError,
+        Selenium::WebDriver::Error::UnknownError,
+        Selenium::WebDriver::Error::WebDriverError
+      ].freeze
+
+      # 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.is_a?(Maze::Driver::ResilientAppium)
+            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)
+        Maze.driver && DRIVER_ERRORS.include?(event.result.exception.class)
+      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

data/lib/maze/runner.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'open3'
+require_relative './interactive_cli'
+
+module Maze
+  # Runs scripts and commands, applying relevant environment variables as necessary
+  class Runner
+    # Determines the default path to the `scripts` directory.  Can be overwritten in the env.rb file.
+    SCRIPT_PATH ||= File.expand_path(File.join(File.dirname(__FILE__), '..', 'features', 'scripts')) unless defined? SCRIPT_PATH
+
+    class << self
+      # Runs a command, applying previously set environment variables.
+      # The output from the command is always printed in debug mode -
+      # just so the caller can verify something about the output.
+      #
+      # @param cmd [String] The command to run
+      # @param blocking [Boolean] Optional. Whether to wait for a return code before proceeding
+      # @param success_codes [Array] Optional. An array of integer codes which indicate the run was successful
+      #
+      # @return [Array, Thread] If blocking, the output and exit_status are returned
+      def run_command(cmd, blocking: true, success_codes: [0])
+        executor = lambda do
+          $logger.debug "Executing: #{cmd}"
+
+          Open3.popen2e(environment, cmd) do |_stdin, stdout_and_stderr, wait_thr|
+            # Add the pid to the list of pids to kill at the end
+            pids << wait_thr.pid unless blocking
+
+            output = []
+            stdout_and_stderr.each do |line|
+              output << line
+              $logger.debug line.chomp
+            end
+
+            exit_status = wait_thr.value.to_i
+            $logger.debug "Exit status: #{exit_status}"
+
+            # if the command fails we log the output at warn level too
+            if !success_codes.nil? && !success_codes.include?(exit_status) && $logger.level != Logger::DEBUG
+              output.each { |line| $logger.warn(cmd) { line.chomp } }
+            end
+
+            return [output, exit_status]
+          end
+        end
+
+        if blocking
+          executor.call
+        else
+          Thread.new(&executor)
+        end
+      end
+
+      # Runs a script in the script directory indicated by the SCRIPT_PATH environment variable.
+      #
+      # @param script_name [String] The name of the script to run
+      # @param blocking [Boolean] Optional. Whether to wait for a return code before proceeding
+      # @param success_codes [Array] Optional. An array of integer codes which indicate the run was successful
+      # @param command [String] Optional.  Command to run the script with, e.g. 'ruby'.
+      #
+      # @return [Array] If blocking, the output and exit_status are returned
+      def run_script(script_name, blocking: false, success_codes: [0], command: nil)
+        script_path = File.join(SCRIPT_PATH, script_name)
+        script_path = File.join(Dir.pwd, script_name) unless File.exist? script_path
+        if command
+          script_path = "#{command} #{script_path}"
+        elsif Gem.win_platform?
+          # Windows does not support the shebang that we use in the scripts so it
+          # needs to know how to execute the script. Passing `cmd /c` tells windows
+          # to use its known file associations to execute this path. If Ruby is
+          # installed on Windows then it will know that `rb` files should be executed
+          # using Ruby etc.
+          script_path = "cmd /c #{script_path}"
+        end
+        run_command(script_path, blocking: blocking, success_codes: success_codes)
+      end
+
+      # Creates a new interactive session. Can only be called if no session already
+      # exists. Check with {interactive_session?} if necessary.
+      #
+      # @return [InteractiveCLI] The interactiveCLI instance
+      def start_interactive_session(*args)
+        raise 'An interactive session is already running!' if interactive_session?
+
+        wait = Maze::Wait.new(interval: 0.3, timeout: 3)
+
+        interactive_session = InteractiveCLI.new(*args)
+
+        success = wait.until { interactive_session.running? }
+        raise 'Shell session did not start in time!' unless success
+
+        @interactive_session = interactive_session
+      end
+
+      def interactive_session?
+        !@interactive_session.nil?
+      end
+
+      def interactive_session
+        raise 'No interactive session is running!' unless interactive_session?
+
+        @interactive_session
+      end
+
+      # Stops the interactive session, allowing a new one to be started
+      #
+      # @return [Boolean] True if the interactive session exited successfully
+      def stop_interactive_session
+        raise 'No interactive session is running!' unless interactive_session?
+
+        success = @interactive_session.stop
+
+        # Make sure the process is killed if it did not stop
+        pids << @interactive_session.pid if @interactive_session.running?
+
+        @interactive_session = nil
+
+        success
+      end
+
+      # Stops all script processes previously started by this class.
+      def kill_running_scripts
+        stop_interactive_session if interactive_session?
+
+        pids.each do |p|
+          Process.kill('KILL', p)
+        rescue Errno::ESRCH
+          # ignored
+        end
+        pids.clear
+      end
+
+      # Allows access to a hash of environment variables applied to command and script runs.
+      #
+      # @return [Hash] The hash of currently set environment variables and their values
+      def environment
+        @environment ||= {}
+      end
+
+      # Allows access to the process ids created by the runner.
+      #
+      # @return [Array] pids created by the runner
+      def pids
+        @pids ||= []
+      end
+    end
+  end
+end

data/lib/maze/sauce_labs_utils.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Maze
+  # Utils supporting the SauceLabs device farm integration
+  class SauceLabsUtils
+    PID_FILE = 'sc.pid'
+    READY_FILE = 'sc.ready'
+
+    class << self
+      attr_accessor :connect_shell
+
+      # Uploads an app to Sauce Labs for later consumption
+      # @param username [String] the Sauce Labs username
+      # @param access_key [String] the Sauce Labs access key
+      def upload_app(username, access_key, app)
+        uuid_regex = /\A[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}\z/
+
+        if uuid_regex.match? app
+          $logger.info "Using pre-uploaded app with UUID #{app}"
+          app_uuid = app
+        else
+          expanded_app = Maze::Helper.expand_path(app)
+          $logger.info "Uploading app: #{expanded_app}"
+
+          # Upload the app tp Sauce Labs
+          uri = URI('https://api.us-west-1.saucelabs.com/v1/storage/upload')
+          request = Net::HTTP::Post.new(uri)
+          request.basic_auth(username, access_key)
+          request.set_form({ 'payload' => File.new(expanded_app, 'rb') }, 'multipart/form-data')
+
+          res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+            http.request(request)
+          end
+
+          # Pull the UUID from the response
+          begin
+            response = JSON.parse res.body
+
+            if response.key?('item') && response['item'].key?('id')
+              app_uuid = response['item']['id']
+              $logger.info "Uploaded app UUID: #{app_uuid}"
+              $logger.info 'You can use this UUID to avoid uploading the same app more than once.'
+            else
+              $logger.error "Unexpected response body: #{}"
+              raise 'App upload failed'
+            end
+          rescue JSON::ParserError
+            $logger.error "Expected JSON response, received: #{body}"
+            raise
+          end
+        end
+        app_uuid
+      end
+
+      # Sauce Connect
+      # @param sc_local [String] path to the Sauce Connect binary
+      # @param tunnel_id [String] unique key for the tunnel instance
+      # @param username [String] Sauce Labs username
+      # @param access_key [String] Sauce Labs access key
+      def start_sauce_connect(sc_local, tunnel_id, username, access_key)
+        $logger.info 'Starting Sauce Connect tunnel'
+        endpoint = 'https://saucelabs.com/rest/v1'
+        wait = Maze::Wait.new(interval: 0.3, timeout: 3)
+        connect_shell = Maze::InteractiveCLI.new
+        success = wait.until { connect_shell.running? }
+        raise 'Shell session did not start in time!' unless success
+
+        command = "#{sc_local} -u #{username} -k #{access_key} -x #{endpoint} " \
+                  "-i #{tunnel_id} -d #{PID_FILE} -l sc.log -f #{READY_FILE}"
+
+        # TODO Handle the case where the command fails, providing suitable diagnostics
+        File.delete(READY_FILE) if File.exist?(READY_FILE)
+        File.delete(PID_FILE) if File.exist?(PID_FILE)
+        connect_shell.run_command command
+        success = Maze::Wait.new(timeout: 30).until do
+          File.exist? READY_FILE
+        end
+        unless success
+          $logger.info "Failed: #{connect_shell.stdout_lines}"
+        end
+      end
+
+      def stop_sauce_connect
+        pid = nil
+        File.open(PID_FILE, 'r') do |file|
+          pid = file.read.to_i
+        end
+        Process.kill('INT', pid)
+        Maze::Wait.new(timeout: 30).until do
+          `ps aux | awk '{print $2 }' | grep #{pid}`.empty?
+        end
+        File.delete(PID_FILE) if File.exist?(PID_FILE)
+      end
+    end
+  end
+end

data/lib/maze/server.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'securerandom'
+require 'webrick'
+require_relative './logger'
+require_relative './request_list'
+
+module Maze
+  # Receives and stores requests through a WEBrick HTTPServer
+  class Server
+
+    class << self
+      # Allows overwriting of the server status code
+      attr_writer :status_code
+
+      # Dictates if the status code should be reset after use
+      attr_writer :reset_status_code
+
+      # Allows a delay in milliseconds before responding to HTTP requests to be set
+      attr_writer :response_delay_ms
+
+      # Dictates if the response delay should be reset after use
+      attr_writer :reset_response_delay
+
+      # @return [String] The UUID attached to all command requests for this session
+      attr_reader :command_uuid
+
+      # The intended HTTP status code on a successful request
+      #
+      # @return [Integer] The HTTP status code, defaults to 200
+      def status_code
+        code = @status_code ||= 200
+        @status_code = 200 if reset_status_code
+        code
+      end
+
+      def reset_status_code
+        @reset_status_code ||= false
+      end
+
+      def response_delay_ms
+        delay = @response_delay_ms ||= 0
+        @response_delay_ms = 0 if reset_response_delay
+        delay
+      end
+
+      def reset_response_delay
+        @reset_response_delay ||= false
+      end
+
+      # Provides dynamic access to request lists by name
+      #
+      # @param type [String, Symbol] Request type
+      # @return Request list for the type given
+      def list_for(type)
+        type = type.to_s
+        case type
+        when 'error', 'errors'
+          errors
+        when 'session', 'sessions'
+          sessions
+        when 'build', 'builds'
+          builds
+        when 'log', 'logs'
+          logs
+        when 'upload', 'uploads'
+          uploads
+        when 'sourcemap', 'sourcemaps'
+          sourcemaps
+        when 'invalid', 'invalid requests'
+          invalid_requests
+        else
+          raise "Invalid request type '#{type}'"
+        end
+      end
+
+      # A list of error requests received
+      #
+      # @return [RequestList] Received error requests
+      def errors
+        @errors ||= RequestList.new
+      end
+
+      # A list of session requests received
+      #
+      # @return [RequestList] Received error requests
+      def sessions
+        @sessions ||= RequestList.new
+      end
+
+      # A list of build requests received
+      #
+      # @return [RequestList] Received build requests
+      def builds
+        @builds ||= RequestList.new
+      end
+
+      # A list of upload requests received
+      #
+      # @return [RequestList] Received upload requests
+      def uploads
+        @uploads ||= RequestList.new
+      end
+
+      # A list of sourcemap requests received
+      #
+      # @return [RequestList] Received sourcemap requests
+      def sourcemaps
+        @sourcemaps ||= RequestList.new
+      end
+
+      # A list of log requests received
+      #
+      # @return [RequestList] Received log requests
+      def logs
+        @logs ||= RequestList.new
+      end
+
+      # A list of commands for a test fixture to perform.  Strictly speaking these are responses to HTTP
+      # requests, but the list behavior is all we need.
+      #
+      # @return [RequestList] Commands to be performed
+      def commands
+        @commands ||= RequestList.new
+      end
+
+      # Whether the server thread is running
+      # An array of any invalid requests received.
+      # Each request is hash consisting of:
+      #   request: The original HTTPRequest object
+      #   reason: Reason for being considered invalid. Examples include invalid JSON and missing/invalid digest.
+      # @return [RequestList] An array of received requests
+      def invalid_requests
+        @invalid_requests ||= RequestList.new
+      end
+
+      # Whether the server thread is running
+      #
+      # @return [Boolean] If the server is running
+      def running?
+        @thread&.alive?
+      end
+
+      # Starts the WEBrick server in a separate thread
+      def start
+        attempts = 0
+        $logger.info 'Starting mock server'
+        @command_uuid = SecureRandom.uuid
+        $logger.info "Fixture commands UUID: #{@command_uuid}"
+        loop do
+
+          @thread = Thread.new do
+            options = {
+                Port: Maze.config.port,
+                Logger: $logger,
+                AccessLog: []
+            }
+            options[:BindAddress] = Maze.config.bind_address unless Maze.config.bind_address.nil?
+            server = WEBrick::HTTPServer.new(options)
+
+            # Mount a block to respond to all requests with status:200
+            server.mount_proc '/' do |_request, response|
+              $logger.info 'Received request on server root, responding with 200'
+              response.header['Access-Control-Allow-Origin'] = '*'
+              response.body = 'Maze runner received request'
+              response.status = 200
+            end
+
+            # When adding more endpoints, be sure to update the 'I should receive no requests' step
+            server.mount '/notify', Servlets::Servlet, :errors
+            server.mount '/sessions', Servlets::Servlet, :sessions
+            server.mount '/builds', Servlets::Servlet, :builds
+            server.mount '/uploads', Servlets::Servlet, :uploads
+            server.mount '/sourcemap', Servlets::Servlet, :sourcemaps
+            server.mount '/react-native-source-map', Servlets::Servlet, :sourcemaps
+            server.mount '/command', Servlets::CommandServlet
+            server.mount '/logs', Servlets::LogServlet
+            server.start
+          rescue StandardError => e
+            $logger.warn "Failed to start mock server: #{e.message}"
+          ensure
+            server&.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 mock server' if attempts == 3
+
+          # Failed to start - sleep before retrying
+          $logger.info 'Retrying in 5 seconds'
+          sleep 5
+        end
+      end
+
+      # Stops the WEBrick server thread if it's running
+      def stop
+        @thread&.kill if @thread&.alive?
+        @thread = nil
+      end
+    end
+  end
+end

data/lib/maze/servlets/base_servlet.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Maze
+  module Servlets
+
+    # Base servlet to avoid duplication of common code
+    class BaseServlet < WEBrick::HTTPServlet::AbstractServlet
+      # Logs and returns a set of valid headers for this servlet.
+      #
+      # @param request [HTTPRequest] The incoming GET request
+      # @param response [HTTPResponse] The response to return
+      def do_OPTIONS(request, response)
+        response.header['Access-Control-Allow-Origin'] = '*'
+        response.header['Access-Control-Allow-Headers'] = %w[Accept
+                                                             Bugsnag-Api-Key Bugsnag-Integrity
+                                                             Bugsnag-Payload-Version
+                                                             Bugsnag-Sent-At Content-Type
+                                                             Origin].join(',')
+      end
+    end
+  end
+end

data/lib/maze/servlets/command_servlet.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Maze
+  module Servlets
+
+    # Allows clients to queue up "commands", in the form of Ruby hashes, using Maze::Server.commands.add.  GET
+    # requests made to the /command endpoint will then respond with each queued command in turn.
+    class CommandServlet < BaseServlet
+      # Serves the next command, if these is one.
+      #
+      # @param _request [HTTPRequest] The incoming GET request
+      # @param response [HTTPResponse] The response to return
+      def do_GET(_request, response)
+        response.header['Access-Control-Allow-Origin'] = '*'
+
+        commands = Maze::Server.commands
+        # Note that empty? is not the same as size == 0 (design bug to be corrected in v7)
+        if commands.size == 0
+          response.body = 'No commands to provide'
+          response.status = 400
+        else
+          command = commands.current
+          command[:uuid] = Maze::Server.command_uuid
+          response.body = JSON.pretty_generate(command)
+          response.status = 200
+          commands.next
+        end
+      end
+
+      # Logs and returns a set of valid headers for this servlet.
+      #
+      # @param request [HTTPRequest] The incoming GET request
+      # @param response [HTTPResponse] The response to return
+      def do_OPTIONS(request, response)
+        super
+
+        response.header['Access-Control-Allow-Methods'] = 'POST, OPTIONS'
+        response.status = Server.status_code
+      end
+    end
+  end
+end

data/lib/maze/servlets/log_servlet.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Maze
+  module Servlets
+
+    # Receives log requests sent from the test fixture
+    class LogServlet < BaseServlet
+      # Constructor
+      #
+      # @param server [HTTPServer] WEBrick HTTPServer
+      def initialize(server)
+        super server
+        @requests = Server.logs
+      end
+
+      # Logs and parses an incoming POST request.
+      # Parses `multipart/form-data` and `application/json` content-types.
+      # Parsed requests are added to the requests list.
+      #
+      # @param request [HTTPRequest] The incoming GET request
+      # @param response [HTTPResponse] The response to return
+      def do_POST(request, response)
+        hash = {
+          body: JSON.parse(request.body),
+          request: request
+        }
+        @requests.add(hash)
+
+        response.header['Access-Control-Allow-Origin'] = '*'
+        response.status = Server.status_code
+      rescue JSON::ParserError => e
+        msg = "Unable to parse request as JSON: #{e.message}"
+        $logger.error msg
+        Server.invalid_requests.add({
+          reason: msg,
+          request: request,
+          body: request.body
+        })
+      rescue StandardError => e
+        $logger.error "Invalid request: #{e.message}"
+        Server.invalid_requests.add({
+          invalid: true,
+          reason: e.message,
+          request: {
+            request_uri: request.request_uri,
+            header: request.header.to_h,
+            body: request.inspect
+          }
+        })
+      end
+
+      # Logs and returns a set of valid headers for this servlet.
+      #
+      # @param request [HTTPRequest] The incoming GET request
+      # @param response [HTTPResponse] The response to return
+      def do_OPTIONS(request, response)
+        super
+
+        response.header['Access-Control-Allow-Methods'] = 'POST, OPTIONS'
+        response.status = Server.status_code
+      end
+    end
+  end
+end