bugsnag-maze-runner 6.27.0 → 7.22.1

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/support/internal_hooks.rb

@@ -16,7 +16,7 @@ BeforeAll do
   # - 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, :sl, :bb, :local].include?(Maze.config.farm) && !Maze.config.app.nil?
+  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
@@ -40,17 +40,31 @@ BeforeAll do
   # Record the local server starting time
   Maze.start_time = Time.now.strftime('%Y-%m-%d %H:%M:%S')
 
-  # Start document server, if asked for
-  Maze::DocumentServer.start unless Maze.config.document_server_root.nil?
+  # 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
@@ -58,6 +72,12 @@ 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)
@@ -76,7 +96,7 @@ Before do |scenario|
   end
 
   # Invoke the internal hook for the mode of operation
-  Maze.internal_hooks.before
+  Maze.internal_hooks.before scenario
 
   # Call any blocks registered by the client
   Maze.hooks.call_before scenario
@@ -92,14 +112,6 @@ After do |scenario|
   # Call any blocks registered by the client
   Maze.hooks.call_after scenario
 
-  # Make sure we reset to HTTP 200 return status after each scenario
-  Maze::Server.status_code = 200
-  Maze::Server.reset_status_code = false
-
-  # Similarly for the response delay
-  Maze::Server.response_delay_ms = 0
-  Maze::Server.reset_response_delay = false
-
   # Stop document server if started by the Cucumber step
   Maze::DocumentServer.manual_stop
 
@@ -119,7 +131,7 @@ After do |scenario|
 
   Maze::Proxy.instance.stop
 
-  # Log unprocessed requests on Buildkite if the scenario fails
+  # 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')
@@ -130,21 +142,15 @@ After do |scenario|
   end
 
   # Log all received requests to file
-  write_requests(scenario) if Maze.config.file_log
+  Maze::MazeOutput.new(scenario).write_requests if Maze.config.file_log
 
   # Invoke the internal hook for the mode of operation
-  Maze.internal_hooks.after
+  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.errors.clear
-  Maze::Server.sessions.clear
-  Maze::Server.builds.clear
-  Maze::Server.uploads.clear
-  Maze::Server.sourcemaps.clear
-  Maze::Server.logs.clear
-  Maze::Server.invalid_requests.clear
+  Maze::Server.reset!
   Maze::Runner.environment.clear
   Maze::Store.values.clear
   Maze::Aws::Sam.reset!
@@ -152,10 +158,10 @@ end
 
 def output_received_requests(request_type)
   request_queue = Maze::Server.list_for(request_type)
-  if request_queue.empty?
+  count = request_queue.size_all
+  if count == 0
     $logger.info "No #{request_type} received"
   else
-    count = request_queue.size_all
     $logger.info "#{count} #{request_type} were received:"
     request_queue.all.each.with_index(1) do |request, number|
       $stdout.puts "--- #{request_type} #{number} of #{count}"
@@ -164,70 +170,11 @@ def output_received_requests(request_type)
   end
 end
 
-# Writes each list of requests to a separate file under, e.g:
-# maze_output/failed/scenario_name/errors.log
-def write_requests(scenario)
-  folder1 = File.join(Dir.pwd, 'maze_output')
-  folder2 = scenario.failed? ? 'failed' : 'passed'
-  folder3 = Maze::Helper.to_friendly_filename(scenario.name)
-
-  path = File.join(folder1, folder2, folder3)
-
-  FileUtils.makedirs(path)
-
-  request_types = %w[errors sessions builds uploads logs sourcemaps invalid]
-
-  request_types.each do |request_type|
-    list = Maze::Server.list_for(request_type).all
-    next if list.empty?
-
-    filename = "#{request_type}.log"
-    filepath = File.join(path, filename)
-
-    counter = 1
-    File.open(filepath, 'w+') do |file|
-      list.each do |request|
-        file.puts "=== Request #{counter} of #{list.size} ==="
-        if request[:invalid]
-          invalid_request = true
-          uri = request[:request][:request_uri]
-          headers = request[:request][:header]
-          body = request[:request][:body]
-        else
-          invalid_request = false
-          uri = request[:request].request_uri
-          headers = request[:request].header
-          body = request[:body]
-        end
-        file.puts "URI: #{uri}"
-        file.puts "HEADERS:"
-        headers.each do |key, values|
-          file.puts "  #{key}: #{values.map {|v| "'#{v}'"}.join(' ')}"
-        end
-        file.puts
-        file.puts "BODY:"
-        if !invalid_request && headers["content-type"].first == 'application/json'
-          file.puts JSON.pretty_generate(body)
-        else
-          file.puts body
-        end
-        file.puts
-        if request.include?(:reason)
-          file.puts "REASON:"
-          file.puts request[:reason]
-          file.puts
-        end
-        counter += 1
-      end
-    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.empty?
+  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

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

data/lib/maze/aws_public_ip.rb

@@ -0,0 +1,53 @@
+module Maze
+  # Determines the public IP address and port when running on Buildkite with the Elastic CI Stack for AWS
+  class AwsPublicIp
+    attr_reader :address
+
+    def initialize
+      # This class is only relevant on Buildkite
+      return unless ENV['BUILDKITE']
+
+      ip = determine_public_ip
+      port = determine_public_port
+
+      @address = "#{ip}:#{port}"
+    end
+
+    # Determines the public IP address of the running AWS instance
+    def determine_public_ip
+      # 169.254.169.254 is the address of the AWS instance metadata service
+      # See https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instancedata-data-retrieval.html
+      `curl --silent -XGET http://169.254.169.254/latest/meta-data/public-ipv4`
+    end
+
+    # Determines the external port of the running Docker container that's associated with the port of the mock server
+    def determine_public_port
+      port = 0
+      count = 0
+      max_attempts = 30
+
+      # Give up after 30 seconds
+      while port == 0 && count < max_attempts do
+        hostname = ENV['HOSTNAME']
+        command = "curl --silent -XGET --unix-socket /var/run/docker.sock http://localhost/containers/#{hostname}/json"
+        result = Maze::Runner.run_command(command)
+        if result[1] == 0
+          begin
+            json_string = result[0][0].strip
+            json_result = JSON.parse(json_string)
+            port = json_result['NetworkSettings']['Ports']["#{Maze.config.port}/tcp"][0]['HostPort']
+          rescue StandardError
+            $logger.error "Unable to parse public port from: #{json_string}"
+            return 0
+          end
+        end
+
+        count += 1
+        sleep 1 if port == 0 && count < max_attempts
+      end
+      $logger.error "Failed to determine public port within #{max_attempts} attempts" if port == 0 && count == max_attempts
+
+      port
+    end
+  end
+end

data/lib/maze/checks/assert_check.rb

@@ -24,7 +24,15 @@ module Maze
       end
 
       def match(pattern, string, message = nil)
-        assert_match(pattern, string, message)
+        regexp = if pattern.class == Regexp
+                   pattern
+                 else
+                   Regexp.new(pattern)
+                 end
+        if message.nil?
+          message = "<#{string}> was not matched by regex <#{pattern}>"
+        end
+        assert_match(regexp, string, message)
       end
 
       def equal(expected, act, message = nil)
@@ -59,33 +67,3 @@ module Maze
     end
   end
 end
-
-# Wrapper for Maze.check.true to avoid making a breaking change.
-# @deprecated TODO Remove in v7
-def assert_true(value, message = nil)
-  Maze.check.true value, message
-end
-
-# Wrapper for Maze.check.false to avoid making a breaking change.
-# @deprecated TODO Remove in v7
-def assert_false(value, message = nil)
-  Maze.check.false value, message
-end
-
-# Wrapper for Maze.check.not_nil to avoid making a breaking change.
-# @deprecated TODO Remove in v7
-def assert_not_nil(value, message = nil)
-  Maze.check.not_nil value, message
-end
-
-# Wrapper for Maze.check.not_nil to avoid making a breaking change.
-# @deprecated TODO Remove in v7
-def assert_block(message = 'block failed', &block)
-  Maze.check.block(message, &block)
-end
-
-# Wrapper for Maze.check.true to avoid making a breaking change.
-# @deprecated TODO Remove in v7
-def assert_equal(value, message = nil)
-  Maze.check.equal value, message
-end

data/lib/maze/client/appium/base_client.rb

@@ -0,0 +1,131 @@
+require 'json'
+
+module Maze
+  module Client
+    module Appium
+      class BaseClient
+        FIXTURE_CONFIG = 'fixture_config.json'
+
+        def initialize
+          @session_ids = []
+        end
+
+        def start_session
+          prepare_session
+
+          start_driver(Maze.config)
+
+          # Set bundle/app id for later use
+          Maze.driver.app_id = case Maze::Helper.get_current_platform
+                               when 'android'
+                                 Maze.driver.session_capabilities['appPackage']
+                               when 'ios'
+                                 Maze.driver.session_capabilities['CFBundleIdentifier'] # Present on BS and locally
+                               end
+          # Ensure the device is unlocked
+          Maze.driver.unlock
+
+          log_run_intro
+        end
+
+        def prepare_session
+          raise 'Method not implemented by this class'
+        end
+
+        def maze_address
+          raise 'Method not implemented by this class'
+        end
+
+        def start_driver(config)
+          retry_failure = config.device_list.nil? || config.device_list.empty?
+          driver = nil
+          until Maze.driver
+            begin
+              start_driver_closure = Proc.new do
+                begin
+                  config.capabilities = device_capabilities
+                  driver = Maze::Driver::Appium.new config.appium_server_url,
+                                                    config.capabilities,
+                                                    config.locator
+
+                  result = driver.start_driver
+                  if result
+                    # Log details of this session
+                    $logger.info "Created Appium session: #{driver.session_id}"
+                    @session_ids << driver.session_id
+                    udid = driver.session_capabilities['udid']
+                    $logger.info "Running on device: #{udid}" unless udid.nil?
+                  end
+                  result
+                rescue => start_error
+                  $logger.error "Session creation failed: #{start_error}"
+                  raise start_error unless retry_failure
+                  false
+                end
+              end
+
+              if retry_failure
+                wait = Maze::Wait.new(interval: 10, timeout: 60)
+                success = wait.until(&start_driver_closure)
+
+                unless success
+                  $logger.error 'Appium driver failed to start after 6 attempts in 60 seconds'
+                  raise RuntimeError.new('Appium driver failed to start in 60 seconds')
+                end
+              else
+                start_driver_closure.call
+              end
+
+              # Infer OS version if necessary when running locally
+              if Maze.config.farm == :local && Maze.config.os_version.nil?
+                version = case Maze.config.os
+                          when 'android'
+                            driver.session_capabilities['platformVersion'].to_f
+                          when 'ios'
+                            driver.session_capabilities['sdkVersion'].to_f
+                          end
+                $logger.info "Inferred OS version to be #{version}"
+                Maze.config.os_version = version
+              end
+
+              Maze.driver = driver
+            rescue ::Selenium::WebDriver::Error::UnknownError => original_exception
+              $logger.warn "Attempt to acquire #{config.device} device from farm #{config.farm} failed"
+              $logger.warn "Exception: #{original_exception.message}"
+              if config.device_list.empty?
+                $logger.error 'No further devices to try - raising original exception'
+                raise original_exception
+              else
+                config.device = config.device_list.first
+                config.device_list = config.device_list.drop(1)
+                $logger.warn "Retrying driver initialisation using next device: #{config.device}"
+              end
+            end
+          end
+        end
+
+        def start_scenario
+          # Launch the app on macOS
+          Maze.driver.get(Maze.config.app) if Maze.config.os == 'macos'
+        end
+
+        def device_capabilities
+          raise 'Method not implemented by this class'
+        end
+
+        def log_run_intro
+          raise 'Method not implemented by this class'
+        end
+
+        def log_run_outro
+          raise 'Method not implemented by this class'
+        end
+
+        def stop_session
+          Maze.driver&.driver_quit
+          Maze::AppiumServer.stop if Maze::AppiumServer.running
+        end
+      end
+    end
+  end
+end