bugsnag-maze-runner 7.22.1

data/lib/features/steps/error_reporting_steps.rb

@@ -0,0 +1,358 @@
+# frozen_string_literal: true
+
+# @!group Error reporting steps
+
+# Verifies that generic elements of an error payload are present.
+# APIKey fields and headers are tested against the '$api_key' global variable.
+#
+# @step_input version [String] The payload version expected
+# @step_input name [String] The expected name of the notifier
+Then('the error is valid for the error reporting API version {string} for the {string} notifier') do |version, name|
+  step "the error is valid for the error reporting API version \"#{version}\"" \
+       " for the \"#{name}\" notifier with the apiKey \"#{$api_key}\""
+end
+
+# Verifies that generic elements of an error payload are present.
+#
+# @step_input version [String] The payload version expected
+# @step_input name [String] The expected name of the notifier
+# @step_input api_key [String] The API key expected
+Then('the error is valid for the error reporting API version {string}' \
+     ' for the {string} notifier with the apiKey {string}') do |payload_version, notifier_name, api_key|
+  steps %(
+    Then the error "Bugsnag-Api-Key" header equals "#{api_key}"
+    And the error payload field "apiKey" equals "#{api_key}"
+    And the error "Bugsnag-Payload-Version" header equals "#{payload_version}"
+    And the error payload contains the payloadVersion "#{payload_version}"
+    And the error "Content-Type" header equals "application/json"
+    And the error "Bugsnag-Sent-At" header is a timestamp
+    And the error Bugsnag-Integrity header is valid
+
+    And the error payload field "notifier.name" equals "#{notifier_name}"
+    And the error payload field "notifier.url" is not null
+    And the error payload field "notifier.version" is not null
+    And the error payload field "events" is a non-empty array
+
+    And each element in error payload field "events" has "severity"
+    And each element in error payload field "events" has "severityReason.type"
+    And each element in error payload field "events" has "unhandled"
+    And each element in error payload field "events" has "exceptions"
+  )
+end
+
+
+# Verifies that an event is correct for an unhandled error
+# This checks various elements of the payload matching an unhandled error including:
+#    The unhandled flag
+#    Any attached session information
+#    Severity
+#
+# @param event [Integer] The event to verify
+Then('event {int} is unhandled') do |event|
+  test_unhandled_state(event, true)
+end
+
+# Verifies that an event is correct for an unhandled error
+# This checks various elements of the payload matching an unhandled error including:
+#    The unhandled flag
+#    Any attached session information
+#    Severity
+#
+# @param event [Integer] The event to verify
+# @param severity [String] An expected severity different to the default "error"
+Then('event {int} is unhandled with the severity {string}') do |event, severity|
+  test_unhandled_state(event, true, severity)
+end
+
+# Verifies that an event is correct for an handled error
+# This checks various elements of the payload matching an unhandled error including:
+#    The unhandled flag
+#    Any attached session information
+#    Severity
+#
+# @param event [Integer] The event to verify
+Then('event {int} is handled') do |event|
+  test_unhandled_state(event, false)
+end
+
+# Verifies that an event is correct for an handled error
+# This checks various elements of the payload matching an unhandled error including:
+#    The unhandled flag
+#    Any attached session information
+#    Severity
+#
+# @param event [Integer] The event to verify
+# @param severity [String] An expected severity different to the default "error"
+Then('event {int} is handled with the severity {string}') do |event, severity|
+  test_unhandled_state(event, false, severity)
+end
+
+# Checks the payloadVersion is set correctly.
+#   For Javascript this should be in the events.
+#   For all other notifiers this should be a top-level key.
+#
+# @step_input payload_version [String] The payload version expected
+Then('the error payload contains the payloadVersion {string}') do |payload_version|
+  body_version = Maze::Helper.read_key_path(Maze::Server.errors.current[:body], 'payloadVersion')
+  body_set = payload_version == body_version
+  event_version = Maze::Helper.read_key_path(Maze::Server.errors.current[:body], 'events.0.payloadVersion')
+  event_set = payload_version == event_version
+  Maze.check.true(
+    body_set || event_set,
+    "The payloadVersion was not the expected value of #{payload_version}. " \
+    "#{body_version} found in body, #{event_version} found in event"
+  )
+end
+
+# Tests whether a value in the first event entry matches a literal.
+#
+# @step_input field [String] The relative location of the value to test
+# @step_input literal [Enum] The literal to test against, one of: true, false, null, not null
+Then(/^the event "(.+)" is (true|false|null|not null)$/) do |field, literal|
+  step "the error payload field \"events.0.#{field}\" is #{literal}"
+end
+
+# Tests whether a value in the first event entry matches a string.
+#
+# @step_input field [String] The relative location of the value to test
+# @step_input string_value [String] The string to match against
+Then('the event {string} equals {string}') do |field, string_value|
+  step "the error payload field \"events.0.#{field}\" equals \"#{string_value}\""
+end
+
+# Tests whether a value in the first event entry matches a floating point value.
+#
+# @step_input field [String] The relative location of the value to test
+# @step_input string_value [String] The string to match against
+Then('the event {string} equals {float}') do |field, float_value|
+  step "the error payload field \"events.0.#{field}\" equals #{float_value}"
+end
+
+# Tests whether a value in the first event entry matches a floating point value, to a given number of decimal places.
+#
+# @step_input field [String] The relative location of the value to test
+# @step_input string_value [String] The string to match against
+Then('the event {string} equals {float} to {int} decimal place(s)') do |field, float_value, places|
+  step "the error payload field \"events.0.#{field}\" equals #{float_value} to #{places} decimal places"
+end
+
+# Tests whether a value in the first event entry equals an integer.
+#
+# @step_input field [String] The relative location of the value to test
+# @step_input value [Integer] The integer to test against
+Then('the event {string} equals {int}') do |field, value|
+  step "the error payload field \"events.0.#{field}\" equals #{value}"
+end
+
+# Tests whether a value in the first event entry starts with a string.
+#
+# @step_input field [String] The relative location of the value to test
+# @step_input string_value [String] The string to match against
+Then('the event {string} starts with {string}') do |field, string_value|
+  step "the error payload field \"events.0.#{field}\" starts with \"#{string_value}\""
+end
+
+# Tests whether a value in the first event entry ends with a string.
+#
+# @step_input field [String] The relative location of the value to test
+# @step_input string_value [String] The string to match against
+Then('the event {string} ends with {string}') do |field, string_value|
+  step "the error payload field \"events.0.#{field}\" ends with \"#{string_value}\""
+end
+
+# Tests whether a value in the first event entry matches a regex.
+#
+# @step_input field [String] The relative location of the value to test
+# @step_input pattern [String] The regex to match against
+Then('the event {string} matches {string}') do |field, pattern|
+  step "the error payload field \"events.0.#{field}\" matches the regex \"#{pattern}\""
+end
+
+# Tests whether a value in the first event entry is a timestamp.
+#
+# @step_input field [String] The relative location of the value to test
+Then('the event {string} is a timestamp') do |field|
+  step "the error payload field \"events.0.#{field}\" matches the regex \"#{TIMESTAMP_REGEX}\""
+end
+
+# Tests whether a value in the first event entry is a numeric and parsable timestamp.
+#
+# @step_input field [String] The relative location of the value to test
+Then('the event {string} is a parsable timestamp in seconds') do |field|
+  step "the error payload field \"events.0.#{field}\" is a parsable timestamp in seconds"
+end
+
+# Tests the Event field value against an environment variable.
+#
+# @step_input field [String] The payload element to check
+# @step_input env_var [String] The environment variable to test against
+Then('the event {string} equals the environment variable {string}') do |field, env_var|
+  step "the error payload field \"events.0.#{field}\" equals the environment variable \"#{env_var}\""
+end
+
+# Tests whether a value in the first event entry matches a JSON fixture.
+#
+# @step_input field [String] The relative location of the value to test
+# @step_input fixture_path [String] The fixture to match against
+Then('the event {string} matches the JSON fixture in {string}') do |field, fixture_path|
+  step "the error payload field \"events.0.#{field}\" matches the JSON fixture in \"#{fixture_path}\""
+end
+
+Then('the event {string} string is empty') do |keypath|
+  value = Maze::Helper.read_key_path(Maze::Server.errors.current[:body], keypath)
+  Maze.check.true(value.nil? || value.empty?, "The #{keypath} is not empty: '#{value}'")
+end
+
+Then('the event {string} is greater than {int}') do |keypath, int|
+  value = Maze::Helper.read_key_path(Maze::Server.errors.current[:body], "events.0.#{keypath}")
+  Maze.check.false(value.nil?, "The event #{keypath} is nil")
+  Maze.check.operator(value, :>, int)
+end
+
+# Tests whether a value in the first exception of the first event entry starts with a string.
+#
+# @step_input field [String] The relative location of the value to test
+# @step_input string_value [String] The string to match against
+Then('the exception {string} starts with {string}') do |field, string_value|
+  step "the error payload field \"events.0.exceptions.0.#{field}\" starts with \"#{string_value}\""
+end
+
+# Tests whether a value in the first exception of the first event entry ends with a string.
+#
+# @step_input field [String] The relative location of the value to test
+# @step_input string_value [String] The string to match against
+Then('the exception {string} ends with {string}') do |field, string_value|
+  step "the error payload field \"events.0.exceptions.0.#{field}\" ends with \"#{string_value}\""
+end
+
+# Tests whether a value in the first exception of the first event entry equals a string.
+#
+# @step_input field [String] The relative location of the value to test
+# @step_input string_value [String] The string to match against
+Then('the exception {string} equals {string}') do |field, string_value|
+  step "the error payload field \"events.0.exceptions.0.#{field}\" equals \"#{string_value}\""
+end
+
+# Tests whether a value in the first exception of the first event entry matches a regex.
+#
+# @step_input field [String] The relative location of the value to test
+# @step_input pattern [String] The regex to match against
+Then('the exception {string} matches {string}') do |field, pattern|
+  step "the error payload field \"events.0.exceptions.0.#{field}\" matches the regex \"#{pattern}\""
+end
+
+# Tests whether a element of a stack frame in the first exception of the first event equals an integer.
+#
+# @step_input key [String] The element of the stack frame to test
+# @step_input num [Integer] The stack frame where the element is present
+# @step_input value [Integer] The value to test against
+Then('the {string} of stack frame {int} equals {int}') do |key, num, value|
+  field = "events.0.exceptions.0.stacktrace.#{num}.#{key}"
+  step "the error payload field \"#{field}\" equals #{value}"
+end
+
+# Tests whether an element of a stack frame in the first exception of the first event matches a regex pattern.
+#
+# @step_input key [String] The element of the stack frame to test
+# @step_input num [Integer] The stack frame where the element is present
+# @step_input pattern [String] The regex to match against
+Then('the {string} of stack frame {int} matches {string}') do |key, num, pattern|
+  field = "events.0.exceptions.0.stacktrace.#{num}.#{key}"
+  step "the error payload field \"#{field}\" matches the regex \"#{pattern}\""
+end
+
+# Tests whether an element of a stack frame in the first exception of the first event equals a string.
+#
+# @step_input key [String] The element of the stack frame to test
+# @step_input num [Integer] The stack frame where the element is present
+# @step_input value [String] The value to test against
+Then('the {string} of stack frame {int} equals {string}') do |key, num, value|
+  field = "events.0.exceptions.0.stacktrace.#{num}.#{key}"
+  step "the error payload field \"#{field}\" equals \"#{value}\""
+end
+
+# Tests whether an element of a stack frame in the first exception of the first event starts with a string.
+#
+# @step_input key [String] The element of the stack frame to test
+# @step_input num [Integer] The stack frame where the element is present
+# @step_input value [String] The value to test against
+Then('the {string} of stack frame {int} starts with {string}') do |key, num, value|
+  field = "events.0.exceptions.0.stacktrace.#{num}.#{key}"
+  step "the error payload field \"#{field}\" starts with \"#{value}\""
+end
+
+# Tests whether an element of a stack frame in the first exception of the first event ends with a string.
+#
+# @step_input key [String] The element of the stack frame to test
+# @step_input num [Integer] The stack frame where the element is present
+# @step_input value [String] The value to test against
+Then('the {string} of stack frame {int} ends with {string}') do |key, num, value|
+  field = "events.0.exceptions.0.stacktrace.#{num}.#{key}"
+  step "the error payload field \"#{field}\" ends with \"#{value}\""
+end
+
+# Tests whether an element of a stack frame in the first exception of the first event matches a literal.
+#
+# @step_input key [String] The element of the stack frame to test
+# @step_input num [Integer] The stack frame where the element is present
+# @step_input literal [Enum] The literal to test against, one of: true, false, null, not null
+Then(/^the "(.*)" of stack frame (\d*) is (true|false|null|not null)$/) do |key, num, literal|
+  field = "events.0.exceptions.0.stacktrace.#{num}.#{key}"
+  step "the error payload field \"#{field}\" is #{literal}"
+end
+
+# Tests whether a thread from the first event, identified by name, is the error reporting thread.
+#
+# @step_input thread_name [String] The name of the thread to test
+Then('the thread with name {string} contains the error reporting flag') do |thread_name|
+  validate_error_reporting_thread('name', thread_name)
+end
+
+# Tests whether a thread from the first event, identified by an id, is the error reporting thread.
+#
+# @step_input thread_id [String] The id of the thread to test
+Then('the thread with id {string} contains the error reporting flag') do |thread_id|
+  validate_error_reporting_thread('id', thread_id)
+end
+
+# Tests that a thread from the first event, identified by a particular key-value pair, is the error reporting thread.
+#
+# @param payload_key [String] The thread identifier key
+# @param payload_value [Any] The thread identifier value
+def validate_error_reporting_thread(payload_key, payload_value)
+  threads = Maze::Server.errors.current[:body]['events'].first['threads']
+  Maze.check.kind_of Array, threads
+  count = 0
+
+  threads.each do |thread|
+    count += 1 if thread[payload_key].to_s == payload_value && thread['errorReportingThread'] == true
+  end
+  Maze.check.equal(1, count)
+end
+
+# Tests whether an event has the correct attributes we'd expect for un/handled events
+#
+# @param event [Integer] The index of the event
+# @param unhandled [Boolean] Whether the event is unhandled or handled
+# @param severity [String] Optional. An overwritten severity to look for
+def test_unhandled_state(event, unhandled, severity = nil)
+  expected_unhandled_state = unhandled ? 'true' : 'false'
+  expected_severity = if severity
+                        severity
+                      elsif unhandled
+                        'error'
+                      else
+                        'warning'
+                      end
+  steps %(
+    Then the error payload field "events.#{event}.unhandled" is #{expected_unhandled_state}
+    And the error payload field "events.#{event}.severity" equals "#{expected_severity}"
+  )
+
+  return if Maze::Helper.read_key_path(Maze::Server.errors.current[:body], "events.#{event}.session").nil?
+
+  session_field = unhandled ? 'unhandled' : 'handled'
+  steps %(
+    And the error payload field "events.#{event}.session.events.#{session_field}" is greater than 0
+  )
+end

data/lib/features/steps/feature_flag_steps.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+# @!group Feature flag steps
+
+# Verifies that there are no feature flags present in a given event
+#
+# @step_input event_id [Integer] The id of the event in the payloads array
+Then('event {int} has no feature flags') do |event_id|
+  event = Maze::Helper.read_key_path(Maze::Server.errors.current[:body], "events.#{event_id}")
+  Maze.check.false(has_feature_flags?(event), "Feature flags expected to be absent or empty, was #{event['featureFlags']}")
+end
+
+# Verifies that the are no feature flags present
+Then('the event has no feature flags') do
+  steps %(
+    Then event 0 has no feature flags
+  )
+end
+
+# Verifies a feature flag with a specific variant is uniquely present in a given event
+#
+# @step_input event_id [Integer] The id of the event in the payloads array
+# @step_input flag_name [String] The featureFlag value expected
+# @step_input variant [String] The variant value expected
+Then('event {int} contains the feature flag {string} with variant {string}') do |event_id, flag_name, variant|
+  event = Maze::Helper.read_key_path(Maze::Server.errors.current[:body], "events.#{event_id}")
+  Maze.check.true(has_feature_flags?(event), "Expected feature flags were not present in event #{event_id}: #{event}")
+  feature_flags = event['featureFlags']
+  # Test for flag name uniqueness
+  Maze.check.true(
+    feature_flags.one? { |flag| flag['featureFlag'].eql?(flag_name) },
+    "Expected single flag with 'featureFlag' value: #{flag_name}. Present flags: #{feature_flags}"
+  )
+
+  flag = feature_flags.find { |flag| flag['featureFlag'].eql?(flag_name) }
+  # Test the variant value
+  Maze.check.true(
+    flag.has_key?('variant') && flag['variant'].eql?(variant),
+    "Feature flag: #{flag} did not have variant: #{variant}. All flags: #{feature_flags}"
+  )
+end
+
+# Verifies a feature flag with a specific variant is uniquely present
+#
+# @step_input flag_name [String] The featureFlag value expected
+# @step_input variant [String] The variant value expected
+Then('the event contains the feature flag {string} with variant {string}') do |flag_name, variant|
+  steps %(
+    Then event 0 contains the feature flag "#{flag_name}" with variant "#{variant}"
+  )
+end
+
+# Verifies a feature flag with no variant (either null or missing) is uniquely present in a given event
+#
+# @step_input event_id [Integer] The id of the event in the payloads array
+# @step_input flag_name [String] The featureFlag value expected
+Then('event {int} contains the feature flag {string} with no variant') do |event_id, flag_name|
+  event = Maze::Helper.read_key_path(Maze::Server.errors.current[:body], "events.#{event_id}")
+  Maze.check.true(has_feature_flags?(event),
+                  "Expected feature flags were not present in event #{event_id}: #{event}")
+  feature_flags = event['featureFlags']
+  # Test for flag name uniqueness
+  Maze.check.true(
+    feature_flags.one? { |flag| flag['featureFlag'].eql?(flag_name) },
+    "Expected single flag with 'featureFlag' value: #{flag_name}. All flags: #{feature_flags}"
+  )
+
+  flag = feature_flags.find { |flag| flag['featureFlag'].eql?(flag_name) }
+  # Test the variant value
+  Maze.check.false(
+    flag.has_key?('variant'),
+    "Feature flag: #{flag} expected to have no variant. All flags: #{feature_flags}"
+  )
+end
+
+# Verifies a feature flag with no variant (either null or missing) is uniquely present
+#
+# @step_input flag_name [String] The featureFlag value expected
+Then('the event contains the feature flag {string} with no variant') do |flag_name|
+  steps %(
+    Then event 0 contains the feature flag "#{flag_name}" with no variant
+  )
+end
+
+# Verifies that a number of feature flags outlined in a table are all present and unique in the given event
+#
+# The DataTable used for this step should have `featureFlag` and `variant` columns, containing the appropriate
+# values.  For flags with a variant leave the `variant` column blank.
+#
+# Example:
+#   | featureFlag | variant |
+#   | my_flag_1   | var_1   |
+#   | my_flag_2   | var_2   |
+#   | my_flag_3   |         | # Should not have a variant present
+#
+# @step_input event_id [Integer] The id of the event in the payloads array
+# @step_input table [Cucumber::MultilineArgument::DataTable] Table of expected values
+Then('event {int} contains the following feature flags:') do |event_id, table|
+  event = Maze::Helper.read_key_path(Maze::Server.errors.current[:body], "events.#{event_id}")
+  verify_feature_flags_with_table(event, table)
+end
+
+# Verifies that a number of feature flags outlined in a table are all present and unique
+#
+# See above for data table details
+#
+# @step_input table [Cucumber::MultilineArgument::DataTable] Table of expected values
+Then('the event contains the following feature flags:') do |table|
+  event = Maze::Helper.read_key_path(Maze::Server.errors.current[:body], 'events.0')
+  verify_feature_flags_with_table(event, table)
+end
+
+# Verifies a feature flag a specific name is not present, regardless of variant, for a given event
+#
+# @step_input event_id [Integer] The id of the event in the payloads array
+# @step_input flag_name [String] The featureFlag value not expected
+Then('event {int} does not contain the feature flag {string}') do |event_id, flag_name|
+  event = Maze::Helper.read_key_path(Maze::Server.errors.current[:body], "events.#{event_id}")
+  Maze.check.true(
+    has_feature_flags?(event),
+    "Expected feature flags were not present in event #{event_id}: #{event}"
+  )
+  feature_flags = event['featureFlags']
+  Maze.check.true(
+    feature_flags.none? { |flag| flag['featureFlag'].eql?(flag_name) },
+    "Expected to not find feature flag #{flag_name}.  All flags: #{feature_flags}"
+  )
+end
+
+# Verifies a feature flag a specific name is not present, regardless of variant
+#
+# @step_input flag_name [String] The featureFlag value not expected
+Then('the event does not contain the feature flag {string}') do |flag_name|
+  steps %(
+    Then event 0 does not contain the feature flag "#{flag_name}"
+  )
+end
+
+def verify_feature_flags_with_table(event, table)
+  Maze.check.true(
+    has_feature_flags?(event),
+    "Expected feature flags were not present in event: #{event}"
+  )
+  feature_flags = event['featureFlags']
+
+  expected_features = table.hashes
+  Maze.check.true(
+    feature_flags.size == expected_features.size,
+    "Expected #{expected_features.size} features,
+    found #{feature_flags}"
+  )
+  expected_features.each do |expected|
+    flag_name = expected['featureFlag']
+    variant = expected['variant']
+    # Test for flag name uniqueness
+    Maze.check.true(
+      feature_flags.one? { |flag| flag['featureFlag'].eql?(flag_name) },
+      "Expected single flag with 'featureFlag' value: #{flag_name}. Present flags: #{feature_flags}"
+    )
+    flag = feature_flags.find { |flag| flag['featureFlag'].eql?(flag_name) }
+    # Test the variant value
+    if variant.nil? || expected['variant'].empty?
+      Maze.check.false(
+        flag.has_key?('variant'),
+        "Feature flag: #{flag} expected to have no variant. All flags: #{feature_flags}"
+      )
+    else
+      Maze.check.true(
+        flag.has_key?('variant') && flag['variant'].eql?(variant),
+        "Feature flag: #{flag} did not have variant: #{variant}. All flags: #{feature_flags}"
+      )
+    end
+  end
+end
+
+def has_feature_flags?(event)
+  if event.has_key?('featureFlags')
+    Maze.check.false(
+      event['featureFlags'].nil?,
+      'The feature flags key was present, but null'
+    )
+    Maze.check.true(
+      event['featureFlags'].is_a?(Array),
+      "The feature flags key was present, but the value: #{event['featureFlags']} must be an array"
+    )
+    !event['featureFlags'].empty?
+  else
+    false
+  end
+end

data/lib/features/steps/header_steps.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# @!group Header steps
+
+# Tests that a request header is not null
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input header_name [String] The header to test
+Then('the {word} {string} header is not null') do |request_type, header_name|
+  Maze.check.not_nil(Maze::Server.list_for(request_type).current[:request][header_name],
+                     "The #{request_type} '#{header_name}' header should not be null")
+end
+
+# Tests that a request header is null
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input header_name [String] The header to test
+Then('the {word} {string} header is null') do |request_type, header_name|
+  request = Maze::Server.list_for(request_type).current[:request]
+
+  Maze.check.nil(request[header_name],
+                 "The #{request_type} '#{header_name}' header should be null")
+end
+
+# Tests that request header equals a string
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input header_name [String] The header to test
+# @step_input header_value [String] The string it should match
+Then('the {word} {string} header equals {string}') do |request_type, header_name, header_value|
+  Maze.check.not_nil(Maze::Server.list_for(request_type).current[:request][header_name],
+                     "The #{request_type} '#{header_name}' header wasn't present in the request")
+  Maze.check.equal(header_value, Maze::Server.list_for(request_type).current[:request][header_name])
+end
+
+# Tests that a request header matches a regex
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input header_name [String] The header to test
+# @step_input regex_string [String] The regex to match with
+Then('the {word} {string} header matches the regex {string}') do |request_type, header_name, regex_string|
+  regex = Regexp.new(regex_string)
+  value = Maze::Server.list_for(request_type).current[:request][header_name]
+  Maze.check.match(regex, value)
+end
+
+# Tests that a request header matches one of a list of strings
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input header_name [String] The header to test
+# @step_input header_values [DataTable] A parsed data table
+Then('the {word} {string} header equals one of:') do |request_type, header_name, header_values|
+  Maze.check.include(header_values.raw.flatten, Maze::Server.list_for(request_type).current[:request][header_name])
+end
+
+# Tests that a request header is a timestamp.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input header_name [String] The header to test
+Then('the {word} {string} header is a timestamp') do |request_type, header_name|
+  header = Maze::Server.list_for(request_type).current[:request][header_name]
+  Maze.check.match(TIMESTAMP_REGEX, header)
+end
+
+# Checks that the Bugsnag-Integrity header is a SHA1 or simple digest
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+When('the {word} Bugsnag-Integrity header is valid') do |request_type|
+  Maze.check.true(Maze::Helper.valid_bugsnag_integrity_header(Maze::Server.list_for(request_type).current),
+                  'Invalid Bugsnag-Integrity header detected')
+end
+

data/lib/features/steps/log_steps.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# @!group Log assertion steps
+
+# Tests that a log request matches a given level and message.
+#
+# @step_input log_level [String] The expected log level
+# @step_input message [String] The expected message
+Then('the {string} level log message equals {string}') do |log_level, message|
+  request = Maze::Server.logs.current
+  Maze.check.not_nil(request, 'No log message to check')
+  log = request[:body]
+  Maze.check.equal(log_level, Maze::Helper.read_key_path(log, 'level'))
+  Maze.check.equal(message, Maze::Helper.read_key_path(log, 'message'))
+end
+
+# Tests that a log request matches a given level and message regex.
+#
+# @step_input log_level [String] The expected log level
+# @step_input message_regex [String] Regex for the expected message
+Then('the {string} level log message matches the regex {string}') do |log_level, message_regex|
+  request = Maze::Server.logs.current
+  Maze.check.not_nil(request, 'No log message to check')
+
+  log = request[:body]
+  Maze.check.equal(log_level, Maze::Helper.read_key_path(log, 'level'))
+  regex = Regexp.new(message_regex)
+  Maze.check.match(regex, Maze::Helper.read_key_path(log, 'message'))
+end