beaker 4.38.1 → 5.0.0

data/lib/beaker/ssh_connection.rb

@@ -4,11 +4,9 @@ require 'net/scp'
 
 module Beaker
   class SshConnection
+    attr_accessor :logger, :ip, :vmhostname, :hostname, :ssh_connection_preference
 
-    attr_accessor :logger
-    attr_accessor :ip, :vmhostname, :hostname, :ssh_connection_preference
-
-    SUPPORTED_CONNECTION_METHODS = [:ip, :vmhostname, :hostname]
+    SUPPORTED_CONNECTION_METHODS = %i[ip vmhostname hostname]
 
     RETRYABLE_EXCEPTIONS = [
       SocketError,
@@ -67,18 +65,18 @@ module Beaker
       wait = 3
       max_connection_tries = options[:max_connection_tries] || 11
       begin
-         @logger.debug "Attempting ssh connection to #{host}, user: #{user}, opts: #{ssh_opts}"
+        @logger.debug "Attempting ssh connection to #{host}, user: #{user}, opts: #{ssh_opts}"
 
-         # Work around net-ssh 6+ incompatibilities
-         if ssh_opts.include?(:strict_host_key_checking) && (Net::SSH::Version::CURRENT.major > 5)
-           strict_host_key_checking = ssh_opts.delete(:strict_host_key_checking)
+        # Work around net-ssh 6+ incompatibilities
+        if ssh_opts.include?(:strict_host_key_checking) && (Net::SSH::Version::CURRENT.major > 5)
+          strict_host_key_checking = ssh_opts.delete(:strict_host_key_checking)
 
-           unless ssh_opts[:verify_host_key].is_a?(Symbol)
-             ssh_opts[:verify_host_key] ||= strict_host_key_checking ? :always : :never
-           end
-         end
+          unless ssh_opts[:verify_host_key].is_a?(Symbol)
+            ssh_opts[:verify_host_key] ||= strict_host_key_checking ? :always : :never
+          end
+        end
 
-         Net::SSH.start(host, user, ssh_opts)
+        Net::SSH.start(host, user, ssh_opts)
       rescue *RETRYABLE_EXCEPTIONS => e
         if try <= max_connection_tries
           @logger.warn "Try #{try} -- Host #{host} unreachable: #{e.class.name} - #{e.message}" unless options[:silent]
@@ -105,16 +103,14 @@ module Beaker
       # Try three ways to connect to host (vmhostname, ip, hostname)
       # Try each method in turn until we succeed
       methods = @ssh_connection_preference.dup
-      while (not @ssh) && (not methods.empty?) do
-        unless instance_variable_get("@#{methods[0]}").nil?
-          if SUPPORTED_CONNECTION_METHODS.include?(methods[0])
-            @ssh = connect_block(instance_variable_get("@#{methods[0].to_s}"), @user, @ssh_opts, options)
-          else
-            @logger.warn "Beaker does not support #{methods[0]} to SSH to host, trying next available method."
-            @ssh_connection_preference.delete(methods[0])
-          end
-        else
+      while (not @ssh) && (not methods.empty?)
+        if instance_variable_get("@#{methods[0]}").nil?
           @logger.warn "Skipping #{methods[0]} method to ssh to host as its value is not set. Refer to https://github.com/puppetlabs/beaker/tree/master/docs/how_to/ssh_connection_preference.md to remove this warning"
+        elsif SUPPORTED_CONNECTION_METHODS.include?(methods[0])
+          @ssh = connect_block(instance_variable_get("@#{methods[0]}"), @user, @ssh_opts, options)
+        else
+          @logger.warn "Beaker does not support #{methods[0]} to SSH to host, trying next available method."
+          @ssh_connection_preference.delete(methods[0])
         end
         methods.shift
       end
@@ -157,30 +153,31 @@ module Beaker
       try = 1
       last_wait = 2
       wait = 3
-      command = 'echo echo' #can be run on all platforms (I'm looking at you, windows)
+      command = 'echo echo' # can be run on all platforms (I'm looking at you, windows)
       while try < 11
         result = Result.new(@hostname, command)
         begin
           @logger.notify "Waiting for connection failure on #{@hostname} (attempt #{try}, try again in #{wait} second(s))"
           @logger.debug("\n#{@hostname} #{Time.new.strftime('%H:%M:%S')}$ #{command}")
           @ssh.open_channel do |channel|
-            request_terminal_for( channel, command ) if options[:pty]
+            request_terminal_for(channel, command) if options[:pty]
 
             channel.exec(command) do |terminal, success|
               raise Net::SSH::Exception.new("FAILED: to execute command on a new channel on #{@hostname}") unless success
+
               register_stdout_for terminal, result, stdout_callback
               register_stderr_for terminal, result, stderr_callback
               register_exit_code_for terminal, result
 
-              process_stdin_for( terminal, options[:stdin] ) if options[:stdin]
-             end
-           end
-           loop_tries = 0
-           #loop is actually loop_forever, so let it try 3 times and then quit instead of endless blocking
-           @ssh.loop { loop_tries += 1 ; loop_tries < 4 }
+              process_stdin_for(terminal, options[:stdin]) if options[:stdin]
+            end
+          end
+          loop_tries = 0
+          # loop is actually loop_forever, so let it try 3 times and then quit instead of endless blocking
+          @ssh.loop { loop_tries += 1; loop_tries < 4 }
         rescue *RETRYABLE_EXCEPTIONS => e
           @logger.debug "Connection on #{@hostname} failed as expected (#{e.class.name} - #{e.message})"
-          close #this connection is bad, shut it down
+          close # this connection is bad, shut it down
           return true
         end
         slept = 0
@@ -198,20 +195,21 @@ module Beaker
     end
 
     def try_to_execute command, options = {}, stdout_callback = nil,
-                stderr_callback = stdout_callback
+                       stderr_callback = stdout_callback
 
       result = Result.new(@hostname, command)
 
       @ssh.open_channel do |channel|
-        request_terminal_for( channel, command ) if options[:pty]
+        request_terminal_for(channel, command) if options[:pty]
 
         channel.exec(command) do |terminal, success|
           raise Net::SSH::Exception.new("FAILED: to execute command on a new channel on #{@hostname}") unless success
+
           register_stdout_for terminal, result, stdout_callback
           register_stderr_for terminal, result, stderr_callback
           register_exit_code_for terminal, result
 
-          process_stdin_for( terminal, options[:stdin] ) if options[:stdin]
+          process_stdin_for(terminal, options[:stdin]) if options[:stdin]
         end
       end
 
@@ -243,7 +241,7 @@ module Beaker
     end
 
     def request_terminal_for channel, command
-      channel.request_pty do |ch, success|
+      channel.request_pty do |_ch, success|
         if success
           @logger.debug "Allocated a PTY on #{@hostname} for #{command.inspect}"
         else
@@ -254,7 +252,7 @@ module Beaker
     end
 
     def register_stdout_for channel, output, callback = nil
-      channel.on_data do |ch, data|
+      channel.on_data do |_ch, data|
         callback[data] if callback
         output.stdout << data
         output.output << data
@@ -262,7 +260,7 @@ module Beaker
     end
 
     def register_stderr_for channel, output, callback = nil
-      channel.on_extended_data do |ch, type, data|
+      channel.on_extended_data do |_ch, type, data|
         if type == 1
           callback[data] if callback
           output.stderr << data
@@ -272,7 +270,7 @@ module Beaker
     end
 
     def register_exit_code_for channel, output
-      channel.on_request("exit-status") do |ch, data|
+      channel.on_request("exit-status") do |_ch, data|
         output.exit_code = data.read_long
       end
     end
@@ -288,11 +286,8 @@ module Beaker
     end
 
     def scp_to source, target, options = {}
-
       local_opts = options.dup
-      if local_opts[:recursive].nil?
-        local_opts[:recursive] = File.directory?(source)
-      end
+      local_opts[:recursive] = File.directory?(source) if local_opts[:recursive].nil?
       local_opts[:chunk_size] ||= 16384
 
       result = Result.new(@hostname, [source, target])
@@ -301,18 +296,17 @@ module Beaker
       begin
         # This is probably windows with an environment variable so we need to
         # expand it.
-        target = self.execute(%{echo "#{target}"}).output.strip.gsub('"','') if target.include?('%')
+        target = self.execute(%{echo "#{target}"}).output.strip.delete('"') if target.include?('%')
 
-        @ssh.scp.upload! source, target, local_opts do |ch, name, sent, total|
-          result.stdout << "\tcopying %s: %10d/%d\n" % [name, sent, total]
+        @ssh.scp.upload! source, target, local_opts do |_ch, name, sent, total|
+          result.stdout << (format("\tcopying %s: %10d/%d\n", name, sent, total))
         end
       rescue => e
         logger.warn "#{e.class} error in scp'ing. Forcing the connection to close, which should " <<
-          "raise an error."
+                    "raise an error."
         close
       end
 
-
       # Setting these values allows reporting via result.log(test_name)
       result.stdout << "  SCP'ed file #{source} to #{@hostname}:#{target}"
 
@@ -324,11 +318,8 @@ module Beaker
     end
 
     def scp_from source, target, options = {}
-
       local_opts = options.dup
-      if local_opts[:recursive].nil?
-        local_opts[:recursive] = true
-      end
+      local_opts[:recursive] = true if local_opts[:recursive].nil?
       local_opts[:chunk_size] ||= 16384
 
       result = Result.new(@hostname, [source, target])
@@ -337,14 +328,14 @@ module Beaker
       begin
         # This is probably windows with an environment variable so we need to
         # expand it.
-        source = self.execute(%{echo "#{source}"}).output.strip.gsub('"','') if source.include?('%')
+        source = self.execute(%{echo "#{source}"}).output.strip.delete('"') if source.include?('%')
 
-        @ssh.scp.download! source, target, local_opts do |ch, name, sent, total|
-          result.stdout << "\tcopying %s: %10d/%d\n" % [name, sent, total]
+        @ssh.scp.download! source, target, local_opts do |_ch, name, sent, total|
+          result.stdout << (format("\tcopying %s: %10d/%d\n", name, sent, total))
         end
       rescue => e
         logger.warn "#{e.class} error in scp'ing. Forcing the connection to close, which should " <<
-          "raise an error."
+                    "raise an error."
         close
       end
 

data/lib/beaker/subcommand.rb

@@ -28,7 +28,7 @@ module Beaker
     class_option :'pre-suite', :type => :string, :group => 'Beaker run'
     class_option :'post-suite', :type => :string, :group => 'Beaker run'
     class_option :'pre-cleanup', :type => :string, :group => 'Beaker run'
-    class_option :'provision', :type => :boolean, :group => 'Beaker run'
+    class_option :provision, :type => :boolean, :group => 'Beaker run'
     class_option :'preserve-hosts', :type => :string, :group => 'Beaker run'
     class_option :'preserve-state', :type => :boolean, :group => 'Beaker run'
     class_option :'root-keys', :type => :boolean, :group => 'Beaker run'
@@ -46,16 +46,15 @@ module Beaker
     class_option :'test-results-file', :type => :string, :group => 'Beaker run'
     class_option :ntp, :type => :boolean, :group => 'Beaker run'
     class_option :'repo-proxy', :type => :boolean, :group => 'Beaker run'
-    class_option :'add-el-extras', :type => :boolean, :group => 'Beaker run'
     class_option :'package-proxy', :type => :string, :group => 'Beaker run'
-    class_option :'validate', :type => :boolean, :group => 'Beaker run'
+    class_option :validate, :type => :boolean, :group => 'Beaker run'
     class_option :'collect-perf-data', :type => :boolean, :group => 'Beaker run'
     class_option :'parse-only', :type => :boolean, :group => 'Beaker run'
     class_option :tag, :type => :string, :group => 'Beaker run'
     class_option :'exclude-tags', :type => :string, :group => 'Beaker run'
     class_option :'xml-time-order', :type => :boolean, :group => 'Beaker run'
     class_option :'debug-errors', :type => :boolean, :group => 'Beaker run'
-    class_option :'exec_manual_tests', :type => :boolean, :group => 'Beaker run'
+    class_option :exec_manual_tests, :type => :boolean, :group => 'Beaker run'
     class_option :'test-tag-exclude', :type => :string, :group => 'Beaker run'
     class_option :'test-tag-and', :type => :string, :group => 'Beaker run'
     class_option :'test-tag-or', :type => :string, :group => 'Beaker run'
@@ -76,7 +75,7 @@ module Beaker
     LONGDESC
     option :help, :type => :boolean, :hide => true
     method_option :hosts, :aliases => '-h', :type => :string, :required => true
-    def init()
+    def init
       if options[:help]
         invoke :help, [], ["init"]
         return
@@ -87,9 +86,7 @@ module Beaker
       options_to_write = SubcommandUtil.sanitize_options_for_save(@cli.configured_options)
 
       @cli.logger.notify 'Writing configured options to disk'
-      File.open(SubcommandUtil::SUBCOMMAND_OPTIONS, 'w') do |f|
-        f.write(options_to_write.to_yaml)
-      end
+      File.write(SubcommandUtil::SUBCOMMAND_OPTIONS, options_to_write.to_yaml)
       @cli.logger.notify "Options written to #{SubcommandUtil::SUBCOMMAND_OPTIONS}"
 
       state = YAML::Store.new(SubcommandUtil::SUBCOMMAND_STATE)
@@ -105,16 +102,14 @@ module Beaker
     flag here to override.
     LONGDESC
     option :help, :type => :boolean, :hide => true
-    def provision()
+    def provision
       if options[:help]
         invoke :help, [], ["provision"]
         return
       end
 
       state = YAML::Store.new(SubcommandUtil::SUBCOMMAND_STATE)
-      if state.transaction { state['provisioned']}
-        SubcommandUtil.error_with('Provisioned SUTs detected. Please destroy and reprovision.')
-      end
+      SubcommandUtil.error_with('Provisioned SUTs detected. Please destroy and reprovision.') if state.transaction { state['provisioned'] }
 
       @cli.parse_options
       @cli.provision
@@ -124,7 +119,7 @@ module Beaker
 
       # Update each host provisioned with a flag indicating that it no longer needs
       # provisioning
-      cleaned_hosts.each do |host, host_hash|
+      cleaned_hosts.each do |_host, host_hash|
         host_hash['provision'] = false
       end
 
@@ -154,7 +149,7 @@ module Beaker
     such as: exec pre-suite,tests
     LONG_DESC
     option :help, :type => :boolean, :hide => true
-    def exec(resource=nil)
+    def exec(resource = nil)
       if options[:help]
         invoke :help, [], ["exec"]
         return
@@ -168,7 +163,7 @@ module Beaker
         return
       end
 
-      beaker_suites = [:pre_suite, :tests, :post_suite, :pre_cleanup]
+      beaker_suites = %i[pre_suite tests post_suite pre_cleanup]
       resources = resource.split(',')
       paths = resources.map { |r| Pathname(r) }
       if paths.all?(&:exist?)
@@ -186,11 +181,11 @@ module Beaker
             path.to_s
           end
         end.flatten
-      elsif resources.all? { |r| r =~ /^(pre-suite|tests|post-suite|pre-cleanup)$/ }
+      elsif resources.all? { |r| /^(pre-suite|tests|post-suite|pre-cleanup)$/.match?(r) }
         # The regex match here is loose so that users can supply multiple suites,
         # such as `beaker exec pre-suite,tests`.
         beaker_suites.each do |suite|
-          @cli.options[suite] = [] unless resource.gsub(/-/, '_').match(suite.to_s)
+          @cli.options[suite] = [] unless resource.tr('-', '_').match(suite.to_s)
         end
       else
         raise ArgumentError, "Unable to parse #{resource} with beaker exec"
@@ -198,13 +193,13 @@ module Beaker
 
       @cli.execute!
 
-      if options['preserve-state']
-        @cli.logger.notify 'updating HOSTS key in subcommand_options'
-        hosts = SubcommandUtil.sanitize_options_for_save(@cli.combined_instance_and_options_hosts)
-        options_storage = YAML::Store.new(SubcommandUtil::SUBCOMMAND_OPTIONS)
-        options_storage.transaction do
-          options_storage['HOSTS'] = hosts
-        end
+      return unless options['preserve-state']
+
+      @cli.logger.notify 'updating HOSTS key in subcommand_options'
+      hosts = SubcommandUtil.sanitize_options_for_save(@cli.combined_instance_and_options_hosts)
+      options_storage = YAML::Store.new(SubcommandUtil::SUBCOMMAND_OPTIONS)
+      options_storage.transaction do
+        options_storage['HOSTS'] = hosts
       end
     end
 
@@ -213,25 +208,23 @@ module Beaker
     Destroys the currently provisioned VMs
     LONG_DESC
     option :help, :type => :boolean, :hide => true
-    def destroy()
+    def destroy
       if options[:help]
         invoke :help, [], ["destroy"]
         return
       end
 
       state = YAML::Store.new(SubcommandUtil::SUBCOMMAND_STATE)
-      unless state.transaction { state['provisioned']}
-        SubcommandUtil.error_with('Please provision an environment')
-      end
+      SubcommandUtil.error_with('Please provision an environment') unless state.transaction { state['provisioned'] }
 
       @cli.parse_options
       @cli.options[:provision] = false
       @cli.initialize_network_manager
       @cli.network_manager.cleanup
 
-      state.transaction {
+      state.transaction do
         state.delete('provisioned')
-      }
+      end
     end
   end
 end

data/lib/beaker/subcommands/subcommand_util.rb

@@ -17,10 +17,11 @@ module Beaker
       PERSISTED_HOSTS = Pathname("#{CONFIG_DIR}/.hosts.yaml")
       PERSISTED_HYPERVISORS = Pathname("#{CONFIG_DIR}/.hypervisors.yaml")
       # These options should not be part of persisted subcommand state
-      UNPERSISTED_OPTIONS = [:beaker_version, :command_line, :hosts_file, :logger, :password_prompt, :timestamp]
+      UNPERSISTED_OPTIONS = %i[beaker_version command_line hosts_file logger password_prompt timestamp]
 
       def self.execute_subcommand?(arg0)
         return false if arg0.nil?
+
         (Beaker::Subcommand.instance_methods(false) << :help).include? arg0.to_sym
       end
 
@@ -46,9 +47,9 @@ module Beaker
       end
 
       # Print a message to the console and exit with specified exit code, defaults to 1
-      # @param [String] msg the message to output
+      #  @param [String] msg the message to output
       # @param [Hash<Object>] options to specify exit code or output stack trace
-      def self.error_with(msg, options={})
+      def self.error_with(msg, options = {})
         puts msg
         puts options[:stack_trace] if options[:stack_trace]
         exit_code = options[:exit_code] ? options[:exit_code] : 1
@@ -68,7 +69,6 @@ module Beaker
           $stderr = old_stderr
         end
       end
-
     end
   end
 end

data/lib/beaker/tasks/quick_start.rb

@@ -3,14 +3,13 @@ require 'beaker-hostgenerator'
 CONFIG_DIR = 'acceptance/config'
 
 VAGRANT  = ['ubuntu1404-64default.mdcal-ubuntu1404-64af', '--hypervisor=vagrant',
-            '--global-config={box_url=https://vagrantcloud.com/puppetlabs/boxes/ubuntu-14.04-64-nocm,box=puppetlabs/ubuntu-14.04-64-nocm}']
+            '--global-config={box_url=https://vagrantcloud.com/puppetlabs/boxes/ubuntu-14.04-64-nocm,box=puppetlabs/ubuntu-14.04-64-nocm}',]
 
 VMPOOLER = ['redhat7-64default.mdcal-redhat7-64af']
 
 namespace :beaker_quickstart do
-
   desc 'Generate Default Beaker Host Config File, valid options are: vmpooler or vagrant.'
-  task :gen_hosts, [:hypervisor] do |t, args|
+  task :gen_hosts, [:hypervisor] do |_t, args|
     hosts_file = "#{CONFIG_DIR}/default_#{args[:hypervisor]}_hosts.yaml"
     if args[:hypervisor] == 'vagrant'
       cli = VAGRANT
@@ -33,7 +32,6 @@ namespace :beaker_quickstart do
     end
   end
 
-
   desc 'Generate Default Pre-Suite'
   task :gen_pre_suite do
     pre_suite_file = "acceptance/setup/default_pre_suite.rb"
@@ -71,20 +69,17 @@ end")
 
   desc 'Run Default Smoke Test, after generating default host config and test files, valid options are: vmpooler or vagrant.'
   task :run_test, [:hypervisor] => ["beaker_quickstart:gen_hosts", 'beaker_quickstart:gen_pre_suite',
-                                     'beaker_quickstart:gen_smoke_test'] do
-  |t, args|
-    hypervisor             = args[:hypervisor] ||='vagrant'
-    system_args             = Hash.new
+                                    'beaker_quickstart:gen_smoke_test',] do |_t, args|
+    hypervisor = args[:hypervisor] ||= 'vagrant'
+    system_args             = {}
     system_args[:hosts]     = "acceptance/config/default_#{hypervisor}_hosts.yaml"
     system_args[:pre_suite] = 'acceptance/setup/default_pre_suite.rb'
     system_args[:tests]     = 'acceptance/tests/default_smoke_test.rb'
     puts "About to run - #{beaker_command(system_args)}"
     system(beaker_command(system_args))
   end
-
 end
 
-
 def beaker_command(system_args)
   cmd_parts = []
   cmd_parts << "beaker"

data/lib/beaker/tasks/rake_task.rb

@@ -3,7 +3,6 @@ require 'rake/tasklib'
 require 'rake'
 require 'beaker'
 
-
 module Beaker
   module Tasks
     class RakeTask < ::Rake::TaskLib
@@ -11,17 +10,17 @@ module Beaker
 
       DEFAULT_ACCEPTANCE_ROOT = "./acceptance"
 
-      COMMAND_OPTIONS = [:fail_mode,
-       :hosts,
-       :helper,
-       :keyfile,
-       :log_level,
-       :options_file,
-       :preserve_hosts,
-       :tests,
-       :type,
-       :acceptance_root,
-       :name]
+      COMMAND_OPTIONS = %i[fail_mode
+                           hosts
+                           helper
+                           keyfile
+                           log_level
+                           options_file
+                           preserve_hosts
+                           tests
+                           type
+                           acceptance_root
+                           name]
       # iterates of acceptable params
       COMMAND_OPTIONS.each do |sym|
         attr_accessor(sym.to_sym)
@@ -31,16 +30,17 @@ module Beaker
       # @param args [Array] First argument is always the name of the task
       # if no additonal arguments are defined such as parameters it will default to [:hosts,:type]
       def initialize(*args, &task_block)
+        super
+
         @name = args.shift || 'beaker:test'
-        if args.empty?
-          args = [:hosts,:type]
-        end
+        args = %i[hosts type] if args.empty?
         @acceptance_root = DEFAULT_ACCEPTANCE_ROOT
         @options_file = nil
         define(args, &task_block)
       end
 
       private
+
       # Run the task provided, implements the rake task interface
       #
       # @param verbose [bool] Defines wether to run in verbose mode or not
@@ -51,10 +51,10 @@ module Beaker
         command = beaker_command
         puts command if verbose
         success = system(command)
-        if fail_mode == "fast" && !success
-          $stderr.puts "#{command} failed"
-          exit $?.exitstatus
-        end
+        return unless fail_mode == "fast" && !success
+
+        $stderr.puts "#{command} failed"
+        exit $?.exitstatus
       end
 
       # @private
@@ -64,7 +64,7 @@ module Beaker
                                                                                                                                 .application.last_comment)
         task name, *args do |_, task_args|
           RakeFileUtils.__send__(:verbose, verbose) do
-            task_block.call(*[self, task_args].slice(0, task_block.arity)) if task_block
+            yield(*[self, task_args].slice(0, task_block.arity)) if task_block
             run_task verbose
           end
         end
@@ -75,19 +75,17 @@ module Beaker
       #   if no other options file is provided
       #
       def check_for_beaker_type_config
-        if !@options_file && File.exists?("#{@acceptance_root}/.beaker-#{@type}.cfg")
-          @options_file = File.join(@acceptance_root, ".beaker-#{@type}.cfg")
-        end
+        return unless !@options_file && File.exist?("#{@acceptance_root}/.beaker-#{@type}.cfg")
+
+        @options_file = File.join(@acceptance_root, ".beaker-#{@type}.cfg")
       end
 
       #
       # Check for existence of ENV variables for test if !@tests is undef
       #
       def check_env_variables
-        if File.exists?(File.join(DEFAULT_ACCEPTANCE_ROOT, 'tests'))
-          @tests = File.join(DEFAULT_ACCEPTANCE_ROOT, 'tests')
-        end
-        @tests = ENV['TESTS'] || ENV['TEST'] if !@tests
+        @tests = File.join(DEFAULT_ACCEPTANCE_ROOT, 'tests') if File.exist?(File.join(DEFAULT_ACCEPTANCE_ROOT, 'tests'))
+        @tests = ENV['TESTS'] || ENV.fetch('TEST', nil) if !@tests
       end
 
       #
@@ -97,7 +95,7 @@ module Beaker
         cmd_parts = []
         cmd_parts << "beaker"
         cmd_parts << "--keyfile #{@keyfile}" if @keyfile
-        cmd_parts << "--hosts #{@hosts}" if (@hosts!=nil && !@hosts.empty?)
+        cmd_parts << "--hosts #{@hosts}" if (@hosts != nil && !@hosts.empty?)
         cmd_parts << "--tests #{tests}" if @tests
         cmd_parts << "--options-file #{@options_file}" if @options_file
         cmd_parts << "--type #{@type}" if @type

data/lib/beaker/tasks/test.rb

@@ -1,18 +1,18 @@
 require 'beaker/tasks/rake_task'
 
-Beaker::Tasks::RakeTask.new do |t,args|
+Beaker::Tasks::RakeTask.new do |t, args|
   t.type  = args[:type]
   t.hosts = args[:hosts]
 end
 
 desc "Run Beaker PE tests"
-Beaker::Tasks::RakeTask.new("beaker:test:pe",:hosts) do |t,args|
+Beaker::Tasks::RakeTask.new("beaker:test:pe", :hosts) do |t, args|
   t.type = 'pe'
   t.hosts = args[:hosts]
 end
 
 desc "Run Beaker Git tests"
-Beaker::Tasks::RakeTask.new("beaker:test:git",:hosts) do |t,args|
+Beaker::Tasks::RakeTask.new("beaker:test:git", :hosts) do |t, args|
   t.type = 'git'
   t.hosts = args[:hosts]
-end
+end