bugsnag-maze-runner 6.27.0

data/lib/maze/interactive_cli.rb

@@ -0,0 +1,173 @@
+require 'pty'
+# TODO: Removed pending PLAT-6322
+# require 'boring'
+
+module Maze
+  # Encapsulates a shell session, retaining state and input streams for interactive tests
+  class InteractiveCLI
+    # @!attribute [r] stdout_lines
+    #   @return [Array] An array of output strings received from the terminals STDOUT pipe
+    attr_reader :stdout_lines
+
+    # @!attribute [r] stderr_lines
+    #   @return [Array] An array of error strings received from the terminals STDERR pipe
+    attr_reader :stderr_lines
+
+    # @!attribute [r] pid
+    #   @return [Number, nil] The PID of the running terminal
+    attr_reader :pid
+
+    # @!attribute [r] current_buffer
+    #   @return [String] A string representation of the current output present in the terminal
+    attr_reader :current_buffer
+
+    # Creates an InteractiveCLI instance
+    #
+    # @param shell [String] A path to the shell to run, defaults to `/bin/sh`
+    # @param stop_command [String] The stop command, defaults to `exit`
+    def initialize(shell = '/bin/sh', stop_command = 'exit')
+      @shell = shell
+      @stop_command = stop_command
+      @stdout_lines = []
+      @stderr_lines = []
+      @on_exit_blocks = []
+      @current_buffer = ''
+      # TODO: Removed pending PLAT-6322
+      # @boring = Boring.new
+
+      start_threaded_shell(shell)
+    end
+
+    def start(threaded: true)
+      threaded ? start_threaded_shell(@shell) : start_shell(@shell)
+    end
+
+    # Attempts to stop the shell using the preset command and wait for it to exit
+    #
+    # @return [Boolean] If the shell stopped successfully
+    def stop
+      run_command(@stop_command)
+
+      @in_stream.close
+
+      maybe_thread = @thread.join(15)
+
+      # The thread did not exit!
+      return false if maybe_thread.nil?
+
+      @pid = nil
+      true
+    end
+
+    # @return [Boolean] Whether the shell is currently running
+    def running?
+      !@pid.nil?
+    end
+
+    # Runs the given command if the shell is running
+    #
+    # @param command [String] The command to run
+    #
+    # @return [Boolean] true if the command is executed, false otherwise
+    def run_command(command)
+      return false unless running?
+
+      @in_stream.puts(command)
+
+      true
+    rescue ::Errno::EIO => err
+      $logger.debug(pid) { "EIO error: #{err}" }
+      false
+    end
+
+    def on_exit(&block)
+      @on_exit_blocks << block
+    end
+
+    private
+
+    # Starts a shell on another thread
+    #
+    # @param shell [String] A path to the shell to run
+    def start_threaded_shell(shell)
+      @thread = Thread.new do
+        start_shell(shell)
+      end
+    end
+
+    # Starts a shell
+    #
+    # @param shell [String] A path to the shell to run
+    def start_shell(shell)
+      stderr_reader, stderr_writer = IO.pipe
+
+      PTY.spawn(shell, err: stderr_writer.fileno) do |stdout, stdin, pid|
+        # We don't need to write to stderr so close it ASAP
+        stderr_writer.close
+
+        $logger.debug(pid) { 'PTY spawned!' }
+        @pid = pid
+        @in_stream = stdin
+
+        stdout_thread = Thread.new do
+          stdout.each_char do |char|
+            if char == "\n"
+              line = format_line(@current_buffer)
+
+              $logger.debug("#{pid} STDOUT") { line.dump }
+              @stdout_lines << line
+              @current_buffer.clear
+            else
+              @current_buffer << char
+            end
+          end
+        rescue ::Errno::EIO => err
+          $logger.debug(pid) { "EIO error: #{err}" }
+        end
+
+        stderr_thread = Thread.new do
+          buffer = ''
+
+          stderr_reader.each_char do |char|
+            if char == "\n"
+              line = format_line(buffer)
+
+              $logger.debug("#{pid} STDERR") { line.dump }
+              @stderr_lines << line
+              buffer.clear
+            else
+              buffer << char
+            end
+          end
+        rescue ::Errno::EIO => err
+          $logger.debug(pid) { "EIO error: #{err}" }
+        end
+
+        _, status = Process.wait2(@pid)
+        @pid = nil
+
+        # Stop the thread that's reading from stdout
+        failed = stdout_thread.join(5).nil?
+        raise 'stdout is blocked!' if failed
+
+        # Stop the thread that's reading from stderr
+        failed = stderr_thread.join(5).nil?
+        raise 'stderr is blocked!' if failed
+
+        $logger.debug(pid) { "PTY exit status: #{status.exitstatus}" }
+        @on_exit_blocks.each do |block|
+          block.call(status.exitstatus)
+        end
+      end
+    ensure
+      stderr_reader.close unless stderr_reader.closed?
+      stderr_writer.close unless stderr_writer.closed?
+    end
+
+    def format_line(line)
+      # TODO: Removed pending PLAT-6322
+      # @boring.scrub(line.strip)
+      line.strip
+    end
+  end
+end

data/lib/maze/logger.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'singleton'
+
+# Logger classes
+module Maze
+  # A logger, with level configured according to the environment
+  class Logger < Logger
+
+    include Singleton
+    def initialize
+      if ENV['VERBOSE'] || ENV['DEBUG']
+        super(STDOUT, level: Logger::DEBUG)
+      elsif ENV['QUIET']
+        super(STDOUT, level: Logger::ERROR)
+      else
+        super(STDOUT, level: Logger::INFO)
+      end
+      self.datetime_format = '%Y-%m-%d %H:%M:%S'
+    end
+  end
+
+  $logger = Maze::Logger.instance
+
+  # A collection of logging utilities
+  class LogUtil
+    class << self
+      # Logs Hash-based data, accounting for things like file upload requests that are too big to log meaningfully.
+      #
+      # @param severity [Integer] A constant from Logger::Severity
+      # @param data [Hash] The data to log (currently needs to be a Hash)
+      def log_hash(severity, data)
+        return unless data.is_a? Hash
+
+        # Try to pretty print as JSON, if not too big
+        begin
+          json = JSON.pretty_generate data
+          if json.length < 128 * 1024
+            $logger.add severity, json
+          else
+            log_hash_by_field severity, data
+          end
+        rescue Encoding::UndefinedConversionError
+          log_hash_by_field severity, data
+        end
+      end
+
+      # Logs a hash field by field,
+      #
+      # @param severity [Integer] A Logger::Severity
+      # @param hash [Hash] The Hash
+      def log_hash_by_field(severity, hash)
+        hash.keys.each do |key|
+          value = hash[key].to_s
+          if value.length < 1024
+            $logger.add severity, "  #{key}: #{value}"
+          else
+            $logger.add severity, "  #{key} (length): #{value.length}"
+            $logger.add severity, "  #{key} (start): #{value[0, 1024]}"
+          end
+        end
+      end
+
+      # Produces a clickable link when logged in Buildkite
+      # @param url [String] Link URL
+      # @param text [String] Link text
+      def linkify(url, text)
+        "\033]1339;url='#{url}';content='#{text}'\a"
+      end
+    end
+  end
+end

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/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,245 @@
+# 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::ENABLE_RETRIES,
+                'Enables retrying failed scenarios when tagged',
+                type: :boolean,
+                default: true
+
+            opt Option::ENABLE_BUGSNAG,
+                'Enables reporting to Bugsnag on scenario failure (Require MAZE_BUGSNAG_API_KEY)',
+                type: :boolean,
+                default: true
+
+            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::SEPARATE_SESSIONS,
+                'Start a new Appium session for each scenario',
+                type: :boolean,
+                default: false
+            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::RESILIENT,
+                'Use the resilient Appium driver',
+                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 browsers_<farm>.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
+
+            # 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
+
+            # Sauce Labs-only options
+            opt Option::SL_LOCAL,
+                '(SL only) Path to the Sauce Connect binary. MAZE_SL_LOCAL env var or "/sauce-connect/bin/sc" 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 'cbt'
+            options[Option::USERNAME] ||= ENV['CBT_USERNAME']
+            options[Option::ACCESS_KEY] ||= ENV['CBT_ACCESS_KEY']
+          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 'sl'
+            options[Option::USERNAME] ||= ENV['SAUCE_LABS_USERNAME']
+            options[Option::ACCESS_KEY] ||= ENV['SAUCE_LABS_ACCESS_KEY']
+          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::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::SL_LOCAL] ||= ENV['MAZE_SL_LOCAL'] || '/sauce-connect/bin/sc'
+          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,143 @@
+# frozen_string_literal: true
+
+require_relative '../option'
+require_relative '../browser_stack_devices'
+
+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.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]
+
+          # 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.appium_session_isolation = options[Maze::Option::SEPARATE_SESSIONS]
+          config.app = Maze::Helper.read_at_arg_file options[Maze::Option::APP]
+          config.resilient = options[Maze::Option::RESILIENT]
+          farm = options[Maze::Option::FARM]
+          config.farm = case farm
+                        when nil then :none
+                        when 'cbt' then :cbt
+                        when 'bs' then :bs
+                        when 'sl' then :sl
+                        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]
+
+          # Farm specific options
+          case config.farm
+          when :cbt
+            config.browser = options[Maze::Option::BROWSER]
+            config.sb_local = Maze::Helper.expand_path(options[Maze::Option::SB_LOCAL])
+            username = config.username = options[Maze::Option::USERNAME]
+            access_key = config.access_key = options[Maze::Option::ACCESS_KEY]
+          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
+              config.os_version = Maze::BrowserStackDevices::DEVICE_HASH[config.device]['os_version'].to_f
+            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 :sl
+            device_option = options[Maze::Option::DEVICE]
+            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
+            config.browser = options[Maze::Option::BROWSER]
+            config.os = options[Maze::Option::OS]
+            config.os_version = options[Maze::Option::OS_VERSION].to_f
+            config.sl_local = Maze::Helper.expand_path(options[Maze::Option::SL_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 = "https://#{username}:#{access_key}@ondemand.us-west-1.saucelabs.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.is_a?(Array)
+              config.device = device_option.first
+              config.device_list = device_option.drop(1)
+            else
+              config.device = device_option
+              config.device_list = []
+            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://appium.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