bugsnag-maze-runner 6.27.0

data/lib/features/steps/multipart_request_steps.rb

@@ -0,0 +1,142 @@
+require 'test/unit'
+require 'open-uri'
+require 'json'
+require 'cgi'
+
+# @!group Multipart request assertion steps
+
+# Verifies a request contains the correct Content-Type header and some contents
+# for a multipart/form-data request
+#
+# @param request [Hash] The payload to test
+def valid_multipart_form_data?(request)
+  content_regex = Regexp.new('^multipart\\/form-data; boundary=[\\h-]+$')
+  content_header = request[:request]['Content-Type']
+  Maze.check.match(content_regex, content_header)
+  Maze.check.true(
+    request[:body].size.positive?,
+    "Multipart request payload contained #{request[:body].size} fields"
+  )
+end
+
+# Verifies that any type of request contains multipart form-data
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+Then('the {word} request is valid multipart form-data') do |request_type|
+  list = Maze::Server.list_for request_type
+  valid_multipart_form_data?(list.current)
+end
+
+# Verifies all requests of a given type contain multipart form-data
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+Then('all {word} requests are valid multipart form-data') do |request_type|
+  list = Maze::Server.list_for request_type
+  list.all.all? { |request| valid_multipart_form_data?(request) }
+end
+
+# Tests the number of fields a given type of multipart request contains.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input part_count [Integer] The number of expected fields
+Then('the {word} multipart request has {int} fields') do |request_type, part_count|
+  list = Maze::Server.list_for request_type
+  parts = list.current[:body]
+  Maze.check.equal(part_count, parts.size)
+end
+
+# Tests a given type of multipart request has at least one field.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+Then('the {word} multipart request has a non-empty body') do |request_type|
+  list = Maze::Server.list_for request_type
+  parts = list.current[:body]
+  Maze.check.true(parts.size.positive?, "Multipart request payload contained #{parts.size} fields")
+end
+
+# Takes a hashmap and parses all fields into strings or hashes depending on their format
+# Used to convert a multipart/form-data request into a JSON comparable hash
+#
+# @param body [Hash] The multipart/form-data hash to parse
+#
+# @return [Hash] The result of parsing hash fields to strings/JSON hashes
+def parse_multipart_body(body)
+  body.each_with_object({}) do |(k, v), out|
+    out[k] = JSON.parse(v.to_s)
+  rescue JSON::ParserError
+    out[k] = v.to_s
+  end
+end
+
+# Tests that a given type of multipart payload body does not match a JSON file.
+# JSON formatted multipart fields will be parsed into hashes.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input json_path [String] Path to a JSON file relative to maze-runner root
+Then('the {word} multipart body does not match the JSON file in {string}') do |request_type, json_path|
+  Maze.check.true(File.exist?(json_path), "'#{json_path}' does not exist")
+  payload_list = Maze::Server.list_for request_type
+  raw_payload_value = payload_list.current[:body]
+  payload_value = parse_multipart_body(raw_payload_value)
+  expected_value = JSON.parse(open(json_path, &:read))
+  result = Maze::Compare.value(expected_value, payload_value)
+  Maze.check.false(result.equal?, "Payload:\n#{payload_value}\nExpected:#{expected_value}")
+end
+
+# Tests that a given type of multipart payload body matches a JSON fixture.
+# JSON formatted multipart fields will be parsed into hashes.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input json_path [String] Path to a JSON file relative to maze-runner root
+Then('the {word} multipart body matches the JSON file in {string}') do |request_type, json_path|
+  Maze.check.true(File.exist?(json_path), "'#{json_path}' does not exist")
+  payload_list = Maze::Server.list_for request_type
+  raw_payload_value = payload_list.current[:body]
+  payload_value = parse_multipart_body(raw_payload_value)
+  expected_value = JSON.parse(open(json_path, &:read))
+  result = Maze::Compare.value(expected_value, payload_value)
+  Maze.check.true(result.equal?, "The payload field '#{result.keypath}' does not match the fixture:\n #{result.reasons.join('\n')}")
+end
+
+# Tests that a given type of multipart field matches a JSON fixture.
+# The field will be parsed into a hash.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field_path [String] Path to the tested element
+# @step_input json_path [String] Path to a JSON file relative to maze-runner root
+Then('the {word} multipart field {string} matches the JSON file in {string}') do |request_type, field_path, json_path|
+  Maze.check.true(File.exist?(json_path), "'#{json_path}' does not exist")
+  payload_list = Maze::Server.list_for request_type
+  payload_value = JSON.parse(payload_list.current[:body][field_path].to_s)
+  expected_value = JSON.parse(open(json_path, &:read))
+  result = Maze::Compare.value(expected_value, payload_value)
+  Maze.check.true(result.equal?, "The multipart field '#{result.keypath}' does not match the fixture:\n #{result.reasons.join('\n')}")
+end
+
+# Tests that a multipart request field exists and is not null.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input part_key [String] The key to the multipart element
+Then('the field {string} for multipart {word} is not null') do |part_key, request_type|
+  parts = Maze::Server.list_for(request_type).current[:body]
+  Maze.check.not_nil(parts[part_key], "The field '#{part_key}' should not be null")
+end
+
+# Tests that a multipart request field exists and is null.
+#
+# @step_input part_key [String] The key to the multipart element
+# @step_input request_type [String] The type of request (error, session, build, etc)
+Then('the field {string} for multipart {word} is null') do |part_key, request_type|
+  parts = Maze::Server.list_for(request_type).current[:body]
+  Maze.check.nil(parts[part_key], "The field '#{part_key}' should be null")
+end
+
+# Tests that a multipart request field equals a string.
+#
+# @step_input part_key [String] The key to the multipart element
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input expected_value [String] The string to match against
+Then('the field {string} for multipart {word} equals {string}') do |part_key, request_type, expected_value|
+  parts = Maze::Server.list_for(request_type).current[:body]
+  Maze.check.equal(parts[part_key], expected_value)
+end

data/lib/features/steps/network_steps.rb

@@ -0,0 +1,75 @@
+# @!group Network steps
+
+# Checks that a port on a given host is open and ready for connections.
+#
+# @step_input host [String] The host to check
+# @step_input port [String] The port to check
+When('I wait for the host {string} to open port {string}') do |host, port|
+  Maze::Network.wait_for_port(host, port)
+end
+
+# Sets the HTTP status code to be used for all subsequent requests
+#
+# @step_input status_code [Integer] The status code to return
+When('I set the HTTP status code to {int}') do |status_code|
+  Maze::Server.status_code = status_code
+end
+
+# Sets the HTTP status code to be used for the next request
+#
+# @step_input status_code [Integer] The status code to return
+When('I set the HTTP status code for the next request to {int}') do |status_code|
+  Maze::Server.reset_status_code = true
+  Maze::Server.status_code = status_code
+end
+
+# Sets the response delay to be used for all subsequent requests
+#
+# @step_input response_delay_ms [Integer] The delay in milliseconds
+When('I set the response delay to {int} milliseconds') do |response_delay_ms|
+  Maze::Server.response_delay_ms = response_delay_ms
+end
+
+# Sets the response delay to be used for the next request
+#
+# @step_input delay [Integer] The delay in milliseconds
+When('I set the response delay for the next request to {int} milliseconds') do |delay|
+  Maze::Server.reset_response_delay = true
+  Maze::Server.response_delay_ms = delay
+end
+
+# Attempts to open a URL.
+#
+# @step_input url [String] The URL to open.
+When('I open the URL {string}') do |url|
+  begin
+    open(url, &:read)
+  rescue OpenURI::HTTPError
+    $logger.debug $!.inspect
+  end
+end
+
+# Starts the terminating server to cancel requests received.
+When('I start the terminating server') do
+  Maze::TerminatingServer.start
+end
+
+# Sets the response message on the terminating server
+When('I set the terminated response message to {string}') do |response_message|
+  Maze::TerminatingServer.response = response_message
+end
+
+# Sets the maximum allowable amount of data received to the terminating server
+#
+# @step_input max_length [Integer] The number of bytes receivable
+When('I set the terminating server data threshold to {int} bytes') do |max_length|
+  Maze::TerminatingServer.max_received_size = max_length
+end
+
+# Check if a certain number of connections have been received by the terminating server
+#
+# @step_input request_count [Integer] The number of desired requests
+Then('the terminating server has received {int} requests') do |request_count|
+  Maze.check.equal(request_count, Maze::TerminatingServer.received_request_count,
+    "#{request_count} terminated requests expected, #{Maze::TerminatingServer.received_request_count} received")
+end

data/lib/features/steps/payload_steps.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+# @!group Payload steps
+
+# Tests the payload body does not match a JSON fixture.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input fixture_path [String] Path to a JSON fixture
+Then('the {word} payload body does not match the JSON fixture in {string}') do |request_type, fixture_path|
+  payload_value = Maze::Server.list_for(request_type).current[:body]
+  expected_value = JSON.parse(open(fixture_path, &:read))
+  result = Maze::Compare.value(expected_value, payload_value)
+  Maze.check.false(result.equal?, "Payload:\n#{payload_value}\nExpected:#{expected_value}")
+end
+
+# Test the payload body matches a JSON fixture.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input fixture_path [String] Path to a JSON fixture
+Then('the {word} payload body matches the JSON fixture in {string}') do |request_type, fixture_path|
+  payload_value = Maze::Server.list_for(request_type).current[:body]
+  expected_value = JSON.parse(open(fixture_path, &:read))
+  result = Maze::Compare.value(expected_value, payload_value)
+  Maze.check.true(result.equal?,
+                  "The payload field '#{result.keypath}' does not match the fixture:\n #{result.reasons.join('\n')}")
+end
+
+# Test that a payload element matches a JSON fixture.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field_path [String] Path to the tested element
+# @step_input fixture_path [String] Path to a JSON fixture
+Then('the {word} payload field {string} matches the JSON fixture in {string}') \
+do |request_type, field_path, fixture_path|
+  list = Maze::Server.list_for(request_type)
+  payload_value = Maze::Helper.read_key_path(list.current[:body], field_path)
+  expected_value = JSON.parse(open(fixture_path, &:read))
+  result = Maze::Compare.value(expected_value, payload_value)
+  Maze.check.true(result.equal?,
+                  "The payload field '#{result.keypath}' does not match the fixture:\n #{result.reasons.join('\n')}")
+end
+
+# Tests that a request element is true.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field_path [String] Path to the tested element
+Then('the {word} payload field {string} is true') do |request_type, field_path|
+  list = Maze::Server.list_for(request_type)
+  Maze.check.true(Maze::Helper.read_key_path(list.current[:body], field_path))
+end
+
+# Tests that a request element is false.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field_path [String] Path to the tested element
+Then('the {word} payload field {string} is false') do |request_type, field_path|
+  list = Maze::Server.list_for(request_type)
+  Maze.check.false(Maze::Helper.read_key_path(list.current[:body], field_path))
+end
+
+# Tests that a request element is null.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field_path [String] Path to the tested element
+Then('the {word} payload field {string} is null') do |request_type, field_path|
+  list = Maze::Server.list_for(request_type)
+  Maze.check.nil(Maze::Helper.read_key_path(list.current[:body], field_path))
+end
+
+# Tests that a request element is not null.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field_path [String] Path to the tested element
+Then('the {word} payload field {string} is not null') do |request_type, field_path|
+  list = Maze::Server.list_for(request_type)
+  Maze.check.not_nil(Maze::Helper.read_key_path(list.current[:body], field_path))
+end
+
+# Tests that a payload element equals an integer.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field_path [String] Path to the tested element
+# @step_input int_value [Integer] The value to test against
+Then('the {word} payload field {string} equals {int}') do |request_type, field_path, int_value|
+  Maze.check.equal(int_value,
+                   Maze::Helper.read_key_path(Maze::Server.list_for(request_type).current[:body], field_path))
+end
+
+# Tests the payload field value against an environment variable.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field_path [String] The payload element to test
+# @step_input env_var [String] The environment variable to test against
+Then('the {word} payload field {string} equals the environment variable {string}') \
+do |request_type, field_path, env_var|
+  environment_value = ENV[env_var]
+  Maze.check.false(environment_value.nil?, "The environment variable #{env_var} must not be nil")
+  list = Maze::Server.list_for(request_type)
+  value = Maze::Helper.read_key_path(list.current[:body], field_path)
+
+  Maze.check.equal(environment_value, value)
+end
+
+# Tests a payload field contains a number larger than a value.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field_path [String] The payload element to test
+# @step_input int_value [Integer] The value to compare against
+Then('the {word} payload field {string} is greater than {int}') do |request_type, field_path, int_value|
+  list = Maze::Server.list_for(request_type)
+  value = Maze::Helper.read_key_path(list.current[:body], field_path)
+  Maze.check.kind_of Integer, value
+  Maze.check.operator(value, :>, int_value, "The payload field '#{field_path}' (#{value}) is not greater than '#{int_value}'")
+end
+
+# Tests a payload field contains a number smaller than a value.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field_path [String] The payload element to test
+# @step_input int_value [Integer] The value to compare against
+Then('the {word} payload field {string} is less than {int}') do |request_type, field_path, int_value|
+  list = Maze::Server.list_for(request_type)
+  value = Maze::Helper.read_key_path(list.current[:body], field_path)
+  Maze.check.kind_of Integer, value
+  fail_message = "The #{request_type} payload field '#{field_path}' (#{value}) is not less than '#{int_value}'"
+  Maze.check.operator(value, :<, int_value, fail_message)
+end
+
+# Tests a payload field equals a string.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field_path [String] The payload element to test
+# @step_input string_value [String] The string to test against
+Then('the {word} payload field {string} equals {string}') do |request_type, field_path, string_value|
+  list = Maze::Server.list_for(request_type)
+  Maze.check.equal(string_value, Maze::Helper.read_key_path(list.current[:body], field_path))
+end
+
+# Tests a payload field starts with a string.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field_path [String] The payload element to test
+# @step_input string_value [String] The string to test against
+Then('the {word} payload field {string} starts with {string}') do |request_type, field_path, string_value|
+  list = Maze::Server.list_for(request_type)
+  value = Maze::Helper.read_key_path(list.current[:body], field_path)
+  Maze.check.kind_of String, value
+  Maze.check.true(
+    value.start_with?(string_value),
+    "Field '#{field_path}' value ('#{value}') does not start with '#{string_value}'"
+  )
+end
+
+# Tests a payload field ends with a string.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field_path [String] The payload element to test
+# @step_input string_value [String] The string to test against
+Then('the {word} payload field {string} ends with {string}') do |request_type, field_path, string_value|
+  list = Maze::Server.list_for(request_type)
+  value = Maze::Helper.read_key_path(list.current[:body], field_path)
+  Maze.check.kind_of String, value
+  Maze.check.true(
+    value.end_with?(string_value),
+    "Field '#{field_path}' value ('#{value}') does not end with '#{string_value}'"
+  )
+end
+
+# Tests a payload field is an array with a specific element count.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field [String] The payload element to test
+# @step_input count [Integer] The value expected
+Then('the {word} payload field {string} is an array with {int} elements') do |request_type, field, count|
+  list = Maze::Server.list_for(request_type)
+  value = Maze::Helper.read_key_path(list.current[:body], field)
+  Maze.check.kind_of Array, value
+  Maze.check.equal(count, value.length)
+end
+
+# Tests a payload field is an array with at least one element.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field [String] The payload element to test
+Then('the {word} payload field {string} is a non-empty array') do |request_type, field|
+  list = Maze::Server.list_for(request_type)
+  value = Maze::Helper.read_key_path(list.current[:body], field)
+  Maze.check.kind_of Array, value
+  Maze.check.true(value.length.positive?, "the field '#{field}' must be a non-empty array")
+end
+
+# Tests a payload field matches a regex.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field [String] The payload element to test
+# @step_input regex [String] The regex to test against
+Then('the {word} payload field {string} matches the regex {string}') do |request_type, field, regex_string|
+  regex = Regexp.new(regex_string)
+  list = Maze::Server.list_for(request_type)
+  value = Maze::Helper.read_key_path(list.current[:body], field)
+  Maze.check.match(regex, value)
+end
+
+# Tests a payload field is a numeric timestamp.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field [String] The payload element to test
+Then('the {word} payload field {string} is a parsable timestamp in seconds') do |request_type, field|
+  list = Maze::Server.list_for(request_type)
+  value = Maze::Helper.read_key_path(list.current[:body], field)
+  begin
+    int = value.to_i
+    parsed_time = Time.at(int)
+  rescue StandardError
+    parsed_time = nil
+  end
+  Maze.check.not_nil(parsed_time)
+end
+
+# Tests that every element in an array contains a specified key-value pair.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input key_path [String] The path to the tested array
+# @step_input element_key_path [String] The key for the expected element inside the array
+Then('each element in {word} payload field {string} has {string}') do |request_type, key_path, element_key_path|
+  list = Maze::Server.list_for(request_type)
+  value = Maze::Helper.read_key_path(list.current[:body], key_path)
+  Maze.check.kind_of Array, value
+  value.each do |element|
+    Maze.check.not_nil(Maze::Helper.read_key_path(element, element_key_path),
+                       "Each element in '#{key_path}' must have '#{element_key_path}'")
+  end
+end
+

data/lib/features/steps/proxy_steps.rb

@@ -0,0 +1,34 @@
+# @!group Proxy steps
+
+# Starts an HTTP proxy server.
+#
+Then('I start an http proxy') do
+  Maze::Proxy.instance.start :Http
+end
+
+# Starts an authenticated HTTP proxy server.
+#
+Then('I start an authenticated http proxy') do
+  Maze::Proxy.instance.start :Http, true
+end
+
+# Starts an HTTPS proxy server.
+#
+Then('I start an https proxy') do
+  Maze::Proxy.instance.start :Https
+end
+
+# Starts an authenticated HTTPS proxy server.
+#
+Then('I start an authenticated https proxy') do
+  Maze::Proxy.instance.start :Https, true
+end
+
+# Test the proxy server handled a request for a host.
+#
+# @step_input host [String] Destination host to check
+Then('the proxy handled a request for {string}') do |host|
+  Maze.check.true(Maze::Proxy.instance.handled_host?(host), "The proxy did not handle a request for #{host}")
+end
+
+# @!endgroup

data/lib/features/steps/query_parameter_steps.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# @!group Query parameter steps
+
+# Tests that a query parameter matches a string.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input parameter_name [String] The parameter to test
+# @step_input parameter_value [String] The expected value
+Then('the {word} {string} query parameter equals {string}') do |request_type, parameter_name, parameter_value|
+  Maze.check.equal(parameter_value,
+                   Maze::Helper.parse_querystring(Maze::Server.list_for(request_type).current)[parameter_name][0])
+end
+
+# Tests that a query parameter is present and not null.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input parameter_name [String] The parameter to test
+Then('the {word} {string} query parameter is not null') do |request_type, parameter_name|
+  Maze.check.not_nil(Maze::Helper.parse_querystring(Maze::Server.list_for(request_type).current)[parameter_name][0],
+                     "The '#{parameter_name}' query parameter should not be null")
+end
+
+# Tests that a query parameter is a timestamp.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input parameter_name [String] The parameter to test
+Then('the {word} {string} query parameter is a timestamp') do |request_type, parameter_name|
+  param = Maze::Helper.parse_querystring(Maze::Server.list_for(request_type).current)[parameter_name][0]
+  Maze.check.match(TIMESTAMP_REGEX, param)
+end

data/lib/features/steps/request_assertion_steps.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'test/unit'
+require 'open-uri'
+require 'json'
+require 'cgi'
+require_relative '../../maze/wait'
+
+# @!group Request assertion steps
+
+def assert_received_requests(request_count, list, list_name)
+  timeout = Maze.config.receive_requests_wait
+  wait = Maze::Wait.new(timeout: timeout)
+
+  received = wait.until { list.size >= request_count }
+
+  unless received
+    raise Test::Unit::AssertionFailedError.new <<-MESSAGE
+    Expected #{request_count} #{list_name} but received #{list.size} within the #{timeout}s timeout.
+    This could indicate that:
+    - Bugsnag crashed with a fatal error.
+    - Bugsnag did not make the requests that it should have done.
+    - The requests were made, but not deemed to be valid (e.g. missing integrity header).
+    - The requests made were prevented from being received due to a network or other infrastructure issue.
+    Please check the Maze Runner and device logs to confirm.)
+    MESSAGE
+  end
+
+  Maze.check.equal(request_count, list.size, "#{list.size} #{list_name} received")
+end
+
+#
+# Error request assertions
+#
+# Shortcut to waiting to receive a single request of the given type
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+Then('I wait to receive a(n) {word}') do |request_type|
+  step "I wait to receive 1 #{request_type}"
+end
+
+# Continually checks to see if the required amount of requests have been received,
+# timing out according to @see Maze.config.receive_requests_wait.
+# If all expected requests are received and have the Bugsnag-Sent-At header, they
+# will be sorted by the header.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input request_count [Integer] The amount of requests expected
+Then('I wait to receive {int} {word}') do |request_count, request_type|
+  list = Maze::Server.list_for(request_type)
+  assert_received_requests request_count, list, request_type
+  list.sort_by_sent_at! request_count
+end
+
+# Verify that at least a certain amount of requests have been received
+# This step is only intended for use in stress tests
+#
+# @step_input min_received [Integer] The minimum amount of requests required to pass
+# @step_input request_type [String] The type of request (error, session, build, etc)
+Then('I have received at least {int} {word}') do |min_received, request_type|
+  list = Maze::Server.list_for(request_type)
+  Maze.check.operator(list.size, :>=, min_received, "Actually received #{list.size} #{request_type} requests")
+end
+
+# Assert that the test Server hasn't received any requests - of a specific, or any, type.
+#
+# @step_input request_type [String] The type of request ('error', 'session', build, etc), or 'requests' to assert on all
+#   request types.
+Then('I should receive no {word}') do |request_type|
+  sleep Maze.config.receive_no_requests_wait
+  if request_type == 'requests'
+    # Assert that the test Server hasn't received any requests at all.
+    Maze.check.equal(0, Maze::Server.errors.size, "#{Maze::Server.errors.size} errors received")
+    Maze.check.equal(0, Maze::Server.sessions.size, "#{Maze::Server.sessions.size} sessions received")
+  else
+    list = Maze::Server.list_for(request_type)
+    Maze.check.equal(0, list.size, "#{list.size} #{request_type} received")
+  end
+end
+
+# Moves to the next request
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+Then('I discard the oldest {word}') do |request_type|
+  raise "No #{request_type} to discard" if Maze::Server.list_for(request_type).current.nil?
+
+  Maze::Server.list_for(request_type).next
+end
+
+Then('the received errors match:') do |table|
+  # Checks that each request matches one of the event fields
+  requests = Maze::Server.errors.remaining
+  match_count = 0
+
+  # iterate through each row in the table. exactly 1 request should match each row.
+  table.hashes.each do |row|
+    requests.each do |request|
+      # Skip if no body.events in this request
+      next if (!request.key? :body) || (!request[:body].key? 'events')
+
+      events = request[:body]['events']
+      Maze.check.equal(1, events.length, 'Expected exactly one event per request')
+      match_count += 1 if Maze::Assertions::RequestSetAssertions.request_matches_row(events[0], row)
+    end
+  end
+  Maze.check.equal(requests.size, match_count, 'Unexpected number of requests matched the received payloads')
+end