puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/spec/unit/type/augeas_spec.rb

@@ -6,11 +6,11 @@ augeas = Puppet::Type.type(:augeas)
 describe augeas do
   describe "when augeas is present", :if => Puppet.features.augeas? do
     it "should have a default provider inheriting from Puppet::Provider" do
-      augeas.defaultprovider.ancestors.should be_include(Puppet::Provider)
+      expect(augeas.defaultprovider.ancestors).to be_include(Puppet::Provider)
     end
 
     it "should have a valid provider" do
-      augeas.new(:name => "foo").provider.class.ancestors.should be_include(Puppet::Provider)
+      expect(augeas.new(:name => "foo").provider.class.ancestors).to be_include(Puppet::Provider)
     end
   end
 
@@ -18,19 +18,19 @@ describe augeas do
     it "should be able to create an instance" do
       provider_class = Puppet::Type::Augeas.provider(Puppet::Type::Augeas.providers[0])
       Puppet::Type::Augeas.expects(:defaultprovider).returns provider_class
-      augeas.new(:name => "bar").should_not be_nil
+      expect(augeas.new(:name => "bar")).not_to be_nil
     end
 
     it "should have a parse_commands feature" do
-      augeas.provider_feature(:parse_commands).should_not be_nil
+      expect(augeas.provider_feature(:parse_commands)).not_to be_nil
     end
 
     it "should have a need_to_run? feature" do
-      augeas.provider_feature(:need_to_run?).should_not be_nil
+      expect(augeas.provider_feature(:need_to_run?)).not_to be_nil
     end
 
     it "should have an execute_changes feature" do
-      augeas.provider_feature(:execute_changes).should_not be_nil
+      expect(augeas.provider_feature(:execute_changes)).not_to be_nil
     end
 
     properties = [:returns]
@@ -38,21 +38,21 @@ describe augeas do
 
     properties.each do |property|
       it "should have a #{property} property" do
-        augeas.attrclass(property).ancestors.should be_include(Puppet::Property)
+        expect(augeas.attrclass(property).ancestors).to be_include(Puppet::Property)
       end
 
       it "should have documentation for its #{property} property" do
-        augeas.attrclass(property).doc.should be_instance_of(String)
+        expect(augeas.attrclass(property).doc).to be_instance_of(String)
       end
     end
 
     params.each do |param|
       it "should have a #{param} parameter" do
-        augeas.attrclass(param).ancestors.should be_include(Puppet::Parameter)
+        expect(augeas.attrclass(param).ancestors).to be_include(Puppet::Parameter)
       end
 
       it "should have documentation for its #{param} parameter" do
-        augeas.attrclass(param).doc.should be_instance_of(String)
+        expect(augeas.attrclass(param).doc).to be_instance_of(String)
       end
     end
   end
@@ -64,23 +64,23 @@ describe augeas do
     end
 
     it "should be blank for context" do
-      augeas.new(:name => :context)[:context].should == ""
+      expect(augeas.new(:name => :context)[:context]).to eq("")
     end
 
     it "should be blank for onlyif" do
-      augeas.new(:name => :onlyif)[:onlyif].should == ""
+      expect(augeas.new(:name => :onlyif)[:onlyif]).to eq("")
     end
 
     it "should be blank for load_path" do
-      augeas.new(:name => :load_path)[:load_path].should == ""
+      expect(augeas.new(:name => :load_path)[:load_path]).to eq("")
     end
 
     it "should be / for root" do
-      augeas.new(:name => :root)[:root].should == "/"
+      expect(augeas.new(:name => :root)[:root]).to eq("/")
     end
 
     it "should be false for type_check" do
-      augeas.new(:name => :type_check)[:type_check].should == :false
+      expect(augeas.new(:name => :type_check)[:type_check]).to eq(:false)
     end
   end
 
@@ -90,30 +90,30 @@ describe augeas do
       provider = stub("provider", :need_to_run? => false)
       resource = stub('resource', :resource => nil, :provider => provider, :line => nil, :file => nil)
       changes = augeas.attrclass(:returns).new(:resource => resource)
-      changes.retrieve.should == 0
+      expect(changes.retrieve).to eq(0)
     end
 
     it "should return :need_to_run if it needs to run" do
       provider = stub("provider", :need_to_run? => true)
       resource = stub('resource', :resource => nil, :provider => provider, :line => nil, :file => nil)
       changes = augeas.attrclass(:returns).new(:resource => resource)
-      changes.retrieve.should == :need_to_run
+      expect(changes.retrieve).to eq(:need_to_run)
     end
   end
 
   describe "loading specific files" do
     it "should require lens when incl is used" do
-      lambda { augeas.new(:name => :no_lens, :incl => "/etc/hosts")}.should raise_error(Puppet::Error)
+      expect { augeas.new(:name => :no_lens, :incl => "/etc/hosts")}.to raise_error(Puppet::Error)
     end
 
     it "should require incl when lens is used" do
-      lambda { augeas.new(:name => :no_incl, :lens => "Hosts.lns") }.should raise_error(Puppet::Error)
+      expect { augeas.new(:name => :no_incl, :lens => "Hosts.lns") }.to raise_error(Puppet::Error)
     end
 
     it "should set the context when a specific file is used" do
       fake_provider = stub_everything "fake_provider"
       augeas.stubs(:defaultprovider).returns fake_provider
-      augeas.new(:name => :no_incl, :lens => "Hosts.lns", :incl => "/etc/hosts")[:context].should == "/files/etc/hosts"
+      expect(augeas.new(:name => :no_incl, :lens => "Hosts.lns", :incl => "/etc/hosts")[:context]).to eq("/files/etc/hosts")
     end
   end
 end

data/spec/unit/type/component_spec.rb

@@ -5,49 +5,49 @@ component = Puppet::Type.type(:component)
 
 describe component do
   it "should have a :name attribute" do
-    component.attrclass(:name).should_not be_nil
+    expect(component.attrclass(:name)).not_to be_nil
   end
 
   it "should use Class as its type when a normal string is provided as the title" do
-    component.new(:name => "bar").ref.should == "Class[Bar]"
+    expect(component.new(:name => "bar").ref).to eq("Class[Bar]")
   end
 
   it "should always produce a resource reference string as its title" do
-    component.new(:name => "bar").title.should == "Class[Bar]"
+    expect(component.new(:name => "bar").title).to eq("Class[Bar]")
   end
 
   it "should have a reference string equivalent to its title" do
     comp = component.new(:name => "Foo[bar]")
-    comp.title.should == comp.ref
+    expect(comp.title).to eq(comp.ref)
   end
 
   it "should not fail when provided an invalid value" do
     comp = component.new(:name => "Foo[bar]")
-    lambda { comp[:yayness] = "ey" }.should_not raise_error
+    expect { comp[:yayness] = "ey" }.not_to raise_error
   end
 
   it "should return previously provided invalid values" do
     comp = component.new(:name => "Foo[bar]")
     comp[:yayness] = "eh"
-    comp[:yayness].should == "eh"
+    expect(comp[:yayness]).to eq("eh")
   end
 
   it "should correctly support metaparameters" do
     comp = component.new(:name => "Foo[bar]", :require => "Foo[bar]")
-    comp.parameter(:require).should be_instance_of(component.attrclass(:require))
+    expect(comp.parameter(:require)).to be_instance_of(component.attrclass(:require))
   end
 
   describe "when building up the path" do
     it "should produce the class name if the component models a class" do
-      component.new(:name => "Class[foo]").pathbuilder.must == ["Foo"]
+      expect(component.new(:name => "Class[foo]").pathbuilder).to eq(["Foo"])
     end
 
     it "should produce the class name even for the class named main" do
-      component.new(:name => "Class[main]").pathbuilder.must == ["Main"]
+      expect(component.new(:name => "Class[main]").pathbuilder).to eq(["Main"])
     end
 
     it "should produce a resource reference if the component does not model a class" do
-      component.new(:name => "Foo[bar]").pathbuilder.must == ["Foo[bar]"]
+      expect(component.new(:name => "Foo[bar]").pathbuilder).to eq(["Foo[bar]"])
     end
   end
 end

data/spec/unit/type/computer_spec.rb

@@ -21,7 +21,7 @@ describe Puppet::Type.type(:computer), " when checking computer objects" do
   it "should be able to create an instance" do
     provider_class = Puppet::Type::Computer.provider(Puppet::Type::Computer.providers[0])
     Puppet::Type::Computer.expects(:defaultprovider).returns provider_class
-    computer.new(:name => "bar").should_not be_nil
+    expect(computer.new(:name => "bar")).not_to be_nil
   end
 
   properties = [:en_address, :ip_address]
@@ -29,27 +29,27 @@ describe Puppet::Type.type(:computer), " when checking computer objects" do
 
   properties.each do |property|
     it "should have a #{property} property" do
-      computer.attrclass(property).ancestors.should be_include(Puppet::Property)
+      expect(computer.attrclass(property).ancestors).to be_include(Puppet::Property)
     end
 
     it "should have documentation for its #{property} property" do
-      computer.attrclass(property).doc.should be_instance_of(String)
+      expect(computer.attrclass(property).doc).to be_instance_of(String)
     end
 
     it "should accept :absent as a value" do
       prop = computer.attrclass(property).new(:resource => @resource)
       prop.should = :absent
-      prop.should.must == :absent
+      expect(prop.should).to eq(:absent)
     end
   end
 
   params.each do |param|
     it "should have a #{param} parameter" do
-      computer.attrclass(param).ancestors.should be_include(Puppet::Parameter)
+      expect(computer.attrclass(param).ancestors).to be_include(Puppet::Parameter)
     end
 
     it "should have documentation for its #{param} parameter" do
-      computer.attrclass(param).doc.should be_instance_of(String)
+      expect(computer.attrclass(param).doc).to be_instance_of(String)
     end
   end
 
@@ -60,21 +60,21 @@ describe Puppet::Type.type(:computer), " when checking computer objects" do
     end
 
     it "should be nil for en_address" do
-      computer.new(:name => :en_address)[:en_address].should == nil
+      expect(computer.new(:name => :en_address)[:en_address]).to eq(nil)
     end
 
     it "should be nil for ip_address" do
-      computer.new(:name => :ip_address)[:ip_address].should == nil
+      expect(computer.new(:name => :ip_address)[:ip_address]).to eq(nil)
     end
   end
 
   describe "when managing the ensure property" do
     it "should support a :present value" do
-      lambda { @ensure.should = :present }.should_not raise_error
+      expect { @ensure.should = :present }.not_to raise_error
     end
 
     it "should support an :absent value" do
-      lambda { @ensure.should = :absent }.should_not raise_error
+      expect { @ensure.should = :absent }.not_to raise_error
     end
   end
 end

data/spec/unit/type/cron_spec.rb

@@ -18,25 +18,25 @@ describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows?
   end
 
   it "should have :name be its namevar" do
-    described_class.key_attributes.should == [:name]
+    expect(described_class.key_attributes).to eq([:name])
   end
 
   describe "when validating attributes" do
     [:name, :provider].each do |param|
       it "should have a #{param} parameter" do
-        described_class.attrtype(param).should == :param
+        expect(described_class.attrtype(param)).to eq(:param)
       end
     end
 
     [:command, :special, :minute, :hour, :weekday, :month, :monthday, :environment, :user, :target].each do |property|
       it "should have a #{property} property" do
-        described_class.attrtype(property).should == :property
+        expect(described_class.attrtype(property)).to eq(:property)
       end
     end
 
     [:command, :minute, :hour, :weekday, :month, :monthday].each do |cronparam|
       it "should have #{cronparam} of type CronParam" do
-        described_class.attrclass(cronparam).ancestors.should include CronParam
+        expect(described_class.attrclass(cronparam).ancestors).to include CronParam
       end
     end
   end
@@ -60,10 +60,10 @@ describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows?
 
     describe "command" do
       it "should discard leading spaces" do
-        described_class.new(:name => 'foo', :command => " /bin/true")[:command].should_not match Regexp.new(" ")
+        expect(described_class.new(:name => 'foo', :command => " /bin/true")[:command]).not_to match Regexp.new(" ")
       end
       it "should discard trailing spaces" do
-        described_class.new(:name => 'foo', :command => "/bin/true ")[:command].should_not match Regexp.new(" ")
+        expect(described_class.new(:name => 'foo', :command => "/bin/true ")[:command]).not_to match Regexp.new(" ")
       end
     end
 
@@ -77,11 +77,11 @@ describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows?
       end
 
       it "should translate absent to :absent" do
-        described_class.new(:name => 'foo', :minute => 'absent')[:minute].should == :absent
+        expect(described_class.new(:name => 'foo', :minute => 'absent')[:minute]).to eq(:absent)
       end
 
       it "should translate * to :absent" do
-        described_class.new(:name => 'foo', :minute => '*')[:minute].should == :absent
+        expect(described_class.new(:name => 'foo', :minute => '*')[:minute]).to eq(:absent)
       end
 
       it "should support valid single values" do
@@ -144,11 +144,11 @@ describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows?
       end
 
       it "should translate absent to :absent" do
-        described_class.new(:name => 'foo', :hour => 'absent')[:hour].should == :absent
+        expect(described_class.new(:name => 'foo', :hour => 'absent')[:hour]).to eq(:absent)
       end
 
       it "should translate * to :absent" do
-        described_class.new(:name => 'foo', :hour => '*')[:hour].should == :absent
+        expect(described_class.new(:name => 'foo', :hour => '*')[:hour]).to eq(:absent)
       end
 
       it "should support valid single values" do
@@ -211,11 +211,11 @@ describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows?
       end
 
       it "should translate absent to :absent" do
-        described_class.new(:name => 'foo', :weekday => 'absent')[:weekday].should == :absent
+        expect(described_class.new(:name => 'foo', :weekday => 'absent')[:weekday]).to eq(:absent)
       end
 
       it "should translate * to :absent" do
-        described_class.new(:name => 'foo', :weekday => '*')[:weekday].should == :absent
+        expect(described_class.new(:name => 'foo', :weekday => '*')[:weekday]).to eq(:absent)
       end
 
       it "should support valid numeric weekdays" do
@@ -294,11 +294,11 @@ describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows?
       end
 
       it "should translate absent to :absent" do
-        described_class.new(:name => 'foo', :month => 'absent')[:month].should == :absent
+        expect(described_class.new(:name => 'foo', :month => 'absent')[:month]).to eq(:absent)
       end
 
       it "should translate * to :absent" do
-        described_class.new(:name => 'foo', :month => '*')[:month].should == :absent
+        expect(described_class.new(:name => 'foo', :month => '*')[:month]).to eq(:absent)
       end
 
       it "should support valid numeric values" do
@@ -394,11 +394,11 @@ describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows?
       end
 
       it "should translate absent to :absent" do
-        described_class.new(:name => 'foo', :monthday => 'absent')[:monthday].should == :absent
+        expect(described_class.new(:name => 'foo', :monthday => 'absent')[:monthday]).to eq(:absent)
       end
 
       it "should translate * to :absent" do
-        described_class.new(:name => 'foo', :monthday => '*')[:monthday].should == :absent
+        expect(described_class.new(:name => 'foo', :monthday => '*')[:monthday]).to eq(:absent)
       end
 
       it "should support valid single values" do
@@ -524,20 +524,20 @@ describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows?
       @resource = described_class.new(:name => 'dummy', :command => '/usr/bin/uptime', :user => 'alice')
       @catalog.add_resource @resource
       req = @resource.autorequire
-      req.size.should == 1
-      req[0].target.must == @resource
-      req[0].source.must == @user_alice
+      expect(req.size).to eq(1)
+      expect(req[0].target).to eq(@resource)
+      expect(req[0].source).to eq(@user_alice)
     end
   end
 
   it "should not require a command when removing an entry" do
     entry = described_class.new(:name => "test_entry", :ensure => :absent)
-    entry.value(:command).should == nil
+    expect(entry.value(:command)).to eq(nil)
   end
 
   it "should default to user => root if Etc.getpwuid(Process.uid) returns nil (#12357)" do
     Etc.expects(:getpwuid).returns(nil)
     entry = described_class.new(:name => "test_entry", :ensure => :present)
-    entry.value(:user).should eql "root"
+    expect(entry.value(:user)).to eql "root"
   end
 end

data/spec/unit/type/exec_spec.rb

@@ -57,12 +57,12 @@ describe Puppet::Type.type(:exec) do
 
     it "should return :executed_command as its event" do
       resource = Puppet::Type.type(:exec).new :command => @command
-      resource.parameter(:returns).event.name.should == :executed_command
+      expect(resource.parameter(:returns).event.name).to eq(:executed_command)
     end
 
     describe "when execing" do
       it "should use the 'execute' method to exec" do
-        exec_tester("true").refresh.should == :executed_command
+        expect(exec_tester("true").refresh).to eq(:executed_command)
       end
 
       it "should report a failure" do
@@ -84,8 +84,8 @@ describe Puppet::Type.type(:exec) do
         exec_tester('false', 0, :output => output, :logoutput => true).refresh
         output.split("\n").each do |line|
           log = @logs.shift
-          log.level.should == :err
-          log.message.should == line
+          expect(log.level).to eq(:err)
+          expect(log.message).to eq(line)
         end
       end
 
@@ -96,8 +96,8 @@ describe Puppet::Type.type(:exec) do
 
         output.split("\n").each do |line|
           log = @logs.shift
-          log.level.should == :err
-          log.message.should == line
+          expect(log.level).to eq(:err)
+          expect(log.message).to eq(line)
         end
       end
     end
@@ -110,8 +110,8 @@ describe Puppet::Type.type(:exec) do
 
         output.split("\n").each do |line|
           log = @logs.shift
-          log.level.should == :err
-          log.message.should == line
+          expect(log.level).to eq(:err)
+          expect(log.message).to eq(line)
         end
       end
 
@@ -125,20 +125,20 @@ describe Puppet::Type.type(:exec) do
 
         output.split("\n").each do |line|
           log = @logs.shift
-          log.level.should == :err
-          log.message.should == line
+          expect(log.level).to eq(:err)
+          expect(log.message).to eq(line)
         end
       end
 
       it "shouldn't log the output on success" do
         exec_tester('true', 0, :output => "a\nb\nc\n", :logoutput => :on_failure).refresh
-        @logs.should == []
+        expect(@logs).to eq([])
       end
     end
 
     it "shouldn't log the output on success when non-zero exit status is in a returns array" do
       exec_tester("true", 100, :output => "a\n", :logoutput => :on_failure, :returns => [1, 100]).refresh
-      @logs.should == []
+      expect(@logs).to eq([])
     end
 
     describe " when multiple tries are set," do
@@ -160,7 +160,7 @@ describe Puppet::Type.type(:exec) do
     catalog.add_resource execer
     dependencies = execer.autorequire(catalog)
 
-    dependencies.collect(&:to_s).should == [Puppet::Relationship.new(tmp, execer).to_s]
+    expect(dependencies.collect(&:to_s)).to eq([Puppet::Relationship.new(tmp, execer).to_s])
   end
 
   describe "when handling the path parameter" do
@@ -171,7 +171,7 @@ describe Puppet::Type.type(:exec) do
     }.each do |test, input|
       it "should accept #{test}" do
         type = Puppet::Type.type(:exec).new(:name => @command, :path => input)
-        type[:path].should == expect
+        expect(type[:path]).to eq(expect)
       end
     end
 
@@ -190,13 +190,13 @@ describe Puppet::Type.type(:exec) do
 
       it "should use the path separator of the current platform" do
         type = Puppet::Type.type(:exec).new(:name => @command, :path => "fooqbarqbaz")
-        type[:path].should == %w[foo bar baz]
+        expect(type[:path]).to eq(%w[foo bar baz])
       end
     end
   end
 
   describe "when setting user" do
-    describe "on POSIX systems", :as_platform => :posix do
+    describe "on POSIX systems", :if => Puppet.features.posix? do
       it "should fail if we are not root" do
         Puppet.features.stubs(:root?).returns(false)
         expect {
@@ -217,12 +217,12 @@ describe Puppet::Type.type(:exec) do
         it "should accept '#{value}' as user if we are root" do
           Puppet.features.stubs(:root?).returns(true)
           type = Puppet::Type.type(:exec).new(:name => '/bin/true whatever', :user => value)
-          type[:user].should == value
+          expect(type[:user]).to eq(value)
         end
       end
     end
 
-    describe "on Windows systems", :as_platform => :windows do
+    describe "on Windows systems", :if => Puppet.features.microsoft_windows? do
       before :each do
         Puppet.features.stubs(:root?).returns(true)
       end
@@ -240,7 +240,7 @@ describe Puppet::Type.type(:exec) do
       ['one', 2, 'wheel', 4294967295, 4294967296].each do |value|
         it "should accept '#{value}' without error or judgement" do
           type = Puppet::Type.type(:exec).new(:name => @command, :group => value)
-          type[:group].should == value
+          expect(type[:group]).to eq(value)
         end
       end
     end
@@ -308,7 +308,7 @@ describe Puppet::Type.type(:exec) do
         input = %w{one two three}
         @test.provider.expects(:validatecmd).times(input.length).returns(true)
         @test[param] = input
-        @test[param].should == input
+        expect(@test[param]).to eq(input)
       end
 
       it "should reject the array when any commands return invalid" do
@@ -318,14 +318,14 @@ describe Puppet::Type.type(:exec) do
           @test.provider.expects(:validatecmd).with(cmd).returns(true)
         end
         @test[param] = input
-        @test[param].should == input
+        expect(@test[param]).to eq(input)
       end
 
       it "should reject the array when all commands return invalid" do
         input = %w{one two three}
         @test.provider.expects(:validatecmd).times(input.length).returns(false)
         @test[param] = input
-        @test[param].should == input
+        expect(@test[param]).to eq(input)
       end
     end
   end
@@ -356,7 +356,7 @@ describe Puppet::Type.type(:exec) do
       }.each do |name, data|
         it "should accept #{name}" do
           @exec[:environment] = data
-          @exec[:environment].should == data
+          expect(@exec[:environment]).to eq(data)
         end
       end
 
@@ -375,12 +375,12 @@ describe Puppet::Type.type(:exec) do
       [0, 0.1, 1, 10, 4294967295].each do |valid|
         it "should accept '#{valid}' as valid" do
           @exec[:timeout] = valid
-          @exec[:timeout].should == valid
+          expect(@exec[:timeout]).to eq(valid)
         end
 
         it "should accept '#{valid}' in an array as valid" do
           @exec[:timeout] = [valid]
-          @exec[:timeout].should == valid
+          expect(@exec[:timeout]).to eq(valid)
         end
       end
 
@@ -396,38 +396,30 @@ describe Puppet::Type.type(:exec) do
         end
       end
 
-      describe 'when timeout is exceeded' do
-        subject do
-          ruby_path = Puppet::Util::Execution.ruby_path()
-          Puppet::Type.type(:exec).new(:name => "#{ruby_path} -e 'sleep 1'", :timeout => '0.1')
-        end
+      it "should fail if timeout is exceeded" do
+        ruby_path = Puppet::Util::Execution.ruby_path()
 
-        context 'on POSIX', :unless => Puppet.features.microsoft_windows? do
-          it 'sends a SIGTERM and raises a Puppet::Error' do
-            Process.expects(:kill).at_least_once
-            expect { subject.refresh }.to raise_error Puppet::Error, "Command exceeded timeout"
-          end
-        end
+        ## Leaving this commented version in here because it fails on windows, due to what appears to be
+        ##  an assumption about hash iteration order in lib/puppet/type.rb#hash2resource, where
+        ##  resource[]= will overwrite the namevar with ":name" if the iteration is in the wrong order
+        #sleep_exec = Puppet::Type.type(:exec).new(:name => 'exec_spec sleep command', :command => "#{ruby_path} -e 'sleep 0.02'", :timeout => '0.01')
+        sleep_exec = Puppet::Type.type(:exec).new(:name => "#{ruby_path} -e 'sleep 0.02'", :timeout => '0.01')
 
-        context 'on Windows', :if => Puppet.features.microsoft_windows? do
-          it 'raises a Puppet::Error' do
-            expect { subject.refresh }.to raise_error Puppet::Error, "Command exceeded timeout"
-          end
-        end
+        expect { sleep_exec.refresh }.to raise_error Puppet::Error, "Command exceeded timeout"
       end
 
       it "should convert timeout to a float" do
         command = make_absolute('/bin/false')
         resource = Puppet::Type.type(:exec).new :command => command, :timeout => "12"
-        resource[:timeout].should be_a(Float)
-        resource[:timeout].should == 12.0
+        expect(resource[:timeout]).to be_a(Float)
+        expect(resource[:timeout]).to eq(12.0)
       end
 
       it "should munge negative timeouts to 0.0" do
         command = make_absolute('/bin/false')
         resource = Puppet::Type.type(:exec).new :command => command, :timeout => "-12.0"
-        resource.parameter(:timeout).value.should be_a(Float)
-        resource.parameter(:timeout).value.should == 0.0
+        expect(resource.parameter(:timeout).value).to be_a(Float)
+        expect(resource.parameter(:timeout).value).to eq(0.0)
       end
     end
 
@@ -435,14 +427,14 @@ describe Puppet::Type.type(:exec) do
       [1, 10, 4294967295].each do |valid|
         it "should accept '#{valid}' as valid" do
           @exec[:tries] = valid
-          @exec[:tries].should == valid
+          expect(@exec[:tries]).to eq(valid)
         end
 
         if "REVISIT: too much test log spam" == "a good thing" then
           it "should accept '#{valid}' in an array as valid" do
             pending "inconsistent, but this is not supporting arrays, unlike timeout"
             @exec[:tries] = [valid]
-            @exec[:tries].should == valid
+            expect(@exec[:tries]).to eq(valid)
           end
         end
       end
@@ -467,14 +459,14 @@ describe Puppet::Type.type(:exec) do
       [0, 0.2, 1, 10, 4294967295].each do |valid|
         it "should accept '#{valid}' as valid" do
           @exec[:try_sleep] = valid
-          @exec[:try_sleep].should == valid
+          expect(@exec[:try_sleep]).to eq(valid)
         end
 
         if "REVISIT: too much test log spam" == "a good thing" then
           it "should accept '#{valid}' in an array as valid" do
             pending "inconsistent, but this is not supporting arrays, unlike timeout"
             @exec[:try_sleep] = [valid]
-            @exec[:try_sleep].should == valid
+            expect(@exec[:try_sleep]).to eq(valid)
           end
         end
       end
@@ -506,7 +498,7 @@ describe Puppet::Type.type(:exec) do
       [:true, :false].each do |value|
         it "should accept '#{value}'" do
           @exec[:refreshonly] = value
-          @exec[:refreshonly].should == value
+          expect(@exec[:refreshonly]).to eq(value)
         end
       end
 
@@ -549,7 +541,7 @@ describe Puppet::Type.type(:exec) do
       { :true => false, :false => true }.each do |input, result|
         it "should return '#{result}' when given '#{input}'" do
           @test[:refreshonly] = input
-          @test.check_all_attributes.should == result
+          expect(@test.check_all_attributes).to eq(result)
         end
       end
     end
@@ -564,36 +556,36 @@ describe Puppet::Type.type(:exec) do
       context "with a single item" do
         it "should run when the item does not exist" do
           @test[:creates] = @unexist
-          @test.check_all_attributes.should == true
+          expect(@test.check_all_attributes).to eq(true)
         end
 
         it "should not run when the item exists" do
           @test[:creates] = @exist
-          @test.check_all_attributes.should == false
+          expect(@test.check_all_attributes).to eq(false)
         end
       end
 
       context "with an array with one item" do
         it "should run when the item does not exist" do
           @test[:creates] = [@unexist]
-          @test.check_all_attributes.should == true
+          expect(@test.check_all_attributes).to eq(true)
         end
 
         it "should not run when the item exists" do
           @test[:creates] = [@exist]
-          @test.check_all_attributes.should == false
+          expect(@test.check_all_attributes).to eq(false)
         end
       end
 
       context "with an array with multiple items" do
         it "should run when all items do not exist" do
           @test[:creates] = [@unexist] * 3
-          @test.check_all_attributes.should == true
+          expect(@test.check_all_attributes).to eq(true)
         end
 
         it "should not run when one item exists" do
           @test[:creates] = [@unexist, @exist, @unexist]
-          @test.check_all_attributes.should == false
+          expect(@test.check_all_attributes).to eq(false)
         end
 
         it "should not run when all items exist" do
@@ -625,49 +617,49 @@ describe Puppet::Type.type(:exec) do
         context "with a single item" do
           it "should run if the command exits non-zero" do
             @test[param] = @fail
-            @test.check_all_attributes.should == true
+            expect(@test.check_all_attributes).to eq(true)
           end
 
           it "should not run if the command exits zero" do
             @test[param] = @pass
-            @test.check_all_attributes.should == false
+            expect(@test.check_all_attributes).to eq(false)
           end
         end
 
         context "with an array with a single item" do
           it "should run if the command exits non-zero" do
             @test[param] = [@fail]
-            @test.check_all_attributes.should == true
+            expect(@test.check_all_attributes).to eq(true)
           end
 
           it "should not run if the command exits zero" do
             @test[param] = [@pass]
-            @test.check_all_attributes.should == false
+            expect(@test.check_all_attributes).to eq(false)
           end
         end
 
         context "with an array with multiple items" do
           it "should run if all the commands exits non-zero" do
             @test[param] = [@fail] * 3
-            @test.check_all_attributes.should == true
+            expect(@test.check_all_attributes).to eq(true)
           end
 
           it "should not run if one command exits zero" do
             @test[param] = [@pass, @fail, @pass]
-            @test.check_all_attributes.should == false
+            expect(@test.check_all_attributes).to eq(false)
           end
 
           it "should not run if all command exits zero" do
             @test[param] = [@pass] * 3
-            @test.check_all_attributes.should == false
+            expect(@test.check_all_attributes).to eq(false)
           end
         end
 
         it "should emit output to debug" do
           Puppet::Util::Log.level = :debug
           @test[param] = @fail
-          @test.check_all_attributes.should == true
-          @logs.shift.message.should == "test output"
+          expect(@test.check_all_attributes).to eq(true)
+          expect(@logs.shift.message).to eq("test output")
         end
       end
     end
@@ -680,18 +672,18 @@ describe Puppet::Type.type(:exec) do
 
     it "should return :notrun when check_all_attributes returns true" do
       @exec_resource.stubs(:check_all_attributes).returns true
-      @exec_resource.retrieve[:returns].should == :notrun
+      expect(@exec_resource.retrieve[:returns]).to eq(:notrun)
     end
 
     it "should return default exit code 0 when check_all_attributes returns false" do
       @exec_resource.stubs(:check_all_attributes).returns false
-      @exec_resource.retrieve[:returns].should == ['0']
+      expect(@exec_resource.retrieve[:returns]).to eq(['0'])
     end
 
     it "should return the specified exit code when check_all_attributes returns false" do
       @exec_resource.stubs(:check_all_attributes).returns false
       @exec_resource[:returns] = 42
-      @exec_resource.retrieve[:returns].should == ["42"]
+      expect(@exec_resource.retrieve[:returns]).to eq(["42"])
     end
   end
 
@@ -708,7 +700,7 @@ describe Puppet::Type.type(:exec) do
       @exec_resource.stubs(:provider).returns(provider)
 
       @exec_resource.refresh
-      @exec_resource.output.should == 'silly output'
+      expect(@exec_resource.output).to eq('silly output')
     end
   end
 
@@ -759,15 +751,15 @@ describe Puppet::Type.type(:exec) do
     end
 
     it "should accept a relative command with a path" do
-      type.new(:command => rel, :path => path).must be
+      expect(type.new(:command => rel, :path => path)).to be
     end
 
     it "should accept an absolute command with no path" do
-      type.new(:command => abs).must be
+      expect(type.new(:command => abs)).to be
     end
 
     it "should accept an absolute command with a path" do
-      type.new(:command => abs, :path => path).must be
+      expect(type.new(:command => abs, :path => path)).to be
     end
   end
   describe "when providing a umask" do