bugsnag-maze-runner 7.22.1

data/lib/maze/appium_server.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'pty'
+require 'logger'
+
+module Maze
+  # Basic shell that runs an Appium server on a separate thread
+  class AppiumServer
+    class << self
+      # @return [string|nil] The PID of the appium process (if available)
+      attr_reader :pid
+
+      # @return [thread|nil] The thread running the appium process (if available)
+      attr_reader :appium_thread
+
+      # @return [Logger|nil] The logger used for creating the log file
+      attr_reader :appium_logger
+
+      # Starts a separate thread running the appium server so long as:
+      #   - An instance of the appium server isn't already running
+      #   - The port configured is available
+      #   - The appium command is available via CLI
+      #
+      # @param address [String] The IP address on which to start the appium server
+      # @param port [String] The port on which to start the appium server
+      def start(address: '0.0.0.0', port: '4723')
+        return if running
+
+        # Check if the appium server appears to be running already, warning and carrying on if so
+        unless appium_port_available?(port)
+          $logger.warn "Requested appium port:#{port} is in use. Aborting built-in appium server launch"
+          return
+        end
+
+        # Check if appium is installed, warning if not
+        unless appium_available?
+          $logger.warn 'Appium is unavailable to be started from the command line. Install using `npm i -g appium`'
+          return
+        end
+
+        start_logger
+
+        command = "appium -a #{address} -p #{port}"
+        @appium_thread = Thread.new do
+          PTY.spawn(command) do |stdout, _stdin, pid|
+            @pid = pid
+            $logger.debug("Appium:#{@pid}") { 'Appium server started' }
+            stdout.each do |line|
+              log_line(line)
+            end
+          end
+        end
+
+        # Temporary sleep to allow appium to start
+        sleep 2
+      end
+
+      # Checks whether the server is running, as indicated by the @pid and the appium thread being alive
+      #
+      # @return [Boolean] Whether the local appium server is running
+      def running
+        @appium_thread&.alive? ? true : false
+      end
+
+      # Stops the appium server, if running, using SIGINT for correct shutdown
+      def stop
+        return unless running
+
+        $logger.debug("Appium:#{@pid}") { 'Stopping appium server' }
+        Process.kill('INT', @pid)
+        @pid = nil
+        @appium_thread.join
+        @appium_thread = nil
+      end
+
+      private
+
+      # Checks if the `appium` command is available on CI
+      #
+      # @return [Boolean] Whether the appium command is available
+      def appium_available?
+        `appium -v`
+        true
+      rescue Errno::ENOENT
+        false
+      end
+
+      # Starts the logger targeting a file defined by the APPIUM_LOGFILE config option
+      def start_logger
+        @appium_logger = ::Logger.new(Maze.config.appium_logfile)
+        @appium_logger.datetime_format = '%Y-%m-%d %H:%M:%S'
+      end
+
+      # Logs to a known file, creating the outstream if it isn't already present
+      #
+      # @param line [String] The line to log
+      def log_line(line)
+        return if @appium_logger.nil?
+        @appium_logger.info("Appium:#{@pid}") { line }
+      end
+
+      # Checks if the given port is already in use
+      #
+      # @param port [String] The port that should be available
+      #
+      # @return [Boolean] Whether something is running on the given port
+      def appium_port_available?(port)
+        `netstat -vanp tcp | awk '{ print $4 }' | grep "\.#{port}$"`.empty?
+      end
+    end
+  end
+end

data/lib/maze/assertions/request_set_assertions.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'test/unit'
+require_relative '../helper'
+
+module Maze
+  module Assertions
+    # Provides helper routines for checking sets of requests against values in a table.
+    class RequestSetAssertions
+      class << self
+
+        # Checks that a set of requests satisfy the properties expressed by the table given.
+        #
+        # @param requests [Hash[]] Requests to check
+        # @param table [Cucumber::MultilineArgument::DataTable] Table of expected values, where:
+        #   - headings can be provided as key paths (e.g. events.0.breadcrumbs.0.name)
+        #   - table values can be written as "null" for nil
+        def assert_requests_match(requests, table)
+          Maze.check.equal(table.hashes.length,
+                           requests.length,
+                           'Number of requests do not match number of entries in table.')
+          matches = matching_rows requests, table
+          return if matches.length == table.hashes.length
+
+          # Not all matched - log diagnostic before failing assertion
+          $logger.error "Only #{matches.length} of #{requests.length} matched:"
+          $logger.info matches.keys.sort
+          matches.sort.to_h.each do |row, request|
+            $logger.info "#{table.rows[row]} matched by request element #{matches[request]}"
+          end
+          Maze.check.equal(requests.length, matches.length, 'Not all requests matched a row in the table.')
+        end
+
+        # Given arrays of requests and table-based criteria, determines which rows of the table
+        # are satisfied by one of the requests.  Where multiple rows in the table specify the same
+        # criteria, there must be multiple requests provided to satisfy each.
+        #
+        # @param requests [Hash[]] Requests to check
+        # @param table [Cucumber::MultilineArgument::DataTable] Table of expected values, where:
+        #   - headings can be provided as key paths (e.g. events.0.breadcrumbs.0.name)
+        #   - table values can be written as "null" for nil
+        # @return [Hash] A hash of row to request indexes, indicating the first request matching each row.
+        #   E.g. {0 => 2} means that the first row was satisfied by the 3rd request.
+        def matching_rows(requests, table)
+
+          # iterate through each row in the table. exactly 1 request should match each row.
+          row_to_request_matches = {}
+          table.hashes.each_with_index do |row, row_index|
+            requests.each_with_index do |request, request_index|
+              # Skip if row already matched
+              next if row_to_request_matches.values.include? request_index
+              # Skip if no body in this request
+              next unless request.key?(:body)
+              next unless request_matches_row(request[:body], row)
+
+              # Record the match
+              row_to_request_matches[row_index] = request_index
+            end
+          end
+          row_to_request_matches
+        end
+
+        # Determines if a request body satisfies the criteria expressed by a row.
+        # The special string "null" is interpreted as nil in comparisons and
+        # regular expressions are assumed is the start and end of the string is a '/'.
+        #
+        # @param body [Hash] Request body to consider
+        # @param row [Hash] Hash of keys to expected value, where the keys given can
+        #   be a Mongo-style dot notation path.
+        def request_matches_row(body, row)
+          row.each do |key, expected_value|
+            obs_val = Maze::Helper.read_key_path(body, key)
+            next if ('null'.eql? expected_value) && obs_val.nil? # Both are null/nil
+            next if ('@not_null'.eql? expected_value) && !obs_val.nil? # The value isn't null
+
+            unless obs_val.nil?
+              if expected_value[0] == '/' && expected_value[-1] == '/'
+                # Treat as regexp
+                regex = Regexp.new expected_value[1, expected_value.length - 2]
+                next if regex.match? obs_val.to_s # Value matches regex
+              elsif expected_value.eql? obs_val.to_s
+                # Values match
+                next
+              end
+            end
+
+            # Match not found - return false
+            return false
+          end
+          # All matched - return true
+          true
+        end
+      end
+    end
+  end
+end
+

data/lib/maze/aws/sam.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'shellwords'
+
+module Maze
+  module Aws
+    # Interacts with the AWS SAM CLI to invoke Lambda functions
+    # Note that the SAM CLI must be installed on the host machine as it does not
+    # run in a Docker container! For this reason the "start-api" command is not
+    # supported as it could easily cause port clashes and zombie processes
+    class Sam
+      class << self
+        attr_reader :last_response, :last_exit_code
+
+        # Invoke the given lambda with an optional event
+        #
+        # This happens synchronously so there is no need to wait for a response
+        #
+        # @param directory [String] The directory containing the lambda
+        # @param lambda [String] The name of the lambda to invoke
+        # @param event [String, nil] An optional event file to invoke with
+        #
+        # @return [void]
+        def invoke(directory, lambda, event = nil)
+          command = build_invoke_command(lambda, event)
+
+          output, @last_exit_code = Maze::Runner.run_command("cd #{directory} && #{command}")
+
+          @last_response = parse(output)
+        end
+
+        # Reset the last response and last exit code
+        #
+        # @return [void]
+        def reset!
+          @last_response = nil
+          @last_exit_code = nil
+        end
+
+        private
+
+        # Build the command to invoke the given lambda with the given event
+        #
+        # @param lambda [String] The name of the lambda to invoke
+        # @param event [String, nil] An optional event file to invoke with
+        #
+        # @return [String]
+        def build_invoke_command(lambda, event)
+          command = "sam local invoke #{Shellwords.escape(lambda)}"
+          command += " --event #{Shellwords.escape(event)}" unless event.nil?
+          command += " --docker-network #{Shellwords.escape(ENV['NETWORK_NAME'])}" if ENV.key?('NETWORK_NAME')
+
+          command
+        end
+
+        # The command output contains all stdout/stderr lines in an array. The
+        # Lambda response is the last line of output as JSON. The response body is
+        # also JSON, so we have to parse twice to get a Hash from the output
+        #
+        # @param output [Array<String>] The command's output as an array of lines
+        #
+        # @return [Hash]
+        def parse(output)
+          unless valid?(output)
+            raise <<~ERROR
+              Unable to parse Lambda output!
+              The likely cause is:
+                > #{output.last.chomp}
+
+              Full output:
+                > #{output.map(&:chomp).join("\n  > ")}
+            ERROR
+          end
+
+          # Attempt to parse the last line of output as this is where a JSON
+          # response would be. It's possible for a Lambda to output nothing,
+          # e.g. if it forcefully exited, so we allow JSON parse failures here
+          begin
+            parsed_output = JSON.parse(output.last)
+          rescue JSON::ParserError
+            return {}
+          end
+
+          # Error output has no "body" of additional JSON so we can stop here
+          return parsed_output unless parsed_output.key?('body')
+
+          # The body is _usually_ JSON but doesn't have to be. We attempt to
+          # parse it anyway because it allows us to assert against it easily,
+          # but if this fails then it may just be in another format, e.g. HTML
+          begin
+            parsed_output['body'] = JSON.parse(parsed_output['body'])
+          rescue JSON::ParserError
+            # Ignore
+          end
+
+          parsed_output
+        end
+
+        # Check if the output looks valid. There should be a "END" marker with a
+        # request ID if the lambda invocation completed successfully
+        #
+        # @param output [Array<String>] The command's output as an array of lines
+        #
+        # @return [Boolean]
+        def valid?(output)
+          output.any? { |line| line =~ /^END RequestId:/ }
+        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/bugsnag_config.rb

@@ -0,0 +1,42 @@
+require 'bugsnag'
+
+# Contains logic for running Bugsnag
+module Maze
+  class BugsnagConfig
+    class << self
+      def start_bugsnag(cucumber_config)
+        # Use MAZE_BUGSNAG_API_KEY explicitly to avoid collisions with test env
+        return unless Maze.config.enable_bugsnag && ENV['MAZE_BUGSNAG_API_KEY']
+
+        Bugsnag.configure do |config|
+          config.api_key = ENV['MAZE_BUGSNAG_API_KEY']
+          config.discard_classes << 'Test::Unit::AssertionFailedError'
+          config.add_metadata(:'test driver', {
+            'driver type': Maze.driver.class,
+            'device farm': Maze.config.farm,
+            'capabilities': Maze.config.capabilities
+          }) if Maze.driver
+          config.add_metadata(:'buildkite', {
+            'pipeline': ENV['BUILDKITE_PIPELINE_NAME'],
+            'repo': ENV['BUILDKITE_REPO'],
+            'build url': ENV['BUILDKITE_BUILD_URL'],
+            'branch': ENV['BUILDKITE_BRANCH'],
+            'builder': ENV['BUILDKITE_BUILD_CREATOR'],
+            'message': ENV['BUILDKITE_MESSAGE'],
+            'step': ENV['BUILDKITE_LABEL']
+          }) if ENV['BUILDKITE']
+          config.project_root = Dir.pwd
+        end
+
+        Bugsnag.start_session
+
+        at_exit do
+          if $!
+            Bugsnag.notify($!)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/maze/checks/assert_check.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+require 'test/unit'
+
+module Maze
+  module Checks
+    # Assertion-backed data verification checks
+    class AssertCheck
+      include Test::Unit::Assertions
+
+      def true(test, message = nil)
+        assert_true(test, message)
+      end
+
+      def false(test, message = nil)
+        assert_false(test, message)
+      end
+
+      def nil(test, message = nil)
+        assert_nil(test, message)
+      end
+
+      def not_nil(test, message = nil)
+        assert_not_nil(test, message)
+      end
+
+      def match(pattern, string, message = nil)
+        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)
+        assert_equal(expected, act, message)
+      end
+
+      def not_equal(expected, act, message = nil)
+        assert_not_equal(expected, act, message)
+      end
+
+      def operator(operand1, operator, operand2, message = nil)
+        assert_operator(operand1, operator, operand2, message)
+      end
+
+      def kind_of(klass, object, message = nil)
+        assert_kind_of(klass, object, message)
+      end
+
+      def block(message = 'block failed', &block)
+        assert_block(message, &block)
+      end
+
+      def include(collection, object, message = nil)
+        assert_include(collection, object, message)
+      end
+      alias includes include
+
+      def not_include(collection, object, message = nil)
+        assert_not_include(collection, object, message)
+      end
+      alias not_includes not_include
+    end
+  end
+end

data/lib/maze/checks/noop_check.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Maze
+  module Checks
+    # Assertion-backed data verification checks
+    class NoopCheck
+      def true(_test, _message = nil) end
+
+      def false(_test, _message = nil) end
+
+      def nil(_test, _message = nil) end
+
+      def not_nil(_test, _message = nil) end
+
+      def match(_pattern, _string, _message = nil) end
+
+      def equal(_expected, _actual, _message = nil) end
+
+      def not_equal(_expected, _actual, _message = nil) end
+
+      def operator(_operand1, _operator, _operand2, _message = nil) end
+
+      def kind_of(_klass, _object, _message = nil) end
+
+      def block(_message = 'block failed', &_block) end
+
+      def include(_collection, _object, _message = nil) end
+      alias includes include
+
+      def not_include(_collection, _object, _message = nil) end
+      alias not_includes not_include
+    end
+  end
+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