bugsnag-maze-runner 7.22.1

data/lib/features/steps/session_tracking_steps.rb

@@ -0,0 +1,116 @@
+# @!group Session tracking steps
+
+# Verifies that generic elements of a session payload are present.
+# APIKey fields and headers are tested against the '$api_key' global variable.
+#
+# @step_input payload_version [String] The payload version expected
+# @step_input notifier_name [String] The expected name of the notifier
+Then('the session is valid for the session reporting API version {string} for the {string} notifier') \
+  do |payload_version, notifier_name|
+  steps %(
+    Then the session "bugsnag-api-key" header equals "#{$api_key}"
+    And the session "bugsnag-payload-version" header equals "#{payload_version}"
+    And the session "Content-Type" header equals "application/json"
+    And the session "Bugsnag-Sent-At" header is a timestamp
+
+    And the session payload field "notifier.name" equals "#{notifier_name}"
+    And the session payload field "notifier.url" is not null
+    And the session payload field "notifier.version" is not null
+
+    And the session payload field "app" is not null
+    And the session payload field "device" is not null
+  )
+end
+
+# Verifies that generic elements of a session payload are present for the React Native notifier
+# APIKey fields and headers are tested against the '$api_key' global variable.
+#
+# @step_input payload_version [String] The payload version expected
+# @step_input notifier_name [String] The expected name of the notifier
+# TODO: I'm reluctant to risk changing the previous step implementation right now, but we should consider
+#   refactoring the two at some point to avoid duplication.
+Then('the session is valid for the session reporting API version {string} for the React Native notifier') do |payload_version|
+  steps %{
+    Then the session "bugsnag-api-key" header equals "#{$api_key}"
+    And the session "bugsnag-payload-version" header equals "#{payload_version}"
+    And the session "Content-Type" header equals "application/json"
+    And the session "Bugsnag-Sent-At" header is a timestamp
+
+    And the session payload field "notifier.name" matches the regex "(Bugsnag React Native|(Android|iOS) Bugsnag Notifier)"
+    And the session payload field "notifier.url" is not null
+    And the session payload field "notifier.version" is not null
+
+    And the session payload field "app" is not null
+    And the session payload field "device" is not null
+  }
+end
+
+# Tests whether a value in the first session 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 session "(.+)" is (true|false|null|not null)$/) do |field, literal|
+  step "the session payload field \"sessions.0.#{field}\" is #{literal}"
+end
+
+# Tests whether a value in the first session 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 session {string} equals {string}') do |field, string_value|
+  step "the session payload field \"sessions.0.#{field}\" equals \"#{string_value}\""
+end
+
+# Tests whether a value in the first session entry is a timestamp.
+#
+# @step_input field [String] The relative location of the value to test
+Then('the session {string} is a timestamp') do |field|
+  step "the session payload field \"sessions.0.#{field}\" matches the regex \"#{TIMESTAMP_REGEX}\""
+end
+
+# Tests whether a value in the first sessionCount 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 sessionCount "(.+)" is (true|false|null|not null)$/) do |field, literal|
+  step "the session payload field \"sessionCounts.0.#{field}\" is #{literal}"
+end
+
+# Tests whether a value in the first sessionCount 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 sessionCount {string} equals {string}') do |field, string_value|
+  step "the session payload field \"sessionCounts.0.#{field}\" equals \"#{string_value}\""
+end
+
+# Tests whether a value in the first sessionCount entry equals an integer.
+#
+# @step_input field [String] The relative location of the value to test
+# @step_input int_value [Integer] The integer to test against
+Then('the sessionCount {string} equals {int}') do |field, int_value|
+  step "the session payload field \"sessionCounts.0.#{field}\" equals #{int_value}"
+end
+
+# Tests whether a value in the first sessionCount entry is a timestamp.
+#
+# @step_input field [String] The relative location of the value to test
+Then('the sessionCount {string} is a timestamp') do |field|
+  step "the session payload field \"sessionCounts.0.#{field}\" matches the regex \"#{TIMESTAMP_REGEX}\""
+end
+
+# Tests that a payload has an appropriately structured session array
+Then('the session payload has a valid sessions array') do
+  if sessions = Maze::Server.sessions.current[:body]['sessions']
+    steps %(
+      Then the session "id" is not null
+      And the session "startedAt" is a timestamp
+    )
+  else
+    steps %(
+      Then the sessionCount "sessionsStarted" is not null
+      And the sessionCount "startedAt" is a timestamp
+    )
+  end
+end
+

data/lib/features/steps/trace_steps.rb

@@ -0,0 +1,206 @@
+# @!group Trace steps
+
+# Waits for a given number of spans to be received, which may be spread across one or more trace requests.
+#
+# @step_input span_count [Integer] The number of spans to wait for
+When('I wait for {int} span(s)') do |span_count|
+  assert_received_spans span_count, Maze::Server.list_for('traces')
+end
+
+When('I receive and discard the initial p-value request') do
+  steps %Q{
+    And I wait to receive at least 1 trace
+    And the trace payload field "resourceSpans" is an array with 0 elements
+    And I discard the oldest trace
+  }
+end
+
+Then('I should have received no spans') do
+  sleep Maze.config.receive_no_requests_wait
+  Maze.check.equal spans_from_request_list(Maze::Server.list_for('traces')).size, 0
+end
+
+Then('the trace payload field {string} bool attribute {string} is true') do |field, attribute|
+  check_attribute_equal field, attribute, 'boolValue', true
+end
+
+Then('the trace payload field {string} bool attribute {string} is false') do |field, attribute|
+  check_attribute_equal field, attribute, 'boolValue', false
+end
+
+Then('the trace payload field {string} integer attribute {string} equals {int}') do |field, attribute, expected|
+  check_attribute_equal field, attribute, 'intValue', expected
+end
+
+Then('the trace payload field {string} integer attribute {string} is greater than {int}') do |field, attribute, expected|
+  value = get_attribute_value field, attribute, 'intValue'
+  Maze.check.operator value, :>, expected,
+                      "The payload field '#{field}' attribute '#{attribute}' (#{value}) is not greater than '#{expected}'"
+end
+
+Then('the trace payload field {string} string attribute {string} equals {string}') do |field, attribute, expected|
+  check_attribute_equal field, attribute, 'stringValue', expected
+end
+
+Then('the trace payload field {string} string attribute {string} equals the stored value {string}') do |field, attribute, stored_key|
+  value = get_attribute_value field, attribute, 'stringValue'
+  stored = Maze::Store.values[stored_key]
+  result = Maze::Compare.value value, stored
+  Maze.check.true result.equal?, "Payload value: #{value} does not equal stored value: #{stored}"
+end
+
+Then('the trace payload field {string} string attribute {string} matches the regex {string}') do |field, attribute, pattern|
+  value = get_attribute_value field, attribute, 'stringValue'
+  regex = Regexp.new pattern
+  Maze.check.match regex, value
+end
+
+Then('the trace payload field {string} integer attribute {string} matches the regex {string}') do |field, attribute, pattern|
+  regex = Regexp.new(pattern)
+  list = Maze::Server.traces
+  attributes = Maze::Helper.read_key_path(list.current[:body], "#{field}.attributes")
+  attribute = attributes.find { |a| a['key'] == attribute }
+  value = attribute["value"]["intValue"]
+  Maze.check.match(regex, value)
+end
+
+Then('the trace payload field {string} string attribute {string} exists') do |field, attribute|
+  value = get_attribute_value field, attribute, 'stringValue'
+  Maze.check.not_nil value
+end
+
+Then('the trace payload field {string} string attribute {string} is one of:') do |field, key, possible_values|
+  list = Maze::Server.traces
+  attributes = Maze::Helper.read_key_path(list.current[:body], "#{field}.attributes")
+  attribute = attributes.find { |a| a['key'] == key }
+
+  possible_attributes = possible_values.raw.flatten.map { |v| { 'key' => key, 'value' => { 'stringValue' => v } } }
+  Maze.check.not_nil(attribute, "The attribute #{key} is nil")
+  Maze.check.include(possible_attributes, attribute)
+end
+
+Then('the trace payload field {string} boolean attribute {string} is true') do |field, key|
+  assert_attribute field, key, { 'boolValue' => true }
+end
+
+Then('the trace payload field {string} boolean attribute {string} is false') do |field, key|
+  assert_attribute field, key, { 'boolValue' => false }
+end
+
+# @!group Span steps
+Then('a span {word} equals {string}') do |attribute, expected|
+  spans = spans_from_request_list(Maze::Server.list_for('traces'))
+  selected_attributes = spans.map { |span| span[attribute] }
+  Maze.check.includes selected_attributes, expected
+end
+
+Then('every span field {string} equals {string}') do |key, expected|
+  spans = spans_from_request_list(Maze::Server.list_for('traces'))
+  selected_keys = spans.map { |span| span[key] == expected }
+  Maze.check.not_includes selected_keys, false
+end
+
+Then('every span field {string} matches the regex {string}') do |key, pattern|
+  spans = spans_from_request_list(Maze::Server.list_for('traces'))
+  spans.map { |span| Maze.check.match pattern, span[key] }
+end
+
+Then('every span string attribute {string} exists') do |attribute|
+  spans = spans_from_request_list(Maze::Server.list_for('traces'))
+  spans.map { |span| Maze.check.not_nil span['attributes'].find { |a| a['key'] == attribute }['value']['stringValue'] }
+end
+
+Then('every span string attribute {string} equals {string}') do |attribute, expected|
+  spans = spans_from_request_list(Maze::Server.list_for('traces'))
+  spans.map { |span| Maze.check.equal expected, span['attributes'].find { |a| a['key'] == attribute }['value']['stringValue'] }
+end
+
+Then('every span string attribute {string} matches the regex {string}') do |attribute, pattern|
+  spans = spans_from_request_list(Maze::Server.list_for('traces'))
+  spans.map { |span| Maze.check.match pattern, span['attributes'].find { |a| a['key'] == attribute }['value']['stringValue'] }
+end
+
+Then('every span integer attribute {string} is greater than {int}') do |attribute, expected|
+  spans = spans_from_request_list(Maze::Server.list_for('traces'))
+  spans.map { |span| Maze::check.true span['attributes'].find { |a| a['key'] == attribute }['value']['intValue'].to_i > expected }
+end
+
+Then('every span bool attribute {string} is true') do |attribute|
+  spans = spans_from_request_list(Maze::Server.list_for('traces'))
+  spans.map { |span| Maze::check.true span['attributes'].find { |a| a['key'] == attribute }['value']['boolValue'] }
+end
+
+Then('a span string attribute {string} exists') do |attribute|
+  spans = spans_from_request_list(Maze::Server.list_for('traces'))
+  selected_attributes = spans.map { |span| span['attributes'].find { |a| a['key'] == attribute }['value']['stringValue'] }
+  Maze.check.false(selected_attributes.empty?)
+end
+
+Then('a span string attribute {string} equals {string}') do |attribute, expected|
+  spans = spans_from_request_list(Maze::Server.list_for('traces'))
+  selected_attributes = spans.map { |span| span['attributes'].find { |a| a['key'] == attribute }['value']['stringValue'] }
+  Maze.check.includes selected_attributes, expected
+end
+
+Then('a span field {string} equals {string}') do |key, expected|
+  spans = spans_from_request_list(Maze::Server.list_for('traces'))
+  selected_keys = spans.map { |span| span[key] }
+  Maze.check.includes selected_keys, expected
+end
+
+Then('a span field {string} matches the regex {string}') do |attribute, pattern|
+  regex = Regexp.new pattern
+  spans = spans_from_request_list(Maze::Server.list_for('traces'))
+  selected_attributes = spans.select { |span| regex.match? span[attribute] }
+
+  Maze.check.false(selected_attributes.empty?)
+end
+
+def spans_from_request_list list
+  return list.remaining
+             .flat_map { |req| req[:body]['resourceSpans'] }
+             .flat_map { |r| r['scopeSpans'] }
+             .flat_map { |s| s['spans'] }
+             .select { |s| !s.nil? }
+end
+
+def assert_received_spans(span_count, list)
+  timeout = Maze.config.receive_requests_wait
+  wait = Maze::Wait.new(timeout: timeout)
+
+  received = wait.until { spans_from_request_list(list).size >= span_count }
+  received_count = spans_from_request_list(list).size
+
+  unless received
+    raise Test::Unit::AssertionFailedError.new <<-MESSAGE
+    Expected #{span_count} spans but received #{received_count} 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.operator(span_count, :<=, received_count, "#{received_count} spans received")
+end
+
+def get_attribute_value(field, attribute, attr_type)
+  list = Maze::Server.list_for 'trace'
+  attributes = Maze::Helper.read_key_path list.current[:body], "#{field}.attributes"
+  attribute = attributes.find { |a| a['key'] == attribute }
+  value = attribute&.dig 'value', attr_type
+  attr_type == 'intValue' && value.is_a?(String) ? value.to_i : value
+end
+
+def check_attribute_equal(field, attribute, attr_type, expected)
+  value = get_attribute_value field, attribute, attr_type
+  Maze.check.equal value, expected
+end
+
+def assert_attribute(field, key, expected)
+  list = Maze::Server.traces
+  attributes = Maze::Helper.read_key_path(list.current[:body], "#{field}.attributes")
+  Maze.check.equal attributes.find { |a| a['key'] == key }, { 'key' => key, 'value' => expected }
+end

data/lib/features/steps/value_steps.rb

@@ -0,0 +1,119 @@
+require 'date'
+
+# @!group Value steps
+
+# Stores a payload value against a key for cross-request comparisons.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field [String] The payload field to store
+# @step_input key [String] The key to store the value against
+Then('the {word} payload field {string} is stored as the value {string}') do |request_type, field, key|
+  list = Maze::Server.list_for request_type
+  value = Maze::Helper.read_key_path(list.current[:body], field)
+  Maze::Store.values[key] = value.dup
+end
+
+# Tests whether a payload field matches a previously stored payload value
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field [String] The payload field to test
+# @step_input key [String] The key indicating a previously stored value
+Then('the {word} payload field {string} equals the stored value {string}') do |request_type, field, key|
+  list = Maze::Server.list_for request_type
+  payload_value = Maze::Helper.read_key_path(list.current[:body], field)
+  stored_value = Maze::Store.values[key]
+  result = Maze::Compare.value(payload_value, stored_value)
+  Maze.check.true(result.equal?, "Payload value: #{payload_value} does not equal stored value: #{stored_value}")
+end
+
+# Tests whether a payload field is distinct from a previously stored payload value
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field [String] The payload field to test
+# @step_input key [String] The key indicating a previously stored value
+Then('the {word} payload field {string} does not equal the stored value {string}') do |request_type, field, key|
+  list = Maze::Server.list_for request_type
+  payload_value = Maze::Helper.read_key_path(list.current[:body], field)
+  stored_value = Maze::Store.values[key]
+  result = Maze::Compare.value(payload_value, stored_value)
+  Maze.check.false(result.equal?, "Payload value: #{payload_value} equals stored value: #{stored_value}")
+end
+
+# Tests whether a payload field matches a previously stored payload value, ignoring case
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field [String] The payload field to test
+# @step_input key [String] The key indicating a previously stored value
+Then('the {word} payload field {string} equals the stored value {string} ignoring case') do |request_type, field, key|
+  list = Maze::Server.list_for request_type
+  payload_value = Maze::Helper.read_key_path(list.current[:body], field)
+  stored_value = Maze::Store.values[key]
+  payload_value.downcase!
+  stored_value.downcase!
+  result = Maze::Compare.value(payload_value, stored_value)
+  Maze.check.true(result.equal?, "Payload value: #{payload_value} does not equal stored value: #{stored_value}")
+end
+
+# Tests whether a payload field is distinct from a previously stored payload value, ignoring case
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field [String] The payload field to test
+# @step_input key [String] The key indicating a previously stored value
+Then('the {word} payload field {string} does not equal the stored value {string} ignoring case') do |request_type, field, key|
+  list = Maze::Server.list_for request_type
+  payload_value = Maze::Helper.read_key_path(list.current[:body], field)
+  stored_value = Maze::Store.values[key]
+  payload_value.downcase!
+  stored_value.downcase!
+  result = Maze::Compare.value(payload_value, stored_value)
+  Maze.check.false(result.equal?, "Payload value: #{payload_value} equals stored value: #{stored_value}")
+end
+
+# Tests whether a payload field is a number (Numeric according to Ruby)
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field [String] The payload field to test
+Then('the {word} payload field {string} is a number') 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 Numeric, value
+end
+
+# Tests whether a payload field is an integer (Integer according to Ruby)
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field [String] The payload field to test
+Then('the {word} payload field {string} is an integer') 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 Integer, value
+end
+
+# Tests whether a payload field is a date (parseable as a Date, according to Ruby)
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field [String] The payload field to test
+Then('the {word} payload field {string} is a date') do |request_type, field|
+  list = Maze::Server.list_for request_type
+  value = Maze::Helper.read_key_path(list.current[:body], field)
+  date = begin
+    Date.parse(value)
+  rescue StandardError
+    nil
+  end
+  Maze.check.kind_of Date, date
+end
+
+# Tests whether a payload field (loosely) matches a UUID regex (/[a-fA-F0-9-]!{36}/)
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field [String] The payload field to test
+Then('the {word} payload field {string} is a UUID') do |request_type, field|
+  list = Maze::Server.list_for request_type
+  value = Maze::Helper.read_key_path(list.current[:body], field)
+  Maze.check.not_nil(value, "Expected UUID, got nil for #{field}")
+  match = /[a-fA-F0-9-]{36}/.match(value).size > 0
+  Maze.check.true(match, "Field #{field} is not a UUID, received #{value}")
+end
+
+# @!endgroup

data/lib/features/support/env.rb

@@ -0,0 +1,7 @@
+require 'securerandom'
+
+# The apikey that should be used on this test run
+$api_key = SecureRandom.hex(16).tr('+/=', 'xyz')
+
+# A regex providing the pattern expected from timestamps
+TIMESTAMP_REGEX = /^\d{4}\-\d{2}\-\d{2}T\d{2}:\d{2}:[\d\.]+(Z|[+-]\d{2}:\d{2})?$/

data/lib/features/support/internal_hooks.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require 'cucumber'
+require 'fileutils'
+require 'json'
+require 'securerandom'
+require 'selenium-webdriver'
+require 'uri'
+
+BeforeAll do
+
+  Maze.check = Maze::Checks::AssertCheck.new
+
+  # Infer mode of operation from config, one of:
+  # - Appium (using either remote or local devices)
+  # - Browser (Selenium with local or remote browsers)
+  # - Command (the software under test is invoked with a system call)
+  # TODO Consider making this a specific command line option defaulting to Appium
+  is_appium = [:bs, :bb, :local].include?(Maze.config.farm) && !Maze.config.app.nil?
+  is_browser = !Maze.config.browser.nil?
+  if is_appium
+    Maze.mode = :appium
+    Maze.internal_hooks = Maze::Hooks::AppiumHooks.new
+  elsif is_browser
+    Maze.mode = :browser
+    Maze.internal_hooks = Maze::Hooks::BrowserHooks.new
+  else
+    Maze.mode = :command
+    Maze.internal_hooks = Maze::Hooks::CommandHooks.new
+  end
+  $logger.info "Running in #{Maze.mode.to_s} mode"
+
+  # Clear out maze_output folder
+  maze_output = Dir.glob(File.join(Dir.pwd, 'maze_output', '*'))
+  if Maze.config.file_log && !maze_output.empty?
+    maze_output.each { |path| $logger.info "Clearing contents of #{path}" }
+    FileUtils.rm_rf(maze_output)
+  end
+
+  # Record the local server starting time
+  Maze.start_time = Time.now.strftime('%Y-%m-%d %H:%M:%S')
+
+  # Give each run of the tool a unique id
+  Maze.run_uuid = SecureRandom.uuid
+  $logger.info "UUID for this run: #{Maze.run_uuid}"
+
+  # Determine public IP if enabled
+  if Maze.config.aws_public_ip
+    Maze.public_address = Maze::AwsPublicIp.new.address
+    $logger.info "Public address: #{Maze.public_address}"
+  end
+
+  # Start mock server
+  Maze::Server.start
+  Maze::Server.set_response_delay_generator(Maze::Generator.new [Maze::Server::DEFAULT_RESPONSE_DELAY].cycle)
+  Maze::Server.set_sampling_probability_generator(Maze::Generator.new [Maze::Server::DEFAULT_SAMPLING_PROBABILITY].cycle)
+  Maze::Server.set_status_code_generator(Maze::Generator.new [Maze::Server::DEFAULT_STATUS_CODE].cycle)
+
+  # Invoke the internal hook for the mode of operation
+  Maze.internal_hooks.before_all
+
+  # Call any blocks registered by the client
+  Maze.hooks.call_before_all
+
+  # Start document server, if asked for
+  # This must happen after any client hooks have run, so that they can set the server root
+  Maze::DocumentServer.start unless Maze.config.document_server_root.nil?
+end
+
+# @param config The Cucumber config
+InstallPlugin do |config|
+  # Start Bugsnag
+  Maze::BugsnagConfig.start_bugsnag(config)
+
+  if config.fail_fast?
+    # Register exit code handler
+    Maze::Hooks::ErrorCodeHook.register_exit_code_hook
+    config.filters << Maze::Plugins::ErrorCodePlugin.new(config)
+  end
+
+  # Only add the retry plugin if --retry is not used on the command line
+  config.filters << Maze::Plugins::GlobalRetryPlugin.new(config) if config.options[:retry].zero?
+  config.filters << Maze::Plugins::BugsnagReportingPlugin.new(config)
+  cucumber_report_plugin = Maze::Plugins::CucumberReportPlugin.new
+  cucumber_report_plugin.install_plugin(config)
+end
+
+# Before each scenario
+Before do |scenario|
+  # Default to no dynamic try
+  Maze.dynamic_retry = false
+
+  if ENV['BUILDKITE']
+    location = "\e[90m\t# #{scenario.location}\e[0m"
+    $stdout.puts "--- Scenario: #{scenario.name} #{location}"
+  end
+
+  # Invoke the internal hook for the mode of operation
+  Maze.internal_hooks.before scenario
+
+  # Call any blocks registered by the client
+  Maze.hooks.call_before scenario
+end
+
+# General processing to be run after each scenario
+After do |scenario|
+  # If we're running on macos, take a screenshot if the scenario fails
+  if Maze.config.os == "macos" && scenario.status == :failed
+    Maze::MacosUtils.capture_screen(scenario)
+  end
+
+  # Call any blocks registered by the client
+  Maze.hooks.call_after scenario
+
+  # Stop document server if started by the Cucumber step
+  Maze::DocumentServer.manual_stop
+
+  # Stop terminating server if started by the Cucumber step
+  Maze::TerminatingServer.stop
+
+  # This is here to stop sessions from one test hitting another.
+  # However this does mean that tests take longer.
+  # In addition, reset the last captured exit code
+  # TODO:SM We could try and fix this by generating unique endpoints
+  # for each test.
+  Maze::Docker.reset
+
+  # Make sure that any scripts are killed between test runs
+  # so future tests are run from a clean slate.
+  Maze::Runner.kill_running_scripts
+
+  Maze::Proxy.instance.stop
+
+  # Log all received requests to the console if the scenario fails and/or config says to
+  if (scenario.failed? && Maze.config.log_requests) || Maze.config.always_log
+    $stdout.puts '^^^ +++'
+    output_received_requests('errors')
+    output_received_requests('sessions')
+    output_received_requests('builds')
+    output_received_requests('logs')
+    output_received_requests('invalid requests')
+  end
+
+  # Log all received requests to file
+  Maze::MazeOutput.new(scenario).write_requests if Maze.config.file_log
+
+  # Invoke the internal hook for the mode of operation
+  Maze.internal_hooks.after scenario
+
+ensure
+  # Request arrays in particular are cleared here, rather than in the Before hook, to allow requests to be registered
+  # when a test fixture starts (which can be before the first Before scenario hook fires).
+  Maze::Server.reset!
+  Maze::Runner.environment.clear
+  Maze::Store.values.clear
+  Maze::Aws::Sam.reset!
+end
+
+def output_received_requests(request_type)
+  request_queue = Maze::Server.list_for(request_type)
+  count = request_queue.size_all
+  if count == 0
+    $logger.info "No #{request_type} received"
+  else
+    $logger.info "#{count} #{request_type} were received:"
+    request_queue.all.each.with_index(1) do |request, number|
+      $stdout.puts "--- #{request_type} #{number} of #{count}"
+      Maze::LogUtil.log_hash(Logger::Severity::INFO, request)
+    end
+  end
+end
+
+# Check for invalid requests after each scenario.  This is its own hook as failing a scenario raises an exception
+# and we need the logic in the other After hook to be performed.
+# Furthermore, this hook should appear after the general hook as they are executed in reverse order by Cucumber.
+After do |scenario|
+  unless Maze::Server.invalid_requests.size_all == 0
+    msg = "#{Maze::Server.invalid_requests.size_all} invalid request(s) received during scenario"
+    scenario.fail msg
+  end
+end
+
+# After all tests
+AfterAll do
+
+  if Maze.timers.size.positive?
+    $stdout.puts '--- Timer summary'
+    Maze.timers.report
+  end
+
+  $stdout.puts '+++ All scenarios complete'
+
+  # Stop the mock server
+  Maze::Server.stop
+
+  # In order to not impact future test runs, we down
+  # all services (which removes networks etc) so that
+  # future test runs are from a clean slate.
+  Maze::Docker.down_all_services
+
+  # Invoke the internal hook for the mode of operation
+  Maze.internal_hooks.after_all
+end
+
+at_exit do
+  Maze.internal_hooks.at_exit
+end

data/lib/maze/api/appium/file_manager.rb

@@ -0,0 +1,29 @@
+module Maze
+  module Api
+    module Appium
+      # Provides operations for working with files during Appium runs.
+      class FileManager
+        # param driver
+        def initialize
+          @driver = Maze.driver
+        end
+
+        # Creates a file with the given contents on the device (using Appium).  The file will be located in the app's
+        # Documents directory for iOS and /sdcard/Android/data/<app-id>/ for Android.
+        # @param contents [String] Content of the file to be written
+        # @param filename [String] Name (with no path) of the file to be written on the device
+        def write_app_file(contents, filename)
+          path = case Maze::Helper.get_current_platform
+                 when 'ios'
+                   "@#{@driver.app_id}/Documents/#{filename}"
+                 when 'android'
+                   "/sdcard/Android/data/#{@driver.app_id}/files/#{filename}"
+                 end
+
+          $logger.debug "Pushing file to '#{path}' with contents: #{contents}"
+          @driver.push_file(path, contents)
+        end
+      end
+    end
+  end
+end