beaker 4.38.1 → 5.0.0

data/spec/beaker/options/presets_spec.rb

@@ -2,26 +2,25 @@ require "spec_helper"
 
 module Beaker
   module Options
-
     describe Presets do
-      let(:presets)    { Presets.new }
+      let(:presets) { described_class.new }
 
       it "returns an env_vars OptionsHash" do
         expect(presets.env_vars).to be_instance_of(Beaker::Options::OptionsHash)
       end
 
       it "pulls in env vars of the form ':q_*' and adds them to the :answers of the OptionsHash" do
-         ENV['q_puppet_cloud_install'] = 'n'
-         env = presets.env_vars
-         expect(env[:answers][:q_puppet_cloud_install]).to be === 'n'
-         expect(env[:answers]['q_puppet_cloud_install']).to be === 'n'
-         ENV.delete('q_puppet_cloud_install')
+        ENV['q_puppet_cloud_install'] = 'n'
+        env = presets.env_vars
+        expect(env[:answers][:q_puppet_cloud_install]).to be === 'n'
+        expect(env[:answers]['q_puppet_cloud_install']).to be === 'n'
+        ENV.delete('q_puppet_cloud_install')
       end
 
       it "correctly parses the run_in_parallel array" do
         ENV['BEAKER_RUN_IN_PARALLEL'] = "install,configure"
         env = presets.env_vars
-        expect(env[:run_in_parallel]).to eq(['install', 'configure'])
+        expect(env[:run_in_parallel]).to eq(%w[install configure])
       end
 
       it "removes all empty/nil entries in env_vars" do
@@ -34,10 +33,9 @@ module Beaker
       end
 
       it 'has empty host_tags' do
-        expect(presets.presets.has_key?(:host_tags)).to be_truthy
+        expect(presets.presets).to have_key(:host_tags)
         expect(presets.presets[:host_tags]).to eq({})
       end
-
     end
   end
 end

data/spec/beaker/options/subcommand_options_parser_spec.rb

@@ -3,35 +3,36 @@ require 'spec_helper'
 module Beaker
   module Options
     describe '#parse_subcommand_options' do
-      let(:home_options_file_path) {ENV['HOME']+'/.beaker/subcommand_options.yaml'}
+      let(:home_options_file_path) { ENV.fetch('HOME', nil) + '/.beaker/subcommand_options.yaml' }
       let(:parser_mod) { Beaker::Options::SubcommandOptionsParser }
-      let( :parser ) {parser_mod.parse_subcommand_options(argv, options_file)}
-      let( :file_parser ){parser_mod.parse_options_file({})}
-      let( :argv ) {[]}
-      let( :options_file ) {""}
+      let(:parser) { parser_mod.parse_subcommand_options(argv, options_file) }
+      let(:file_parser) { parser_mod.parse_options_file({}) }
+      let(:argv) { [] }
+      let(:options_file) { "" }
 
       it 'returns an empty OptionsHash if not executing a subcommand' do
-        expect(parser).to be_kind_of(OptionsHash)
+        expect(parser).to be_a(OptionsHash)
         expect(parser).to be_empty
       end
 
       describe 'when the subcommand is init' do
-        let( :argv ) {['init']}
+        let(:argv) { ['init'] }
+
         it 'returns an empty OptionsHash' do
-          expect(parser).to be_kind_of(OptionsHash)
+          expect(parser).to be_a(OptionsHash)
           expect(parser).to be_empty
         end
       end
 
       describe 'when the subcommand is not init' do
-        let( :argv ) {['provision']}
-        let(:options_file) {Beaker::Subcommands::SubcommandUtil::SUBCOMMAND_OPTIONS}
+        let(:argv) { ['provision'] }
+        let(:options_file) { home_options_file_path }
+
         it 'calls parse_options_file with subcommand options file when home_dir is false' do
           allow(parser_mod).to receive(:execute_subcommand?).with('provision').and_return true
           allow(parser_mod).to receive(:parse_options_file).with(Beaker::Subcommands::SubcommandUtil::SUBCOMMAND_OPTIONS)
         end
 
-        let( :options_file ) {home_options_file_path}
         it 'calls parse_options_file with home directory options file when home_dir is true' do
           allow(parser_mod).to receive(:execute_subcommand?).with('provision').and_return true
           allow(parser_mod).to receive(:parse_options_file).with(home_options_file_path)
@@ -40,14 +41,13 @@ module Beaker
         it 'checks for file existence and loads the YAML file' do
           allow(File).to receive(:exist?).and_return true
           allow(YAML).to receive(:load_file).and_return({})
-          expect(file_parser).to be_kind_of(Hash)
-          expect(file_parser).not_to be_kind_of(OptionsHash)
+          expect(file_parser).to be_a(Hash)
+          expect(file_parser).not_to be_a(OptionsHash)
         end
 
-        let(:options_file) {""}
         it 'returns an empty options hash when file does not exist' do
           allow(File).to receive(:exist?).and_return false
-          expect(parser).to be_kind_of(OptionsHash)
+          expect(parser).to be_a(OptionsHash)
           expect(parser).to be_empty
         end
       end

data/spec/beaker/options/validator_spec.rb

@@ -2,15 +2,14 @@ require 'spec_helper'
 
 module Beaker
   module Options
-
     describe Validator do
-      let(:validator) { Validator.new }
+      let(:validator) { described_class.new }
 
       describe '#check_yaml_file' do
-        let(:bad_yaml_path) { File.join(File.expand_path(File.dirname(__FILE__)), 'data', 'badyaml.cfg') }
-        let(:yaml_path) { File.join(File.expand_path(File.dirname(__FILE__)), 'data', 'hosts.cfg') }
+        let(:bad_yaml_path) { File.join(File.expand_path(__dir__), 'data', 'badyaml.cfg') }
+        let(:yaml_path) { File.join(File.expand_path(__dir__), 'data', 'hosts.cfg') }
 
-        before :each do
+        before do
           FakeFS.deactivate!
         end
 
@@ -23,7 +22,7 @@ module Beaker
         end
 
         it 'does not throw errors on valid yaml files' do
-          expect { validator.check_yaml_file(yaml_path) }.to_not raise_error
+          expect { validator.check_yaml_file(yaml_path) }.not_to raise_error
         end
       end
 
@@ -35,7 +34,7 @@ module Beaker
 
       describe '#default_set?' do
         it 'is false when empty' do
-          expect(validator.default_set?([])).to be_falsey
+          expect(validator).not_to be_default_set([])
         end
 
         it 'throws error when more than 1' do
@@ -44,7 +43,7 @@ module Beaker
 
         ['test', 1, 3.4, true, Object.new].each do |val|
           it "is true when contents are #{val.class}" do
-            expect(validator.default_set?([val])).to be_truthy
+            expect(validator).to be_default_set([val])
           end
         end
       end
@@ -52,7 +51,7 @@ module Beaker
       describe '#valid_fail_mode?' do
         %w(stop fast slow).each do |val|
           it "does not throw error when set to #{val}" do
-            expect { validator.validate_fail_mode(val) }.to_not raise_error
+            expect { validator.validate_fail_mode(val) }.not_to raise_error
           end
 
           it "raises error when set to #{val.upcase}" do
@@ -74,7 +73,7 @@ module Beaker
       describe '#valid_preserve_hosts?' do
         %w(always onfail onpass never).each do |val|
           it "does not raise error when set to #{val}" do
-            expect { validator.validate_preserve_hosts(val) }.to_not raise_error
+            expect { validator.validate_preserve_hosts(val) }.not_to raise_error
           end
 
           it "raises error when set to #{val.upcase}" do
@@ -98,18 +97,18 @@ module Beaker
           tag_includes = %w(can tommies should_error potatoes plant)
           tag_excludes = %w(joey long_running pants should_error)
 
-          expect {
+          expect do
             validator.validate_test_tags(tag_includes, [], tag_excludes)
-          }.to raise_error(ArgumentError)
+          end.to raise_error(ArgumentError)
         end
 
         it 'does not raise an error if tags do not overlap' do
           tag_includes = %w(horse dog cat)
           tag_excludes = %w(car truck train)
 
-          expect {
+          expect do
             validator.validate_test_tags(tag_includes, [], tag_excludes)
-          }.to_not raise_error
+          end.not_to raise_error
         end
 
         it 'raises an error if AND and OR are both used' do
@@ -118,19 +117,19 @@ module Beaker
           tag_and = %w(square)
           tag_or  = %w(circle)
 
-          expect {
+          expect do
             validator.validate_test_tags(tag_and, tag_or, [])
-          }.to raise_error(ArgumentError)
+          end.to raise_error(ArgumentError)
         end
       end
 
       describe '#validate_frictionless_roles' do
         it 'does nothing when roles are correct' do
-          expect { validator.validate_frictionless_roles(%w(frictionless)) }.to_not raise_error
-          expect { validator.validate_frictionless_roles(%w(frictionless agent)) }.to_not raise_error
-          expect { validator.validate_frictionless_roles(%w(frictionless test1)) }.to_not raise_error
-          expect { validator.validate_frictionless_roles(%w(frictionless a role)) }.to_not raise_error
-          expect { validator.validate_frictionless_roles(%w(frictionless frictionless some_role)) }.to_not raise_error
+          expect { validator.validate_frictionless_roles(%w(frictionless)) }.not_to raise_error
+          expect { validator.validate_frictionless_roles(%w(frictionless agent)) }.not_to raise_error
+          expect { validator.validate_frictionless_roles(%w(frictionless test1)) }.not_to raise_error
+          expect { validator.validate_frictionless_roles(%w(frictionless a role)) }.not_to raise_error
+          expect { validator.validate_frictionless_roles(%w(frictionless frictionless some_role)) }.not_to raise_error
         end
 
         it 'throws errors when roles conflict' do
@@ -144,7 +143,7 @@ module Beaker
 
       describe '#validate_master_count' do
         it 'does nothing when count is exactly 1' do
-          expect { validator.validate_master_count(1) }.to_not raise_error
+          expect { validator.validate_master_count(1) }.not_to raise_error
         end
 
         it 'throws errors when greater than 1' do
@@ -156,8 +155,8 @@ module Beaker
 
       describe '#validate_files' do
         it 'does not throw an error with non-empty list' do
-          expect { validator.validate_files(['filea'], '.') }.to_not raise_error
-          expect { validator.validate_files(%w(filea fileb), '.') }.to_not raise_error
+          expect { validator.validate_files(['filea'], '.') }.not_to raise_error
+          expect { validator.validate_files(%w(filea fileb), '.') }.not_to raise_error
         end
 
         it 'raises error when file list is empty' do
@@ -168,7 +167,7 @@ module Beaker
       describe '#validate_path' do
         it 'does not throw an error when path is valid' do
           FakeFS do
-            expect { validator.validate_path('.') }.to_not raise_error
+            expect { validator.validate_path('.') }.not_to raise_error
           end
         end
 
@@ -178,11 +177,11 @@ module Beaker
       end
 
       describe '#validate_platform' do
-        let(:valid_platform) { {'platform' => 'test1'} }
-        let(:blank_platform) { {'platform' => ''} }
+        let(:valid_platform) { { 'platform' => 'test1' } }
+        let(:blank_platform) { { 'platform' => '' } }
 
         it 'does not throw an error when host has a platform' do
-          expect { validator.validate_platform(valid_platform, 'vm1') }.to_not raise_error
+          expect { validator.validate_platform(valid_platform, 'vm1') }.not_to raise_error
         end
 
         it 'throws an error when platform is not included' do

data/spec/beaker/perf_spec.rb

@@ -2,21 +2,10 @@ require 'spec_helper'
 
 module Beaker
   describe Perf do
-
     context "When a Perf object is created" do
-      it 'creates a new Perf object' do
-        hosts = Array.new
-        options = Hash.new
-        options[:log_level] = :debug
-        my_logger = Beaker::Logger.new(options)
-        options[:logger] = my_logger
-        perf = Perf.new( hosts, options )
-        expect( perf ).to be_a_kind_of Perf
-      end
-
-      before(:each) do
+      before do
         @options = make_opts
-        @options[:collect_perf_data] = true
+        @options[:collect_perf_data] = 'normal'
         @options[:log_level] = :debug
         @options[:color] = false
         @my_io = StringIO.new
@@ -25,43 +14,53 @@ module Beaker
         @options[:logger] = @my_logger
       end
 
-      it 'creates a new Perf object with a single host, :collect_perf_data = true' do
-        hosts = [ make_host("myHost", @options) ]
+      it 'creates a new Perf object' do
+        hosts = []
+        options = {}
+        options[:log_level] = :debug
+        my_logger = Beaker::Logger.new(options)
+        options[:logger] = my_logger
+        perf = described_class.new(hosts, options)
+        expect(perf).to be_a described_class
+      end
+
+      it 'creates a new Perf object with a single host' do
+        hosts = [make_host("myHost", @options)]
         hosts.each { |host| host['platform'] = "centos-6-x86_64" }
         @my_logger.remove_destination(STDOUT)
-        perf = Perf.new( hosts, @options )
-        expect( perf ).to be_a_kind_of Perf
+        perf = described_class.new(hosts, @options)
+        expect(perf).to be_a described_class
         expect(@my_io.string).to match(/Setup perf on host: myHost/)
       end
 
-      it 'creates a new Perf object with multiple hosts, :collect_perf_data = true' do
-        hosts = [ make_host("myHost", @options), make_host("myOtherHost", @options) ]
+      it 'creates a new Perf object with multiple hosts' do
+        hosts = [make_host("myHost", @options), make_host("myOtherHost", @options)]
         hosts.each { |host| host['platform'] = "centos-6-x86_64" }
         @my_logger.remove_destination(STDOUT)
-        perf = Perf.new( hosts, @options )
-        expect( perf ).to be_a_kind_of Perf
+        perf = described_class.new(hosts, @options)
+        expect(perf).to be_a described_class
         expect(@my_io.string).to match(/Setup perf on host: myHost*\nSetup perf on host: myOtherHost/)
       end
 
-      it 'creates a new Perf object with multiple hosts, :collect_perf_data = true, SLES' do
-        hosts = [ make_host("myHost", @options), make_host("myOtherHost", @options), make_host("myThirdHost", @options) ]
+      it 'creates a new Perf object with multiple hosts, SLES' do
+        hosts = [make_host("myHost", @options), make_host("myOtherHost", @options), make_host("myThirdHost", @options)]
         hosts[0]['platform'] = "centos-6-x86_64"
         hosts[1]['platform'] = "sles-11-x86_64"
         hosts[2]['platform'] = "opensuse-15-x86_64"
         @my_logger.remove_destination(STDOUT)
-        perf = Perf.new( hosts, @options )
-        expect( perf ).to be_a_kind_of Perf
+        perf = described_class.new(hosts, @options)
+        expect(perf).to be_a described_class
         expect(@my_io.string).to match(/Setup perf on host: myHost\nSetup perf on host: myOtherHost/)
       end
     end
 
-    context "When testing is finished, :collect_perf_data = true" do
-      before(:each) do
+    context "When testing is finished" do
+      before do
         @options = make_opts
-        @options[:collect_perf_data] = true
+        @options[:collect_perf_data] = 'normal'
         @options[:log_level] = :debug
         @options[:color] = false
-        @hosts = [ make_host("myHost", @options), make_host("myOtherHost", @options) ]
+        @hosts = [make_host("myHost", @options), make_host("myOtherHost", @options)]
         @my_io = StringIO.new
         @my_logger = Beaker::Logger.new(@options)
         @my_logger.add_destination(@my_io)
@@ -71,8 +70,8 @@ module Beaker
       it "Does the Right Thing on Linux hosts" do
         @hosts[0]['platform'] = "centos-6-x86_64"
         @my_logger.remove_destination(STDOUT)
-        perf = Perf.new( @hosts, @options )
-        expect( perf ).to be_a_kind_of Perf
+        perf = described_class.new(@hosts, @options)
+        expect(perf).to be_a described_class
         perf.print_perf_info
         expect(@my_io.string).to match(/Setup perf on host: myHost\nSetup perf on host: myOtherHost\nPerf \(sysstat\) not supported on host: myOtherHost\nGetting perf data for host: myHost\nGetting perf data for host: myOtherHost\nPerf \(sysstat\) not supported on host: myOtherHost/)
       end
@@ -80,12 +79,11 @@ module Beaker
       it "Does the Right Thing on non-Linux hosts" do
         @hosts[0]['platform'] = "windows"
         @my_logger.remove_destination(STDOUT)
-        perf = Perf.new( @hosts, @options )
-        expect( perf ).to be_a_kind_of Perf
+        perf = described_class.new(@hosts, @options)
+        expect(perf).to be_a described_class
         perf.print_perf_info
         expect(@my_io.string).to match(/Setup perf on host: myHost\nPerf \(sysstat\) not supported on host: myHost\nSetup perf on host: myOtherHost\nPerf \(sysstat\) not supported on host: myOtherHost\nGetting perf data for host: myHost\nPerf \(sysstat\) not supported on host: myHost\nGetting perf data for host: myOtherHost\nPerf \(sysstat\) not supported on host: myOtherHost/)
       end
     end
-
   end
 end

data/spec/beaker/platform_spec.rb

@@ -2,43 +2,37 @@ require 'spec_helper'
 
 module Beaker
   describe Platform do
-
-    let( :logger )    { double( 'logger' ) }
-    let( :platform )  { Platform.new(@name) }
+    let(:logger)    { double('logger') }
+    let(:platform)  { described_class.new(@name) }
 
     context 'initialize' do
-
       describe "recognizes valid platforms" do
-
         it "accepts correctly formatted platform values" do
           @name = 'oracle-version-arch'
-          expect{ platform }.not_to raise_error
+          expect { platform }.not_to raise_error
         end
 
         it "rejects non-supported osfamilies" do
           @name = 'amazon6-version-arch'
-          expect{ platform }.to raise_error(ArgumentError)
+          expect { platform }.to raise_error(ArgumentError)
         end
 
         it "rejects platforms without version/arch" do
           @name = 'ubuntu-5'
-          expect{ platform }.to raise_error(ArgumentError)
+          expect { platform }.to raise_error(ArgumentError)
         end
 
         it "rejects platforms that do not have osfamily at start of string" do
           @name = 'o3l-r5-u6-x86'
-          expect{ platform }.to raise_error(ArgumentError)
+          expect { platform }.to raise_error(ArgumentError)
         end
-
       end
 
       describe "if platform does not have codename" do
-
         it "sets codename to nil" do
           @name = "centos-6.5-x86_64"
           expect(platform.codename).to be_nil
         end
-
       end
 
       describe "platforms with version and codename" do
@@ -57,95 +51,91 @@ module Beaker
     end
 
     context 'to_array' do
-
       it "converts Beaker::Platform object to array of its attribues" do
         @name = 'debian-7-somethingsomething'
-        expect( platform.to_array ).to be === ['debian', '7', 'somethingsomething', 'wheezy']
+        expect(platform.to_array).to be === %w[debian 7 somethingsomething wheezy]
       end
-
     end
 
     context 'with_version_codename' do
-
       it "can convert debian-11-xxx to debian-bullseye-xxx" do
         @name = 'debian-11-xxx'
-        expect( platform.with_version_codename ).to be === 'debian-bullseye-xxx'
+        expect(platform.with_version_codename).to be === 'debian-bullseye-xxx'
       end
 
       it "can convert debian-7-xxx to debian-wheezy-xxx" do
         @name = 'debian-7-xxx'
-        expect( platform.with_version_codename ).to be === 'debian-wheezy-xxx'
+        expect(platform.with_version_codename).to be === 'debian-wheezy-xxx'
       end
 
       it "can convert debian-6-xxx to debian-squeeze-xxx" do
         @name = 'debian-6-xxx'
-        expect( platform.with_version_codename ).to be === 'debian-squeeze-xxx'
+        expect(platform.with_version_codename).to be === 'debian-squeeze-xxx'
       end
 
       it "can convert ubuntu-2204-xxx to ubuntu-jammy-xxx" do
         @name = 'ubuntu-2204-xxx'
-	expect( platform.with_version_codename ).to be === 'ubuntu-jammy-xxx'
+        expect(platform.with_version_codename).to be === 'ubuntu-jammy-xxx'
       end
 
       it "can convert ubuntu-2004-xxx to ubuntu-focal-xxx" do
         @name = 'ubuntu-2004-xxx'
-        expect( platform.with_version_codename ).to be === 'ubuntu-focal-xxx'
+        expect(platform.with_version_codename).to be === 'ubuntu-focal-xxx'
       end
 
       it "can convert ubuntu-1604-xxx to ubuntu-xenial-xxx" do
         @name = 'ubuntu-1604-xxx'
-        expect( platform.with_version_codename ).to be === 'ubuntu-xenial-xxx'
-
+        expect(platform.with_version_codename).to be === 'ubuntu-xenial-xxx'
       end
+
       it "can convert ubuntu-1310-xxx to ubuntu-saucy-xxx" do
         @name = 'ubuntu-1310-xxx'
-        expect( platform.with_version_codename ).to be === 'ubuntu-saucy-xxx'
+        expect(platform.with_version_codename).to be === 'ubuntu-saucy-xxx'
       end
 
       it "can convert ubuntu-12.10-xxx to ubuntu-quantal-xxx" do
         @name = 'ubuntu-12.10-xxx'
-        expect( platform.with_version_codename ).to be === 'ubuntu-quantal-xxx'
+        expect(platform.with_version_codename).to be === 'ubuntu-quantal-xxx'
       end
 
       it "can convert ubuntu-10.04-xxx to ubuntu-lucid-xxx" do
         @name = 'ubuntu-10.04-xxx'
-        expect( platform.with_version_codename ).to be === 'ubuntu-lucid-xxx'
+        expect(platform.with_version_codename).to be === 'ubuntu-lucid-xxx'
       end
 
-      ['centos','redhat'].each do |p|
+      %w[centos redhat].each do |p|
         it "leaves #{p}-7-xxx alone" do
           @name = "#{p}-7-xxx"
-          expect( platform.with_version_codename ).to be === "#{p}-7-xxx"
+          expect(platform.with_version_codename).to be === "#{p}-7-xxx"
         end
       end
     end
 
     context 'with_version_number' do
-
       it "can convert debian-wheezy-xxx to debian-7-xxx" do
         @name = 'debian-wheezy-xxx'
-        expect( platform.with_version_number ).to be === 'debian-7-xxx'
+        expect(platform.with_version_number).to be === 'debian-7-xxx'
       end
 
       it "can convert debian-squeeze-xxx to debian-6-xxx" do
         @name = 'debian-squeeze-xxx'
-        expect( platform.with_version_number ).to be === 'debian-6-xxx'
+        expect(platform.with_version_number).to be === 'debian-6-xxx'
       end
 
       it "can convert ubuntu-saucy-xxx to ubuntu-1310-xxx" do
         @name = 'ubuntu-saucy-xxx'
-        expect( platform.with_version_number ).to be === 'ubuntu-1310-xxx'
+        expect(platform.with_version_number).to be === 'ubuntu-1310-xxx'
       end
 
       it "can convert ubuntu-quantal-xxx to ubuntu-1210-xxx" do
         @name = 'ubuntu-quantal-xxx'
-        expect( platform.with_version_number ).to be === 'ubuntu-1210-xxx'
+        expect(platform.with_version_number).to be === 'ubuntu-1210-xxx'
       end
 
-      ['centos','redhat'].each do |p|
+      %w[centos redhat].each do |p|
         it "leaves #{p}-7-xxx alone" do
           @name = "#{p}-7-xxx"
-          expect( platform.with_version_number ).to be === "#{p}-7-xxx"
+          expect(platform.with_version_number).to be === "#{p}-7-xxx"
         end
       end
     end
@@ -160,11 +150,11 @@ module Beaker
         if YAML.respond_to?(:unsafe_load)
           YAML.unsafe_load(YAML.dump(platform))
         else
-          YAML.load(YAML.dump(platform))
+          YAML.load(YAML.dump(platform)) # rubocop:disable Security/YAMLLoad
         end
       end
 
-      [:variant, :arch, :version, :codename].each do |field|
+      %i[variant arch version codename].each do |field|
         it "deserializes the '#{field}' field" do
           expect(round_tripped.send(field)).to eq platform.send(field)
         end

data/spec/beaker/shared/error_handler_spec.rb

@@ -3,38 +3,29 @@ require 'spec_helper'
 module Beaker
   module Shared
     describe ErrorHandler do
+      let(:backtrace) { "I'm the backtrace\nYes I am!\nI have important information" }
+      let(:logger)    { double('logger') }
 
-      let( :backtrace ) { "I'm the backtrace\nYes I am!\nI have important information" }
-      let( :logger )    { double( 'logger' ) }
-
-      before :each do
-        allow( logger ).to receive( :error ).and_return( true )
-        allow( logger ).to receive( :pretty_backtrace ).and_return( backtrace )
-
+      before do
+        allow(logger).to receive(:error).and_return(true)
+        allow(logger).to receive(:pretty_backtrace).and_return(backtrace)
       end
 
       context 'report_and_raise' do
-
         it "records the backtrace of the exception to the logger" do
           ex = Exception.new("ArgumentError")
-          allow( ex ).to receive( :backtrace ).and_return(backtrace)
+          allow(ex).to receive(:backtrace).and_return(backtrace)
           mesg = "I'm the extra message"
 
           backtrace.each_line do |line|
-            expect( logger ).to receive( :error ).with(line)
+            expect(logger).to receive(:error).with(line)
           end
 
-          expect( subject ).to receive( :raise ).once
+          expect(subject).to receive(:raise).once
 
           subject.report_and_raise(logger, ex, mesg)
-
         end
-
-
-
       end
-
     end
-
   end
 end