bugsnag-maze-runner 7.22.1

data/lib/maze/macos_utils.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Maze
+  class MacosUtils
+    class << self
+      def capture_screen(scenario)
+        path = File.join(File.join(Dir.pwd, 'maze_output'), 'failed', Maze::Helper.to_friendly_filename(scenario.name))
+        FileUtils.makedirs(path)
+
+        system("/usr/sbin/screencapture #{path}/#{Maze::Helper.to_friendly_filename(scenario.name)}-screenshot.jpg")
+      end
+    end
+  end
+end

data/lib/maze/maze_output.rb

@@ -0,0 +1,88 @@
+module Maze
+  # Responsible for writing files to the maze_output directory
+  class MazeOutput
+
+    # @param scenario The Cucumber scenario
+    def initialize(scenario)
+      @scenario = scenario
+    end
+
+    # Writes each list of requests to a separate file under, e.g:
+    # maze_output/failed/scenario_name/errors.log
+    def write_requests
+      path = output_folder
+      FileUtils.makedirs(path)
+
+      request_types = %w[errors sessions builds uploads logs sourcemaps traces invalid]
+
+      request_types.each do |request_type|
+        list = Maze::Server.list_for(request_type).all
+        next if list.empty?
+
+        filename = "#{request_type}.log"
+        filepath = File.join(path, filename)
+
+        counter = 1
+        File.open(filepath, 'w+') do |file|
+          list.each do |request|
+            file.puts "=== Request #{counter} of #{list.size} ==="
+            if request[:invalid]
+              invalid_request = true
+              uri = request[:request][:request_uri]
+              headers = request[:request][:header]
+              body = request[:request][:body]
+            else
+              invalid_request = false
+              uri = request[:request].request_uri
+              headers = request[:request].header
+              body = request[:body]
+            end
+            file.puts "URI: #{uri}"
+            file.puts "HEADERS:"
+            headers.each do |key, values|
+              file.puts "  #{key}: #{values.map {|v| "'#{v}'"}.join(' ')}"
+            end
+            file.puts
+            file.puts "BODY:"
+            if !invalid_request && headers["content-type"].first == 'application/json'
+              file.puts JSON.pretty_generate(body)
+            else
+              file.puts body
+            end
+            file.puts
+            if request.include?(:reason)
+              file.puts "REASON:"
+              file.puts request[:reason]
+              file.puts
+            end
+            counter += 1
+          end
+        end
+      end
+    end
+
+    # Pulls the logs from the device if the scenario fails
+    # @param logs [Array<String>] The lines of log to be written
+    def write_device_logs(logs)
+
+      dir = output_folder
+      FileUtils.makedirs(dir)
+      filepath = File.join(dir, 'device.log')
+
+      File.open(filepath, 'w+') do |file|
+        logs.each { |line| file.puts line }
+      end
+    end
+
+    private
+
+    # Determines the output folder for the scenario
+    def output_folder
+      folder1 = File.join(Dir.pwd, 'maze_output')
+      folder2 = @scenario.failed? ? 'failed' : 'passed'
+      folder3 = Maze::Helper.to_friendly_filename(@scenario.name)
+
+      File.join(folder1, folder2, folder3)
+    end
+  end
+end

data/lib/maze/network.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+module Maze
+  # Sets the maximum number of times Maze runner will ping to see if a port is open, defaulting to 100
+  MAX_MAZE_CONNECT_ATTEMPTS = ENV.fetch('MAX_MAZE_CONNECT_ATTEMPTS', 100).to_i
+
+  # Provides network utility functionality
+  class Network
+    class << self
+      # Repeatedly pings a port to see if the host is ready for a connection.
+      # The maximum amount of attempts is determined by the MAX_MAZE_CONNECT_ATTEMPTS variable.
+      #
+      # @param host [String] The name of the host to connect to
+      # @param port [String] The port to attempt to connect to
+      #
+      # @raise [StandardError] When the port is not available for a connection
+      def wait_for_port(host, port)
+        attempts = 0
+        up = false
+        until (attempts >= MAX_MAZE_CONNECT_ATTEMPTS) || up
+          attempts += 1
+          up = port_open?(host, port)
+          sleep 0.1 unless up
+        end
+        raise "Port not ready in time!" unless up
+      end
+
+      # Attempts to connect to a port, timing out after a time.
+      #
+      # @param host [String] The name of the host to connect to
+      # @param port [String] The port to attempt to connect to
+      # @param seconds [Float] Optional. The length of time to wait before timing out.
+      def port_open?(host, port, seconds=0.1)
+        Timeout::timeout(seconds) do
+          begin
+            TCPSocket.new(host, port).close
+            true
+          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, SocketError
+            false
+          end
+        end
+      rescue Timeout::Error
+        false
+      end
+    end
+  end
+end

data/lib/maze/option/parser.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require 'cucumber/cli/main'
+require 'optimist'
+require_relative '../option'
+require_relative '../../maze'
+
+module Maze
+  module Option
+    # Parses the command line options
+    class Parser
+      class << self
+        def parse(args)
+          parser = Optimist::Parser.new do
+            text 'Maze Runner extends the functionality of Cucumber, ' \
+              'providing all of the command line arguments that it provides.'
+            text ''
+            text 'Usage [OPTIONS] <filenames>'
+            text ''
+            text 'Overridden Cucumber options:'
+            opt :help,
+                'Print this help.'
+            opt :version,
+                'Display Maze Runner and Cucumber versions'
+
+            text ''
+            text 'General options:'
+
+            opt Option::AWS_PUBLIC_IP,
+                'Intended for use on Buildkite with the Elastic CI Stack for CI.  Enables awareness of being run with a public IP address.',
+                type: :boolean,
+                default: false
+
+            opt Option::ENABLE_RETRIES,
+                'Enables retrying failed scenarios when tagged',
+                type: :boolean,
+                default: true
+
+            opt Option::ENABLE_BUGSNAG,
+                'Enables reporting to Bugsnag on scenario failure (requires MAZE_BUGSNAG_API_KEY)',
+                type: :boolean,
+                default: true
+
+            opt Option::REPEATER_API_KEY,
+                'Enables forwarding of all received POST requests to Bugsnag, using the API key provided.  MAZE_REPEATER_API_KEY may also be set.',
+                type: :string
+
+            text ''
+            text 'Server options:'
+
+            opt Option::BIND_ADDRESS,
+                'Mock server bind address',
+                type: :string
+            opt Option::PORT,
+                'Mock server port',
+                default: 9339
+            opt Option::NULL_PORT,
+                'Terminating connection port',
+                default: 9341
+
+            text ''
+            text 'Document server options:'
+
+            opt Option::DS_ROOT,
+                'Document server root',
+                type: :string
+            opt Option::DS_BIND_ADDRESS,
+                'Document server bind address',
+                type: :string
+            opt Option::DS_PORT,
+                'Document server port',
+                default: 9340
+
+            text ''
+            text 'Appium options:'
+
+            opt Option::FARM,
+                'Device farm to use: "bs" (BrowserStack) or "local"',
+                type: :string
+            opt Option::APP,
+                'The app to be installed and run against.  Assumed to be contained in a file if prefixed with @.',
+                type: :string
+            opt Option::A11Y_LOCATOR,
+                'Locate elements by accessibility id rather than id',
+                type: :boolean,
+                default: false
+            opt Option::CAPABILITIES,
+                'Additional desired Appium capabilities as a JSON string',
+                default: '{}'
+
+            text ''
+            text 'Device farm options:'
+
+            opt Option::DEVICE,
+                'Device to use. Can be listed multiple times to have a prioritised list of devices',
+                short: :none,
+                type: :string,
+                multi: true
+            opt Option::BROWSER,
+                'Browser to use (an entry in <farm>_browsers.yml)',
+                short: :none,
+                type: :string
+            opt Option::USERNAME,
+                'Device farm username. Consumes env var from environment based on farm set',
+                type: :string
+            opt Option::ACCESS_KEY,
+                'Device farm access key. Consumes env var from environment based on farm set',
+                type: :string
+            opt Option::APPIUM_VERSION,
+                'The Appium version to use',
+                type: :string
+            opt Option::LIST_DEVICES,
+                'Lists the devices available for the configured device farm, or all devices if none are specified',
+                default: false
+            opt Option::APP_BUNDLE_ID,
+                'The bundle identifier of the test application',
+                type: :string
+            opt Option::TUNNEL,
+                'Start the device farm secure tunnel',
+                default: true
+
+            # SmartBear-only options
+            opt Option::SB_LOCAL,
+                '(SB only) Path to the SBSecureTunnel binary. MAZE_SB_LOCAL env var or "/SBSecureTunnel" by default',
+                type: :string
+
+            # BrowserStack-only options
+            opt Option::BS_LOCAL,
+                '(BS only) Path to the BrowserStackLocal binary. MAZE_BS_LOCAL env var or "/BrowserStackLocal" by default',
+                type: :string
+
+            # TMS options
+            opt Option::TMS_URI,
+                'URI of the test management server root.  MAZE_TMS_URI env var',
+                type: :string
+
+            opt Option::TMS_TOKEN,
+                'Token used to access the test management server.  MAZE_TMS_TOKEN env var',
+                type: :string
+
+            text ''
+            text 'Local device options:'
+
+            opt Option::OS,
+                'OS type to use ("ios", "android")',
+                type: :string
+            opt Option::OS_VERSION,
+                'The intended OS version when running on a local device',
+                type: :string
+            opt Option::APPIUM_SERVER,
+                'Appium server URL, only used for --farm=local. MAZE_APPIUM_SERVER env var or "http://localhost:4723/wd/hub" by default',
+                type: :string
+            opt Option::START_APPIUM,
+                'Whether a local Appium server should be start.  Only used for --farm=local.',
+                default: true
+            opt Option::APPIUM_LOGFILE,
+                'The file local appium server output is logged to, defaulting to "appium_server.log"',
+                default: 'appium_server.log'
+            opt Option::APPLE_TEAM_ID,
+                'Apple Team Id, required for local iOS testing. MAZE_APPLE_TEAM_ID env var by default',
+                type: :string
+            opt Option::UDID,
+                'Apple UDID, required for local iOS testing. MAZE_UDID env var by default',
+                type: :string
+
+            text ''
+            text 'Logging options:'
+
+            opt Option::FILE_LOG,
+                "Writes lists of received requests to the maze_output folder for all scenarios",
+                type: :boolean,
+                default: true
+
+            opt Option::LOG_REQUESTS,
+                "Log lists of received requests to the console in the event of scenario failure.  Defaults to true if the BUILDKITE environment variable is set",
+                type: :boolean,
+                default: false
+
+            opt Option::ALWAYS_LOG,
+                "Always log all received requests at the end of a scenario, whether is passes or fails",
+                type: :boolean,
+                default: false
+
+            version "Maze Runner v#{Maze::VERSION} " \
+                    "(Cucumber v#{Cucumber::VERSION.strip})"
+            text ''
+            text 'The Cucumber help follows:'
+            text ''
+          end
+
+          # Allow for options destined for Cucumber
+          parser.ignore_invalid_options = true
+          options = parser.parse args
+          populate_environmental_defaults(options)
+
+        rescue Optimist::HelpNeeded
+          parser.educate
+          Cucumber::Cli::Main.new(['--help']).execute!
+          exit
+        rescue Optimist::VersionNeeded
+          puts parser.version
+          exit
+        end
+
+        # Populates unset options with appropriate environment variables or default values if necessary
+        #
+        # @param options [Hash] The hash of already-parsed options
+        #
+        # @returns [Hash] The options hash with environment vars added
+        def populate_environmental_defaults(options)
+          case options.farm
+          when 'bs'
+            # Allow browser/device credentials to exist in separate accounts
+            if options[Option::BROWSER]
+              options[Option::USERNAME] ||= ENV['BROWSER_STACK_BROWSERS_USERNAME'] || ENV['BROWSER_STACK_USERNAME']
+              options[Option::ACCESS_KEY] ||= ENV['BROWSER_STACK_BROWSERS_ACCESS_KEY'] ||ENV['BROWSER_STACK_ACCESS_KEY']
+            else
+              options[Option::USERNAME] ||= ENV['BROWSER_STACK_DEVICES_USERNAME'] || ENV['BROWSER_STACK_USERNAME']
+              options[Option::ACCESS_KEY] ||= ENV['BROWSER_STACK_DEVICES_ACCESS_KEY'] ||ENV['BROWSER_STACK_ACCESS_KEY']
+            end
+          when 'bb'
+            options[Option::USERNAME] ||= ENV['BITBAR_USERNAME']
+            options[Option::ACCESS_KEY] ||= ENV['BITBAR_ACCESS_KEY']
+            options[Option::TMS_URI] ||= ENV['MAZE_TMS_URI']
+          end
+
+          options[Option::REPEATER_API_KEY] ||= ENV['MAZE_REPEATER_API_KEY']
+          options[Option::SB_LOCAL] ||= ENV['MAZE_SB_LOCAL'] || '/SBSecureTunnel'
+          options[Option::TMS_URI] ||= ENV['MAZE_TMS_URI']
+          options[Option::TMS_TOKEN] ||= ENV['MAZE_TMS_TOKEN']
+          options[Option::BS_LOCAL] ||= ENV['MAZE_BS_LOCAL'] || '/BrowserStackLocal'
+          options[Option::APPIUM_SERVER] ||= ENV['MAZE_APPIUM_SERVER'] || 'http://localhost:4723/wd/hub'
+          options[Option::APPLE_TEAM_ID] ||= ENV['MAZE_APPLE_TEAM_ID']
+          options[Option::UDID] ||= ENV['MAZE_UDID']
+          options
+        end
+      end
+    end
+  end
+end

data/lib/maze/option/processor.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require_relative '../option'
+
+module Maze
+  module Option
+    # Processes the parsed command line options
+    class Processor
+      class << self
+        # Populates config from the parsed options given
+        # @param config [Configuration] MazeRunner configuration to populate
+        # @param options [Hash] Parsed command line options
+        def populate(config, options)
+
+          # Server options
+          config.bind_address = options[Maze::Option::BIND_ADDRESS]
+          config.port = options[Maze::Option::PORT]
+          config.null_port = options[Maze::Option::NULL_PORT]
+
+          # General options
+          config.aws_public_ip = options[Maze::Option::AWS_PUBLIC_IP]
+          config.enable_retries = options[Maze::Option::ENABLE_RETRIES]
+          config.enable_bugsnag = options[Maze::Option::ENABLE_BUGSNAG]
+          config.tms_uri = options[Maze::Option::TMS_URI]
+          config.tms_token = options[Maze::Option::TMS_TOKEN]
+          config.repeater_api_key = options[Maze::Option::REPEATER_API_KEY]
+
+          # Document server options
+          config.document_server_root = options[Maze::Option::DS_ROOT]
+          config.document_server_bind_address = options[Maze::Option::DS_BIND_ADDRESS]
+          config.document_server_port = options[Maze::Option::DS_PORT]
+
+          # Logger options
+          config.file_log = options[Maze::Option::FILE_LOG]
+          config.log_requests = options[Maze::Option::LOG_REQUESTS] || !ENV['BUILDKITE'].nil?
+          config.always_log = options[Maze::Option::ALWAYS_LOG]
+
+          # General appium options
+          config.app = Maze::Helper.read_at_arg_file options[Maze::Option::APP]
+          farm = options[Maze::Option::FARM]
+          config.farm = case farm
+                        when nil then :none
+                        when 'bs' then :bs
+                        when 'bb' then :bb
+                        when 'local' then :local
+                        else
+                          raise "Unknown farm '#{farm}'"
+                        end
+          config.locator = options[Maze::Option::A11Y_LOCATOR] ? :accessibility_id : :id
+          config.capabilities_option = options[Maze::Option::CAPABILITIES]
+          config.legacy_driver = !ENV['USE_LEGACY_DRIVER'].nil?
+          config.start_tunnel = options[Maze::Option::TUNNEL]
+
+          # Farm specific options
+          case config.farm
+          when :bs
+            device_option = options[Maze::Option::DEVICE]
+            if device_option.nil? || device_option.empty?
+              config.browser = options[Maze::Option::BROWSER]
+            else
+              if device_option.is_a?(Array)
+                config.device = device_option.first
+                config.device_list = device_option.drop(1)
+              else
+                config.device = device_option
+                config.device_list = []
+              end
+              if config.legacy_driver?
+                config.os_version = Maze::Client::Appium::BrowserStackDevices::DEVICE_HASH[config.device]['os_version'].to_f
+              else
+                config.os_version = Maze::Client::Appium::BrowserStackDevices::DEVICE_HASH[config.device]['platformVersion'].to_f
+              end
+            end
+            config.bs_local = Maze::Helper.expand_path(options[Maze::Option::BS_LOCAL])
+            config.appium_version = options[Maze::Option::APPIUM_VERSION]
+            username = config.username = options[Maze::Option::USERNAME]
+            access_key = config.access_key = options[Maze::Option::ACCESS_KEY]
+            config.appium_server_url = "http://#{username}:#{access_key}@hub-cloud.browserstack.com/wd/hub"
+          when :bb then
+            config.username = options[Maze::Option::USERNAME]
+            config.access_key = options[Maze::Option::ACCESS_KEY]
+            config.tms_uri = options[Maze::Option::TMS_URI]
+            device_option = options[Maze::Option::DEVICE]
+            if device_option.nil? || device_option.empty?
+              # BitBar Web
+              config.browser = options[Maze::Option::BROWSER]
+            else
+              # BitBar Devices
+              if device_option.is_a?(Array)
+                config.device = device_option.first
+                config.device_list = device_option.drop(1)
+              else
+                config.device = device_option
+                config.device_list = []
+              end
+            end
+            config.os = options[Maze::Option::OS]
+            config.os_version = options[Maze::Option::OS_VERSION]
+            config.sb_local = Maze::Helper.expand_path(options[Maze::Option::SB_LOCAL])
+            config.appium_server_url = 'https://us-west-mobile-hub.bitbar.com/wd/hub'
+            config.app_bundle_id = options[Maze::Option::APP_BUNDLE_ID]
+          when :local then
+            if options[Maze::Option::BROWSER]
+              config.browser = options[Maze::Option::BROWSER]
+            else
+              os = config.os = options[Maze::Option::OS].downcase
+              config.os_version = options[Maze::Option::OS_VERSION].to_f unless options[Maze::Option::OS_VERSION].nil?
+              config.appium_server_url = options[Maze::Option::APPIUM_SERVER]
+              config.start_appium = options[Maze::Option::START_APPIUM]
+              config.appium_logfile = options[Maze::Option::APPIUM_LOGFILE]
+              if os == 'ios'
+                config.apple_team_id = options[Maze::Option::APPLE_TEAM_ID]
+                config.device_id = options[Maze::Option::UDID]
+              end
+            end
+          when :none
+            if options[Maze::Option::OS]
+              config.os = options[Maze::Option::OS].downcase
+            end
+            if options[Maze::Option::OS_VERSION]
+              config.os_version = options[Maze::Option::OS_VERSION].to_f
+            end
+          else
+            raise "Unexpected farm option #{config.farm}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/maze/option/validator.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require_relative '../option'
+
+module Maze
+  module Option
+    # Validates command line options
+    class Validator
+      # Validates all provided options
+      # @param options [Hash] Parsed command line options
+      def validate(options)
+        errors = []
+
+        #
+        # Common options
+        #
+
+        # --farm
+        farm = options[Option::FARM]
+        if farm && !%w[bs local bb].include?(farm)
+          errors << "--#{Option::FARM} must be 'bs', 'bb' or 'local' if provided"
+        end
+
+        # --capabilities
+        begin
+          JSON.parse(options[Option::CAPABILITIES])
+        rescue JSON::ParserError
+          errors << "--#{Option::CAPABILITIES} must be valid JSON (given #{options[Option::CAPABILITIES]})"
+        end
+
+        # --repeater-api-key
+        key = options[Option::REPEATER_API_KEY]
+        key_regex = /^[0-9a-fA-F]{32}$/
+        if key && !key_regex.match?(key)
+          errors << "--#{Option::REPEATER_API_KEY} must be set to a 32-character hex value"
+        end
+
+        # Farm specific options
+        validate_bs options, errors if farm == 'bs'
+        validate_bitbar options, errors if farm == 'bb'
+        validate_local options, errors if farm == 'local'
+
+        errors
+      end
+
+      # Validates BrowserStack options
+      def validate_bs(options, errors)
+        # BS local binary
+        bs_local = Maze::Helper.expand_path options[Option::BS_LOCAL]
+        errors << "BrowserStack local binary '#{bs_local}' not found" unless File.exist? bs_local
+
+        # Device
+        browser = options[Option::BROWSER]
+        device = options[Option::DEVICE]
+        if browser.nil? && device.empty?
+          errors << "Either --#{Option::BROWSER} or --#{Option::DEVICE} must be specified"
+        elsif browser
+
+          browsers = YAML.safe_load(File.read("#{__dir__}/../client/selenium/bs_browsers.yml"))
+
+          unless browsers.include? browser
+            browser_list = browsers.keys.join ', '
+            errors << "Browser type '#{browser}' unknown on BrowserStack.  Must be one of: #{browser_list}."
+          end
+        elsif device
+          device.each do |device_key|
+            next if Maze::Client::Appium::BrowserStackDevices::DEVICE_HASH.key? device_key
+            errors << "Device type '#{device_key}' unknown on BrowserStack.  Must be one of #{Maze::Client::Appium::BrowserStackDevices::DEVICE_HASH.keys}"
+          end
+          # App
+          app = Maze::Helper.read_at_arg_file options[Option::APP]
+          if app.nil?
+            errors << "--#{Option::APP} must be provided when running on a device"
+          else
+            unless app.start_with?('bs://')
+              app = Maze::Helper.expand_path app
+              errors << "app file '#{app}' not found" unless File.exist?(app)
+            end
+          end
+        end
+
+        # Credentials
+        errors << "--#{Option::USERNAME} must be specified" if options[Option::USERNAME].nil?
+        errors << "--#{Option::ACCESS_KEY} must be specified" if options[Option::ACCESS_KEY].nil?
+      end
+
+      # Validates BitBar device options
+      def validate_bitbar(options, errors)
+        browser = options[Option::BROWSER]
+        device = options[Option::DEVICE]
+
+        if ENV['BUILDKITE'] && browser
+          errors << "--#{Option::TMS_URI} must be specified when running on Buildkite" if options[Option::TMS_URI].nil?
+        else
+          errors << "--#{Option::USERNAME} must be specified" if options[Option::USERNAME].nil?
+          errors << "--#{Option::ACCESS_KEY} must be specified" if options[Option::ACCESS_KEY].nil?
+        end
+
+        # Device
+        if browser.nil? && device.empty?
+          errors << "Either --#{Option::BROWSER} or --#{Option::DEVICE} must be specified"
+        elsif browser
+          browsers = YAML.safe_load(File.read("#{__dir__}/../client/selenium/bb_browsers.yml"))
+
+          unless browsers.include? browser
+            browser_list = browsers.keys.join ', '
+            errors << "Browser type '#{browser}' unknown on BitBar.  Must be one of: #{browser_list}."
+          end
+        elsif device
+          app = options[Option::APP]
+          if app.nil?
+            errors << "--#{Option::APP} must be provided when running on a device"
+          else
+            uuid_regex = /\A[0-9]+\z/
+            unless uuid_regex.match? app
+              app = Maze::Helper.expand_path app
+              errors << "app file '#{app}' not found" unless File.exist?(app)
+            end
+          end
+        end
+      end
+
+      # Validates Local device options
+      def validate_local(options, errors)
+        if options[Option::BROWSER].nil?
+          errors << "--#{Option::APP} must be specified" if options[Option::APP].nil?
+
+          # OS
+          if options[Option::OS].nil?
+            errors << "--#{Option::OS} must be specified"
+          else
+            os = options[Option::OS].downcase
+            errors << 'os must be android, ios, macos or windows' unless %w[android ios macos windows].include? os
+            if os == 'ios'
+              errors << "--#{Option::APPLE_TEAM_ID} must be specified for iOS" if options[Option::APPLE_TEAM_ID].nil?
+              errors << "--#{Option::UDID} must be specified for iOS" if options[Option::UDID].nil?
+            end
+          end
+
+          # OS Version
+          unless options[Option::OS_VERSION].nil?
+            # Ensure OS version is a valid float so that notifier tests can perform numeric checks
+            # e.g 'Maze.config.os_version > 7'
+            unless /^[1-9][0-9]*(\.[0-9])?/.match? options[Option::OS_VERSION]
+              errors << "--#{Option::OS_VERSION} must be a valid version matching '/^[1-9][0-9]*(\\.[0-9])?/'"
+            end
+          end
+        else
+          # TODO Validate browser options
+        end
+      end
+    end
+  end
+end