bugsnag-maze-runner 7.22.1

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,135 @@
+# @!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.set_status_code_generator(Maze::Generator.new [status_code].cycle)
+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.set_status_code_generator(create_defaulting_generator([status_code], Maze::Server::DEFAULT_STATUS_CODE))
+end
+
+# Sets the HTTP status code to be used for the next set of requests
+#
+# @step_input status_codes [String] A comma separated list of status codes to return
+When('I set the HTTP status code for the next requests to {string}') do |status_codes|
+  codes = status_codes.split(',').map(&:strip)
+  Maze::Server.set_status_code_generator(create_defaulting_generator(codes, Maze::Server::DEFAULT_STATUS_CODE))
+end
+
+# Steps the HTTP status code to be used for all subsequent requests for a given connection type
+#
+# @step_input http_verb [String] The type of request this code will be used for
+# @step_input status_code [Integer] The status code to return
+When('I set the HTTP status code for {string} requests to {int}') do |http_verb, status_code|
+  raise("Invalid HTTP verb: #{http_verb}") unless Maze::Server::ALLOWED_HTTP_VERBS.include?(http_verb)
+  Maze::Server.set_status_code_generator(Maze::Generator.new([status_code].cycle), http_verb)
+end
+
+# Steps the HTTP status code to be used for the next request for a given connection type
+#
+# @step_input http_verb [String] The type of request this code will be used for
+# @step_input status_code [Integer] The status code to return
+When('I set the HTTP status code for the next {string} request to {int}') do |http_verb, status_code|
+  raise("Invalid HTTP verb: #{http_verb}") unless Maze::Server::ALLOWED_HTTP_VERBS.include?(http_verb)
+  Maze::Server.set_status_code_generator(create_defaulting_generator([status_code], Maze::Server::DEFAULT_STATUS_CODE), http_verb)
+end
+
+# Sets the sampling probability to be used for all subsequent trace responses
+#
+# @step_input sampling_probability [String] The sampling probability to return
+When('I set the sampling probability to {string}') do |sampling_probability|
+  Maze::Server.set_sampling_probability_generator(Maze::Generator.new [sampling_probability].cycle)
+end
+
+# Sets the sampling probability to be used for the next trace responses
+#
+# @step_input status_code [Integer] The status code to return
+When('I set the sampling probability for the next trace to {string}') do |sampling_probability|
+  Maze::Server.set_sampling_probability_generator(create_defaulting_generator([sampling_probability], Maze::Server::DEFAULT_SAMPLING_PROBABILITY))
+end
+
+# Sets the sampling probability to be used for the next set of trace requests
+#
+# @step_input sampling_probability [String] A comma separated list of values to use, with "null" used to omit the header
+When('I set the sampling probability for the next traces to {string}') do |status_codes|
+  codes = status_codes.split(',').map(&:strip)
+  Maze::Server.set_sampling_probability_generator(create_defaulting_generator(codes, Maze::Server::DEFAULT_SAMPLING_PROBABILITY))
+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.set_response_delay_generator(Maze::Generator.new [response_delay_ms].cycle)
+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.set_response_delay_generator(create_defaulting_generator([delay], Maze::Server::DEFAULT_RESPONSE_DELAY))
+end
+
+def create_defaulting_generator(codes, default)
+  enumerator = Enumerator.new do |yielder|
+    codes.each do |code|
+      yielder.yield code
+    end
+
+    loop do
+      yielder.yield default
+    end
+  end
+  Maze::Generator.new enumerator
+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,257 @@
+# 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 that a payload element equals a float.
+#
+# @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 float_value [Float] The value to test against
+Then('the {word} payload field {string} equals {float}') do |request_type, field_path, float_value|
+  Maze.check.equal(float_value,
+                   Maze::Helper.read_key_path(Maze::Server.list_for(request_type).current[:body], field_path))
+end
+
+# Tests that a payload element equals a float, to a given number of decimal places.
+#
+# @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 float_value [Float] The value to test against
+# @step_input places [Int] The number of decimal places to round the actual value to first
+Then('the {word} payload field {string} equals {float} to {int} decimal place(s)') do |request_type, field_path, float_value, places|
+  body = Maze::Server.list_for(request_type).current[:body]
+  rounded_value = Maze::Helper.read_key_path(body, field_path).round places
+  Maze.check.equal(float_value,
+                   rounded_value)
+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