bugsnag-maze-runner 10.4.1 → 10.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f745470ec2a7a2cb2b8dc9f022fbff21475388aa431ca48ba1bf32d7bd8698f3
-  data.tar.gz: 1ed4e8b8f1301faa0d3a3b2a79b8af811ed9e0099645b0adc1287c7e77ca67e8
+  metadata.gz: 12e2b7e1d8f5c4a28703fdb5840d5761303008e4afb80d6653c91001e44139a8
+  data.tar.gz: ddaa085ac42386037eaa09c665a9a7b27746921769718ab707c2ef1b4d943c02
 SHA512:
-  metadata.gz: de7ae3599f1fb17e4b8b7ae482e70201c082d73edfe21ab887f1ed0cd71bc13b5e2893e1707a5c51723a1a9daf6dc340f64e402a4689cd4041c09b6974f2572e
-  data.tar.gz: 87a56b00c9f0293cc518172488e65651671118172a3624daae1647380fae23352c7976f600bf29e3c0e105141a307c024bd13fb1bae13c1b3a9f4630796bdc34
+  metadata.gz: fec79817d83e81db975f98a8e01cb759179d3bdd2052058aaabfdeb078a21b95f47e9dfe0d724bf4ec33390cc2cc83a2c888470357ac7f3d441e4768a2482c32
+  data.tar.gz: 18c1eadc34738d6cf0aebc27191303d74e87d3f6a76e7e10365291c948aaf7847214e2bb81b8d7e31ea6dd306c1eccd80cc11662a6a24c75e4b4e32bbe7ab9b7

data/bin/maze-runner

@@ -62,6 +62,7 @@ require_relative '../lib/maze/loggers/logger'
 require_relative '../lib/maze/servlets/base_servlet'
 require_relative '../lib/maze/servlets/all_commands_servlet'
 require_relative '../lib/maze/servlets/command_servlet'
+require_relative '../lib/maze/servlets/idempotent_command_servlet'
 require_relative '../lib/maze/servlets/error_config_servlet'
 require_relative '../lib/maze/servlets/servlet'
 require_relative '../lib/maze/servlets/log_servlet'

data/lib/features/steps/span_steps.rb

@@ -0,0 +1,175 @@
+# @!group Span steps
+
+# Disable timestamp validation for spans
+#
+When('I disable timestamp validation for spans') do
+  Maze.config.span_timestamp_validation = false
+end
+
+# 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
+Then('I wait to receive {int} span(s)') do |span_count|
+  SpanSupport.assert_received_span_count Maze::Server.traces, span_count
+end
+
+# Waits for a minimum number of spans to be received, which may be spread across one or more trace requests.
+# If more spans than requested are received, this step will still pass.
+#
+# @step_input span_min [Integer] The minimum number of spans to wait for
+Then('I wait to receive at least {int} span(s)') do |span_min|
+  SpanSupport.assert_received_minimum_span_count Maze::Server.traces, span_min
+end
+
+# Waits for a minimum number of spans to be received, which may be spread across one or more trace requests.
+# If more spans than the maximum requested number of spans are received, this step will fail.
+#
+# @step_input span_min [Integer] The minimum number of spans to wait for
+# @step_input span_max [Integer] The maximum number of spans to receive before failure
+Then('I wait to receive between {int} and {int} span(s)') do |span_min, span_max|
+  SpanSupport.assert_received_ranged_span_count Maze::Server.traces, span_min, span_max
+end
+
+Then('I should have received no spans') do
+  sleep Maze.config.receive_no_requests_wait
+  Maze.check.equal SpanSupport.spans_from_request_list(Maze::Server.traces).size, 0
+end
+
+Then('a span {word} equals {string}') do |attribute, expected|
+  spans = SpanSupport.spans_from_request_list(Maze::Server.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 = SpanSupport.spans_from_request_list(Maze::Server.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 = SpanSupport.spans_from_request_list(Maze::Server.traces)
+  spans.map { |span| Maze.check.match pattern, span[key] }
+end
+
+Then('every span string attribute {string} exists') do |attribute|
+  spans = SpanSupport.spans_from_request_list(Maze::Server.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 = SpanSupport.spans_from_request_list(Maze::Server.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 = SpanSupport.spans_from_request_list(Maze::Server.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 = SpanSupport.spans_from_request_list(Maze::Server.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 = SpanSupport.spans_from_request_list(Maze::Server.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 = SpanSupport.spans_from_request_list(Maze::Server.traces)
+  selected_attributes = spans.map { |span| span['attributes'].find { |a| a['key'].eql?(attribute) && a['value'].has_key?('stringValue') } }.compact
+  Maze.check.false(selected_attributes.empty?)
+end
+
+Then('a span string attribute {string} equals {string}') do |attribute, expected|
+  spans = SpanSupport.spans_from_request_list(Maze::Server.traces)
+  selected_attributes = spans.map { |span| span['attributes'].find { |a| a['key'].eql?(attribute) && a['value'].has_key?('stringValue') } }.compact
+  attribute_values = selected_attributes.map { |a| a['value']['stringValue'] }
+  Maze.check.includes attribute_values, expected
+end
+
+Then('a span field {string} equals {string}') do |key, expected|
+  spans = SpanSupport.spans_from_request_list(Maze::Server.traces)
+  selected_keys = spans.map { |span| span[key] }
+  Maze.check.includes selected_keys, expected
+end
+
+Then('a span field {string} equals {int}') do |key, expected|
+  spans = SpanSupport.spans_from_request_list(Maze::Server.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 = SpanSupport.spans_from_request_list(Maze::Server.traces)
+  selected_attributes = spans.select { |span| regex.match? span[attribute] }
+
+  Maze.check.false(selected_attributes.empty?)
+end
+
+Then('a span named {string} contains the attributes:') do |span_name, table|
+  named_spans = SpanSupport.get_named_spans(span_name)
+  expected_attributes = table.hashes
+
+  match = false
+  named_spans.each do |span|
+    matches = expected_attributes.map do |expected_attribute|
+      span['attributes'].find_all { |attribute| attribute['key'].eql?(expected_attribute['attribute']) }
+                        .any? { |attribute| attribute_value_matches?(attribute['value'], expected_attribute['type'], expected_attribute['value']) }
+    end
+    if matches.all? && !matches.empty?
+      match = true
+      break
+    end
+  end
+
+  unless match
+    raise Test::Unit::AssertionFailedError.new "No spans were found containing all of the given attributes"
+  end
+end
+
+Then('a span named {string} has a parent named {string}') do |child_name, parent_name|
+  spans = SpanSupport.spans_from_request_list(Maze::Server.traces)
+  child_spans = spans.find_all { |span| span['name'].eql?(child_name) }
+  raise Test::Unit::AssertionFailedError.new "No spans were found with the name #{child_name}" if child_spans.empty?
+  parent_spans = spans.find_all { |span| span['name'].eql?(parent_name) }
+  raise Test::Unit::AssertionFailedError.new "No spans were found with the name #{parent_name}" if parent_spans.empty?
+
+  expected_parent_ids = child_spans.map { |span| span['parentSpanId'] }
+  parent_ids = parent_spans.map { |span| span['spanId'] }
+  match = expected_parent_ids.any? { |expected_id| parent_ids.include?(expected_id) }
+
+  unless match
+    raise Test::Unit::AssertionFailedError.new "No child span named #{child_name} was found with a parent named #{parent_name}"
+  end
+end
+
+Then('a span named {string} has the following properties:') do |span_name, table|
+  named_spans = SpanSupport.get_named_spans(span_name)
+  expected_properties = table.hashes
+
+  match = false
+  named_spans.each do |span|
+    matches = expected_properties.map do |expected_property|
+      property = Maze::Helper.read_key_path(span, expected_property['property'])
+      expected_property['value'].eql?(property.to_s)
+    end
+    if matches.all? && !matches.empty?
+      match = true
+      break
+    end
+  end
+
+  unless match
+    raise Test::Unit::AssertionFailedError.new "No spans were found containing all of the given properties"
+  end
+end
+
+Then('the {string} field of the span named {string} is stored as the value {string}') do |field, span_name, store_key|
+  SpanSupport.store_named_span_field(span_name, field, store_key)
+end
+
+

data/lib/features/steps/trace_steps.rb

@@ -1,40 +1,5 @@
 # @!group Trace steps
 
-# Disable timestamp validation for spans
-#
-When('I disable timestamp validation for spans') do
-  Maze.config.span_timestamp_validation = false
-end
-
-# 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
-Then('I wait to receive {int} span(s)') do |span_count|
-  assert_received_span_count Maze::Server.list_for('traces'), span_count
-end
-
-# Waits for a minimum number of spans to be received, which may be spread across one or more trace requests.
-# If more spans than requested are received, this step will still pass.
-#
-# @step_input span_min [Integer] The minimum number of spans to wait for
-Then('I wait to receive at least {int} span(s)') do |span_min|
-  assert_received_minimum_span_count Maze::Server.list_for('traces'), span_min
-end
-
-# Waits for a minimum number of spans to be received, which may be spread across one or more trace requests.
-# If more spans than the maximum requested number of spans are received, this step will fail.
-#
-# @step_input span_min [Integer] The minimum number of spans to wait for
-# @step_input span_max [Integer] The maximum number of spans to receive before failure
-Then('I wait to receive between {int} and {int} span(s)') do |span_min, span_max|
-  assert_received_ranged_span_count Maze::Server.list_for('traces'), span_min, span_max
-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('I enter unmanaged traces mode') do
   Maze.config.unmanaged_traces_mode = true
 end
@@ -110,154 +75,6 @@ Then('the trace payload field {string} double attribute {string} equals {float}'
   check_attribute_equal field, attribute, 'doubleValue', expected
 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'].eql?(attribute) && a['value'].has_key?('stringValue') } }.compact
-  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'].eql?(attribute) && a['value'].has_key?('stringValue') } }.compact
-  attribute_values = selected_attributes.map { |a| a['value']['stringValue'] }
-  Maze.check.includes attribute_values, 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} equals {int}') 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
-
-Then('a span named {string} contains the attributes:') do |span_name, table|
-  spans = spans_from_request_list(Maze::Server.list_for('traces'))
-  named_spans = spans.find_all { |span| span['name'].eql?(span_name) }
-  raise Test::Unit::AssertionFailedError.new "No spans were found with the name #{span_name}" if named_spans.empty?
-
-  expected_attributes = table.hashes
-
-  match = false
-  named_spans.each do |span|
-    matches = expected_attributes.map do |expected_attribute|
-      span['attributes'].find_all { |attribute| attribute['key'].eql?(expected_attribute['attribute']) }
-        .any? { |attribute| attribute_value_matches?(attribute['value'], expected_attribute['type'], expected_attribute['value']) }
-    end
-    if matches.all? && !matches.empty?
-      match = true
-      break
-    end
-  end
-
-  unless match
-    raise Test::Unit::AssertionFailedError.new "No spans were found containing all of the given attributes"
-  end
-end
-
-Then('a span named {string} has a parent named {string}') do |child_name, parent_name|
-  spans = spans_from_request_list(Maze::Server.list_for('traces'))
-  child_spans = spans.find_all { |span| span['name'].eql?(child_name) }
-  raise Test::Unit::AssertionFailedError.new "No spans were found with the name #{child_name}" if child_spans.empty?
-  parent_spans = spans.find_all { |span| span['name'].eql?(parent_name) }
-  raise Test::Unit::AssertionFailedError.new "No spans were found with the name #{parent_name}" if parent_spans.empty?
-
-  expected_parent_ids = child_spans.map { |span| span['parentSpanId'] }
-  parent_ids = parent_spans.map { |span| span['spanId'] }
-  match = expected_parent_ids.any? { |expected_id| parent_ids.include?(expected_id) }
-
-  unless match
-    raise Test::Unit::AssertionFailedError.new "No child span named #{child_name} was found with a parent named #{parent_name}"
-  end
-end
-
-Then('a span named {string} has the following properties:') do |span_name, table|
-  spans = spans_from_request_list(Maze::Server.list_for('traces'))
-  found_spans = spans.find_all { |span| span['name'].eql?(span_name) }
-  raise Test::Unit::AssertionFailedError.new "No spans were found with the name #{span_name}" if found_spans.empty?
-
-  expected_properties = table.hashes
-
-  match = false
-  found_spans.each do |span|
-    matches = expected_properties.map do |expected_property|
-      property = Maze::Helper.read_key_path(span, expected_property['property'])
-      expected_property['value'].eql?(property.to_s)
-    end
-    if matches.all? && !matches.empty?
-      match = true
-      break
-    end
-  end
-
-  unless match
-    raise Test::Unit::AssertionFailedError.new "No spans were found containing all of the given properties"
-  end
-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 attribute_value_matches?(attribute_value, expected_type, expected_value)
   # Check that the required value type key is present
   unless attribute_value.keys.include?(expected_type)
@@ -284,42 +101,6 @@ def attribute_value_matches?(attribute_value, expected_type, expected_value)
   end
 end
 
-def assert_received_span_count(list, count)
-  assert_received_spans(list, count, count)
-end
-
-def assert_received_minimum_span_count(list, minimum)
-  assert_received_spans(list, minimum)
-end
-
-def assert_received_ranged_span_count(list, minimum, maximum)
-  assert_received_spans(list, minimum, maximum)
-end
-
-def assert_received_spans(list, min_received, max_received = nil)
-  timeout = Maze.config.receive_requests_wait
-  wait = Maze::Wait.new(timeout: timeout)
-
-  received = wait.until { spans_from_request_list(list).size >= min_received }
-  received_count = spans_from_request_list(list).size
-
-  unless received
-    raise Test::Unit::AssertionFailedError.new <<-MESSAGE
-    Expected #{min_received} 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(max_received, :>=, received_count, "#{received_count} spans received") if max_received
-
-  Maze::Schemas::Validator.validate_payload_elements(list, 'trace')
-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"

data/lib/features/steps/value_steps.rb

@@ -69,6 +69,11 @@ Then('the {request_type} payload field {string} does not equal the stored value
   Maze.check.false(result.equal?, "Payload value: #{payload_value} equals stored value: #{stored_value}")
 end
 
+Then('the stored value {string} equals {string}') do |key, value|
+  stored_value = Maze::Store.values[key]
+  Maze.check.equal(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)

data/lib/features/support/internal_hooks.rb

@@ -292,7 +292,7 @@ AfterAll do
     Maze.timers.report
   end
 
-  $stdout.puts '+++ All scenarios complete'
+  $stdout.puts '+++ Test run complete'
 
   # Stop the mock server
   Maze::Server.stop

data/lib/features/support/span_support.rb

@@ -0,0 +1,63 @@
+class SpanSupport
+  class << self
+    def spans_from_request_list(list)
+      list.remaining
+          .flat_map { |req| req[:body]['resourceSpans'] }
+          .flat_map { |r| r['scopeSpans'] }
+          .flat_map { |s| s['spans'] }
+          .select { |s| !s.nil? }
+    end
+
+    def get_named_spans(span_name)
+      spans = spans_from_request_list(Maze::Server.traces)
+      named_spans = spans.find_all { |span| span['name'].eql?(span_name) }
+      raise Test::Unit::AssertionFailedError.new "No spans were found with the name #{span_name}" if named_spans.empty?
+      named_spans
+    end
+
+    def assert_received_span_count(list, count)
+      assert_received_spans(list, count, count)
+    end
+
+    def assert_received_minimum_span_count(list, minimum)
+      assert_received_spans(list, minimum)
+    end
+
+    def assert_received_ranged_span_count(list, minimum, maximum)
+      assert_received_spans(list, minimum, maximum)
+    end
+
+    def assert_received_spans(list, min_received, max_received = nil)
+      timeout = Maze.config.receive_requests_wait
+      wait = Maze::Wait.new(timeout: timeout)
+
+      received = wait.until { SpanSupport.spans_from_request_list(list).size >= min_received }
+      received_count = SpanSupport.spans_from_request_list(list).size
+
+      unless received
+        raise Test::Unit::AssertionFailedError.new <<-MESSAGE
+Expected #{min_received} 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(max_received, :>=, received_count, "#{received_count} spans received") if max_received
+
+      Maze::Schemas::Validator.validate_payload_elements(list, 'trace')
+    end
+
+    def store_named_span_field(span_name, field, store_key)
+      spans = SpanSupport.get_named_spans(span_name)
+      values = spans.map { |span| span[field] }.compact
+      raise Test::Unit::AssertionFailedError.new "Expected 1 span named #{span_name}, found #{values.size}" unless values.size == 1
+
+      value = Maze::Helper.read_key_path(spans[0], field)
+      Maze::Store.values[store_key] = value.dup
+    end
+  end
+end

data/lib/maze/client/selenium/bs_browsers.yml

@@ -24,12 +24,6 @@ ie_11:
   os: "windows"
   osVersion: "10"
 
-edge_14:
-  browserName: "edge"
-  browserVersion: "14"
-  os: "windows"
-  osVersion: "10"
-
 edge_15:
   browserName: "edge"
   browserVersion: "15"
@@ -68,7 +62,7 @@ safari_6:
 
 safari_10:
   browserName: "safari"
-  browserVersion: "10.0"
+  browserVersion: "10.1"
   os: "OS X"
   osVersion: "sierra"
 
@@ -86,29 +80,22 @@ safari_13:
 
 safari_14:
   browserName: "Safari"
-  browserVersion: "14.0"
+  browserVersion: "14.1"
   os: "OS X"
   osVersion: "Big Sur"
 
 safari_15:
   browserName: "Safari"
-  browserVersion: "15.0"
+  browserVersion: "15.6"
   os: "OS X"
   osVersion: "Monterey"
 
 safari_16:
   browserName: "Safari"
-  browserVersion: "16.0"
+  browserVersion: "16.5"
   os: "OS X"
   osVersion: "Ventura"
 
-ios_9:
-  browserName: "iphone"
-  device: "iPhone 6S"
-  os: "ios"
-  osVersion: "9.0"
-  realMobile: true
-
 ios_10:
   browserName: "iphone"
   device: "iPhone 7"
@@ -123,14 +110,6 @@ ios_11:
   osVersion: "11"
   realMobile: true
 
-# Using iPad Pro here because no iPhone is available on BrowserStack with iOS 12
-ios_12:
-  browserName: "iphone"
-  device: "iPad Pro 12.9 2018"
-  os: "ios"
-  osVersion: "12"
-  realMobile: true
-
 ios_13:
   browserName: "iphone"
   device: "iPhone 11"
@@ -172,32 +151,11 @@ ios_18:
   osVersion: "18"
   realMobile: true
 
-android_4:
-  browserName: "Android Browser"
-  device: "Google Nexus 5"
-  os: "android"
-  osVersion: "4.4"
-  realMobile: true
-
-android_5:
-  browserName: "Android Browser"
-  device: "Samsung Galaxy S6"
-  os: "android"
-  osVersion: "5.0"
-  realMobile: true
-
-android_6:
-  browserName: "Android Browser"
-  device: "Samsung Galaxy S7"
-  os: "android"
-  osVersion: "6.0"
-  realMobile: true
-
 android_8:
   browserName: "Android Browser"
-  device: "Samsung Galaxy S9"
+  device: "Samsung Galaxy Note 9"
   os: "android"
-  osVersion: "8.0"
+  osVersion: "8.1"
   realMobile: true
 
 android_9:

data/lib/maze/request_list.rb

@@ -26,8 +26,10 @@ module Maze
     # @param request The new request, from which a clone is made
     def add(request)
       clone = request.clone
-      # UUID primarily used for commands, but no harm to set on everything
+      # UUID and other metadata primarily used for commands, but no harm to set on everything
       clone[:uuid] = SecureRandom.uuid
+      clone[:cucumber_scenario_name] = Maze.scenario.name
+      clone[:cucumber_scenario_location] = Maze.scenario.location
       clone[:run_uuid] = Maze.run_uuid
       @requests.append clone
       @count += 1

data/lib/maze/server.rb

@@ -272,6 +272,7 @@ module Maze
             server.mount '/breakpad-symbol', Servlets::Servlet, :sourcemaps
             server.mount '/unity-line-mappings', Servlets::Servlet, :sourcemaps
             server.mount '/command', Servlets::CommandServlet
+            server.mount '/idem-command', Servlets::IdempotentCommandServlet
             server.mount '/commands', Servlets::AllCommandsServlet
             server.mount '/error-config', Servlets::ErrorConfigServlet
             server.mount '/logs', Servlets::LogServlet

data/lib/maze/servlets/idempotent_command_servlet.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Maze
+  module Servlets
+
+    # Allows clients to queue up "commands", in the form of Ruby hashes, using Maze::Server.commands.add.  GET
+    # requests made to the /command endpoint will then respond with each queued command in turn.
+    class IdempotentCommandServlet < BaseServlet
+
+      NOOP_COMMAND = '{"action": "noop", "message": "No commands queued"}'
+      RESET_COMMAND = '{"action": "reset_uuid", "message": "The UUID given was unknown - client must reset its last known UUID"}'
+
+      # Serves the next command, if there is one.
+      #
+      # @param request [HTTPRequest] The incoming GET request
+      # @param response [HTTPResponse] The response to return
+      def do_GET(request, response)
+        after_uuid = request.query['after']
+        if after_uuid.nil?
+          response.body = "The 'after' query parameter must be provided, but may be an empty string"
+          response.status = 400
+        else
+          command_after(after_uuid, response)
+        end
+
+        response.header['Access-Control-Allow-Origin'] = '*'
+      end
+
+      def send_current_command(response)
+        commands = Maze::Server.commands
+
+        if commands.size_remaining == 0
+          response.body = NOOP_COMMAND
+          response.status = 200
+        else
+          command = commands.current
+          response.body = JSON.pretty_generate(command)
+          response.status = 200
+          commands.next
+        end
+      end
+
+      def command_after(uuid, response)
+        commands = Maze::Server.commands
+        if uuid.empty?
+          # Return the first command in the list, if there is one
+          index = -1
+        else
+          # Find the matching command
+          index = commands.all.find_index {|command| command[:uuid] == uuid }
+        end
+
+        if index.nil?
+          # No matching command - client must reset its UUID
+          response.body = RESET_COMMAND
+          response.status = 200
+        else
+          if index + 1 < commands.size_all
+            # Respond with the next command in the queue
+            command = commands.get(index + 1)
+            command_json = JSON.pretty_generate(command)
+            response.body = command_json
+            response.status = 200
+          else
+            # The UUID given was for the last command in the list
+            response.body = NOOP_COMMAND
+            response.status = 200
+          end
+        end
+      end
+
+      # Logs and returns a set of valid headers for this servlet.
+      #
+      # @param request [HTTPRequest] The incoming GET request
+      # @param response [HTTPResponse] The response to return
+      def do_OPTIONS(request, response)
+        super
+
+        response.header['Access-Control-Allow-Methods'] = 'POST, OPTIONS'
+        response.status = Server.status_code('OPTIONS')
+      end
+    end
+  end
+end

data/lib/maze.rb

@@ -8,7 +8,7 @@ require_relative 'maze/timers'
 # providing an alternative to the proliferation of global variables or singletons.
 module Maze
 
-  VERSION = '10.4.1'
+  VERSION = '10.6.0'
 
   class << self
     attr_accessor :check, :driver, :internal_hooks, :mode, :start_time, :dynamic_retry, :public_address,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bugsnag-maze-runner
 version: !ruby/object:Gem::Version
-  version: 10.4.1
+  version: 10.6.0
 platform: ruby
 authors:
 - Steve Kirkland
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-10-10 00:00:00.000000000 Z
+date: 2025-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cucumber
@@ -422,12 +422,14 @@ files:
 - lib/features/steps/request_assertion_steps.rb
 - lib/features/steps/runner_steps.rb
 - lib/features/steps/session_tracking_steps.rb
+- lib/features/steps/span_steps.rb
 - lib/features/steps/trace_steps.rb
 - lib/features/steps/value_steps.rb
 - lib/features/support/cucumber_types.rb
 - lib/features/support/env.rb
 - lib/features/support/error_config_support.rb
 - lib/features/support/internal_hooks.rb
+- lib/features/support/span_support.rb
 - lib/maze.rb
 - lib/maze/api/appium/app_manager.rb
 - lib/maze/api/appium/device_manager.rb
@@ -514,6 +516,7 @@ files:
 - lib/maze/servlets/base_servlet.rb
 - lib/maze/servlets/command_servlet.rb
 - lib/maze/servlets/error_config_servlet.rb
+- lib/maze/servlets/idempotent_command_servlet.rb
 - lib/maze/servlets/log_servlet.rb
 - lib/maze/servlets/reflective_servlet.rb
 - lib/maze/servlets/servlet.rb