beaker 1.21.0 → 2.0.0

data/spec/beaker/command_spec.rb

@@ -42,53 +42,42 @@ module Beaker
     end
 
     describe '#environment_string_for' do
+      let(:host) { {'pathseparator' => ':'} }
+
       it 'returns a blank string if theres no env' do
-        expect( subject.environment_string_for({}, {}) ).to be == ''
+        expect( subject.environment_string_for(host, {}) ).to be == ''
       end
 
       it 'takes an env hash with var_name/value pairs' do
-        expect( subject.environment_string_for({}, {:HOME => '/'}) ).
-          to be == 'env HOME="/"'
+        expect( subject.environment_string_for(host, {:HOME => '/'}) ).
+          to be == "env HOME=\"/\""
       end
 
       it 'takes an env hash with var_name/value[Array] pairs' do
-        expect( subject.environment_string_for({}, {:LD_PATH => ['/', '/tmp']}) ).
-          to be == 'env LD_PATH="/:/tmp"'
-      end
-
-      it 'takes var_names where there is an array of default values' do
-        env = {:PATH => { :default => [ '/bin', '/usr/bin' ] } }
-        expect( subject.environment_string_for({}, env) ).
-          to be == 'env PATH="/bin:/usr/bin"'
-
+        expect( subject.environment_string_for(host, {:LD_PATH => ['/', '/tmp']}) ).
+          to be == "env LD_PATH=\"/:/tmp\""
       end
+    end
 
-      it 'takes var_names where there is an array of host specific values' do
-        host = { 'pe_path' => '/opt/puppet/bin', 'foss_path' => '/usr/bin' }
-        env = {:PATH => { :host => [ 'pe_path', 'foss_path' ] } }
-        expect( subject.environment_string_for( host, env ) ).
-          to be == 'env PATH="/opt/puppet/bin:/usr/bin"'
+  end
+  describe HostCommand do
+    let(:command) { @command || '/bin/ls' }
+    let(:args)    { @args    || Array.new }
+    let(:options) { @options || Hash.new  }
+    subject(:cmd) { HostCommand.new( command, args, options ) }
+    let(:host)    { Hash.new }
 
-      end
-      it 'when using an array of values it allows to specify the separator' do
-        host = { 'whoosits_separator' => ' **sparkles** ' }
-        env = {
-          :WHOOSITS => {
-            :default => [ 'whatsits', 'wonkers' ],
-            :opts => {:separator => {:host => 'whoosits_separator' } }
-          }
-        }
-        expect( subject.environment_string_for( host, env ) ).
-          to be == 'env WHOOSITS="whatsits **sparkles** wonkers"'
-      end
+    it 'returns a simple string passed in' do
+      @command = "pants"
+      expect( cmd.cmd_line host ).to be === @command
     end
-
-    describe '#parse_env_hash_for' do
-      it 'has too many responsiblities' do
-        env = { :PATH => { :default => [ '/bin', '/usr/bin' ] } }
-        var_array = cmd.parse_env_hash_for host, env
-        expect( var_array ).to be == [ 'PATH="/bin:/usr/bin"' ]
-      end
+    it 'returns single quoted string correctly' do
+      @command = "str_p = 'pants'; str_p"
+      expect( cmd.cmd_line host ).to be === @command
+    end
+    it 'returns empty strings when given the escaped version of the same' do
+      @command = "\"\""
+      expect( cmd.cmd_line host ).to be === ""
     end
   end
 end

data/spec/beaker/dsl/assertions_spec.rb

@@ -20,12 +20,12 @@ CONSOLE
 CONSOLE
 
       result = double
-      result.should_receive( :nil? ).at_least( :once ).and_return( false )
-      result.should_receive( :stdout ).and_return( stdout )
-      result.should_receive( :output ).and_return( stdout )
-      result.should_receive( :stderr ).and_return( '' )
+      expect( result ).to receive( :nil? ).at_least( :once ).and_return( false )
+      expect( result ).to receive( :stdout ).and_return( stdout )
+      expect( result ).to receive( :output ).and_return( stdout )
+      expect( result ).to receive( :stderr ).and_return( '' )
 
-      subject.should_receive( :result ).at_least( :once ).and_return( result )
+      expect( subject ).to receive( :result ).at_least( :once ).and_return( result )
       expect { subject.assert_output expectation }.to_not raise_error
     end
 
@@ -52,51 +52,44 @@ STDERR
 EXPECT
 
       result = double
-      result.should_receive( :nil? ).at_least( :once ).and_return( false )
-      result.should_receive( :stdout ).and_return( stdout )
-      result.should_receive( :output ).and_return( output )
-      result.should_receive( :stderr ).and_return( stderr )
+      expect( result ).to receive( :nil? ).at_least( :once ).and_return( false )
+      expect( result ).to receive( :stdout ).and_return( stdout )
+      expect( result ).to receive( :output ).and_return( output )
+      expect( result ).to receive( :stderr ).and_return( stderr )
 
-      subject.should_receive( :result ).at_least( :once ).and_return( result )
+      expect( subject ).to receive( :result ).at_least( :once ).and_return( result )
       expect { subject.assert_output expectation }.to_not raise_error
     end
 
     it 'raises an approriate error when output does not match expectations' do
-      output = <<OUTPUT
+      FakeFS.without do
+        output = <<OUTPUT
 This is on stdout
 Holy Crap, what HAPPENED!?!?!?
 And THIS is again on stdout
 OUTPUT
 
-      stdout = <<STDOUT
+        stdout = <<STDOUT
 This is on stdout
 And THIS is again on stdout
 STDOUT
 
-      stderr = <<STDERR
+        stderr = <<STDERR
 Holy Crap, what HAPPENED!?!?!?
 STDERR
 
-      expectation = <<EXPECT
+        expectation = <<EXPECT
         STDOUT> This is on stdout
         STDERR> While this is on stderr
         STDOUT> And THIS is again on stdout
 EXPECT
+        result = double
+        expect( result ).to receive( :nil? ).at_least( :once ).and_return( false )
+        expect( result ).to receive( :output ).and_return( output )
 
-      require 'rbconfig'
-      ruby_conf = defined?(RbConfig) ? RbConfig::CONFIG : Config::CONFIG
-      if ruby_conf['MINOR'].to_i == 8
-        exception = Test::Unit::AssertionFailedError
-      else
-        exception = MiniTest::Assertion
+        expect( subject ).to receive( :result ).at_least( :once ).and_return( result )
+        expect { subject.assert_output expectation }.to raise_error( MiniTest::Assertion )
       end
-
-      result = double
-      result.should_receive( :nil? ).at_least( :once ).and_return( false )
-      result.should_receive( :output ).and_return( output )
-
-      subject.should_receive( :result ).at_least( :once ).and_return( result )
-      expect { subject.assert_output expectation }.to raise_error( exception )
     end
   end
 end

data/spec/beaker/dsl/ezbake_utils_spec.rb

@@ -25,7 +25,7 @@ class ClassMixedWithEZBakeUtils
   end
 
   def logger
-    @logger ||= RSpec::Mocks::Mock.new('logger').as_null_object
+    @logger ||= RSpec::Mocks::Double.new('logger').as_null_object
   end
 end
 
@@ -107,7 +107,7 @@ describe ClassMixedWithEZBakeUtils do
     end
 
     it "initializes EZBakeUtils.config" do
-      Dir.stub( :chdir ).and_yield()
+      allow( Dir ).to receive( :chdir ).and_yield()
       allow(subject).to receive(:conditionally_clone) { true }
 
       expect(subject).to receive(:`).with(/^lein.*/).ordered
@@ -191,7 +191,7 @@ describe ClassMixedWithEZBakeUtils do
     end
 
     it "raises an exception for unsupported *nix-like platforms" do
-      Dir.stub( :chdir ).and_yield()
+      allow( Dir ).to receive( :chdir ).and_yield()
       install_from_ezbake_common_expects
       expect{ 
         subject.install_from_ezbake host, "blah", "blah"
@@ -201,7 +201,7 @@ describe ClassMixedWithEZBakeUtils do
     context "When Beaker::DSL::EZBakeUtils.config is nil" do
       let( :platform ) { Beaker::Platform.new('el-7-i386') }
       before do
-        Dir.stub( :chdir ).and_yield()
+        allow( Dir ).to receive( :chdir ).and_yield()
         subject.wipe_out_ezbake_config
       end
 
@@ -220,7 +220,7 @@ describe ClassMixedWithEZBakeUtils do
     context "When Beaker::DSL::EZBakeUtils.config is a hash" do
       let( :platform ) { Beaker::Platform.new('el-7-i386') }
       before do
-        Dir.stub( :chdir ).and_yield()
+        allow( Dir ).to receive( :chdir ).and_yield()
         subject.initialize_ezbake_config
       end
 

data/spec/beaker/dsl/helpers_spec.rb

@@ -7,14 +7,15 @@ class ClassMixedWithDSLHelpers
   include Beaker::DSL::Patterns
 
   def logger
-    @logger ||= RSpec::Mocks::Mock.new('logger').as_null_object
+    RSpec::Mocks::Double.new('logger').as_null_object
   end
+
 end
 
 describe ClassMixedWithDSLHelpers do
-  let( :opts )     { Beaker::Options::Presets.env_vars }
-  let( :command )  { 'ls' }
-  let( :host ) { double.as_null_object }
+  let( :opts )   { Beaker::Options::Presets.env_vars }
+  let( :command ){ 'ls' }
+  let( :host )   { double.as_null_object }
   let( :result ) { Beaker::Result.new( host, command ) }
 
   let( :master ) { make_host( 'master',   :roles => %w( master agent default)    ) }
@@ -22,7 +23,7 @@ describe ClassMixedWithDSLHelpers do
   let( :custom ) { make_host( 'custom',   :roles => %w( custom agent )    ) }
   let( :dash )   { make_host( 'console',  :roles => %w( dashboard agent ) ) }
   let( :db )     { make_host( 'db',       :roles => %w( database agent )  ) }
-  let( :hosts ) { [ master, agent, dash, db, custom ] }
+  let( :hosts )  { [ master, agent, dash, db, custom ] }
 
   describe '#on' do
 
@@ -33,38 +34,38 @@ describe ClassMixedWithDSLHelpers do
     end
 
     it 'allows the environment the command is run within to be specified' do
-      subject.stub( :hosts ).and_return( hosts )
+      allow( subject ).to receive( :hosts ).and_return( hosts )
 
-      Beaker::Command.should_receive( :new ).
+      expect( Beaker::Command ).to receive( :new ).
         with( 'ls ~/.bin', [], {'ENV' => { :HOME => '/tmp/test_home' }} )
 
       subject.on( host, 'ls ~/.bin', :environment => {:HOME => '/tmp/test_home' } )
     end
 
     it 'if the host is a String Object, finds the matching hosts with that String as role' do
-      subject.stub( :hosts ).and_return( hosts )
+      allow( subject ).to receive( :hosts ).and_return( hosts )
 
-      master.should_receive( :exec ).once
+      expect( master ).to receive( :exec ).once
 
       subject.on( 'master', 'echo hello')
 
     end
 
     it 'if the host is a Symbol Object, finds the matching hsots with that Symbol as role' do
-      subject.stub( :hosts ).and_return( hosts )
+      allow( subject ).to receive( :hosts ).and_return( hosts )
 
-      master.should_receive( :exec ).once
+      expect( master ).to receive( :exec ).once
 
       subject.on( :master, 'echo hello')
 
     end
 
     it 'delegates to itself for each host passed' do
-      subject.stub( :hosts ).and_return( hosts )
+      allow( subject ).to receive( :hosts ).and_return( hosts )
       expected = []
       hosts.each_with_index do |host, i|
         expected << i
-        host.should_receive( :exec ).and_return( i )
+        expect( host ).to receive( :exec ).and_return( i )
       end
 
       results = subject.on( hosts, command )
@@ -73,8 +74,8 @@ describe ClassMixedWithDSLHelpers do
 
     context 'upon command completion' do
       before :each do
-        subject.stub( :hosts ).and_return( hosts )
-        host.should_receive( :exec ).and_return( result )
+        allow( subject ).to receive( :hosts ).and_return( hosts )
+        expect( host ).to receive( :exec ).and_return( result )
         @res = subject.on( host, command )
       end
 
@@ -97,8 +98,8 @@ describe ClassMixedWithDSLHelpers do
 
     context 'when passed a block with arity of 1' do
       before :each do
-        subject.stub( :hosts ).and_return( hosts )
-        host.should_receive( :exec ).and_return( result )
+        allow( subject ).to receive( :hosts ).and_return( hosts )
+        expect( host ).to receive( :exec ).and_return( result )
       end
 
       it 'yields result' do
@@ -129,8 +130,8 @@ describe ClassMixedWithDSLHelpers do
 
     context 'when passed a block with arity of 0' do
       before :each do
-        subject.stub( :hosts ).and_return( hosts )
-        host.should_receive( :exec ).and_return( result )
+        allow( subject ).to receive( :hosts ).and_return( hosts )
+        expect( host ).to receive( :exec ).and_return( result )
       end
 
       it 'yields self' do
@@ -161,11 +162,69 @@ describe ClassMixedWithDSLHelpers do
 
   end
 
+  describe "#retry_on" do
+    it 'fails correctly when command never succeeds' do
+      result.stdout = 'stdout'
+      result.stderr = 'stderr'
+      result.exit_code = 1
+
+      retries = 5
+
+      opts = {
+        :max_retries    => retries,
+        :retry_interval => 0.0001,
+      }
+
+      allow( subject ).to receive(:on).and_return(result)
+      expect( subject ).to receive(:on).exactly(retries+2)
+      expect { subject.retry_on(host, command, opts) }.to raise_error(RuntimeError)
+    end
+
+    it 'will return success correctly if it succeeds the first time' do
+      result.stdout = 'stdout'
+      result.stderr = 'stderr'
+      result.exit_code = 0
+
+      opts = {
+        :max_retries    => 5,
+        :retry_interval => 0.0001,
+      }
+
+      allow( subject ).to receive(:on).and_return(result)
+      expect( subject ).to receive(:on).once
+
+      result_given = subject.retry_on(host, command, opts)
+      expect(result_given.exit_code).to be === 0
+    end
+
+    it 'will return success correctly if it succeeds after failing a few times' do
+      result.stdout = 'stdout'
+      result.stderr = 'stderr'
+
+      opts = {
+        :max_retries    => 10,
+        :retry_interval => 0.1,
+      }
+
+      reps_num = 4
+      count = 0
+      allow( subject ).to receive(:on) do
+        result.exit_code = count > reps_num ? 0 : 1
+        count += 1
+        result
+      end
+      expect( subject ).to receive(:on).exactly(reps_num + 2)
+
+      result_given = subject.retry_on(host, command, opts)
+      expect(result_given.exit_code).to be === 0
+    end
+  end
+
   describe "shell" do
     it 'delegates to #on with the default host' do
-      subject.stub( :hosts ).and_return( hosts )
+      allow( subject ).to receive( :hosts ).and_return( hosts )
 
-      subject.should_receive( :on ).with( master, "echo hello", {}).once
+      expect( subject ).to receive( :on ).with( master, "echo hello", {}).once
 
       subject.shell( "echo hello" )
     end
@@ -173,12 +232,12 @@ describe ClassMixedWithDSLHelpers do
 
   describe '#scp_from' do
     it 'delegates to the host' do
-      subject.stub( :hosts ).and_return( hosts )
-      subject.should_receive( :logger ).exactly( hosts.length ).times
-      result.should_receive( :log ).exactly( hosts.length ).times
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :logger ).exactly( hosts.length ).times
+      expect( result ).to receive( :log ).exactly( hosts.length ).times
 
       hosts.each do |host|
-        host.should_receive( :do_scp_from ).and_return( result )
+        expect( host ).to receive( :do_scp_from ).and_return( result )
       end
 
       subject.scp_from( hosts, '/var/log/my.log', 'log/my.log' )
@@ -187,12 +246,12 @@ describe ClassMixedWithDSLHelpers do
 
   describe '#scp_to' do
     it 'delegates to the host' do
-      subject.stub( :hosts ).and_return( hosts )
-      subject.should_receive( :logger ).exactly( hosts.length ).times
-      result.should_receive( :log ).exactly( hosts.length ).times
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :logger ).exactly( hosts.length ).times
+      expect( result ).to receive( :log ).exactly( hosts.length ).times
 
       hosts.each do |host|
-        host.should_receive( :do_scp_to ).and_return( result )
+        expect( host ).to receive( :do_scp_to ).and_return( result )
       end
 
       subject.scp_to( hosts, '/var/log/my.log', 'log/my.log' )
@@ -204,14 +263,14 @@ describe ClassMixedWithDSLHelpers do
       my_opts = { :silent => true }
       tmpfile = double
 
-      tmpfile.should_receive( :path ).exactly( 2 ).times.
+      expect( tmpfile ).to receive( :path ).exactly( 2 ).times.
         and_return( '/local/path/to/blah' )
 
-      Tempfile.should_receive( :open ).and_yield( tmpfile )
+      expect( Tempfile ).to receive( :open ).and_yield( tmpfile )
 
-      File.should_receive( :open )
+      expect( File ).to receive( :open )
 
-      subject.should_receive( :scp_to ).
+      expect( subject ).to receive( :scp_to ).
         with( hosts, '/local/path/to/blah', '/remote/path', my_opts )
 
       subject.create_remote_file( hosts, '/remote/path', 'blah', my_opts )
@@ -219,7 +278,7 @@ describe ClassMixedWithDSLHelpers do
   end
 
   describe '#create_tmpdir_for_user' do
-    let(:host) { double.as_null_object }
+    let(:host) { {} }
     let(:result) { double.as_null_object }
 
     before :each do
@@ -233,9 +292,10 @@ describe ClassMixedWithDSLHelpers do
       context 'with no path name argument' do
         context 'without puppet installed on host' do
           it 'raises an error' do
-            allow(host).to receive(:tmpdir).and_return("tmpdirname")
+            cmd = "the command"
             allow(result).to receive(:exit_code).and_return(1)
-            expect(subject).to receive(:on).with(host, /^puppet.*/).and_return(result)
+            expect(Beaker::Command).to receive(:new).with(/puppet master --configprint user/, [], {"ENV"=>{}, :cmdexe=>true}).and_return(cmd)
+            expect(subject).to receive(:on).with(host, cmd).and_return(result)
             expect{
               subject.create_tmpdir_for_user host
             }.to raise_error(RuntimeError, /`puppet master --configprint` failed,/)
@@ -243,7 +303,9 @@ describe ClassMixedWithDSLHelpers do
         end
         context 'with puppet installed on host' do
           it 'executes chown once' do
-            expect(subject).to receive(:on).with(host, /^puppet.*/).and_return(result)
+            cmd = "the command"
+            expect(Beaker::Command).to receive(:new).with(/puppet master --configprint user/, [], {"ENV"=>{}, :cmdexe=>true}).and_return(cmd)
+            expect(subject).to receive(:on).with(host, cmd).and_return(result)
             expect(subject).to receive(:on).with(host, /^getent passwd puppet/).and_return(result)
             expect(host).to receive(:tmpdir).with(/\/tmp\/beaker.*/)
             expect(subject).to receive(:on).with(host, /chown puppet.puppet.*/)
@@ -254,7 +316,9 @@ describe ClassMixedWithDSLHelpers do
 
       context 'with path name argument' do
         it 'executes chown once' do
-          expect(subject).to receive(:on).with(host, /^puppet.*/).and_return(result)
+          cmd = "the command"
+          expect(Beaker::Command).to receive(:new).with(/puppet master --configprint user/, [], {"ENV"=>{}, :cmdexe=>true}).and_return(cmd)
+          expect(subject).to receive(:on).with(host, cmd).and_return(result)
           expect(subject).to receive(:on).with(host, /^getent passwd puppet/).and_return(result)
           expect(host).to receive(:tmpdir).with(/\/tmp\/bogus.*/).and_return("/tmp/bogus")
           expect(subject).to receive(:on).with(host, /chown puppet.puppet \/tmp\/bogus.*/)
@@ -288,17 +352,17 @@ describe ClassMixedWithDSLHelpers do
 
   describe '#run_script_on' do
     it 'scps the script to a tmpdir and executes it on host(s)' do
-      subject.should_receive( :scp_to )
-      subject.should_receive( :on )
+      expect( subject ).to receive( :scp_to )
+      expect( subject ).to receive( :on )
       subject.run_script_on( 'host', '~/.bin/make-enterprisy' )
     end
   end
 
   describe '#run_script' do
     it 'delegates to #run_script_on with the default host' do
-      subject.stub( :hosts ).and_return( hosts )
+      allow( subject ).to receive( :hosts ).and_return( hosts )
 
-      subject.should_receive( :run_script_on ).with( master, "/tmp/test.sh", {}).once
+      expect( subject ).to receive( :run_script_on ).with( master, "/tmp/test.sh", {}).once
 
       subject.run_script( '/tmp/test.sh' )
     end
@@ -307,22 +371,22 @@ describe ClassMixedWithDSLHelpers do
   describe 'confine' do
     let(:logger) { double.as_null_object }
     before do
-      subject.stub( :logger ).and_return( logger )
+      allow( subject ).to receive( :logger ).and_return( logger )
     end
 
     it 'skips the test if there are no applicable hosts' do
-      subject.stub( :hosts ).and_return( [] )
-      subject.stub( :hosts= )
-      logger.should_receive( :warn )
-      subject.should_receive( :skip_test ).
+      allow( subject ).to receive( :hosts ).and_return( [] )
+      allow( subject ).to receive( :hosts= )
+      expect( logger ).to receive( :warn )
+      expect( subject ).to receive( :skip_test ).
         with( 'No suitable hosts found' )
 
       subject.confine( :to, {} )
     end
 
     it 'raises when given mode is not :to or :except' do
-      subject.stub( :hosts )
-      subject.stub( :hosts= )
+      allow( subject ).to receive( :hosts )
+      allow( subject ).to receive( :hosts= )
 
       expect {
         subject.confine( :regardless, {:thing => 'value'} )
@@ -332,8 +396,8 @@ describe ClassMixedWithDSLHelpers do
     it 'rejects hosts that do not meet simple hash criteria' do
       hosts = [ {'thing' => 'foo'}, {'thing' => 'bar'} ]
 
-      subject.should_receive( :hosts ).and_return( hosts )
-      subject.should_receive( :hosts= ).
+      expect( subject ).to receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :hosts= ).
         with( [ {'thing' => 'foo'} ] )
 
       subject.confine :to, :thing => 'foo'
@@ -342,8 +406,8 @@ describe ClassMixedWithDSLHelpers do
     it 'rejects hosts that match a list of criteria' do
       hosts = [ {'thing' => 'foo'}, {'thing' => 'bar'}, {'thing' => 'baz'} ]
 
-      subject.should_receive( :hosts ).and_return( hosts )
-      subject.should_receive( :hosts= ).
+      expect( subject ).to receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :hosts= ).
         with( [ {'thing' => 'bar'} ] )
 
       subject.confine :except, :thing => ['foo', 'baz']
@@ -357,15 +421,15 @@ describe ClassMixedWithDSLHelpers do
       ret2 = (Struct.new('Result2', :stdout)).new('a_zone')
       hosts = [ host1, host2, host3 ]
 
-      subject.should_receive( :hosts ).and_return( hosts )
-      subject.should_receive( :on ).
+      expect( subject ).to receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :on ).
         with( host1, '/sbin/zonename' ).
         and_return( ret1 )
-      subject.should_receive( :on ).
+      expect( subject ).to receive( :on ).
         with( host1, '/sbin/zonename' ).
         and_return( ret2 )
 
-      subject.should_receive( :hosts= ).with( [ host1 ] )
+      expect( subject ).to receive( :hosts= ).with( [ host1 ] )
 
       subject.confine :to, :platform => 'solaris' do |host|
         subject.on( host, '/sbin/zonename' ).stdout =~ /:global/
@@ -376,7 +440,7 @@ describe ClassMixedWithDSLHelpers do
   describe '#select_hosts' do
     let(:logger) { double.as_null_object }
     before do
-      subject.stub( :logger ).and_return( logger )
+      allow( subject ).to receive( :logger ).and_return( logger )
     end
 
     it 'it returns an empty array if there are no applicable hosts' do
@@ -395,13 +459,15 @@ describe ClassMixedWithDSLHelpers do
       host1 = {'platform' => 'solaris1'}
       host2 = {'platform' => 'solaris2'}
       host3 = {'platform' => 'windows'}
-      ret1 = (Struct.new('Result1', :stdout)).new(':global')
-      ret2 = (Struct.new('Result2', :stdout)).new('a_zone')
+      ret1 = double('result1')
+      allow( ret1 ).to receive( :stdout ).and_return(':global')
+      ret2 = double('result2')
+      allow( ret2 ).to receive( :stdout ).and_return('a_zone')
       hosts = [ host1, host2, host3 ]
-      subject.should_receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :hosts ).and_return( hosts )
 
-      subject.should_receive( :on ).with( host1, '/sbin/zonename' ).once.and_return( ret1 )
-      subject.should_receive( :on ).with( host2, '/sbin/zonename' ).once.and_return( ret2 )
+      expect( subject ).to receive( :on ).with( host1, '/sbin/zonename' ).once.and_return( ret1 )
+      expect( subject ).to receive( :on ).with( host2, '/sbin/zonename' ).once.and_return( ret2 )
 
       selected_hosts = subject.select_hosts 'platform' => 'solaris' do |host|
                              subject.on(host, '/sbin/zonename').stdout =~ /:global/
@@ -412,13 +478,13 @@ describe ClassMixedWithDSLHelpers do
 
   describe '#apply_manifest_on' do
     it 'calls puppet' do
-      subject.stub( :hosts ).and_return( hosts )
-      subject.should_receive( :create_remote_file ).and_return( true )
-      subject.should_receive( :puppet ).
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :create_remote_file ).and_return( true )
+      expect( subject ).to receive( :puppet ).
       #  with( 'apply', '--verbose', 'agent' ).
         and_return( 'puppet_command' )
 
-      subject.should_receive( :on ).
+      expect( subject ).to receive( :on ).
         with( agent, 'puppet_command',
               :acceptable_exit_codes => [0] )
 
@@ -426,29 +492,29 @@ describe ClassMixedWithDSLHelpers do
     end
 
     it 'operates on an array of hosts' do
-      subject.stub( :hosts ).and_return( hosts )
+      allow( subject ).to receive( :hosts ).and_return( hosts )
       the_hosts = [master, agent]
 
-      subject.should_receive( :create_remote_file ).twice.and_return( true )
+      expect( subject ).to receive( :create_remote_file ).twice.and_return( true )
       the_hosts.each do |host|
-        subject.should_receive( :puppet ).
+        expect( subject ).to receive( :puppet ).
           and_return( 'puppet_command' )
 
-        subject.should_receive( :on ).
+        expect( subject ).to receive( :on ).
           with( host, 'puppet_command', :acceptable_exit_codes => [0] )
       end
 
       result = subject.apply_manifest_on( the_hosts, 'include foobar' )
-      result.should(be_an(Array))
+      expect(result).to be_an(Array)
     end
 
     it 'adds acceptable exit codes with :catch_failures' do
-      subject.stub( :hosts ).and_return( hosts )
-      subject.should_receive( :create_remote_file ).and_return( true )
-      subject.should_receive( :puppet ).
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :create_remote_file ).and_return( true )
+      expect( subject ).to receive( :puppet ).
         and_return( 'puppet_command' )
 
-      subject.should_receive( :on ).
+      expect( subject ).to receive( :on ).
         with( agent, 'puppet_command',
               :acceptable_exit_codes => [0,2] )
 
@@ -457,12 +523,12 @@ describe ClassMixedWithDSLHelpers do
                                 :catch_failures => true )
     end
     it 'allows acceptable exit codes through :catch_failures' do
-      subject.stub( :hosts ).and_return( hosts )
-      subject.should_receive( :create_remote_file ).and_return( true )
-      subject.should_receive( :puppet ).
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :create_remote_file ).and_return( true )
+      expect( subject ).to receive( :puppet ).
         and_return( 'puppet_command' )
 
-      subject.should_receive( :on ).
+      expect( subject ).to receive( :on ).
         with( agent, 'puppet_command',
               :acceptable_exit_codes => [4,0,2] )
 
@@ -472,12 +538,12 @@ describe ClassMixedWithDSLHelpers do
                                 :catch_failures => true )
     end
     it 'enforces a 0 exit code through :catch_changes' do
-      subject.stub( :hosts ).and_return( hosts )
-      subject.should_receive( :create_remote_file ).and_return( true )
-      subject.should_receive( :puppet ).
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :create_remote_file ).and_return( true )
+      expect( subject ).to receive( :puppet ).
         and_return( 'puppet_command' )
 
-      subject.should_receive( :on ).with(
+      expect( subject ).to receive( :on ).with(
         agent,
         'puppet_command',
         :acceptable_exit_codes => [0]
@@ -490,12 +556,12 @@ describe ClassMixedWithDSLHelpers do
       )
     end
     it 'enforces a 2 exit code through :expect_changes' do
-      subject.stub( :hosts ).and_return( hosts )
-      subject.should_receive( :create_remote_file ).and_return( true )
-      subject.should_receive( :puppet ).
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :create_remote_file ).and_return( true )
+      expect( subject ).to receive( :puppet ).
         and_return( 'puppet_command' )
 
-      subject.should_receive( :on ).with(
+      expect( subject ).to receive( :on ).with(
         agent,
         'puppet_command',
         :acceptable_exit_codes => [2]
@@ -508,12 +574,12 @@ describe ClassMixedWithDSLHelpers do
       )
     end
     it 'enforces exit codes through :expect_failures' do
-      subject.stub( :hosts ).and_return( hosts )
-      subject.should_receive( :create_remote_file ).and_return( true )
-      subject.should_receive( :puppet ).
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :create_remote_file ).and_return( true )
+      expect( subject ).to receive( :puppet ).
         and_return( 'puppet_command' )
 
-      subject.should_receive( :on ).with(
+      expect( subject ).to receive( :on ).with(
         agent,
         'puppet_command',
         :acceptable_exit_codes => [1,4,6]
@@ -526,7 +592,7 @@ describe ClassMixedWithDSLHelpers do
       )
     end
     it 'enforces exit codes through :expect_failures' do
-      subject.stub( :hosts ).and_return( hosts )
+      allow( subject ).to receive( :hosts ).and_return( hosts )
       expect {
         subject.apply_manifest_on(
           agent,
@@ -537,12 +603,12 @@ describe ClassMixedWithDSLHelpers do
       }.to raise_error ArgumentError, /catch_failures.+expect_failures/
     end
     it 'enforces added exit codes through :expect_failures' do
-      subject.stub( :hosts ).and_return( hosts )
-      subject.should_receive( :create_remote_file ).and_return( true )
-      subject.should_receive( :puppet ).
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :create_remote_file ).and_return( true )
+      expect( subject ).to receive( :puppet ).
         and_return( 'puppet_command' )
 
-      subject.should_receive( :on ).with(
+      expect( subject ).to receive( :on ).with(
         agent,
         'puppet_command',
         :acceptable_exit_codes => [1,2,3,4,5,6]
@@ -557,17 +623,17 @@ describe ClassMixedWithDSLHelpers do
     end
 
     it 'can set the --parser future flag' do
-      subject.stub( :hosts ).and_return( hosts )
-      subject.should_receive( :create_remote_file ).and_return( true )
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :create_remote_file ).and_return( true )
 
-      expect( subject ).to receive( :on ).with {|h, command, opts|
+      expect( subject ).to receive( :on ) do |h, command, opts|
         cmdline = command.cmd_line( h )
         expect( h ).to be == agent
         expect( cmdline ).to include('puppet apply')
         expect( cmdline ).to include('--parser=future')
         expect( cmdline ).to include('--detailed-exitcodes')
         expect( cmdline ).to include('--verbose')
-      }
+      end
 
       subject.apply_manifest_on(
         agent,
@@ -579,16 +645,16 @@ describe ClassMixedWithDSLHelpers do
     end
 
     it 'can set the --noops flag' do
-      subject.stub( :hosts ).and_return( hosts )
-      subject.should_receive( :create_remote_file ).and_return( true )
-      expect( subject ).to receive( :on ).with {|h, command, opts|
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :create_remote_file ).and_return( true )
+      expect( subject ).to receive( :on ) do |h, command, opts|
         cmdline = command.cmd_line( h )
         expect( h ).to be == agent
         expect( cmdline ).to include('puppet apply')
         expect( cmdline ).to include('--detailed-exitcodes')
         expect( cmdline ).to include('--verbose')
         expect( cmdline ).to include('--noop')
-      }
+      end
       subject.apply_manifest_on(
         agent,
         'class { "boo": }',
@@ -599,11 +665,28 @@ describe ClassMixedWithDSLHelpers do
     end
   end
 
+  it 'can set the --debug flag' do
+    allow( subject ).to receive( :hosts ).and_return( hosts )
+    allow( subject ).to receive( :create_remote_file ).and_return( true )
+    expect( subject ).to receive( :on ) do |h, command, opts|
+      cmdline = command.cmd_line( h )
+      expect( h ).to be == agent
+      expect( cmdline ).to include('puppet apply')
+      expect( cmdline ).not_to include('--verbose')
+      expect( cmdline ).to include('--debug')
+    end
+    subject.apply_manifest_on(
+      agent,
+      'class { "boo": }',
+      :debug => true,
+    )
+  end
+
   describe "#apply_manifest" do
     it "delegates to #apply_manifest_on with the default host" do
-      subject.stub( :hosts ).and_return( hosts )
+      allow( subject ).to receive( :hosts ).and_return( hosts )
 
-      subject.should_receive( :apply_manifest_on ).with( master, 'manifest', {:opt => 'value'}).once
+      expect( subject ).to receive( :apply_manifest_on ).with( master, 'manifest', {:opt => 'value'}).once
 
       subject.apply_manifest( 'manifest', {:opt => 'value'}  )
 
@@ -612,17 +695,17 @@ describe ClassMixedWithDSLHelpers do
 
   describe '#stub_hosts_on' do
     it 'executes puppet on the host passed and ensures it is reverted' do
-      subject.stub( :hosts ).and_return( hosts )
+      allow( subject ).to receive( :hosts ).and_return( hosts )
       logger = double.as_null_object
 
-      subject.stub( :logger ).and_return( logger )
-      subject.should_receive( :on ).twice
-      subject.should_receive( :teardown ).and_yield
-      subject.should_receive( :puppet ).once.
+      allow( subject ).to receive( :logger ).and_return( logger )
+      expect( subject ).to receive( :on ).twice
+      expect( subject ).to receive( :teardown ).and_yield
+      expect( subject ).to receive( :puppet ).once.
         with( 'resource', 'host',
               'puppetlabs.com',
               'ensure=present', 'ip=127.0.0.1' )
-      subject.should_receive( :puppet ).once.
+      expect( subject ).to receive( :puppet ).once.
         with( 'resource', 'host',
               'puppetlabs.com',
               'ensure=absent' )
@@ -632,10 +715,10 @@ describe ClassMixedWithDSLHelpers do
   end
 
   describe "#stub_hosts" do
-    it "delegates to #stub_hosts_on with the default host" do
-      subject.stub( :hosts ).and_return( hosts )
+    it "delegates to stub_hosts_on with the default host" do
+      allow( subject ).to receive( :hosts ).and_return( hosts )
 
-      subject.should_receive( :stub_hosts_on ).with( master, 'ipspec' ).once
+      expect( subject ).to receive( :stub_hosts_on ).with( master, 'ipspec' ).once
 
       subject.stub_hosts( 'ipspec'  )
 
@@ -644,13 +727,13 @@ describe ClassMixedWithDSLHelpers do
 
   describe '#stub_forge_on' do
     it 'stubs forge.puppetlabs.com with the value of `forge`' do
-      subject.stub( :hosts ).and_return( hosts )
+      allow( subject ).to receive( :hosts ).and_return( hosts )
       host = make_host('my_host', {})
-      Resolv.should_receive( :getaddress ).
+      expect( Resolv ).to receive( :getaddress ).
         with( 'my_forge.example.com' ).and_return( '127.0.0.1' )
-      subject.should_receive( :stub_hosts_on ).
+      expect( subject ).to receive( :stub_hosts_on ).
         with( host, 'forge.puppetlabs.com' => '127.0.0.1' )
-      subject.should_receive( :stub_hosts_on ).
+      expect( subject ).to receive( :stub_hosts_on ).
         with( host, 'forgeapi.puppetlabs.com' => '127.0.0.1' )
 
       subject.stub_forge_on( host, 'my_forge.example.com' )
@@ -658,11 +741,11 @@ describe ClassMixedWithDSLHelpers do
   end
 
   describe "#stub_forge" do
-    it "delegates to #stub_forge_on with the default host" do
-      subject.stub( :options ).and_return( {} )
-      subject.stub( :hosts ).and_return( hosts )
+    it "delegates to stub_forge_on with the default host" do
+      allow( subject ).to receive( :options ).and_return( {} )
+      allow( subject ).to receive( :hosts ).and_return( hosts )
 
-      subject.should_receive( :stub_forge_on ).with( master, nil ).once
+      expect( subject ).to receive( :stub_forge_on ).with( master, nil ).once
 
       subject.stub_forge( )
 
@@ -700,7 +783,7 @@ describe ClassMixedWithDSLHelpers do
     let( :result_fail ) { Beaker::Result.new( [], "" ) }
     let( :result_pass ) { Beaker::Result.new( [], "" ) }
     before :each do
-      subject.stub( :sleep ).and_return( true )
+      allow( subject ).to receive( :sleep ).and_return( true )
       result_fail.stdout = 'stdout'
       result_fail.stderr = 'stderr'
       result_fail.exit_code = 1
@@ -712,13 +795,13 @@ describe ClassMixedWithDSLHelpers do
     it 'runs the pe-puppet on a system without pe-puppet-agent' do
       vardir = '/var'
       deb_agent = make_host( 'deb', :platform => 'debian-7-amd64' )
-      deb_agent.stub( :puppet ).and_return( { 'vardir' => vardir } )
+      allow( deb_agent ).to receive( :puppet ).and_return( { 'vardir' => vardir } )
 
-      subject.stub( :hosts ).and_return( hosts )
-      subject.should_receive( :on ).with( deb_agent, "[ -e '#{vardir}/state/agent_catalog_run.lock' ]", :acceptable_exit_codes => [0,1] ).once.and_return( result_fail )
-      subject.should_receive( :on ).with( deb_agent, "[ -e /etc/init.d/pe-puppet-agent ]", :acceptable_exit_codes => [0,1] ).once.and_return( result_fail )
-      subject.should_receive( :puppet_resource ).with( "service", "pe-puppet", "ensure=stopped").once
-      subject.should_receive( :on ).once
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :on ).with( deb_agent, "[ -e '#{vardir}/state/agent_catalog_run.lock' ]", :acceptable_exit_codes => [0,1] ).once.and_return( result_fail )
+      expect( subject ).to receive( :on ).with( deb_agent, "[ -e /etc/init.d/pe-puppet-agent ]", :acceptable_exit_codes => [0,1] ).once.and_return( result_fail )
+      expect( subject ).to receive( :puppet_resource ).with( "service", "pe-puppet", "ensure=stopped").once
+      expect( subject ).to receive( :on ).once
 
       subject.stop_agent_on( deb_agent )
 
@@ -727,13 +810,13 @@ describe ClassMixedWithDSLHelpers do
     it 'runs the pe-puppet-agent on a unix system with pe-puppet-agent' do
       vardir = '/var'
       el_agent = make_host( 'el', :platform => 'el-5-x86_64' )
-      el_agent.stub( :puppet ).and_return( { 'vardir' => vardir } )
+      allow( el_agent ).to receive( :puppet ).and_return( { 'vardir' => vardir } )
 
-      subject.stub( :hosts ).and_return( hosts )
-      subject.should_receive( :on ).with( el_agent, "[ -e '#{vardir}/state/agent_catalog_run.lock' ]", :acceptable_exit_codes => [0,1] ).once.and_return( result_fail )
-      subject.should_receive( :on ).with( el_agent, "[ -e /etc/init.d/pe-puppet-agent ]", :acceptable_exit_codes => [0,1] ).once.and_return( result_pass )
-      subject.should_receive( :puppet_resource ).with("service", "pe-puppet-agent", "ensure=stopped").once
-      subject.should_receive( :on ).once
+      allow( subject ).to receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :on ).with( el_agent, "[ -e '#{vardir}/state/agent_catalog_run.lock' ]", :acceptable_exit_codes => [0,1] ).once.and_return( result_fail )
+      expect( subject ).to receive( :on ).with( el_agent, "[ -e /etc/init.d/pe-puppet-agent ]", :acceptable_exit_codes => [0,1] ).once.and_return( result_pass )
+      expect( subject ).to receive( :puppet_resource ).with("service", "pe-puppet-agent", "ensure=stopped").once
+      expect( subject ).to receive( :on ).once
 
       subject.stop_agent_on( el_agent )
     end
@@ -742,9 +825,9 @@ describe ClassMixedWithDSLHelpers do
 
   describe "#stop_agent" do
     it 'delegates to #stop_agent_on with default host' do
-      subject.stub( :hosts ).and_return( hosts )
+      allow( subject ).to receive( :hosts ).and_return( hosts )
 
-      subject.should_receive( :stop_agent_on ).with( master ).once
+      expect( subject ).to receive( :stop_agent_on ).with( master ).once
 
       subject.stop_agent( )
 
@@ -753,35 +836,34 @@ describe ClassMixedWithDSLHelpers do
 
   describe "#sign_certificate_for" do
     it 'signs certs' do
-      subject.stub( :sleep ).and_return( true )
+      allow( subject ).to receive( :sleep ).and_return( true )
 
       result.stdout = "+ \"#{agent}\""
-      subject.stub( :hosts ).and_return( hosts )
+      allow( subject ).to receive( :hosts ).and_return( hosts )
 
-      subject.stub( :puppet ) do |arg|
+      allow( subject ).to receive( :puppet ) do |arg|
         arg
       end
 
-      subject.should_receive( :on ).with( master, "cert --sign --all", :acceptable_exit_codes => [0,24]).once
-      subject.should_receive( :on ).with( master, "cert --list --all").once.and_return( result )
-
+      expect( subject ).to receive( :on ).with( master, "cert --sign --all --allow-dns-alt-names", :acceptable_exit_codes => [0,24]).once
+      expect( subject ).to receive( :on ).with( master, "cert --list --all").once.and_return( result )
 
       subject.sign_certificate_for( agent )
     end
 
     it 'retries 11 times before quitting' do
-      subject.stub( :sleep ).and_return( true )
+      allow( subject ).to receive( :sleep ).and_return( true )
 
       result.stdout = " \"#{agent}\""
-      subject.stub( :hosts ).and_return( hosts )
+      allow( subject ).to receive( :hosts ).and_return( hosts )
 
-      subject.stub( :puppet ) do |arg|
+      allow( subject ).to receive( :puppet ) do |arg|
         arg
       end
 
-      subject.should_receive( :on ).with( master, "cert --sign --all", :acceptable_exit_codes => [0,24]).exactly( 11 ).times
-      subject.should_receive( :on ).with( master, "cert --list --all").exactly( 11 ).times.and_return( result )
-      subject.should_receive( :fail_test ).once
+      expect( subject ).to receive( :on ).with( master, "cert --sign --all --allow-dns-alt-names", :acceptable_exit_codes => [0,24]).exactly( 11 ).times
+      expect( subject ).to receive( :on ).with( master, "cert --list --all").exactly( 11 ).times.and_return( result )
+      expect( subject ).to receive( :fail_test ).once
 
       subject.sign_certificate_for( agent )
     end
@@ -790,9 +872,9 @@ describe ClassMixedWithDSLHelpers do
 
   describe "#sign_certificate" do
     it 'delegates to #sign_certificate_for with the default host' do
-      subject.stub( :hosts ).and_return( hosts )
+      allow( subject ).to receive( :hosts ).and_return( hosts )
 
-      subject.should_receive( :sign_certificate_for ).with( master ).once
+      expect( subject ).to receive( :sign_certificate_for ).with( master ).once
 
       subject.sign_certificate(  )
     end
@@ -813,14 +895,14 @@ describe ClassMixedWithDSLHelpers do
 
     def stub_host_and_subject_to_allow_the_default_testdir_argument_to_be_created
       subject.instance_variable_set(:@path, test_case_path)
-      host.stub(:tmpdir).and_return(tmpdir_path)
-      host.stub(:file_exist?).and_return(true)
-      subject.stub( :options ).and_return( {} )
+      allow( host ).to receive(:tmpdir).and_return(tmpdir_path)
+      allow( host ).to receive(:file_exist?).and_return(true)
+      allow( subject ).to receive( :options ).and_return( {} )
     end
 
     before do
       stub_host_and_subject_to_allow_the_default_testdir_argument_to_be_created
-      subject.stub(:curl_with_retries)
+      allow( subject ).to receive(:curl_with_retries)
     end
 
     it "raises an ArgumentError if you try to submit a String instead of a Hash of options" do
@@ -828,7 +910,7 @@ describe ClassMixedWithDSLHelpers do
     end
 
     it 'raises the early_exception if backup_the_file fails' do
-      subject.should_receive(:backup_the_file).and_raise(RuntimeError.new('puppet conf backup failed'))
+      expect( subject ).to receive(:backup_the_file).and_raise(RuntimeError.new('puppet conf backup failed'))
       expect {
         subject.with_puppet_running_on(host, {})
       }.to raise_error(RuntimeError, /puppet conf backup failed/)
@@ -859,30 +941,30 @@ describe ClassMixedWithDSLHelpers do
       let(:logger) { double }
 
       def stub_post_setup
-        subject.stub( :restore_puppet_conf_from_backup)
-        subject.stub( :bounce_service)
-        subject.stub( :stop_puppet_from_source_on)
-        subject.stub( :dump_puppet_log)
-        subject.stub( :restore_puppet_conf_from_backup)
-        subject.stub( :puppet_master_started)
-        subject.stub( :start_puppet_from_source_on!)
-        subject.stub( :lay_down_new_puppet_conf)
-        subject.stub( :logger) .and_return( logger )
-        logger.stub( :error)
-        logger.stub( :debug)
+        allow( subject ).to receive( :restore_puppet_conf_from_backup)
+        allow( subject ).to receive( :bounce_service)
+        allow( subject ).to receive( :stop_puppet_from_source_on)
+        allow( subject ).to receive( :dump_puppet_log)
+        allow( subject ).to receive( :restore_puppet_conf_from_backup)
+        allow( subject ).to receive( :puppet_master_started)
+        allow( subject ).to receive( :start_puppet_from_source_on!)
+        allow( subject ).to receive( :lay_down_new_puppet_conf)
+        allow( subject ).to receive( :logger) .and_return( logger )
+        allow( logger ).to receive( :error)
+        allow( logger ).to receive( :debug)
       end
 
       before do
         stub_post_setup
-        subject.stub( :options) .and_return( {:is_puppetserver => true})
-        subject.stub( :modify_tk_config)
-        host.stub(:puppet).with('master') .and_return({'confdir' => default_confdir,
+        allow( subject ).to receive( :options) .and_return( {:is_puppetserver => true})
+        allow( subject ).to receive( :modify_tk_config)
+        allow( host ).to receive(:puppet).with('master') .and_return({'confdir' => default_confdir,
                                                        'vardir' => default_vardir})
       end
 
       describe 'and command line args passed' do
         it 'modifies SUT trapperkeeper configuration w/ command line args' do
-          subject.should_receive( :modify_tk_config).with(host, puppetserver_conf,
+          expect( subject ).to receive( :modify_tk_config).with(host, puppetserver_conf,
                                                           custom_puppetserver_opts)
           subject.with_puppet_running_on(host, conf_opts)
         end
@@ -891,7 +973,7 @@ describe ClassMixedWithDSLHelpers do
       describe 'and no command line args passed' do
         let(:command_line_args) { nil }
         it 'modifies SUT trapperkeeper configuration w/ puppet defaults' do
-          subject.should_receive( :modify_tk_config).with(host, puppetserver_conf,
+          expect( subject ).to receive( :modify_tk_config).with(host, puppetserver_conf,
                                                           default_puppetserver_opts)
           subject.with_puppet_running_on(host, conf_opts)
         end
@@ -900,7 +982,7 @@ describe ClassMixedWithDSLHelpers do
 
     describe "with valid arguments" do
       before do
-        Tempfile.should_receive(:open).with('beaker')
+        expect( Tempfile ).to receive(:open).with('beaker')
       end
 
       context 'for pe hosts' do
@@ -915,7 +997,7 @@ describe ClassMixedWithDSLHelpers do
 
         it 'yields to a block after bouncing service' do
           execution = 0
-          subject.stub(:curl_with_retries)
+          allow( subject ).to receive(:curl_with_retries)
           expect do
             subject.with_puppet_running_on(host, {}) do
               expect(host).to execute_commands_matching(/puppet resource service #{host['puppetservice']}.*ensure=running/).exactly(1).times
@@ -934,14 +1016,14 @@ describe ClassMixedWithDSLHelpers do
         end
 
         it 'bounces puppet twice' do
-          subject.stub(:curl_with_retries)
+          allow( subject ).to receive(:curl_with_retries)
           subject.with_puppet_running_on(host, {})
           expect(host).to execute_commands_matching(/apache2ctl graceful/).exactly(2).times
         end
 
         it 'yields to a block after bouncing service' do
           execution = 0
-          subject.stub(:curl_with_retries)
+          allow( subject ).to receive(:curl_with_retries)
           expect do
             subject.with_puppet_running_on(host, {}) do
               expect(host).to execute_commands_matching(/apache2ctl graceful/).once
@@ -956,7 +1038,7 @@ describe ClassMixedWithDSLHelpers do
         let(:use_service) { true }
 
         it 'stops and starts master using service scripts' do
-          subject.stub(:curl_with_retries)
+          allow( subject ).to receive(:curl_with_retries)
           subject.with_puppet_running_on(host, {})
           expect(host).to execute_commands_matching(/puppet resource service #{host['puppetservice']}.*ensure=running/).exactly(2).times
           expect(host).to execute_commands_matching(/puppet resource service #{host['puppetservice']}.*ensure=stopped/).exactly(2).times
@@ -980,15 +1062,15 @@ describe ClassMixedWithDSLHelpers do
         let('use-service') { false }
 
         it 'does not try to stop if not started' do
-          subject.should_receive(:start_puppet_from_source_on!).and_return false
-          subject.should_not_receive(:stop_puppet_from_source_on)
+          expect( subject ).to receive(:start_puppet_from_source_on!).and_return false
+          expect( subject ).to_not receive(:stop_puppet_from_source_on)
 
           subject.with_puppet_running_on(host, {})
         end
 
         context 'successfully' do
           before do
-            host.should_receive(:port_open?).with(8140).and_return(true)
+            expect( host ).to receive(:port_open?).with(8140).and_return(true)
           end
 
           it 'starts puppet from source' do
@@ -1044,7 +1126,7 @@ describe ClassMixedWithDSLHelpers do
 
         context 'when a puppetservice is not used' do
           before do
-            host.should_receive(:port_open?).with(8140).and_return(true)
+            expect( host ).to receive(:port_open?).with(8140).and_return(true)
           end
 
           it 'backs up puppet.conf' do
@@ -1060,7 +1142,7 @@ describe ClassMixedWithDSLHelpers do
           end
 
           it "doesn't restore a non-existent file" do
-            subject.stub(:backup_the_file)
+            allow( subject ).to receive(:backup_the_file)
             subject.with_puppet_running_on(host, {})
             expect(host).to execute_commands_matching(/rm -f '#{original_location}'/)
           end
@@ -1068,14 +1150,17 @@ describe ClassMixedWithDSLHelpers do
       end
 
       describe 'handling failures' do
+
+        let(:logger) { double.as_null_object }
         before do
-          subject.should_receive(:stop_puppet_from_source_on).and_raise(RuntimeError.new('Also failed in teardown.'))
+          allow( subject ).to receive( :logger ).and_return( logger )
+          expect( subject ).to receive(:stop_puppet_from_source_on).and_raise(RuntimeError.new('Also failed in teardown.'))
         end
 
         it 'does not swallow an exception raised from within test block if ensure block also fails' do
-          host.should_receive(:port_open?).with(8140).and_return(true)
+          expect( host ).to receive(:port_open?).with(8140).and_return(true)
 
-          subject.logger.should_receive(:error).with(/Raised during attempt to teardown.*Also failed in teardown/)
+          expect( subject.logger ).to receive(:error).with(/Raised during attempt to teardown.*Also failed in teardown/)
 
           expect do
             subject.with_puppet_running_on(host, {}) { raise 'Failed while yielding.' }
@@ -1083,9 +1168,9 @@ describe ClassMixedWithDSLHelpers do
         end
 
         it 'dumps the puppet logs if there is an error in the teardown' do
-          host.should_receive(:port_open?).with(8140).and_return(true)
+          expect( host ).to receive(:port_open?).with(8140).and_return(true)
 
-          subject.logger.should_receive(:notify).with(/Dumping master log/)
+          expect( subject.logger ).to receive(:notify).with(/Dumping master log/)
 
           expect do
             subject.with_puppet_running_on(host, {})
@@ -1093,9 +1178,9 @@ describe ClassMixedWithDSLHelpers do
         end
 
         it 'does not mask the teardown error with an error from dumping the logs' do
-          host.should_receive(:port_open?).with(8140).and_return(true)
+          expect( host ).to receive(:port_open?).with(8140).and_return(true)
 
-          subject.logger.should_receive(:notify).with(/Dumping master log/).and_raise("Error from dumping logs")
+          expect( subject.logger ).to receive(:notify).with(/Dumping master log/).and_raise("Error from dumping logs")
 
           expect do
             subject.with_puppet_running_on(host, {})
@@ -1103,8 +1188,8 @@ describe ClassMixedWithDSLHelpers do
         end
 
         it 'does not swallow a teardown exception if no earlier exception was raised' do
-          host.should_receive(:port_open?).with(8140).and_return(true)
-          subject.logger.should_not_receive(:error)
+          expect( host ).to receive(:port_open?).with(8140).and_return(true)
+          expect( subject.logger).to_not receive(:error)
           expect do
             subject.with_puppet_running_on(host, {})
           end.to raise_error(RuntimeError, 'Also failed in teardown.')
@@ -1115,9 +1200,9 @@ describe ClassMixedWithDSLHelpers do
 
   describe '#with_puppet_running' do
     it 'delegates to #with_puppet_running_on with the default host' do
-      subject.stub( :hosts ).and_return( hosts )
+      allow( subject ).to receive( :hosts ).and_return( hosts )
 
-      subject.should_receive( :with_puppet_running_on ).with( master, {:opt => 'value'}, '/dir').once
+      expect( subject ).to receive( :with_puppet_running_on ).with( master, {:opt => 'value'}, '/dir').once
 
       subject.with_puppet_running( {:opt => 'value'}, '/dir'  )
 
@@ -1128,18 +1213,18 @@ describe ClassMixedWithDSLHelpers do
   describe '#fact_on' do
     it 'retrieves a fact on a single host' do
       result.stdout = "family\n"
-      subject.should_receive(:facter).with('osfamily',{}).once
-      subject.should_receive(:on).and_return(result)
+      expect( subject ).to receive(:facter).with('osfamily',{}).once
+      expect( subject ).to receive(:on).and_return(result)
 
       expect( subject.fact_on('host','osfamily') ).to be === result.stdout.chomp
     end
 
     it 'retrieves an array of facts from multiple hosts' do
-      subject.stub( :hosts ).and_return( hosts )
+      allow( subject ).to receive( :hosts ).and_return( hosts )
       times = hosts.length
       result.stdout = "family\n"
       hosts.each do |host|
-        host.should_receive(:exec).and_return(result)
+        expect( host ).to receive(:exec).and_return(result)
       end
 
       expect( subject.fact_on(hosts,'osfamily') ).to be === [result.stdout.chomp] * hosts.length
@@ -1149,8 +1234,8 @@ describe ClassMixedWithDSLHelpers do
 
   describe '#fact' do
     it 'delegates to #fact_on with the default host' do
-      subject.stub(:hosts).and_return(hosts)
-      subject.should_receive(:fact_on).with(master,"osfamily",{}).once
+      allow( subject ).to receive(:hosts).and_return(hosts)
+      expect( subject ).to receive(:fact_on).with(master,"osfamily",{}).once
 
       subject.fact('osfamily')
     end
@@ -1165,15 +1250,15 @@ describe ClassMixedWithDSLHelpers do
 
     shared_examples 'modify-tk-config-without-error' do
       it 'dumps to the SUT config file path' do
-        JSON.stub(:dump)
-        subject.stub(:create_remote_file).with(host, config_file_path, anything())
+        allow( JSON ).to receive(:dump)
+        allow( subject ).to receive(:create_remote_file).with(host, config_file_path, anything())
         subject.modify_tk_config(host, config_file_path, options_hash, replace)
       end
     end
 
     before do
-      host.stub(:file_exist?).with(invalid_config_file_path).and_return(false)
-      host.stub(:file_exist?).with(config_file_path).and_return(true)
+      allow( host ).to receive(:file_exist?).with(invalid_config_file_path).and_return(false)
+      allow( host ).to receive(:file_exist?).with(config_file_path).and_return(true)
     end
 
     describe 'if file does not exist on SUT' do
@@ -1195,15 +1280,15 @@ describe ClassMixedWithDSLHelpers do
       describe 'given a false value to its `replace` parameter' do
         let(:replace) { false }
         before do
-          subject.should_receive(:read_tk_config_string).with(anything())
+          expect( subject ).to receive(:read_tk_config_string).with(anything())
         end
         include_examples('modify-tk-config-without-error')
       end
 
       describe 'given a true value to its `replace` parameter' do
         before do
-          JSON.should_receive(:dump)
-          subject.should_receive(:create_remote_file).with(host, config_file_path, anything())
+          expect( JSON ).to receive(:dump)
+          expect( subject ).to receive(:create_remote_file).with(host, config_file_path, anything())
         end
         include_examples('modify-tk-config-without-error')
       end