bugsnag-maze-runner 6.27.0

data/lib/maze/browsers_cbt.yml

@@ -0,0 +1,100 @@
+# Selenium capabilities for browserNames available on CrossbrowserNameTesting
+---
+ie_8:
+  browserName: "Internet Explorer"
+  version: "8"
+  platform: "Windows 7"
+
+ie_9:
+  browserName: "Internet Explorer"
+  version: "9"
+  platform: "Windows 7"
+
+ie_10:
+  browserName: "Internet Explorer"
+  version: "10"
+  os: "windows"
+  platform: "Windows 7 64-Bit"
+
+ie_11:
+  browserName: "Internet Explorer"
+  version: "11"
+  platform: "Windows 7 64-Bit"
+
+edge_14:
+  browserName: "MicrosoftEdge"
+  version: "14"
+  platform: "Windows 10"
+
+edge_15:
+  browserName: "MicrosoftEdge"
+  version: "15"
+  platform: "Windows 10"
+
+safari_8:
+  browserName: "Safari"
+  version: "8"
+  platform: "Mac OSX 10.10"
+
+safari_10:
+  browserName: "Safari"
+  version: "10"
+  platform: "Mac OSX 10.12"
+
+safari_13:
+  browserName: "Safari"
+  version: "13"
+  platform: "Mac OSX 10.15"
+
+safari_14:
+  browserName: "Safari"
+  version: "14"
+  platform: "MacOS 11.0"
+
+iphone_7_simulator:
+  browserName: "Safari"
+  deviceName: "iPhone 7 Simulator"
+  platformVersion': "10.0"
+  platformName': "iOS"
+
+iphone_xr:
+  browserName: "Safari"
+  deviceName': "iPhone XR"
+  platformVersion': "12.1"
+  platformName': "iOS"
+
+android_s7:
+  browserName: "Chrome"
+  deviceName: "Galaxy S7"
+  platformVersion: "7.0"
+  platformName: "Android"
+
+firefox_30:
+  browserName: "Firefox"
+  version: "30"
+  platform: "Windows 7"
+
+firefox_56:
+  browserName: "Firefox"
+  version: "56"
+  platform: "Mac OSX 10.13"
+
+firefox_95:
+  browserName: "Firefox"
+  version: "95"
+  platform: "Windows 10"
+
+chrome_43:
+  browserName: "Chrome"
+  version: "43"
+  platform: "Windows 7"
+
+chrome_61:
+  browserName: "Chrome"
+  version: "61"
+  platform: "Windows 10"
+
+chrome_96:
+  browserName: "Chrome"
+  version: "96"
+  platform: "Windows 10"

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/capabilities.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Maze
+  # Appium capabilities for each target farm
+  class Capabilities
+    class << self
+      # @param device_type [String] A key from @see BrowserStackDevices::DEVICE_HASH
+      # @param local_id [String] unique key for the tunnel instance
+      # @param capabilities_option [String] extra capabilities provided on the command line
+      def for_browser_stack_device(device_type, local_id, appium_version, capabilities_option)
+        capabilities = {
+          'browserstack.console' => 'errors',
+          'browserstack.localIdentifier' => local_id,
+          'browserstack.local' => 'true',
+          'noReset' => 'true'
+        }
+        capabilities.merge! BrowserStackDevices::DEVICE_HASH[device_type]
+        capabilities.merge! JSON.parse(capabilities_option)
+        capabilities['browserstack.appium_version'] = appium_version unless appium_version.nil?
+        capabilities
+      end
+
+      # @param browser_type [String] A key from @see browsers_bs.yml
+      # @param local_id [String] unique key for the tunnel instance
+      # @param capabilities_option [String] extra capabilities provided on the command line
+      def for_browser_stack_browser(browser_type, local_id, capabilities_option)
+        capabilities = Selenium::WebDriver::Remote::Capabilities.new
+        capabilities['browserstack.local'] = 'true'
+        capabilities['browserstack.localIdentifier'] = local_id
+        capabilities['browserstack.console'] = 'errors'
+        browsers = YAML.safe_load(File.read("#{__dir__}/browsers_bs.yml"))
+        capabilities.merge! browsers[browser_type]
+        capabilities.merge! JSON.parse(capabilities_option)
+        capabilities
+      end
+
+      # @param browser_type [String] A key from @see browsers_cbt.yml
+      # @param local_id [String] unique key for the SB tunnel instance
+      # @param capabilities_option [String] extra capabilities provided on the command line
+      def for_cbt_browser(browser_type, local_id, capabilities_option)
+        capabilities = Selenium::WebDriver::Remote::Capabilities.new
+        capabilities['tunnel_name'] = local_id
+        browsers = YAML.safe_load(File.read("#{__dir__}/browsers_cbt.yml"))
+        capabilities.merge! browsers[browser_type]
+        capabilities.merge! JSON.parse(capabilities_option)
+        capabilities
+      end
+
+      # @param device_type [String]
+      def for_bitbar_device(bitbar_api_key, device_type, platform, platform_version, capabilities_option)
+        capabilities = {
+          'bitbar_apiKey' => bitbar_api_key,
+          'bitbar_testrun' => "#{platform} #{platform_version}",
+          'bitbar_findDevice' => false,
+          'bitbar_testTimeout' => 7200,
+          'disabledAnimations' => 'true',
+          'noReset' => 'true'
+        }
+        capabilities.merge! BitBarDevices.get_device(device_type, platform, platform_version, bitbar_api_key)
+        capabilities.merge! JSON.parse(capabilities_option)
+        capabilities
+      end
+
+      # Constructs Appium capabilities for running on a local Android or iOS device.
+      # @param platform [String] 'ios' or 'android'
+      # @param capabilities_option [String] extra capabilities provided on the command line
+      # @param team_id [String] Apple Team Id, for iOS only
+      # @param udid [String] device UDID, for iOS only
+      # noinspection RubyStringKeysInHashInspection
+      def for_local(platform, capabilities_option, team_id = nil, udid = nil)
+        capabilities = case platform.downcase
+                       when 'android'
+                         {
+                           'platformName' => 'Android',
+                           'automationName' => 'UiAutomator2',
+                           'autoGrantPermissions' => 'true',
+                           'noReset' => 'true'
+                         }
+                       when 'ios'
+                         {
+                           'platformName' => 'iOS',
+                           'automationName' => 'XCUITest',
+                           'deviceName' => udid,
+                           'xcodeOrgId' => team_id,
+                           'xcodeSigningId' => 'iPhone Developer',
+                           'udid' => udid,
+                           'noReset' => 'true',
+                           'waitForQuiescence' => false,
+                           'newCommandTimeout' => 0
+                         }
+                       when 'macos'
+                         {
+                           'platformName' => 'Mac'
+                         }
+                       else
+                         raise "Unsupported platform: #{platform}"
+                       end
+        common = {
+          'os' => platform,
+          'autoAcceptAlerts': 'true'
+        }
+        capabilities.merge! common
+        capabilities.merge! JSON.parse(capabilities_option)
+      end
+
+      def for_sauce_labs_device(device_name, os, os_version, tunnel_id, appium_version, capabilities_option)
+        capabilities = {
+          'noReset' => true,
+          'deviceOrientation' => 'portrait',
+          'tunnelIdentifier' => tunnel_id,
+          'browserName' => '',
+          'autoAcceptAlerts' => true,
+          'sendKeyStrategy' => 'setValue',
+          'waitForQuiescence' => false,
+          'newCommandTimeout' => 0
+        }
+        capabilities['deviceName'] = device_name unless device_name.nil?
+        capabilities['platformName'] = os unless os.nil?
+        capabilities['platformVersion'] = os_version unless os_version.nil?
+        capabilities.merge! JSON.parse(capabilities_option)
+        capabilities['appiumVersion'] = appium_version unless appium_version.nil?
+        capabilities
+      end
+    end
+  end
+end

data/lib/maze/checks/assert_check.rb

@@ -0,0 +1,91 @@
+# 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)
+        assert_match(pattern, 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
+
+# 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/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/compare.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Maze
+  # Routines for conducting comparisons
+  module Compare
+    # Provides a way to delivering results of element comparisons to test steps
+    class Result
+      # @!attribute [r] reasons
+      #   @return [Array] An array of reasons for a comparison result
+      attr_reader :reasons
+
+      # @!attribute [w] equal
+      #   @param [Boolean] Indicates if the comparison indicated the elements were equal
+      attr_writer :equal
+
+      # @!attribute [r] keys
+      #   @return [Array] An array of keys checked
+      attr_reader :keys
+
+      # Creates the Result object
+      def initialize
+        @equal = true
+        @keys = []
+        @reasons = []
+      end
+
+      # Indicates if the values compared to produced this result were equal
+      #
+      # @return [Boolean] Whether the elements were equal
+      def equal?
+        @equal
+      end
+
+      # Returns the keys traversed in order to compare the end values
+      #
+      # @return [String] The keypath used in the test
+      def keypath
+        keys.length > 0 ? keys.reverse.join('.') : '<root>'
+      end
+
+      # Provides a standard assertion of equality, with standardised output
+      def assert_equal
+        Maze.check.true(@equal, "The compared fields do not match:\n #{result.reasons.join('\n')}")
+      end
+    end
+
+    class << self
+      # Compares two objects for value equality, traversing to compare each
+      # nested object.
+      #
+      # @param obj1 [Any] The first object to compare
+      # @param obj2 [Any] The second object to compare
+      # @param result [Result|nil] Optional. Used for comparing recursively
+      #
+      # @return [Result] The result of comparing the objects
+      def value(obj1, obj2, result = nil)
+        result ||= Result.new
+        return result if obj1 == 'IGNORE'
+
+        if obj1 == 'NUMBER'
+          if obj2.is_a?(Numeric)
+            return result
+          else
+            result.equal = false
+            result.reasons << "A Number was expected, '#{obj2.class} received"
+            return result
+          end
+        end
+
+        unless obj1.class == obj2.class
+          result.equal = false
+          result.reasons << "Object types differ - expected '#{obj1.class}', received '#{obj2.class}'"
+          return result
+        end
+
+        case obj1
+        when Array
+          array(obj1, obj2, result)
+        when Hash
+          hash(obj1, obj2, result)
+        when String
+          string(obj1, obj2, result)
+        else
+          result.reasons << "#{obj1} is not equal to #{obj2}" unless (result.equal = (obj1 == obj2))
+        end
+        result
+      end
+
+      # Compares two arrays for value equality, traversing and comparing each element.
+      # Results are written to the given Result object.
+      #
+      # @param array1 [Array] The first array to compare
+      # @param array2 [Array] The second array to compare
+      # @param result [Result] The Result to store the results
+      def array(array1, array2, result)
+        unless array1.length == array2.length
+          result.equal = false
+          result.reasons << "Expected #{array1.length} items in array, received #{array2.length}"
+          return
+        end
+
+        array1.each_with_index do |obj1, index|
+          value(obj1, array2[index], result)
+          unless result.equal?
+            result.keys << index.to_s
+            break
+          end
+        end
+      end
+
+      # Compares two hashes for value equality, traversing and comparing each key-value pair.
+      # Results are written to the given Result object.
+      #
+      # @param hash1 [Hash] The first hash to compare
+      # @param hash2 [Hash] The second hash to compare
+      # @param result [Result] The Result to store the results
+      def hash(hash1, hash2, result)
+        unless hash1.keys.length == hash2.keys.length
+          result.equal = false
+          missing = hash1.keys - hash2.keys
+          unexpected = hash2.keys - hash1.keys
+          result.reasons << "Missing keys from hash: #{missing.join(',')}" unless missing.empty?
+          result.reasons << "Unexpected keys in hash: #{unexpected.join(',')}" unless unexpected.empty?
+          return
+        end
+
+        hash1.each do |key, value|
+          value(value, hash2[key], result)
+          unless result.equal?
+            result.keys << key
+            break
+          end
+        end
+      end
+
+      # Compares two strings, writing the results to the given Result object.
+      #
+      # @param template [String] The expected string
+      # @param str2 [String] The string to compare
+      # @param result [Result] The Result to store the results
+      def string(template, str2, result)
+        return if template == str2 || regex_match(template, str2)
+
+        result.equal = false
+        result.reasons << "'#{str2}' does not match '#{template}'"
+      end
+
+      # Matches a string against a regex
+      #
+      # @param template [String] The regex to test with
+      # @param value [String] The value to test
+      #
+      # @return [Boolean] Whether the regex produced a match
+      def regex_match(template, value)
+        regex = template
+        regex = "^#{regex}$" unless regex.start_with?('^') || regex.end_with?('$')
+        value =~ /#{regex}/
+      end
+    end
+  end
+end