bugsnag-maze-runner 7.22.1

data/lib/features/steps/app_automator_steps.rb

@@ -0,0 +1,228 @@
+# @!group App Automator steps
+
+# Checks a UI element is present
+# Requires a running Appium driver
+#
+# @step_input element_id [String] The locator id
+Given('the element {string} is present') do |element_id|
+  present = Maze.driver.wait_for_element(element_id)
+  raise Maze::Error::AppiumElementNotFoundError.new("The element #{element_id} could not be found", element_id) unless present
+end
+
+# Checks a UI element is present within a specified number of seconds
+# Requires a running Appium driver
+#
+# @step_input element_id [String] The locator id
+# @step_input timeout [Int] The number of seconds to wait before timing out
+Given('the element {string} is present within {int} seconds') do |element_id, timeout|
+  present = Maze.driver.wait_for_element(element_id, timeout)
+  raise Maze::Error::AppiumElementNotFoundError.new("The element #{element_id} could not be found", element_id) unless present
+end
+
+# Clicks a given element
+# Requires a running Appium driver
+#
+# @step_input element_id [String] The locator id
+When('I click the element {string}') do |element_id|
+  Maze.driver.click_element(element_id)
+end
+
+# Sends the app to the background indefinitely
+# Requires a running Appium driver
+When('I send the app to the background') do
+  Maze.driver.background_app(-1)
+end
+
+# Sends the app to the background for a number of seconds
+# Requires a running Appium driver
+#
+# @step_input timeout [Integer] The amount of time the app is in the background in seconds
+When('I send the app to the background for {int} second(s)') do |timeout|
+  Maze.driver.background_app(timeout)
+end
+
+# Clears a given element
+# Requires a running Appium driver
+#
+# @step_input element_id [String] The locator id
+When('I clear the element {string}') do |element_id|
+  Maze.driver.clear_element(element_id)
+end
+
+# Sends keys to a given element
+# Requires a running Appium driver
+#
+# @step_input keys [String] The keys to send to the element
+# @step_input element_id [String] The locator id
+When('I send the keys {string} to the element {string}') do |keys, element_id|
+  Maze.driver.send_keys_to_element(element_id, keys)
+end
+
+# Tests that the given payload value is correct for the target BrowserStack platform.
+# This step will assume the expected and payload values are strings.
+# If the step is invoked when a remote BrowserStack device is not in use this step will fail.
+#
+# The DataTable used for this step should have `ios` and `android` in the same row as their expected value:
+#   | android | Java.lang.RuntimeException |
+#   | ios     | NSException                |
+#
+# If the expected value is set to "@skip", the check should be skipped
+# If the expected value is set to "@null", the check will be for null
+# If the expected value is set to "@not_null", the check will be for a non-null value
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field_path [String] The field to test
+# @step_input platform_values [DataTable] A table of acceptable values for each platform
+Then('the {word} payload field {string} equals the platform-dependent string:') do |request_type, field_path, platform_values|
+  test_string_platform_values(request_type, field_path, platform_values)
+end
+
+# See `the error payload field {string} equals the platform-dependent string:`
+#
+# @step_input field_path [String] The field to test, prepended with "events.0"
+# @step_input platform_values [DataTable] A table of acceptable values for each platform
+Then('the event {string} equals the platform-dependent string:') do |field_path, platform_values|
+  test_string_platform_values('error', "events.0.#{field_path}", platform_values)
+end
+
+# Tests that the given payload value is correct for the target BrowserStack platform.
+# This step will assume the expected and payload values are numeric.
+# If the step is invoked when a remote BrowserStack device is not in use this step will fail.
+#
+# The DataTable used for this step should have `ios` and `android` in the same row as their expected value:
+#   | android | 1  |
+#   | ios     | 5.5 |
+#
+# If the expected value is set to "@skip", the check should be skipped
+# If the expected value is set to "@null", the check will be for null
+# If the expected value is set to "@not_null", the check will be for a non-null value
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field_path [String] The field to test
+# @step_input platform_values [DataTable] A table of acceptable values for each platform
+Then('the {word} payload field {string} equals the platform-dependent numeric:') do |request_type, field_path, platform_values|
+  test_numeric_platform_values(request_type, field_path, platform_values)
+end
+
+# See `the payload field {string} equals the platform-dependent numeric:`
+#
+# @step_input field_path [String] The field to test, prepended with "events.0"
+# @step_input platform_values [DataTable] A table of acceptable values for each platform
+Then('the event {string} equals the platform-dependent numeric:') do |field_path, platform_values|
+  test_numeric_platform_values('error', "events.0.#{field_path}", platform_values)
+end
+
+# Tests that the given payload value is correct for the target BrowserStack platform.
+# This step will assume the expected and payload values are booleans.
+# If the step is invoked when a remote BrowserStack device is not in use this step will fail.
+#
+# The DataTable used for this step should have `ios` and `android` in the same row as their expected value:
+#   | android | 1 |
+#   | ios     | 5 |
+#
+# If the expected value is set to "@skip", the check should be skipped
+# If the expected value is set to "@null", the check will be for null
+# If the expected value is set to "@not_null", the check will be for a non-null value
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field_path [String] The field to test
+# @step_input platform_values [DataTable] A table of acceptable values for each platform
+Then('the {word} payload field {string} equals the platform-dependent boolean:') do |request_type, field_path, platform_values|
+  test_boolean_platform_values(request_type, field_path, platform_values)
+end
+
+# See `the payload field {string} equals the platform-dependent boolean:`
+#
+# @step_input field_path [String] The field to test, prepended with "events.0"
+# @step_input platform_values [DataTable] A table of acceptable values for each platform
+Then('the event {string} equals the platform-dependent boolean:') do |field_path, platform_values|
+  test_boolean_platform_values('error', "events.0.#{field_path}", platform_values)
+end
+
+# See `the payload field {string} equals the platform-dependent string:`
+#
+# @step_input field_path [String] The field to test, prepended with "events.0.exceptions.0."
+# @step_input platform_values [DataTable] A table of acceptable values for each platform
+Then('the exception {string} equals the platform-dependent string:') do |field_path, platform_values|
+  test_string_platform_values('error', "events.0.exceptions.0.#{field_path}", platform_values)
+end
+
+# See `the payload field {string} equals the platform-dependent string:`
+#
+# @step_input field_path [String] The field to test, prepended with "events.0.exceptions.0.stacktrace.#!{num}"
+# @step_input num [Integer] The index of the stack frame to test
+# @step_input platform_values [DataTable] A table of acceptable values for each platform
+Then('the {string} of stack frame {int} equals the platform-dependent string:') do |field_path, num, platform_values|
+  test_string_platform_values('error', "events.0.exceptions.0.stacktrace.#{num}.#{field_path}", platform_values)
+end
+
+# Sends keys to a given element, clearing it first
+# Requires a running Appium driver
+#
+# @step_input keys [String] The keys to send to the element
+# @step_input element_id [String] The locator id
+When('I clear and send the keys {string} to the element {string}') do |keys, element_id|
+  Maze.driver.clear_and_send_keys_to_element(element_id, keys)
+end
+
+def get_expected_platform_value(platform_values)
+  os = Maze::Helper.get_current_platform
+  expected_value = Hash[platform_values.raw][os.downcase]
+  raise("There is no expected value for the current platform \"#{os}\"") if expected_value.nil?
+
+  expected_value
+end
+
+def should_skip_platform_check(expected_value)
+  expected_value.eql?('@skip')
+end
+
+def test_string_platform_values(request_type, field_path, platform_values)
+  expected_value = get_expected_platform_value(platform_values)
+  return if should_skip_platform_check(expected_value)
+
+  list = Maze::Server.list_for(request_type)
+  payload_value = Maze::Helper.read_key_path(list.current[:body], field_path)
+  assert_equal_with_nullability(expected_value, payload_value)
+end
+
+def test_boolean_platform_values(request_type, field_path, platform_values)
+  expected_value = get_expected_platform_value(platform_values)
+  return if should_skip_platform_check(expected_value)
+
+  expected_bool = case expected_value.downcase
+                  when 'true'
+                    true
+                  when 'false'
+                    false
+                  else
+                    expected_value
+                  end
+  list = Maze::Server.list_for(request_type)
+  payload_value = Maze::Helper.read_key_path(list.current[:body], field_path)
+  assert_equal_with_nullability(expected_bool, payload_value)
+end
+
+def test_numeric_platform_values(request_type, field_path, platform_values)
+  expected_value = get_expected_platform_value(platform_values)
+  return if should_skip_platform_check(expected_value)
+
+  list = Maze::Server.list_for(request_type)
+  payload_value = Maze::Helper.read_key_path(list.current[:body], field_path)
+
+  # Need to do a little more processing here to allow floats
+  special_value = expected_value.eql?('@null') || expected_value.eql?('@not_null')
+  expectation = special_value ? expected_value : expected_value.to_f
+  assert_equal_with_nullability(expectation, payload_value)
+end
+
+def assert_equal_with_nullability(expected_value, payload_value)
+  case expected_value
+  when '@null'
+    Maze.check.nil(payload_value)
+  when '@not_null'
+    Maze.check.not_nil(payload_value)
+  else
+    Maze.check.equal(expected_value, payload_value)
+  end
+end

data/lib/features/steps/aws_sam_steps.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require_relative '../../maze'
+require_relative '../../maze/aws/sam'
+
+# @!group AWS SAM steps
+
+# Invoke a lambda directly with 'sam invoke'
+#
+# @step_input lambda_name [String] The name of the lambda to invoke
+# @step_input directory [String] The directory to invoke the lambda in
+Given('I invoke the {string} lambda in {string}') do |lambda_name, directory|
+  Maze::Aws::Sam.invoke(directory, lambda_name)
+end
+
+# Invoke a lambda directly with 'sam invoke' and the given event
+#
+# @step_input lambda_name [String] The name of the lambda to invoke
+# @step_input directory [String] The directory to invoke the lambda in
+# @step_input event_file [String] The event file to call the lambda with
+Given('I invoke the {string} lambda in {string} with the {string} event') do |lambda_name, directory, event_file|
+  Maze::Aws::Sam.invoke(directory, lambda_name, event_file)
+end
+
+# Test the exit code of the SAM CLI process.
+#
+# @step_input expected [Integer] The expected exit code
+Then('the SAM exit code equals {int}') do |expected|
+  Maze.check.equal(expected, Maze::Aws::Sam.last_exit_code)
+end
+
+# Test the Lambda response is empty but not-null. This indicates the Lambda did
+# not respond but did run successfully
+Then('the lambda response is empty') do
+  Maze.check.not_nil(Maze::Aws::Sam.last_response, 'No lambda response!')
+
+  Maze.check.equal({}, Maze::Aws::Sam.last_response)
+end
+
+# Test a Lambda response field equals the given string.
+#
+# @step_input key_path [String] The response element to test
+# @step_input expected [String] The string to test against
+Then('the lambda response {string} equals {string}') do |key_path, expected|
+  Maze.check.not_nil(Maze::Aws::Sam.last_response, 'No lambda response!')
+
+  actual = Maze::Helper.read_key_path(Maze::Aws::Sam.last_response, key_path)
+
+  Maze.check.equal(expected, actual)
+end
+
+# Test a Lambda response field contains the given string.
+#
+# @step_input key_path [String] The response element to test
+# @step_input expected [String] The string to test against
+Then('the lambda response {string} contains {string}') do |key_path, expected|
+  Maze.check.not_nil(Maze::Aws::Sam.last_response, 'No lambda response!')
+
+  actual = Maze::Helper.read_key_path(Maze::Aws::Sam.last_response, key_path)
+
+  Maze.check.include(actual, expected)
+end
+
+# Test a Lambda response field equals the given integer.
+#
+# @step_input key_path [String] The response element to test
+# @step_input expected [Integer] The integer to test against
+Then('the lambda response {string} equals {int}') do |key_path, expected|
+  Maze.check.not_nil(Maze::Aws::Sam.last_response, 'No lambda response!')
+
+  actual = Maze::Helper.read_key_path(Maze::Aws::Sam.last_response, key_path)
+
+  Maze.check.equal(expected, actual)
+end
+
+# Test a Lambda response field is true.
+#
+# @step_input key_path [String] The response element to test
+Then('the lambda response {string} is true') do |key_path|
+  Maze.check.not_nil(Maze::Aws::Sam.last_response, 'No lambda response!')
+
+  actual = Maze::Helper.read_key_path(Maze::Aws::Sam.last_response, key_path)
+
+  Maze.check.true(actual)
+end
+
+# Test a Lambda response field is false.
+#
+# @step_input key_path [String] The response element to test
+Then('the lambda response {string} is false') do |key_path|
+  Maze.check.not_nil(Maze::Aws::Sam.last_response, 'No lambda response!')
+
+  actual = Maze::Helper.read_key_path(Maze::Aws::Sam.last_response, key_path)
+
+  Maze.check.false(actual)
+end
+
+# Test a Lambda response field is null.
+#
+# @step_input key_path [String] The response element to test
+Then('the lambda response {string} is null') do |key_path|
+  Maze.check.not_nil(Maze::Aws::Sam.last_response, 'No lambda response!')
+
+  actual = Maze::Helper.read_key_path(Maze::Aws::Sam.last_response, key_path)
+
+  Maze.check.nil(actual)
+end
+
+# Test a Lambda response field is not null.
+#
+# @step_input key_path [String] The response element to test
+Then('the lambda response {string} is not null') do |key_path|
+  Maze.check.not_nil(Maze::Aws::Sam.last_response, 'No lambda response!')
+
+  actual = Maze::Helper.read_key_path(Maze::Aws::Sam.last_response, key_path)
+
+  Maze.check.not_nil(actual)
+end
+
+# Test a Lambda response field is greater than the given integer.
+#
+# @step_input key_path [String] The response element to test
+# @step_input expected [Integer] The integer to test against
+Then('the lambda response {string} is greater than {int}') do |key_path, expected|
+  Maze.check.not_nil(Maze::Aws::Sam.last_response, 'No lambda response!')
+
+  actual = Maze::Helper.read_key_path(Maze::Aws::Sam.last_response, key_path)
+
+  Maze.check.operator(actual, :>, expected)
+end
+
+# Test a Lambda response field is less than the given integer.
+#
+# @step_input key_path [String] The response element to test
+# @step_input expected [Integer] The integer to test against
+Then('the lambda response {string} is less than {int}') do |key_path, expected|
+  Maze.check.not_nil(Maze::Aws::Sam.last_response, 'No lambda response!')
+
+  actual = Maze::Helper.read_key_path(Maze::Aws::Sam.last_response, key_path)
+
+  Maze.check.operator(actual, :<, expected)
+end
+
+# Test a Lambda response field starts with the given string.
+#
+# @step_input key_path [String] The response element to test
+# @step_input expected [String] The string to test against
+Then('the lambda response {string} starts with {string}') do |key_path, expected|
+  Maze.check.not_nil(Maze::Aws::Sam.last_response, 'No lambda response!')
+
+  actual = Maze::Helper.read_key_path(Maze::Aws::Sam.last_response, key_path)
+
+  Maze.check.kind_of(String, actual)
+  Maze.check.true(
+    actual.start_with?(expected),
+    "Field '#{key_path}' value ('#{actual}') does not start with '#{expected}'"
+  )
+end
+
+# Test a Lambda response field ends with the given string.
+#
+# @step_input key_path [String] The response element to test
+# @step_input expected [String] The string to test against
+Then('the lambda response {string} ends with {string}') do |key_path, expected|
+  Maze.check.not_nil(Maze::Aws::Sam.last_response, 'No lambda response!')
+
+  actual = Maze::Helper.read_key_path(Maze::Aws::Sam.last_response, key_path)
+
+  Maze.check.kind_of(String, actual)
+  Maze.check.true(
+    actual.end_with?(expected),
+    "Field '#{key_path}' value ('#{actual}') does not start with '#{expected}'"
+  )
+end
+
+# Test a Lambda response field is an array with a specific number of elements.
+#
+# @step_input key_path [String] The response element to test
+# @step_input expected [Integer] The expected number of elements
+Then('the lambda response {string} is an array with {int} element(s)') do |key_path, expected|
+  Maze.check.not_nil(Maze::Aws::Sam.last_response, 'No lambda response!')
+
+  actual = Maze::Helper.read_key_path(Maze::Aws::Sam.last_response, key_path)
+
+  Maze.check.kind_of(Array, actual)
+  Maze.check.equal(expected, actual.length)
+end
+
+# Test a Lambda response field is an array with at least 1 element.
+#
+# @step_input key_path [String] The response element to test
+Then('the lambda response {string} is a non-empty array') do |key_path|
+  Maze.check.not_nil(Maze::Aws::Sam.last_response, 'No lambda response!')
+
+  actual = Maze::Helper.read_key_path(Maze::Aws::Sam.last_response, key_path)
+
+  Maze.check.kind_of(Array, actual)
+  Maze.check.false(actual.empty?)
+end
+
+# Test a Lambda response field matches the given regex.
+#
+# @step_input key_path [String] The response element to test
+# @step_input expected [String] The regex to match against
+Then('the lambda response {string} matches the regex {string}') do |key_path, regex|
+  expected = Regexp.new(regex)
+  Maze.check.not_nil(Maze::Aws::Sam.last_response, 'No lambda response!')
+
+  actual = Maze::Helper.read_key_path(Maze::Aws::Sam.last_response, key_path)
+
+  Maze.check.match(expected, actual)
+end

data/lib/features/steps/breadcrumb_steps.rb

@@ -0,0 +1,80 @@
+# @!group Breadcrumb steps
+
+# Tests whether the first event entry contains the specified number of breadcrumbs.
+#
+# @step_input expected [Integer] The expected number of breadcrumbs
+Then("the event has {int} breadcrumb(s)") do |expected|
+  breadcrumbs = Maze::Server.errors.current[:body]['events'].first['breadcrumbs']
+
+  Maze.check.equal(
+    expected,
+    breadcrumbs&.length || 0,
+    "Expected event to have '#{expected}' breadcrumbs, but got: #{breadcrumbs}"
+  )
+end
+
+# Tests whether the first event entry contains no breadcrumbs.
+Then("the event has no breadcrumbs") do
+  breadcrumbs = Maze::Server.errors.current[:body]['events'].first['breadcrumbs']
+
+  Maze.check.true(
+    # some notifiers may omit breadcrumbs entirely when empty, otherwise it should
+    # be an empty array
+    breadcrumbs.nil? || breadcrumbs.empty?,
+    "Expected event not to have breadcrumbs, but got: #{breadcrumbs}"
+  )
+end
+
+# Tests whether the first event entry contains a specific breadcrumb with a type and name.
+#
+# @step_input type [String] The expected breadcrumb's type
+# @step_input name [String] The expected breadcrumb's name
+Then('the event has a {string} breadcrumb named {string}') do |type, name|
+  breadcrumbs = Maze::Server.errors.current[:body]['events'].first['breadcrumbs']
+
+  Maze.check.true(
+    breadcrumbs.any? { |crumb| crumb['type'] == type && crumb['name'] == name },
+    "Expected event to have a breadcrumb with type '#{type}' and name '#{name}', but got: #{breadcrumbs}"
+  )
+end
+
+# Tests whether the first event entry contains a specific breadcrumb with a type and message.
+#
+# @step_input type [String] The expected breadcrumb's type
+# @step_input message [String] The expected breadcrumb's message
+Then('the event has a {string} breadcrumb with message {string}') do |type, message|
+  value = Maze::Server.errors.current[:body]['events'].first['breadcrumbs']
+  found = value.any? { |crumb| crumb['type'] == type && crumb['metaData'] && crumb['metaData']['message'] == message }
+  raise("No breadcrumb matched: #{value}") unless found
+end
+
+# Tests whether the first event entry does not contain a breadcrumb with a specific type.
+# Used for confirming filtering of breadcrumbs
+#
+# @step_input type [String] The type of breadcrumb expected to not be present
+Then('the event does not have a {string} breadcrumb') do |type|
+  value = Maze::Server.errors.current[:body]['events'].first['breadcrumbs']
+  found = value.any? { |crumb| crumb['type'] == type  }
+  raise("Breadcrumb with type: #{type} matched") if found
+end
+
+# Test whether the first event entry does not contain a breadcrumb with a specific type and message.
+# Used for confirming filtering of breadcrumbs
+#
+# @step_input type [String] The type of the breadcrumb expected to be absent
+# @step_input message [String] The message of the breadcrumb expected to be absent
+Then('the event does not have a {string} breadcrumb with message {string}') do |type, message|
+  value = Maze::Server.errors.current[:body]['events'].first['breadcrumbs']
+  found = value.any? { |crumb| crumb['type'] == type && crumb['metaData'] && crumb['metaData']['message'] == message }
+  raise("Breadcrumb with type: #{type} and message: #{message} matched") if found
+end
+
+# Tests whether any breadcrumb matches a given JSON fixture.  This follows all the usual rules for JSON fixture matching.
+#
+# @step_input json_fixture [String] A path to the JSON fixture to compare against
+Then('the event contains a breadcrumb matching the JSON fixture in {string}') do |json_fixture|
+  breadcrumbs = Maze::Helper.read_key_path(Maze::Server.errors.current[:body], 'events.0.breadcrumbs')
+  expected = JSON.parse(open(json_fixture, &:read))
+  match = breadcrumbs.any? { |breadcrumb| Maze::Compare.value(expected, breadcrumb).equal? }
+  Maze.check.true(match, 'No breadcrumbs in the event matched the given breadcrumb')
+end

data/lib/features/steps/browser_steps.rb

@@ -0,0 +1,93 @@
+# @!group Browser steps
+
+When('I navigate to the URL {string}') do |path|
+  begin
+    $logger.debug "Navigating to: #{path}"
+    Maze.driver.navigate.to path
+  rescue => exception
+    $logger.error("#{exception.class} occurred during navigation attempt with message: #{exception.message}")
+    $logger.error("Restarting driver and retrying navigation to: #{path}")
+    Maze.driver.restart_driver
+    Maze.driver.navigate.to path
+    # If a further error occurs it will get thrown as normal
+  end
+end
+
+Then(/^the error is a valid browser payload for the error reporting API$/) do
+  if !/^ie_(8|9|10)$/.match(Maze.config.browser)
+    steps %(
+      Then the error "Bugsnag-API-Key" header is not null
+      And the error "Content-Type" header equals one of:
+        | application/json |
+        | application/json; charset=UTF-8 |
+      And the error "Bugsnag-Payload-Version" header equals "4"
+      And the error "Bugsnag-Sent-At" header is a timestamp
+    )
+  else
+    steps %(
+      Then the error "apiKey" query parameter is not null
+      And the error "payloadVersion" query parameter equals "4"
+      And the error "sentAt" query parameter is a timestamp
+    )
+  end
+  steps %(
+    And the error payload field "notifier.name" is not null
+    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"
+
+    And the exception "type" equals "browserjs"
+  )
+end
+
+Then('the session is a valid browser payload for the session tracking API') do
+  if !/^ie_(8|9|10)$/.match(Maze.config.browser)
+    steps %(
+      Then the session "Bugsnag-API-Key" header is not null
+      And the session "Content-Type" header equals one of:
+        | application/json |
+        | application/json; charset=UTF-8 |
+      And the session "Bugsnag-Payload-Version" header equals "1"
+      And the session "Bugsnag-Sent-At" header is a timestamp
+    )
+  else
+    steps %(
+      Then the session "apiKey" query parameter is not null
+      And the session "payloadVersion" query parameter equals "1"
+      And the session "sentAt" query parameter is a timestamp
+    )
+  end
+  steps %(
+    And the session payload field "app" is not null
+    And the session payload field "device" is not null
+    And the session payload field "notifier.name" is not null
+    And the session payload field "notifier.url" is not null
+    And the session payload field "notifier.version" is not null
+    And the session payload has a valid sessions array
+  )
+end
+
+Then('the event device ID is valid') do
+  if Maze.driver.local_storage?
+    step('the event "device.id" matches "^c[a-z0-9]{20,32}$"')
+  else
+    $logger.info('Local storage is not supported in this browser, assuming device ID is null')
+    step('the event "device.id" is null')
+  end
+end
+
+Then('the event device ID is {string}') do |expected_id|
+  if Maze.driver.local_storage?
+    step("the event \"device.id\" equals \"#{expected_id}\"")
+  else
+    $logger.info('Local storage is not supported in this browser, assuming device ID is null')
+    step('the event "device.id" is null')
+  end
+end
+
+# @!endgroup

data/lib/features/steps/build_api_steps.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# @!group Build API Steps
+
+# Tests whether the top-most payload is valid for the Bugsnag build API
+# APIKey fields and headers are tested against the '$api_key' global variable
+Then('the build is valid for the Build API') do
+  steps %(
+    And the build payload field "apiKey" equals "#{$api_key}"
+    And the build payload field "appVersion" is not null
+  )
+end
+
+# Tests whether the top-most payload is valid for the Android mapping API
+# APIKey fields and headers are tested against the '$api_key' global variable
+Then('the build is valid for the Android Mapping API') do
+  steps %(
+    And the build payload field "apiKey" equals "#{$api_key}"
+    And the build payload field "proguard" is not null
+    And the build payload field "appId" is not null
+    And the build payload field "versionCode" is not null
+    And the build payload field "buildUUID" is not null
+    And the build payload field "versionName" is not null
+  )
+end

data/lib/features/steps/document_server_steps.rb

@@ -0,0 +1,7 @@
+# @!group Document steps
+
+# Starts the document server manually.  It will be stopped automatically at the end of each scenario
+# (if started in this way).
+When('I start the document server') do
+  Maze::DocumentServer.manual_start
+end