beaker 4.38.1 → 4.39.0

data/spec/beaker/host_spec.rb

@@ -16,7 +16,7 @@ module Beaker
     end
 
     it 'can be read like a hash' do
-      expect{ host['value'] }.to_not raise_error
+      expect{ host['value'] }.not_to raise_error
     end
 
     it 'can be written like a hash' do
@@ -29,39 +29,39 @@ module Beaker
 
       it "can be a pe host" do
         options['type'] = 'pe'
-        expect(host.is_pe?).to be_truthy
-        expect(host.use_service_scripts?).to be_truthy
-        expect(host.is_using_passenger?).to be_truthy
-        expect(host.graceful_restarts?).to be_falsy
+        expect(host).to be_is_pe
+        expect(host).to be_use_service_scripts
+        expect(host).to be_is_using_passenger
+        expect(host).not_to be_graceful_restarts
       end
 
       it "can be a foss-source host" do
-        expect(host.is_pe?).to be_falsy
-        expect(host.use_service_scripts?).to be_falsy
-        expect(host.is_using_passenger?).to be_falsy
+        expect(host).not_to be_is_pe
+        expect(host).not_to be_use_service_scripts
+        expect(host).not_to be_is_using_passenger
       end
 
       it "can be a foss-package host" do
         options['use-service'] = true
-        expect(host.is_pe?).to be_falsy
-        expect(host.use_service_scripts?).to be_truthy
-        expect(host.is_using_passenger?).to be_falsy
-        expect(host.graceful_restarts?).to be_falsy
+        expect(host).not_to be_is_pe
+        expect(host).to be_use_service_scripts
+        expect(host).not_to be_is_using_passenger
+        expect(host).not_to be_graceful_restarts
       end
 
       it "can be a foss-packaged host using passenger" do
         host.uses_passenger!
-        expect(host.is_pe?).to be_falsy
-        expect(host.use_service_scripts?).to be_truthy
-        expect(host.is_using_passenger?).to be_truthy
-        expect(host.graceful_restarts?).to be_truthy
+        expect(host).not_to be_is_pe
+        expect(host).to be_use_service_scripts
+        expect(host).to be_is_using_passenger
+        expect(host).to be_graceful_restarts
       end
 
       it 'can be an AIO host' do
         options['type'] = 'aio'
-        expect(host.is_pe?).to be_falsy
-        expect(host.use_service_scripts?).to be_falsy
-        expect(host.is_using_passenger?).to be_falsy
+        expect(host).not_to be_is_pe
+        expect(host).not_to be_use_service_scripts
+        expect(host).not_to be_is_using_passenger
       end
 
       it 'sets the paths correctly for an AIO host' do
@@ -74,7 +74,7 @@ module Beaker
       it "sets passenger property" do
         host.uses_passenger!
         expect(host['passenger']).to be_truthy
-        expect(host.is_using_passenger?).to be_truthy
+        expect(host).to be_is_using_passenger
       end
 
       it "sets puppetservice" do
@@ -91,28 +91,28 @@ module Beaker
     describe "graceful_restarts?" do
       it "is true if graceful-restarts property is set true" do
         options['graceful-restarts'] = true
-        expect(host.graceful_restarts?).to be_truthy
+        expect(host).to be_graceful_restarts
       end
 
       it "is false if graceful-restarts property is set false" do
         options['graceful-restarts'] = false
-        expect(host.graceful_restarts?).to be_falsy
+        expect(host).not_to be_graceful_restarts
       end
 
       it "is false if is_pe and graceful-restarts is nil" do
         options['type'] = 'pe'
-        expect(host.graceful_restarts?).to be_falsy
+        expect(host).not_to be_graceful_restarts
       end
 
       it "is true if is_pe and graceful-restarts is true" do
         options['type'] = 'pe'
         options['graceful-restarts'] = true
-        expect(host.graceful_restarts?).to be_truthy
+        expect(host).to be_graceful_restarts
       end
 
       it "falls back to passenger property if not pe and graceful-restarts is nil" do
         host.uses_passenger!
-        expect(host.graceful_restarts?).to be_truthy
+        expect(host).to be_graceful_restarts
       end
     end
 
@@ -199,17 +199,17 @@ module Beaker
 
     describe "executing commands" do
       let(:command) { Beaker::Command.new('ls') }
-      let(:host) { Beaker::Host.create('host', {}, make_host_opts('host', options.merge(platform))) }
+      let(:host) { described_class.create('host', {}, make_host_opts('host', options.merge(platform))) }
       let(:result) { Beaker::Result.new(host, 'ls') }
 
-      before :each do
+      before do
         result.stdout = 'stdout'
         result.stderr = 'stderr'
 
         logger = double(:logger)
         allow( logger ).to receive(:host_output)
         allow( logger ).to receive(:debug)
-        allow( logger ).to receive(:with_indent) { |&block| block.call }
+        allow( logger ).to receive(:with_indent).and_yield
         host.instance_variable_set :@logger, logger
         conn = double(:connection)
         allow( conn ).to receive(:execute).and_return(result)
@@ -221,12 +221,12 @@ module Beaker
 
       it 'takes a command object and a hash of options' do
         result.exit_code = 0
-        expect{ host.exec(command, {}) }.to_not raise_error
+        expect{ host.exec(command, {}) }.not_to raise_error
       end
 
       it 'acts on the host\'s logger and connection object' do
         result.exit_code = 0
-        expect( host.instance_variable_get(:@logger) ).to receive(:debug).at_least(1).times
+        expect( host.instance_variable_get(:@logger) ).to receive(:debug).at_least(:once)
         expect( host.instance_variable_get(:@connection) ).to receive(:execute).once
         host.exec(command)
       end
@@ -280,38 +280,43 @@ module Beaker
         }
         expect( host.logger ).to receive( :warn ).with( /overrides/ )
 
-        expect { host.exec(command, opts) }.to_not raise_error
+        expect { host.exec(command, opts) }.not_to raise_error
       end
 
       it 'explicitly closes the connection when :reset_connection is set' do
         expect( host ).to receive( :close )
-        expect { host.exec(command, :reset_connection => true) }.to_not raise_error
+        expect { host.exec(command, :reset_connection => true) }.not_to raise_error
       end
 
       context "controls the result objects logging" do
         it "and passes a test if the exit_code doesn't match the default :acceptable_exit_codes of 0" do
           result.exit_code = 0
-          expect{ host.exec(command,{}) }.to_not raise_error
+          expect{ host.exec(command,{}) }.not_to raise_error
         end
+
         it "and fails a test if the exit_code doesn't match the default :acceptable_exit_codes of 0" do
           result.exit_code = 1
           expect{ host.exec(command,{}) }.to raise_error
         end
+
         it "and passes a test if the exit_code matches :acceptable_exit_codes" do
           result.exit_code = 0
-          expect{ host.exec(command,{:acceptable_exit_codes => 0}) }.to_not raise_error
+          expect{ host.exec(command,{:acceptable_exit_codes => 0}) }.not_to raise_error
         end
+
         it "and fails a test if the exit_code doesn't match :acceptable_exit_codes" do
           result.exit_code = 0
           expect{ host.exec(command,{:acceptable_exit_codes => 1}) }.to raise_error
         end
+
         it "and passes a test if the exit_code matches one of the :acceptable_exit_codes" do
           result.exit_code = 127
-          expect{ host.exec(command,{:acceptable_exit_codes => [1,127]}) }.to_not raise_error
+          expect{ host.exec(command,{:acceptable_exit_codes => [1,127]}) }.not_to raise_error
         end
+
         it "and passes a test if the exit_code matches one of the range of :acceptable_exit_codes" do
           result.exit_code = 1
-          expect{ host.exec(command,{:acceptable_exit_codes => (0..127)}) }.to_not raise_error
+          expect{ host.exec(command,{:acceptable_exit_codes => (0..127)}) }.not_to raise_error
         end
       end
     end
@@ -401,7 +406,7 @@ module Beaker
         allow( conn ).to receive(:vmhostname).and_return(host['vmhostname'])
         allow( conn ).to receive(:hostname).and_return(host.name)
 
-        host.do_scp_to *args
+        host.do_scp_to(*args)
       end
 
       it 'calls for host scp post operations after SCPing happens' do
@@ -422,7 +427,7 @@ module Beaker
         allow( conn ).to receive(:hostname).and_return(host.name)
         expect( host ).to receive( :scp_post_operations ).ordered
 
-        host.do_scp_to *args
+        host.do_scp_to(*args)
       end
 
       it 'throws an IOError when the file given doesn\'t exist' do
@@ -433,7 +438,7 @@ module Beaker
         let( :source_path ) { '/repos/puppetlabs-inifile' }
         let( :target_path ) { '/etc/puppetlabs/modules/inifile' }
 
-        before :each do
+        before do
           test_dir = "#{source_path}/tests"
           other_test_dir = "#{source_path}/tests2"
 
@@ -449,6 +454,7 @@ module Beaker
           create_files( @fileset1 )
           create_files( @fileset2 )
         end
+
         it 'can take an ignore list that excludes all files and not call scp_to' do
           logger = host[:logger]
           conn = double(:connection)
@@ -460,8 +466,9 @@ module Beaker
           expect( host ).to receive( :mkdir_p ).exactly(0).times
           expect( conn ).to receive(:scp_to).exactly(0).times
 
-          host.do_scp_to *args
+          host.do_scp_to(*args)
         end
+
         it 'can take an ignore list that excludes a single file and scp the rest' do
           created_target_path = File.join(target_path, File.basename(source_path))
           exclude_file = '07_InstallCACerts.rb'
@@ -478,21 +485,21 @@ module Beaker
           expect( host ).to receive( :mkdir_p ).with("#{created_target_path}/tests2")
 
           (@fileset1 + @fileset2).each do |file|
-            if file !~ /#{exclude_file}/
+            if !/#{exclude_file}/.match?(file)
               file_args = [ file, File.join(created_target_path, File.dirname(file).gsub(source_path,'')), {:ignore => [exclude_file], :dry_run => false} ]
               conn_args = file_args
               expect( conn ).to receive(:scp_to).with( *conn_args ).and_return(Beaker::Result.new(host, 'output!'))
             else
               file_args = [ file, File.join(created_target_path, File.dirname(file).gsub(source_path,'')), {:ignore => [exclude_file], :dry_run => false} ]
               conn_args = file_args
-              expect( conn ).to_not receive(:scp_to).with( *conn_args )
+              expect( conn ).not_to receive(:scp_to).with( *conn_args )
             end
           end
           allow( conn ).to receive(:ip).and_return(host['ip'])
           allow( conn ).to receive(:vmhostname).and_return(host['vmhostname'])
           allow( conn ).to receive(:hostname).and_return(host.name)
 
-          host.do_scp_to *args
+          host.do_scp_to(*args)
         end
       end
 
@@ -500,7 +507,7 @@ module Beaker
         let( :source_path ) { '/puppetlabs-inifile' }
         let( :target_path ) { '/etc/puppetlabs/modules/inifile' }
 
-        before :each do
+        before do
           test_dir = "#{source_path}/tests"
           other_test_dir = "#{source_path}/tests/tests2"
           another_test_dir = "#{source_path}/tests/tests3"
@@ -520,7 +527,7 @@ module Beaker
           create_files( @fileset3 )
         end
 
-        it "should create target dirs with correct path seperator" do
+        it "creates target dirs with correct path seperator" do
           create_files(['source'])
           exclude_file = '04_ValidateSignCert.rb'
           logger = host[:logger]
@@ -538,27 +545,27 @@ module Beaker
           expect( host ).to receive( :mkdir_p ).with("#{created_target_path}/tests/tests3")
 
           (@fileset1 + @fileset2 + @fileset3).each do |file|
-            if file !~ /#{exclude_file}/
+            if !/#{exclude_file}/.match?(file)
               file_args = [ file, File.join(created_target_path, File.dirname(file).gsub(source_path,'')), {:ignore => [exclude_file], :dry_run => false} ]
               conn_args = file_args
               expect( conn ).to receive(:scp_to).with( *conn_args ).and_return(Beaker::Result.new(host, 'output!'))
             else
               file_args = [ file, File.join(created_target_path, File.dirname(file).gsub(source_path,'')), {:ignore => [exclude_file], :dry_run => false} ]
               conn_args = file_args
-              expect( conn ).to_not receive(:scp_to).with( *conn_args )
+              expect( conn ).not_to receive(:scp_to).with( *conn_args )
             end
           end
           allow( conn ).to receive(:ip).and_return(host['ip'])
           allow( conn ).to receive(:vmhostname).and_return(host['vmhostname'])
           allow( conn ).to receive(:hostname).and_return(host.name)
 
-          host.do_scp_to *args
+          host.do_scp_to(*args)
         end
       end
 
       context "using an ignore array" do
 
-        before :each do
+        before do
           test_dir = 'tmp/tests'
           other_test_dir = 'tmp/tests2'
 
@@ -586,7 +593,7 @@ module Beaker
           expect( host ).to receive( :mkdir_p ).exactly(0).times
           expect( conn ).to receive(:scp_to).exactly(0).times
 
-          host.do_scp_to *args
+          host.do_scp_to(*args)
         end
 
         it 'can take an ignore list that excludes a single file and scp the rest' do
@@ -603,20 +610,20 @@ module Beaker
           expect( host ).to receive( :mkdir_p ).with('target/tmp/tests')
           expect( host ).to receive( :mkdir_p ).with('target/tmp/tests2')
           (@fileset1 + @fileset2).each do |file|
-            if file !~ /#{exclude_file}/
+            if !/#{exclude_file}/.match?(file)
               file_args = [ file, File.join('target', File.dirname(file)), {:ignore => [exclude_file], :dry_run => false} ]
               conn_args = file_args
               expect( conn ).to receive(:scp_to).with( *conn_args ).and_return(Beaker::Result.new(host, 'output!'))
             else
               file_args = [ file, File.join('target', File.dirname(file)), {:ignore => [exclude_file], :dry_run => false} ]
               conn_args = file_args
-              expect( conn ).to_not receive(:scp_to).with( *conn_args )
+              expect( conn ).not_to receive(:scp_to).with( *conn_args )
             end
           end
           allow( conn ).to receive(:ip).and_return(host['ip'])
           allow( conn ).to receive(:vmhostname).and_return(host['vmhostname'])
           allow( conn ).to receive(:hostname).and_return(host.name)
-          host.do_scp_to *args
+          host.do_scp_to(*args)
         end
 
         it 'can take an ignore list that excludes a dir and scp the rest' do
@@ -630,12 +637,12 @@ module Beaker
           allow( Dir ).to receive( :glob ).and_return( @fileset1 + @fileset2 )
 
           expect( logger ).to receive(:trace)
-          expect( host ).to_not receive( :mkdir_p ).with('target/tmp/tests')
+          expect( host ).not_to receive( :mkdir_p ).with('target/tmp/tests')
           expect( host ).to receive( :mkdir_p ).with('target/tmp/tests2')
           (@fileset1).each do |file|
             file_args = [ file, File.join('target', File.dirname(file)), {:ignore => [exclude_file], :dry_run => false} ]
             conn_args = file_args
-            expect( conn ).to_not receive(:scp_to).with( *conn_args )
+            expect( conn ).not_to receive(:scp_to).with( *conn_args )
           end
           (@fileset2).each do |file|
             file_args = [ file, File.join('target', File.dirname(file)), {:ignore => [exclude_file], :dry_run => false} ]
@@ -646,7 +653,7 @@ module Beaker
           allow( conn ).to receive(:ip).and_return(host['ip'])
           allow( conn ).to receive(:vmhostname).and_return(host['vmhostname'])
           allow( conn ).to receive(:hostname).and_return(host.name)
-          host.do_scp_to *args
+          host.do_scp_to(*args)
         end
       end
     end
@@ -666,7 +673,7 @@ module Beaker
         allow( conn ).to receive(:ip).and_return(host['ip'])
         allow( conn ).to receive(:vmhostname).and_return(host['vmhostname'])
         allow( conn ).to receive(:hostname).and_return(host.name)
-        host.do_scp_from *args
+        host.do_scp_from(*args)
       end
     end
 
@@ -686,7 +693,7 @@ module Beaker
 
         expect( Rsync ).to receive(:run).with( *rsync_args ).and_return(Rsync::Result.new('raw rsync output', 0))
 
-        host.do_rsync_to *args
+        host.do_rsync_to(*args)
 
         expect(Rsync.host).to eq('root@default.ip.address')
       end
@@ -730,8 +737,8 @@ module Beaker
         rsync_args = ['source', 'target', ['-az', "-e \"ssh -i #{key} -p 22 -o 'StrictHostKeyChecking no'\"", "--exclude '.bundle'"]]
         expect(Rsync).to receive(:run).twice.with(*rsync_args).and_return(Rsync::Result.new('raw rsync output', 0))
 
-        host.do_rsync_to *args
-        host.do_rsync_to *args
+        host.do_rsync_to(*args)
+        host.do_rsync_to(*args)
       end
     end
 
@@ -746,14 +753,16 @@ module Beaker
           host.instance_variable_set :@connection, conn
           allow(host).to receive(:close).and_call_original
         end
+
         it 'does not raise an error' do
-          expect { host.close }.to_not raise_error
+          expect { host.close }.not_to raise_error
         end
       end
     end
 
     describe '#get_public_ip' do
-      let (:aws) { double('AWSmock')}
+      let(:aws) { double('AWSmock')}
+
       it 'calls upon the ec2 instance to get the ip address' do
         host.host_hash[:hypervisor] = 'ec2'
         host.host_hash[:instance] = aws
@@ -814,7 +823,7 @@ module Beaker
 
       it 'does not call get_ip when #get_public_ip returns an address' do
         allow( host ).to receive(:get_public_ip).and_return('127.0.0.1')
-        expect(host).to_not receive(:get_ip)
+        expect(host).not_to receive(:get_ip)
         expect(host.ip).to eq('127.0.0.1')
       end
     end

data/spec/beaker/hypervisor/hypervisor_spec.rb

@@ -4,8 +4,8 @@ module Beaker
   describe Hypervisor do
     let( :hosts ) { make_hosts( { :platform => 'el-5' } ) }
 
-    context "#create" do
-      let( :hypervisor ) { Beaker::Hypervisor }
+    describe "#create" do
+      let( :hypervisor ) { described_class }
 
       it "includes custom hypervisor and call set_ssh_connection_preference" do
         allow(hypervisor).to receive(:set_ssh_connection_preference).with([], hypervisor)
@@ -39,9 +39,9 @@ module Beaker
 
     end
 
-    context "#configure" do
+    describe "#configure" do
       let( :options ) { make_opts.merge({ 'logger' => double().as_null_object }) }
-      let( :hypervisor ) { Beaker::Hypervisor.new( hosts, options ) }
+      let( :hypervisor ) { described_class.new( hosts, options ) }
 
       context 'if :timesync option set true on host' do
         it 'does call timesync for host' do
@@ -67,7 +67,7 @@ module Beaker
           options[:timesync] = true
           hosts[0].options[:timesync] = false
           allow( hypervisor ).to receive( :set_env )
-          expect( hypervisor ).to_not receive( :timesync )
+          expect( hypervisor ).not_to receive( :timesync )
           hypervisor.configure
         end
       end
@@ -92,7 +92,7 @@ module Beaker
         it "does not call disable_iptables" do
           options[:disable_iptables] = false
           allow( hypervisor ).to receive( :set_env )
-          expect( hypervisor ).to receive( :disable_iptables ).never
+          expect( hypervisor ).not_to receive( :disable_iptables )
           hypervisor.configure
         end
       end
@@ -101,7 +101,7 @@ module Beaker
         it "calls disable_iptables once" do
           options[:disable_iptables] = true
           allow( hypervisor ).to receive( :set_env )
-          expect( hypervisor ).to receive( :disable_iptables ).exactly( 1 ).times
+          expect( hypervisor ).to receive( :disable_iptables ).once
           hypervisor.configure
         end
       end
@@ -119,7 +119,7 @@ module Beaker
         it "does not call disable_updates_puppetlabs_com" do
           options[:disable_updates] = false
           allow( hypervisor ).to receive( :set_env )
-          expect( hypervisor ).to receive( :disable_updates ).never
+          expect( hypervisor ).not_to receive( :disable_updates )
           hypervisor.configure
         end
       end
@@ -132,12 +132,12 @@ module Beaker
           options[:add_el_extras]     = true
           options[:disable_iptables]  = true
           options[:host_name_prefix]  = "test-"
-          expect( hypervisor ).to_not receive( :timesync )
-          expect( hypervisor ).to_not receive( :sync_root_keys )
-          expect( hypervisor ).to_not receive( :add_el_extras )
-          expect( hypervisor ).to_not receive( :disable_iptables )
-          expect( hypervisor ).to_not receive( :set_env )
-          expect( hypervisor ).to_not receive( :host_name_prefix )
+          expect( hypervisor ).not_to receive( :timesync )
+          expect( hypervisor ).not_to receive( :sync_root_keys )
+          expect( hypervisor ).not_to receive( :add_el_extras )
+          expect( hypervisor ).not_to receive( :disable_iptables )
+          expect( hypervisor ).not_to receive( :set_env )
+          expect( hypervisor ).not_to receive( :host_name_prefix )
           hypervisor.configure
         end
       end

data/spec/beaker/localhost_connection_spec.rb

@@ -3,18 +3,20 @@ require 'net/ssh'
 
 module Beaker
   describe LocalConnection do
+    subject(:connection) { described_class.new(options) }
+
     let( :options )   { { :logger => double('logger').as_null_object, :ssh_env_file => '/path/to/ssh/file'} }
-    subject(:connection) { LocalConnection.new(options) }
 
-    before :each do
+
+    before do
       allow( subject ).to receive(:sleep)
     end
 
     describe '#self.connect' do
       it 'loggs message' do
         expect(options[:logger]).to receive(:debug).with('Local connection, no connection to start')
-        connection_constructor = LocalConnection.connect(options)
-        expect( connection_constructor ).to be_a_kind_of LocalConnection
+        connection_constructor = described_class.connect(options)
+        expect( connection_constructor ).to be_a_kind_of described_class
       end
     end
 

data/spec/beaker/logger_junit_spec.rb

@@ -11,14 +11,14 @@ module Beaker
       it 'rejects all invalid values' do
         invalid_values = [0x8, 0x10, 0xB, 0x0019, 0xD800, 0xDFFF, 0xFFFE, 0x99999, 0x110000]
         invalid_values.each do |value|
-          expect( LoggerJunit.is_valid_xml(value) ).to be === false
+          expect( described_class.is_valid_xml(value) ).to be === false
         end
       end
 
       it 'accepts valid values' do
         valid_values = [0x9, 0xA, 0x0020, 0xD7FF, 0xE000, 0xFFFD, 0x100000, 0x10FFFF]
         valid_values.each do |value|
-          expect( LoggerJunit.is_valid_xml(value) ).to be === true
+          expect( described_class.is_valid_xml(value) ).to be === true
         end
       end
 
@@ -29,12 +29,12 @@ module Beaker
       it 'escapes invalid xml characters correctly' do
         testing_string = 'pants'
         testing_string << 0x8
-        expect( LoggerJunit.escape_invalid_xml_chars(testing_string) ).to be === 'pants\8'
+        expect( described_class.escape_invalid_xml_chars(testing_string) ).to be === 'pants\8'
       end
 
       it 'leaves a string of all valid xml characters alone' do
         testing_string = 'pants man, pants!'
-        expect( LoggerJunit.escape_invalid_xml_chars(testing_string) ).to be === testing_string
+        expect( described_class.escape_invalid_xml_chars(testing_string) ).to be === testing_string
       end
 
     end
@@ -42,16 +42,16 @@ module Beaker
     describe '#copy_stylesheet_into_xml_dir' do
 
       it 'copies the stylesheet into the correct location' do
-        allow( File ).to receive( :file? ) { false }
+        allow( File ).to receive( :file? ).and_return(false)
         correct_location = File.join(File.dirname(xml_file), File.basename(stylesheet))
         expect( FileUtils ).to receive( :copy ).with( stylesheet, correct_location )
-        LoggerJunit.copy_stylesheet_into_xml_dir(stylesheet, xml_file)
+        described_class.copy_stylesheet_into_xml_dir(stylesheet, xml_file)
       end
 
       it 'skips action if the file doesn\'t exist' do
-        allow( File ).to receive( :file? ) { true }
+        allow( File ).to receive( :file? ).and_return(true)
         expect( FileUtils ).not_to receive( :copy )
-        LoggerJunit.copy_stylesheet_into_xml_dir(stylesheet, xml_file)
+        described_class.copy_stylesheet_into_xml_dir(stylesheet, xml_file)
       end
 
     end
@@ -60,10 +60,9 @@ module Beaker
 
       it 'opens the given file for writing, and writes the doc to it' do
         mock_doc = Object.new
-        doc_xml = 'flibbity-floo'
         allow( mock_doc ).to receive( :write ).with(File, 2)
         expect( File ).to receive( :open ).with( xml_file, 'w' )
-        LoggerJunit.finish(mock_doc, xml_file)
+        described_class.finish(mock_doc, xml_file)
       end
 
     end
@@ -71,19 +70,19 @@ module Beaker
     describe '#write_xml' do
 
       it 'throws an error with 1-arity in the given block' do
-        allow( LoggerJunit ).to receive( :get_xml_contents )
-        expect{ LoggerJunit.write_xml(xml_file, stylesheet) do |hey| end }.to raise_error(ArgumentError)
+        allow( described_class ).to receive( :get_xml_contents )
+        expect{ described_class.write_xml(xml_file, stylesheet) do |hey| end }.to raise_error(ArgumentError)
       end
 
       it 'doesn\'t throw an error with 2-arity in the given block' do
-        allow( LoggerJunit ).to receive( :get_xml_contents )
-        allow( LoggerJunit ).to receive( :finish )
-        expect{ LoggerJunit.write_xml(xml_file, stylesheet) do |hey1, hey2| end }.not_to raise_error
+        allow( described_class ).to receive( :get_xml_contents )
+        allow( described_class ).to receive( :finish )
+        expect{ described_class.write_xml(xml_file, stylesheet) do |hey1, hey2| end }.not_to raise_error
       end
 
       it 'throws an error with 3-arity in the given block' do
-        allow( LoggerJunit ).to receive( :get_xml_contents )
-        expect{ LoggerJunit.write_xml(xml_file, stylesheet) do |hey1, hey2, hey3| end }.to raise_error(ArgumentError)
+        allow( described_class ).to receive( :get_xml_contents )
+        expect{ described_class.write_xml(xml_file, stylesheet) do |hey1, hey2, hey3| end }.to raise_error(ArgumentError)
       end
 
     end