bugsnag-maze-runner 7.22.1

data/lib/maze/server.rb

@@ -0,0 +1,251 @@
+# 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
+    ALLOWED_HTTP_VERBS = %w[OPTIONS GET POST PUT DELETE HEAD TRACE PATCH CONNECT]
+    DEFAULT_RESPONSE_DELAY = 0
+    DEFAULT_SAMPLING_PROBABILITY = 1
+    DEFAULT_STATUS_CODE = 200
+
+    class << self
+      # Sets the response delay generator.
+      #
+      # @param generator [Maze::Generator] The new generator
+      def set_response_delay_generator(generator)
+        @response_delay_generator&.close
+        @response_delay_generator = generator
+      end
+
+      # Sets the sampling probability generator.
+      #
+      # @param generator [Maze::Generator] The new generator
+      def set_sampling_probability_generator(generator)
+        @sampling_probability_generator&.close
+        @sampling_probability_generator = generator
+      end
+
+      # Sets the status code generator for the HTTP verb given.  If no verb is given then the
+      # generator will be shared across all allowable HTTP verbs.
+      #
+      # @param generator [Maze::Generator] The new generator
+      # @param verb [String] HTTP verb
+      def set_status_code_generator(generator, verb = nil)
+        @status_code_generators ||= {}
+        Array(verb || ALLOWED_HTTP_VERBS).each do |verb|
+          old = @status_code_generators[verb]
+          @status_code_generators[verb] = generator
+
+          # Close the old generator unless it's still being used by another verb
+          old&.close unless @status_code_generators.value?(old)
+        end
+      end
+
+      # The intended HTTP status code on a successful request
+      #
+      # @param verb [String] HTTP verb for which the status code is wanted
+      #
+      # @return [Integer] The HTTP status code for the verb given
+      def status_code(verb)
+        if @status_code_generators[verb].nil? || @status_code_generators[verb].closed?
+          DEFAULT_STATUS_CODE
+        else
+          @status_code_generators[verb].next
+        end
+      end
+
+      def sampling_probability
+        @sampling_probability_generator.next
+      end
+
+      def response_delay_ms
+        @response_delay_generator.next
+      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 'trace', 'traces'
+          traces
+        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 trace requests received
+      #
+      # @return [RequestList] Received error requests
+      def traces
+        @traces ||= 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
+        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.debug '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 '/traces', Servlets::TraceServlet, :traces, Maze::Schemas::TRACE_SCHEMA
+            server.mount '/react-native-source-map', Servlets::Servlet, :sourcemaps
+            server.mount '/command', Servlets::CommandServlet
+            server.mount '/logs', Servlets::LogServlet
+            server.mount '/reflect', Servlets::ReflectiveServlet
+            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
+
+      def reset!
+        # Reset generators
+        set_response_delay_generator(Maze::Generator.new [DEFAULT_RESPONSE_DELAY].cycle)
+        set_status_code_generator(Maze::Generator.new [DEFAULT_STATUS_CODE].cycle)
+        set_sampling_probability_generator(Maze::Generator.new [DEFAULT_SAMPLING_PROBABILITY].cycle)
+
+        # Clear request lists
+        errors.clear
+        sessions.clear
+        builds.clear
+        uploads.clear
+        sourcemaps.clear
+        traces.clear
+        logs.clear
+        invalid_requests.clear
+      end
+    end
+  end
+end

data/lib/maze/servlets/base_servlet.rb

@@ -0,0 +1,27 @@
+# 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
+          Bugsnag-Span-Sampling
+          Content-Type
+          Origin
+        ].join(',')
+      end
+    end
+  end
+end

data/lib/maze/servlets/command_servlet.rb

@@ -0,0 +1,47 @@
+# 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
+
+        if commands.size_remaining == 0
+          response.body = '{"action": "noop", "message": "No commands queued"}'
+          response.status = 200
+        else
+          command = commands.current
+          command_json = JSON.pretty_generate(command)
+          command[:uuid] = Maze.run_uuid
+          response.body = command_json
+          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('OPTIONS')
+      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('POST')
+      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('OPTIONS')
+      end
+    end
+  end
+end

data/lib/maze/servlets/reflective_servlet.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+require 'rack'
+
+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 < BaseServlet
+
+      # 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']
+
+        # For JSON, pull the instructions from the body.  Otherwise, take them from the query string.
+        if content_type == 'application/json'
+          body = JSON.parse(request.body)
+          delay_ms = body['delay_ms']
+          status = body['status']
+        else
+          query = Rack::Utils.parse_nested_query(request.query_string)
+          delay_ms = query['delay_ms']
+          status = query['status']
+        end
+
+        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,199 @@
+# frozen_string_literal: true
+
+require 'zlib'
+require 'stringio'
+require 'json_schemer'
+require 'delegate'
+
+module Maze
+  class HttpRequest < SimpleDelegator
+    def body
+      @body ||= decode_body
+    end
+
+    private
+
+    def decode_body
+      delegate = __getobj__
+      if %r{^gzip$}.match(delegate['Content-Encoding'])
+        gz_element = Zlib::GzipReader.new(StringIO.new(delegate.body))
+        gz_element.read
+      else
+        delegate.body
+      end
+    end
+  end
+
+  module Servlets
+
+    # Receives and parses the requests and payloads sent from the test fixture
+    class Servlet < BaseServlet
+      prepend RequestRepeater
+
+      # Constructor
+      #
+      # @param server [HTTPServer] WEBrick HTTPServer
+      # @param request_type [Symbol] Request type that the servlet will receive
+      # @param schema [Dictionary] A `json-schema` describing the payload for POST requests
+      def initialize(server, request_type, schema=nil)
+        super server
+        @request_type = request_type
+        @requests = Server.list_for request_type
+        @schema = JSONSchemer.schema(schema) unless schema.nil?
+      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)
+        # Turn the WEBrick HttpRequest into our internal HttpRequest delegate
+        request = HttpRequest.new(request)
+
+        content_type = request['Content-Type']
+        if %r{^multipart/form-data; boundary=([^;]+)}.match(content_type)
+          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
+        if @schema
+          schema_errors = @schema.validate(hash[:body])
+          hash[:schema_errors] = schema_errors.to_a
+        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
+        set_response_header response.header
+        response.status = Server.status_code('POST')
+      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
+
+      def set_response_header(header)
+        header['Access-Control-Allow-Origin'] = '*'
+      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('OPTIONS')
+      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)
+        when %r{^application/json$}
+          $logger.debug "BODY: #{JSON.pretty_generate(JSON.parse(request.body))}"
+        else
+          $logger.debug "BODY: #{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/servlets/trace_servlet.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Maze
+  module Servlets
+    class TraceServlet < Servlet
+      def set_response_header(header)
+        super
+        value = Maze::Server.sampling_probability
+        header['Bugsnag-Sampling-Probability'] =  value unless value == 'null'
+      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