beaker 4.40.0 → 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]}"), @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
 
@@ -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])
@@ -304,15 +299,14 @@ module Beaker
         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]
+          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])
@@ -340,11 +331,11 @@ module Beaker
         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]
+          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

@@ -46,7 +46,6 @@ 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 :'collect-perf-data', :type => :boolean, :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
@@ -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?)
@@ -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,12 +3,11 @@ 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|
     hosts_file = "#{CONFIG_DIR}/default_#{args[:hypervisor]}_hosts.yaml"
@@ -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
@@ -75,19 +75,17 @@ module Beaker
       #   if no other options file is provided
       #
       def check_for_beaker_type_config
-        if !@options_file && File.exist?("#{@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.exist?(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

data/lib/beaker/test_case.rb

@@ -1,4 +1,4 @@
-[ 'host', 'dsl' ].each do |lib|
+%w[host dsl].each do |lib|
   require "beaker/#{lib}"
 end
 
@@ -41,10 +41,10 @@ module Beaker
     # Assumed to be an Array.
     attr_accessor :exports
 
-    #The full log for this test
+    # The full log for this test
     attr_accessor :sublog
 
-    #The result for the last command run
+    # The result for the last command run
     attr_accessor :last_result
 
     # A Hash of 'product name' => 'version installed', only set when
@@ -71,31 +71,21 @@ module Beaker
     # The exception that may have stopped this test's execution.
     attr_reader :exception
 
-    # @deprecated
-    # The amount of time taken to execute the test. Unused, probably soon
-    # to be removed or refactored.
+    # The amount of time taken to execute the test
     attr_reader :runtime
 
     # An Array of Procs to be called after test execution has stopped
     # (whether by exception or not).
     attr_reader :teardown_procs
 
-    # @deprecated
-    # Legacy accessor from when test files would only contain one remote
-    # action.  Contains the Result of the last call to utilize
-    # {Beaker::DSL::Helpers#on}.  Do not use as it is not safe
-    # in test files that use multiple calls to
-    # {Beaker::DSL::Helpers#on}.
-    attr_accessor :result
-
     # @param [Hosts,Array<Host>] these_hosts The hosts to execute this test
     #                                        against/on.
     # @param [Logger] logger A logger that implements
     #                        {Beaker::Logger}'s interface.
     # @param [Hash{Symbol=>String}] options Parsed command line options.
     # @param [String] path The local path to a test file to be executed.
-    def initialize(these_hosts, logger, options={}, path=nil)
-      @hosts   = these_hosts
+    def initialize(these_hosts, logger, options = {}, path = nil)
+      @hosts = these_hosts
       @logger = logger
       @sublog = ""
       @options = options
@@ -109,7 +99,6 @@ module Beaker
       @exports  = []
       set_current_test_filename(@path ? File.basename(@path, '.rb') : nil)
 
-
       #
       # We put this on each wrapper (rather than the class) so that methods
       # defined in the tests don't leak out to other tests.
@@ -120,17 +109,17 @@ module Beaker
 
           set_current_step_name(nil)
 
-          #add arbitrary role methods
+          # add arbitrary role methods
           roles = []
           @hosts.each do |host|
             roles << host[:roles]
           end
-          add_role_def( roles.flatten.uniq )
+          add_role_def(roles.flatten.uniq)
 
           @runtime = Benchmark.realtime do
             begin
               test = File.read(path)
-              eval test,nil,path,1
+              eval test, nil, path, 1
             rescue FailTest, TEST_EXCEPTION_CLASS => e
               log_and_fail_test(e, :fail)
             rescue PassTest
@@ -168,18 +157,18 @@ module Beaker
         #
         # @param exception [Exception] exception to fail with
         # @param exception [Symbol] the test status
-        def log_and_fail_test(exception, status=:error)
+        def log_and_fail_test(exception, status = :error)
           logger.error("#{exception.class}: #{exception.message}")
           bt = exception.backtrace
           logger.pretty_backtrace(bt).each_line do |line|
             logger.error(line)
           end
           # If the status is already a test failure or error, don't overwrite with the teardown failure.
-          unless status == :teardown_error && (@test_status == :error || @test_status == :fail)
-            status = :error if status == :teardown_error
-            @test_status = status
-            @exception   = exception
-          end
+          return if status == :teardown_error && (@test_status == :error || @test_status == :fail)
+
+          status = :error if status == :teardown_error
+          @test_status = status
+          @exception   = exception
         end
       end
     end
@@ -198,6 +187,5 @@ module Beaker
       end
       hash
     end
-
   end
 end