bugsnag-maze-runner 7.22.1

data/lib/features/steps/request_assertion_steps.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require 'test/unit'
+require 'open-uri'
+require 'json'
+require 'cgi'
+require_relative '../../maze/wait'
+
+# @!group Request assertion steps
+
+def assert_received_requests(request_count, list, list_name, precise = true)
+  timeout = Maze.config.receive_requests_wait
+  wait = Maze::Wait.new(timeout: timeout)
+
+  received = wait.until { list.size_remaining >= request_count }
+
+  unless received
+    raise Test::Unit::AssertionFailedError.new <<-MESSAGE
+    Expected #{request_count} #{list_name} but received #{list.size_remaining} 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
+
+  if precise
+    Maze.check.equal(request_count, list.size_remaining, "#{list.size_remaining} #{list_name} received")
+  else
+    Maze.check.operator(request_count, :<=, list.size_remaining, "#{list.size_remaining} #{list_name} received")
+  end
+
+  verify_schema_matches(list, list_name)
+  validate_payload_elements(list, list_name)
+end
+
+def verify_schema_matches(list, list_name)
+  request_schema_results = list.all.map { |request| request[:schema_errors] }
+  passed = true
+  request_schema_results.each.with_index(1) do |schema_errors, index|
+    next if schema_errors.nil?
+    if schema_errors.size > 0
+      passed = false
+      $stdout.puts "\n"
+      $stdout.puts "\e[31m--- #{list_name} #{index} failed validation with errors at the following locations:\e[0m"
+      schema_errors.each do |error|
+        $stdout.puts "\e[31m#{error["data_pointer"]} failed to match #{error["schema_pointer"]}\e[0m"
+      end
+      $stdout.puts "\n"
+    end
+  end
+
+  unless passed
+    raise Test::Unit::AssertionFailedError.new 'The received payloads did not match the endpoint schema.  A full list of the errors can be found above'
+  end
+end
+
+def validate_payload_elements(list, list_name)
+  validator_class = case list_name
+  when 'trace', 'traces'
+    Maze::Schemas::TraceValidator
+  else
+    nil
+  end
+
+  if validator_class
+    validators = list.all.map do |request|
+      validator = validator_class.new(request[:body])
+      validator.validate
+      validator
+    end
+
+    return if validators.all? { |validator| validator.success }
+    validators.each.with_index(1) do |validator, index|
+      unless validator.success
+        $stdout.puts "\n"
+        $stdout.puts "\e[31m--- #{list_name} #{index} failed validation with the following errors:\e[0m"
+        validator.errors.each do |error|
+          $stdout.puts "\e[31m#{error}\e[0m"
+        end
+        $stdout.puts "\n"
+      end
+    end
+    raise Test::Unit::AssertionFailedError.new("One or more #{list_name} payloads failed validation.  A full list of the errors can be found above")
+  end
+end
+
+#
+# Error request assertions
+#
+# Shortcut to waiting to receive a single request of the given type
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+Then('I wait to receive a(n) {word}') do |request_type|
+  step "I wait to receive 1 #{request_type}"
+end
+
+# Continually checks to see if the required amount of requests have been received,
+# timing out according to @see Maze.config.receive_requests_wait.
+# If all expected requests are received and have the Bugsnag-Sent-At header, they
+# will be sorted by the header.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input request_count [Integer] The amount of requests expected
+Then('I wait to receive {int} {word}') do |request_count, request_type|
+  list = Maze::Server.list_for(request_type)
+  assert_received_requests request_count, list, request_type
+  list.sort_by_sent_at! request_count
+end
+
+# Continually checks to see if at least the number requests given has been received,
+# timing out according to @see Maze.config.receive_requests_wait.
+#
+# This step can tolerate receiving more than the expected number of requests.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input request_count [Integer] The amount of requests expected
+Then('I wait to receive at least {int} {word}') do |request_count, request_type|
+  list = Maze::Server.list_for(request_type)
+  assert_received_requests request_count, list, request_type, false
+end
+
+# Sorts the remaining requests in a list by the field path given.
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+# @step_input field_path [String] The field to sort by
+Then('I sort the {word} by the payload field {string}') do |request_type, field_path|
+  list = Maze::Server.list_for(request_type)
+  list.sort_by! field_path
+end
+
+# Verify that at least a certain amount of requests have been received
+# This step is only intended for use in stress tests
+#
+# @step_input min_received [Integer] The minimum amount of requests required to pass
+# @step_input request_type [String] The type of request (error, session, build, etc)
+Then('I have received at least {int} {word}') do |min_received, request_type|
+  list = Maze::Server.list_for(request_type)
+  Maze.check.operator(list.size_remaining, :>=, min_received, "Actually received #{list.size_remaining} #{request_type} requests")
+end
+
+# Assert that the test Server hasn't received any requests - of a specific, or any, type.
+#
+# @step_input request_type [String] The type of request ('error', 'session', build, etc), or 'requests' to assert on all
+#   request types.
+Then('I should receive no {word}') do |request_type|
+  sleep Maze.config.receive_no_requests_wait
+  if request_type == 'requests'
+    # Assert that the test Server hasn't received any requests at all.
+    Maze.check.equal(0, Maze::Server.errors.size_remaining, "#{Maze::Server.errors.size_remaining} errors received")
+    Maze.check.equal(0, Maze::Server.sessions.size_remaining, "#{Maze::Server.sessions.size_remaining} sessions received")
+  else
+    list = Maze::Server.list_for(request_type)
+    Maze.check.equal(0, list.size_remaining, "#{list.size_remaining} #{request_type} received")
+  end
+end
+
+# Moves to the next request
+#
+# @step_input request_type [String] The type of request (error, session, build, etc)
+Then('I discard the oldest {word}') do |request_type|
+  raise "No #{request_type} to discard" if Maze::Server.list_for(request_type).current.nil?
+
+  Maze::Server.list_for(request_type).next
+end
+
+Then('the received errors match:') do |table|
+  # Checks that each request matches one of the event fields
+  requests = Maze::Server.errors.remaining
+  match_count = 0
+
+  # iterate through each row in the table. exactly 1 request should match each row.
+  table.hashes.each do |row|
+    requests.each do |request|
+      # Skip if no body.events in this request
+      next if (!request.key? :body) || (!request[:body].key? 'events')
+
+      events = request[:body]['events']
+      Maze.check.equal(1, events.length, 'Expected exactly one event per request')
+      match_count += 1 if Maze::Assertions::RequestSetAssertions.request_matches_row(events[0], row)
+    end
+  end
+  Maze.check.equal(requests.size, match_count, 'Unexpected number of requests matched the received payloads')
+end

data/lib/features/steps/runner_steps.rb

@@ -0,0 +1,428 @@
+require 'securerandom'
+require_relative '../../maze/wait'
+
+# @!group Runner steps
+
+# Sets an environment variable for subsequent scripts or commands.
+#
+# @step_input key [String] The environment variable
+# @step_input value [String] The intended value of the environment variable
+When('I set environment variable {string} to {string}') do |key, value|
+  Maze::Runner.environment[key] = value
+end
+
+# Sets an environment variable to a given endpoint.
+#
+# @step_input endpoint [String] The endpoint to set
+# @step_input name [String] The environment variable
+When('I store the {word} endpoint in the environment variable {string}') do |endpoint, name|
+  steps %(
+    When I set environment variable "#{name}" to "http://maze-runner:#{Maze.config.port}/#{endpoint}"
+  )
+end
+
+# Sets an environment variable to the currently set API key.
+#
+# @step_input name [String] The environment variable
+When('I store the api key in the environment variable {string}') do |name|
+  steps %Q{
+    When I set environment variable "#{name}" to "#{$api_key}"
+  }
+end
+
+# Runs a script, blocking until it returns.
+#
+# @step_input script_path [String] Path to the script to be run
+When('I run the script {string} synchronously') do |script_path|
+  Maze::Runner.run_script(script_path, blocking: true)
+end
+
+# Runs a script with a given interpreter, blocking until it returns.
+#
+# @step_input script_path [String] Path to the script to be run
+# @step_input command [String] The command to run the script with, e.g. 'ruby'
+When('I run the script {string} using {word} synchronously') do |script_path, command|
+  Maze::Runner.run_script(script_path, blocking: true, command: command)
+end
+
+# Runs a script.
+#
+# @step_input script_path [String] Path to the script to be run
+When('I run the script {string}') do |script_path|
+  Maze::Runner.run_script script_path
+end
+
+# Starts a docker-compose service.
+#
+# @step_input service [String] The name of the service to run
+When('I start the service {string}') do |service|
+  Maze::Docker.start_service service
+end
+
+# Runs a docker-compose service using a specific command.
+#
+# @step_input service [String] The name of the service to run
+# @step_input command [String] The command to run inside the service
+When('I run the service {string} with the command {string}') do |service, command|
+  Maze::Docker.start_service(service, command: command)
+end
+
+# Runs a docker-compose service in an interactive CLI.
+#
+# @step_input service [String] The name of the service to run
+When('I run the service {string} interactively') do |service|
+  # Stop the old session if one exists
+  step('I stop the current shell') if Maze::Runner.interactive_session?
+
+  Maze::Docker.start_service(service, interactive: true)
+end
+
+# Runs a docker-compose service using a specific command in an interactive CLI.
+#
+# @step_input service [String] The name of the service to run
+# @step_input command [String] The command to run inside the service
+When('I run the service {string} with the command {string} interactively') do |service, command|
+  # Stop the old session if one exists
+  step('I stop the current shell') if Maze::Runner.interactive_session?
+
+  Maze::Docker.start_service(service, command: command, interactive: true)
+end
+
+# Runs a docker-compose service using a specific command provided as a Gherkin multi-line string.
+#
+# @step_input service [String] The name of the service to run
+# @step_input command [String] The command to run inside the service (as a Gherkin multi-line string)
+When('I run the service {string} with the command') do |service, command|
+  one_line_cmd = command.gsub("\n", ' ').gsub(/ +/, ' ')
+  Maze::Docker.start_service(service, command: one_line_cmd)
+end
+
+# Executes a command in the given docker compose service.
+#
+# The service must already be running for this to succeed as it uses 'docker
+# compose exec'.
+#
+# @step_input command [String] The command to run inside the service
+# @step_input service [String] The name of the service
+When('I execute the command {string} in the service {string}') do |command, service|
+  Maze::Docker.exec(service, command)
+end
+
+# Executes a command in the given docker compose service in the background.
+#
+# The service must already be running for this to succeed as it uses 'docker
+# compose exec --detach'.
+#
+# @step_input command [String] The command to run inside the service
+# @step_input service [String] The name of the service
+When('I execute the command {string} in the service {string} in the background') do |command, service|
+  Maze::Docker.exec(service, command, detach: true)
+end
+
+# Allows validation of the last exit code of the last run docker-compose command.
+# Will fail if no commands have been run.
+#
+# @step_input expected_code [Integer] The expected exit code
+Then('the exit code of the last docker command was {int}') do |expected_code|
+  wait = Maze::Wait.new(timeout: Maze.config.receive_requests_wait)
+  success = wait.until { !Maze::Docker.last_exit_code.nil? }
+
+  Maze.check.true(success, 'No docker exit code available to verify')
+  Maze.check.equal(Maze::Docker.last_exit_code, expected_code)
+end
+
+# A shortcut for the above assuming 0 as a successful exit code
+# Will fail if no commands have been run
+Then('the last run docker command exited successfully') do
+  step('the exit code of the last docker command was 0')
+end
+
+# Allows testing that the last exit code was not 0
+# Will fail if no commands have been run
+Then('the last run docker command did not exit successfully') do
+  wait = Maze::Wait.new(timeout: Maze.config.receive_requests_wait)
+  success = wait.until { !Maze::Docker.last_exit_code.nil? }
+
+  Maze.check.true(success, 'No docker exit code available to verify')
+  Maze.check.not_equal(Maze::Docker.last_exit_code, 0)
+end
+
+# Allows testing a docker command output a specific string
+# Will fail if no commands have been run
+#
+# @step_input expected_string [String] The string expected in a single log line
+Then('the last run docker command output {string}') do |expected_string|
+  wait = Maze::Wait.new(timeout: Maze.config.receive_requests_wait)
+  success = wait.until { !Maze::Docker.last_command_logs.nil? }
+
+  Maze.check.true(success, 'No docker logs available to verify')
+
+  docker_output = Maze::Docker.last_command_logs
+  output_included = docker_output.any? { |line| line.include?(expected_string) }
+
+  Maze.check.true(output_included, %(
+    No line of output included '#{expected_string}'.
+    Full output:
+    #{docker_output.join('\n')}
+  ))
+end
+
+# Waits for a number of seconds, performing no actions.
+#
+# @step_input seconds [Integer] The number of seconds to sleep for
+When('I wait for {int} second(s)') do |seconds|
+  $logger.warn 'Sleep was used! Please avoid using sleep in tests!'
+  sleep(seconds)
+end
+
+# Starts an interactive shell
+When('I start a new shell') do
+  # Stop the old session if one exists
+  step('I stop the current shell') if Maze::Runner.interactive_session?
+
+  Maze::Runner.start_interactive_session
+end
+
+# Stops currently running interactive shell
+When('I stop the current shell') do
+  shell = Maze::Runner.interactive_session
+  result = Maze::Runner.stop_interactive_session
+
+  Maze.check.true(result, 'The shell is still running when it should have exited')
+  Maze.check.false(shell.running?, 'The shell is still running when it should have exited')
+end
+
+# Run a command on the shell
+#
+# @step_input command [String] The command to run on the shell
+When('I input {string} interactively') do |command|
+  current_shell = Maze::Runner.interactive_session
+  success = current_shell.run_command(command)
+  Maze.check.true(success, 'The terminal had already closed')
+end
+
+# Send a return or enter to the interactive session
+When('I input a return interactively') do
+  step('I input "" interactively')
+end
+
+# Assert the current stdout line in the shell exactly matches the given string
+#
+# @step_input expected [String] The expected string
+Then('the current stdout line is {string}') do |expected|
+  current_shell = Maze::Runner.interactive_session
+  Maze.check.equal(expected, current_shell.current_buffer)
+end
+
+# Assert the current stdout line in the shell includes the given string
+#
+# @step_input expected [String] The expected string
+Then('the current stdout line contains {string}') do |expected|
+  current_shell = Maze::Runner.interactive_session
+  Maze.check.include(current_shell.current_buffer, expected)
+end
+
+# Waits for a line matching a regex to be present in the current stdout
+# Times out after Maze.config.receive_requests_wait seconds.
+#
+# @step_input regex [String] The regex to match against
+Then('I wait for the current stdout line to match the regex {string}') do |regex|
+  wait = Maze::Wait.new(timeout: Maze.config.receive_requests_wait)
+  shell = Maze::Runner.interactive_session
+
+  success = wait.until { shell.current_buffer.match?(regex) }
+
+  Maze.check.true(success, "The current output line \"#{shell.current_buffer}\" did not match \"#{regex}\"")
+end
+
+# Waits for a specific shell prompt to be present in the buffered stdout line,
+# timing out after Maze.config.receive_requests_wait seconds.
+#
+# @step_input expected_prompt [String] The prompt expected in the current buffer
+Then('I wait for the shell prompt {string}') do |expected_prompt|
+  wait = Maze::Wait.new(timeout: Maze.config.receive_requests_wait)
+  shell = Maze::Runner.interactive_session
+
+  success = wait.until { shell.current_buffer == expected_prompt }
+
+  Maze.check.true(success, "The current output line \"#{shell.current_buffer}\" did not match \"#{expected_prompt}\"")
+end
+
+# Verify a string appears in the stdout logs
+#
+# @step_input expected_line [String] The string present in stdout logs
+Then('the shell has output {string} to stdout') do |expected_line|
+  current_shell = Maze::Runner.interactive_session
+  match = current_shell.stdout_lines.any? { |line| line == expected_line }
+  Maze.check.true(match, "No output lines from #{current_shell.stdout_lines} matched #{expected_line}")
+end
+
+# Wait for a string to appear in the stdout logs, timing out after Maze.config.receive_requests_wait seconds.
+#
+# @step_input expected_line [String] The string present in stdout logs
+Then('I wait for the shell to output {string} to stdout') do |expected_line|
+  wait = Maze::Wait.new(timeout: Maze.config.receive_requests_wait)
+  current_shell = Maze::Runner.interactive_session
+
+  success = wait.until do
+    current_shell.stdout_lines.any? { |line| line == expected_line }
+  end
+
+  Maze.check.true(success, "No output lines from #{current_shell.stdout_lines} matched #{expected_line}")
+end
+
+# Verify a string using a regex in the stdout logs
+#
+# @step_input regex_matcher [String] The regex expected to match a line in stdout logs
+Then('the shell has output a match for the regex {string} to stdout') do |regex_matcher|
+  current_shell = Maze::Runner.interactive_session
+  match = current_shell.stdout_lines.any? { |line| line.match?(regex_matcher) }
+  Maze.check.true(match, "No output lines from #{current_shell.stdout_lines} matched #{regex_matcher}")
+end
+
+# Wait for a string matching a regex in the stdout logs, timing out after Maze.config.receive_requests_wait seconds.
+#
+# @step_input regex_matcher [String] The regex expected to match a line in stdout logs
+Then('I wait for the shell to output a match for the regex {string} to stdout') do |regex_matcher|
+  wait = Maze::Wait.new(timeout: Maze.config.receive_requests_wait)
+  current_shell = Maze::Runner.interactive_session
+
+  success = wait.until do
+    current_shell.stdout_lines.any? { |line| line.match?(regex_matcher) }
+  end
+
+  Maze.check.true(success, "No output lines from #{current_shell.stdout_lines} matched #{regex_matcher}")
+end
+
+# Wait for the shell to output a number of strings in STDOUT, as defined by a table.
+# This step will time out after Maze.config.receive_requests_wait seconds.
+#
+# @step_input expected_lines [Array] An array of strings expected in STDOUT
+Then('I wait for the interactive shell to output the following lines in stdout') do |expected_lines|
+  wait = Maze::Wait.new(timeout: Maze.config.receive_requests_wait)
+  current_shell = Maze::Runner.interactive_session
+
+  success = wait.until do
+    current_stdout = current_shell.stdout_lines.join("\n")
+    current_stdout.include?(expected_lines)
+  end
+
+  Maze.check.true(
+    success,
+    "Lines present in stdout: #{current_shell.stdout_lines} did not include all of: #{expected_lines}"
+  )
+end
+
+# Verify a string appears in the stderr logs
+#
+# @step_input expected_err [String] The string present in stderr logs
+Then('the shell has output {string} to stderr') do |expected_err|
+  current_shell = Maze::Runner.interactive_session
+  match = current_shell.stderr_lines.any? { |line| line == expected_err }
+  Maze.check.true(match, "No output lines from #{current_shell.stderr_lines} matched #{expected_err}")
+end
+
+# Wait for a string to appear in the stderr logs
+#
+# @step_input expected_line [String] The string present in stderr logs
+Then('I wait for the shell to output {string} to stderr') do |expected_line|
+  wait = Maze::Wait.new(timeout: Maze.config.receive_requests_wait)
+  current_shell = Maze::Runner.interactive_session
+
+  success = wait.until do
+    current_shell.stderr_lines.any? { |line| line == expected_line }
+  end
+
+  Maze.check.true(success, "No output lines from #{current_shell.stderr_lines} matched #{expected_line}")
+end
+
+# Verify the last interactive command exited successfully (assuming a 0 is a success)
+Then('the last interactive command exited successfully') do
+  Maze.check.true(
+    Maze::Runner.interactive_session?,
+    'No interactive session is running so the exit code cannot be checked'
+  )
+
+  uuid = SecureRandom.uuid
+
+  steps %Q{
+    When I input "[ $? = 0 ] && echo '#{uuid} exited with 0' || echo '#{uuid} exited with error'" interactively
+    Then I wait for the shell to output a match for the regex "#{uuid} exited with 0" to stdout
+  }
+end
+
+# Verify the exit code of the last interactive command
+#
+# @step_input exit_code [Integer] The expected exit code
+Then('the last interactive command exit code is {int}') do |exit_code|
+  Maze.check.true(
+    Maze::Runner.interactive_session?,
+    'No interactive session is running so the exit code cannot be checked'
+  )
+
+  uuid = SecureRandom.uuid
+
+  steps %Q{
+    When I input "echo #{uuid} $?" interactively
+    Then I wait for the shell to output a match for the regex "#{uuid} #{exit_code}" to stdout
+  }
+end
+
+# Assert that the last interactive command exited with an error code (assuming non-0 is an error)
+Then('the last interactive command exited with an error code') do
+  Maze.check.true(
+    Maze::Runner.interactive_session?,
+    'No interactive session is running so the exit code cannot be checked'
+  )
+
+  uuid = SecureRandom.uuid
+
+  steps %Q{
+    When I input "[ $? = 0 ] && echo '#{uuid} exited with 0' || echo '#{uuid} exited with error'" interactively
+    Then I wait for the shell to output a match for the regex "#{uuid} exited with error" to stdout
+  }
+end
+
+# Assert that an expected_line is present in a file located relative to the interactive terminal's CWD
+#
+# @step_input filename [String] The file tested, relative to the CWD of the interactive terminal
+# @step_input expected_line [String] The line expected in the file
+Then('the interactive file {string} contains {string}') do |filename, expected_line|
+  steps %(
+    When I input "fgrep '#{expected_line.gsub(/"/, '\"')}' #{filename}" interactively
+    And I wait for the current stdout line to match the regex "[#>$]\\s?"
+    Then the last interactive command exited successfully
+  )
+end
+
+# Assert that a line is not present in a file located relative to the interactive terminal's CWD
+#
+# @step_input filename [String] The file tested, relative to the CWD of the interactive terminal
+# @step_input excluded_line [String] The line that should not be present be in the file
+Then('the interactive file {string} does not contain {string}') do |filename, excluded_line|
+  steps %(
+    When I input "fgrep '#{excluded_line.gsub(/"/, '\"')}' #{filename}" interactively
+    And I wait for the current stdout line to match the regex "[#>$]\\s?"
+    Then the last interactive command exited with an error code
+  )
+end
+
+# Assert that a file located relative to the CWD of the interactive terminal contains all of the expected lines
+#
+# @step_input filename [String] The file tested, relative to the CWD of the interactive terminal
+# @step_input expected_lines [String] The lines expected in the file as a multi-line string
+Then('the interactive file {string} contains:') do |filename, expected_lines|
+  expected_lines.each_line do |line|
+    step("the interactive file '#{filename}' contains '#{line.chomp}'")
+  end
+end
+
+# Assert that a file located relative to the CWD of the interactive terminal does not contain any of the excluded lines
+#
+# @step_input filename [String] The file tested, relative to the CWD of the interactive terminal
+# @step_input excluded_lines [String] The lines that should not be present in the file, as a multi-line string
+Then('the interactive file {string} does not contain:') do |filename, excluded_lines|
+  excluded_lines.each_line do |line|
+    step("the interactive file '#{filename}' does not contain '#{line.chomp}'")
+  end
+end