bugsnag-maze-runner 6.27.0

data/lib/maze/servlets/reflective_servlet.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Maze
+  module Servlets
+    # Receives HTTP requests and responds according to the parameters given, which are:
+    # - delay_ms - milliseconds to wait before responding
+    # - status - HTTP response code
+    # For GET requests these are expected to passed as GET parameters,
+    # for POST requests they are expected to be given as JSON fields.
+    class ReflectiveServlet < WEBrick::HTTPServlet::AbstractServlet
+
+      # Accepts a GET request to provide a reflective response to.
+      #
+      # @param request [HTTPRequest] The incoming GET request
+      # @param response [HTTPResponse] The response to return
+      def do_GET(request, response)
+        delay_ms = request.query['delay_ms']
+        status = request.query['status']
+        reflect response, delay_ms, status
+      end
+
+      # Accepts a POST request to provide a reflective response to.
+      #
+      # @param request [HTTPRequest] The incoming GET request
+      # @param response [HTTPResponse] The response to return
+      def do_POST(request, response)
+
+        content_type = request['Content-Type']
+        unless content_type == 'application/json'
+          msg = "Content-Type '#{content_type}' not supported - only application/json is supported at present"
+          $logger.error msg
+          response.status = 415
+          response.body = msg
+          return
+        end
+
+        body = JSON.parse(request.body)
+        delay_ms = body['delay_ms']
+        status = body['status']
+
+        reflect response, delay_ms, status
+      rescue JSON::ParserError => e
+        msg = "Unable to parse request as JSON: #{e.message}"
+        $logger.error msg
+        response.status = 418
+      rescue StandardError => e
+        $logger.error "Invalid request: #{e.message}"
+        response.status = 500
+      end
+
+      def reflect(response, delay_ms, status)
+        sleep delay_ms.to_i / 1000 unless delay_ms.nil?
+        response.status = status || 200
+        response.header['Access-Control-Allow-Origin'] = '*'
+        response.body = "Returned status #{status} after waiting #{delay_ms} ms"
+      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'] = 'GET, POST, OPTIONS'
+      end
+    end
+  end
+end

data/lib/maze/servlets/servlet.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Maze
+  module Servlets
+
+    # Receives and parses the requests and payloads sent from the test fixture
+    class Servlet < BaseServlet
+      # Constructor
+      #
+      # @param server [HTTPServer] WEBrick HTTPServer
+      # @param request_type [Symbol] Request type that the servlet will receive
+      def initialize(server, request_type)
+        super server
+        @request_type = request_type
+        @requests = Server.list_for request_type
+      end
+
+      # Logs an incoming GET WEBrick request.
+      #
+      # @param request [HTTPRequest] The incoming GET request
+      # @param _response [HTTPResponse] The response to return
+      def do_GET(request, _response)
+        log_request(request)
+      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)
+        log_request(request)
+        case request['Content-Type']
+        when %r{^multipart/form-data; boundary=([^;]+)}
+          boundary = WEBrick::HTTPUtils::dequote($1)
+          body = WEBrick::HTTPUtils.parse_form_data(request.body, boundary)
+          hash = {
+            body: body,
+            request: request
+          }
+        else
+          # "content-type" is assumed to be JSON (which mimics the behaviour of
+          # the actual API). This supports browsers that can't set this header for
+          # cross-domain requests (IE8/9)
+          digests = check_digest request
+          hash = {
+            body: JSON.parse(request.body),
+            request: request,
+            digests: digests
+          }
+        end
+        @requests.add(hash)
+
+        # For the response, delaying if configured to do so
+        response_delay_ms = Server.response_delay_ms
+        if response_delay_ms.positive?
+          $logger.info "Waiting #{response_delay_ms} milliseconds before responding"
+          sleep response_delay_ms / 1000.0
+        end
+        response.header['Access-Control-Allow-Origin'] = '*'
+        response.status = Server.status_code
+      rescue JSON::ParserError => e
+        msg = "Unable to parse request as JSON: #{e.message}"
+        if Maze.config.captured_invalid_requests.include? @request_type
+          $logger.error msg
+          Server.invalid_requests.add({
+            reason: msg,
+            request: request,
+            body: request.body
+          })
+        else
+          $logger.warn msg
+        end
+      rescue StandardError => e
+        if Maze.config.captured_invalid_requests.include? @request_type
+          $logger.error "Invalid request: #{e.message}"
+          Server.invalid_requests.add({
+            invalid: true,
+            reason: e.message,
+            request: {
+              request_uri: request.request_uri,
+              header: request.header,
+              body: request.inspect
+            }
+          })
+        else
+          $logger.warn "Invalid request: #{e.message}"
+        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
+
+      private
+
+      def log_request(request)
+        $logger.debug "#{request.request_method} request received"
+        $logger.debug "URI: #{request.unparsed_uri}"
+        $logger.debug "HEADERS: #{request.raw_header}"
+        return if request.body.nil?
+
+        case request['Content-Type']
+        when nil
+          nil
+        when %r{^multipart/form-data; boundary=([^;]+)}
+          boundary = WEBrick::HTTPUtils.dequote(Regexp.last_match(1))
+          body = WEBrick::HTTPUtils.parse_form_data(request.body, boundary)
+          $logger.debug 'BODY:'
+          LogUtil.log_hash(Logger::Severity::DEBUG, body)
+        else
+          $logger.debug "BODY: #{JSON.pretty_generate(JSON.parse(request.body))}"
+        end
+      end
+
+      # Checks the Bugsnag-Integrity header, if present, against the request and based on configuration.
+      # If the header is present, if the digest must be correct.  However, the header need only be present
+      # if configuration says so.
+      def check_digest(request)
+        header = request['Bugsnag-Integrity']
+        if header.nil? && Maze.config.enforce_bugsnag_integrity
+          raise 'Bugsnag-Integrity header must be present according to Maze.config.enforce_bugsnag_integrity'
+        end
+        return if header.nil?
+
+        # Header must have type and digest
+        parts = header.split ' '
+        raise "Invalid Bugsnag-Integrity header: #{header}" unless parts.size == 2
+
+        # Both digest types are stored whatever
+        sha1 = Digest::SHA1.hexdigest(request.body)
+        simple = request.body.bytesize
+        $logger.debug "DIGESTS computed: sha1=#{sha1} simple=#{simple}"
+
+        # Check digests match
+        case parts[0]
+        when 'sha1'
+          raise "Given sha1 #{parts[1]} does not match the computed #{sha1}" unless parts[1] == sha1
+        when 'simple'
+          raise "Given simple digest #{parts[1].inspect} does not match the computed #{simple.inspect}" unless parts[1].to_i == simple
+        else
+          raise "Invalid Bugsnag-Integrity digest type: #{parts[0]}"
+        end
+
+        {
+          sha1: sha1,
+          simple: simple
+        }
+      end
+    end
+  end
+end

data/lib/maze/smart_bear_utils.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Maze
+  # Utils supporting the BrowserStack device farm integration
+  class SmartBearUtils
+    class << self
+      SB_READY_FILE = 'sb.ready'
+      SB_KILL_FILE = 'sb.kill'
+
+      # Starts the SmartBear local tunnel
+      #
+      # @param sb_local [String] path to the SBSecureTunnel binary
+      # @param username [String] Username to start the tunnel with
+      # @param access_key [String] CBT access key
+      # @param tunnel_name [String] Tunnel name
+      def start_local_tunnel(sb_local, username, access_key, tunnel_name=nil)
+        # Make sure the ready/kill files are already deleted
+        File.delete(SB_READY_FILE) if File.exist?(SB_READY_FILE)
+        File.delete(SB_KILL_FILE) if File.exist?(SB_KILL_FILE)
+
+        $logger.info 'Starting CBT SBSecureTunnel'
+        command = "#{sb_local} --username #{username} --authkey #{access_key} --acceptAllCerts " \
+                  "--ready #{SB_READY_FILE} --kill #{SB_KILL_FILE}"
+        command << " --tunnelname #{tunnel_name}" unless tunnel_name.nil?
+
+        output = start_tunnel_thread(command)
+
+        success = Maze::Wait.new(timeout: 30).until do
+          File.exist?(SB_READY_FILE)
+        end
+        unless success
+          $logger.error "Failed: #{output}"
+        end
+      end
+
+      # Stops the local tunnel
+      def stop_local_tunnel
+        FileUtils.touch(SB_KILL_FILE)
+        Maze::Wait.new(timeout: 30).until do
+          !File.exist?(SB_READY_FILE)
+        end
+        File.delete(SB_READY_FILE) if File.exist?(SB_READY_FILE)
+        File.delete(SB_KILL_FILE) if File.exist?(SB_KILL_FILE)
+      end
+
+      private
+
+      def start_tunnel_thread(cmd)
+        executor = lambda do
+          Open3.popen2e(Maze::Runner.environment, cmd) do |_stdin, stdout_and_stderr, wait_thr|
+
+            output = []
+            stdout_and_stderr.each do |line|
+              output << line
+              $logger.debug('SBSecureTunnel') {line.chomp}
+            end
+
+            exit_status = wait_thr.value.to_i
+            $logger.debug "Exit status: #{exit_status}"
+
+            output.each { |line| $logger.warn('SBSecureTunnel') {line.chomp} } unless exit_status == 0
+
+            return [output, exit_status]
+          end
+        end
+
+        Thread.new(&executor)
+      end
+    end
+  end
+end

data/lib/maze/store.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Maze
+  # Provides a hash to store values for cross-request comparisons
+  class Store
+    class << self
+      # Returns the hash of stored values for the current scenario
+      #
+      # @return [Hash] The stored value hash
+      def values
+        @values ||= {}
+      end
+    end
+  end
+end

data/lib/maze/terminating_server.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+module Maze
+  # Receives and terminates network connections without reading any data
+  class TerminatingServer
+    CONTINUE_RESPONSE = "HTTP/1.1 100 CONTINUE\n\r"
+    BAD_REQUEST_RESPONSE = "HTTP/1.1 400 BAD REQUEST\n\r"
+
+    class << self
+
+      # Starts the socket accept loop in a separate thread
+      def start
+        # Only run a single server thread
+        return if running?
+
+        attempts = 0
+        loop do
+
+          @thread = Thread.new do
+            # Reset the received count
+            @received_requests = 0
+
+            Socket.tcp_server_loop(Maze.config.null_port) {|socket, _client_addrinfo|
+              $logger.info 'Terminating server received request'
+              @received_requests += 1
+              headers = receive_headers(socket)
+
+              body_length = headers['Content-Length']
+              receive_data(socket, body_length) unless body_length.nil?
+
+              end_connection(socket)
+            }
+          rescue StandardError => e
+            $logger.warn "Terminating server error: #{e.message}"
+          end
+
+          break if running?
+
+          # Bail out after 3 attempts
+          attempts += 1
+          raise 'Too many failed attempts to start terminating server' if attempts == 3
+
+          # Failed to start - sleep before retrying
+          $logger.info 'Retrying in 3 seconds'
+          sleep 1
+        end
+      end
+
+      # The maximum string length to be received before disconnecting
+      #
+      # @return [Integer] The string length, defaults to 1MB
+      def max_received_size
+        @max_received_size ||= 1048576
+      end
+
+      # Set the maximum string length to be received before disconnecting
+      #
+      # @param new_max_size [Integer] The new maximum size
+      def max_received_size=(new_max_size)
+        @max_received_size = new_max_size
+      end
+
+      # The response string sent to a connected client
+      #
+      # @return [String] The response string, defaults to "400/BAD REQUEST"
+      def response
+        @response ||= BAD_REQUEST_RESPONSE
+      end
+
+      # Set the response string to an arbitrary value
+      #
+      # @param new_response [String] The new response
+      def response=(new_response)
+        @response = new_response
+      end
+
+      # Resets the response string to "400/BAD REQUEST" and the read size to 1MB
+      def reset_elements
+        @response = BAD_REQUEST_RESPONSE
+        @max_received_size = 1048576
+      end
+
+      # Whether the server thread is running
+      #
+      # @return [Boolean] If the server is running
+      def running?
+        @thread&.alive?
+      end
+
+      # Outputs the amount of times the server has received a connection on the last run
+      def received_request_count
+        @received_requests ||= 0
+      end
+
+      # Stops the socket accept loop if alive
+      def stop
+        @thread&.kill if @thread&.alive?
+        @thread = nil
+      end
+
+      private
+
+      def receive_headers(socket)
+        headers = {}
+        while (request = socket.gets) && (request.chomp.length > 0)
+          key, val = request.chomp.split(': ')
+          headers[key] = val
+          $logger.debug "Received #{headers.size} headers"
+        end
+        headers
+      end
+
+      def receive_data(socket, body_length)
+        read_length = body_length.to_i < max_received_size ? body_length.to_i : max_received_size
+        $logger.info "Reading #{read_length} bytes"
+        socket.read(read_length)
+      end
+
+      def end_connection(socket)
+        $logger.info "Responding with: #{response}"
+        # Unlikely to be used, but replicates pipeline response
+        socket.print response
+        socket.close
+      end
+    end
+  end
+end

data/lib/maze/timers.rb

@@ -0,0 +1,51 @@
+module Maze
+
+  # A simple run/stop timer
+  class Timer
+    attr_accessor :total
+
+    def initialize
+      @total = 0
+    end
+
+    def time(&block)
+      start = Time.now
+
+      block.call
+    ensure
+      @total += Time.now - start
+    end
+
+    def reset
+      @total = 0
+    end
+  end
+
+  # Stores a collection of timers
+  class Timers
+    def initialize
+      @timers = {}
+    end
+
+    def add(name)
+      timer = Timer.new
+      @timers[name] = timer
+      timer
+    end
+
+    def get(name)
+      @timers[name]
+    end
+
+    def size
+      @timers.size
+    end
+
+    def report
+      $logger.info 'Timer totals:'
+      @timers.sort.each do |name, timer|
+        $logger.info "  #{name}: #{timer.total}"
+      end
+    end
+  end
+end

data/lib/maze/wait.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Maze
+  # Allows repeated attempts at something, until it is successful or the timeout
+  # is exceed
+  class Wait
+    # @param interval [Numeric] Optional. The time to sleep between attempts
+    # @param timeout [Numeric] The amount of time to spend on attempts before giving up
+    def initialize(interval: 0.1, timeout:)
+      raise "Interval must be greater than zero, got '#{interval}'" unless interval > 0
+      raise "Timeout (#{timeout}) must be greater than interval (#{interval})" unless timeout > interval
+
+      @interval = interval
+      @max_attempts = timeout / interval
+    end
+
+    # Wait until the given block succeeds (returns a truthy value) or the
+    # timeout is exceeded
+    #
+    # @return [Object] The last value returned by the block
+    def until(&block)
+      success = false
+      attempts = 0
+
+      until success || attempts >= @max_attempts do
+        attempts += 1
+        success = block.call
+
+        sleep @interval unless success
+      end
+
+      success
+    end
+  end
+end

data/lib/maze.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'maze/configuration'
+require_relative 'maze/hooks/hooks'
+require_relative 'maze/timers'
+
+# Glues the various parts of MazeRunner together that need to be accessed globally,
+# providing an alternative to the proliferation of global variables or singletons.
+module Maze
+  VERSION = '6.27.0'
+
+  class << self
+    attr_accessor :check, :driver, :internal_hooks, :mode, :start_time, :dynamic_retry
+
+    def config
+      @config ||= Maze::Configuration.new
+    end
+
+    def hooks
+      @hooks ||= Maze::Hooks::Hooks.new
+    end
+
+    def timers
+      @timers ||= Maze::Timers.new
+    end
+  end
+end