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

data/spec/unit/type/noop_metaparam_spec.rb

@@ -12,27 +12,27 @@ describe Puppet::Type.type(:file).attrclass(:noop) do
   end
 
   it "should accept true as a value" do
-    lambda { @file[:noop] = true }.should_not raise_error
+    expect { @file[:noop] = true }.not_to raise_error
   end
 
   it "should accept false as a value" do
-    lambda { @file[:noop] = false }.should_not raise_error
+    expect { @file[:noop] = false }.not_to raise_error
   end
 
   describe "when set on a resource" do
     it "should default to the :noop setting" do
       Puppet[:noop] = true
-      @file.noop.should == true
+      expect(@file.noop).to eq(true)
     end
 
     it "should prefer true values from the attribute" do
       @file[:noop] = true
-      @file.noop.should be_true
+      expect(@file.noop).to be_truthy
     end
 
     it "should prefer false values from the attribute" do
       @file[:noop] = false
-      @file.noop.should be_false
+      expect(@file.noop).to be_falsey
     end
   end
 end

data/spec/unit/type/package/package_settings_spec.rb

@@ -8,12 +8,12 @@ describe Puppet::Type.type(:package) do
   end
 
   it "should have a :package_settings feature that requires :package_settings_insync?, :package_settings and :package_settings=" do
-    described_class.provider_feature(:package_settings).methods.should == [:package_settings_insync?, :package_settings, :package_settings=]
+    expect(described_class.provider_feature(:package_settings).methods).to eq([:package_settings_insync?, :package_settings, :package_settings=])
   end
 
   context "when validating attributes" do
     it "should have a package_settings property" do
-      described_class.attrtype(:package_settings).should == :property
+      expect(described_class.attrtype(:package_settings)).to eq(:property)
     end
   end
 
@@ -36,7 +36,7 @@ describe Puppet::Type.type(:package) do
           end
           it { expect { resource }.to_not raise_error }
           it "should set package_settings to :settings" do
-            resource.value(:package_settings).should be :settings
+            expect(resource.value(:package_settings)).to be :settings
           end
         end
       end
@@ -50,7 +50,7 @@ describe Puppet::Type.type(:package) do
           end
           it { expect { resource }.to_not raise_error }
           it "should set package_settings to :valid_value" do
-            resource.value(:package_settings).should == :valid_value
+            expect(resource.value(:package_settings)).to eq(:valid_value)
           end
         end
         context "and {:package_settings => :invalid_value}" do
@@ -80,7 +80,7 @@ describe Puppet::Type.type(:package) do
             expect { resource }.to_not raise_error 
           end
           it "should set package_settings to :a" do
-            resource.value(:package_settings).should be :a
+            expect(resource.value(:package_settings)).to be :a
           end
         end
       end
@@ -104,19 +104,19 @@ describe Puppet::Type.type(:package) do
       describe "#insync?(:is)" do
         it "returns the result of provider.package_settings_insync?(:should,:is)" do
           resource.provider.expects(:package_settings_insync?).once.with(:should,:is).returns :ok1
-          resource.property(:package_settings).insync?(:is).should be :ok1
+          expect(resource.property(:package_settings).insync?(:is)).to be :ok1
         end
       end
       describe "#should_to_s(:newvalue)" do
         it "returns the result of provider.package_settings_should_to_s(:should,:newvalue)" do
           resource.provider.expects(:package_settings_should_to_s).once.with(:should,:newvalue).returns :ok2
-          resource.property(:package_settings).should_to_s(:newvalue).should be :ok2
+          expect(resource.property(:package_settings).should_to_s(:newvalue)).to be :ok2
         end
       end
       describe "#is_to_s(:currentvalue)" do
         it "returns the result of provider.package_settings_is_to_s(:should,:currentvalue)" do
           resource.provider.expects(:package_settings_is_to_s).once.with(:should,:currentvalue).returns :ok3
-          resource.property(:package_settings).is_to_s(:currentvalue).should be :ok3
+          expect(resource.property(:package_settings).is_to_s(:currentvalue)).to be :ok3
         end
       end
     end
@@ -127,7 +127,7 @@ describe Puppet::Type.type(:package) do
         end
         it "returns the result of provider.package_settings_change_to_s(:currentvalue,:newvalue)" do
           resource.provider.expects(:package_settings_change_to_s).once.with(:currentvalue,:newvalue).returns :ok4
-          resource.property(:package_settings).change_to_s(:currentvalue,:newvalue).should be :ok4
+          expect(resource.property(:package_settings).change_to_s(:currentvalue,:newvalue)).to be :ok4
         end
       end
     end

data/spec/unit/type/package_spec.rb

@@ -6,48 +6,52 @@ describe Puppet::Type.type(:package) do
     Puppet::Util::Storage.stubs(:store)
   end
 
+  it "should have a :reinstallable feature that requires the :reinstall method" do
+    expect(Puppet::Type.type(:package).provider_feature(:reinstallable).methods).to eq([:reinstall])
+  end
+
   it "should have an :installable feature that requires the :install method" do
-    Puppet::Type.type(:package).provider_feature(:installable).methods.should == [:install]
+    expect(Puppet::Type.type(:package).provider_feature(:installable).methods).to eq([:install])
   end
 
   it "should have an :uninstallable feature that requires the :uninstall method" do
-    Puppet::Type.type(:package).provider_feature(:uninstallable).methods.should == [:uninstall]
+    expect(Puppet::Type.type(:package).provider_feature(:uninstallable).methods).to eq([:uninstall])
   end
 
   it "should have an :upgradeable feature that requires :update and :latest methods" do
-    Puppet::Type.type(:package).provider_feature(:upgradeable).methods.should == [:update, :latest]
+    expect(Puppet::Type.type(:package).provider_feature(:upgradeable).methods).to eq([:update, :latest])
   end
 
   it "should have a :purgeable feature that requires the :purge latest method" do
-    Puppet::Type.type(:package).provider_feature(:purgeable).methods.should == [:purge]
+    expect(Puppet::Type.type(:package).provider_feature(:purgeable).methods).to eq([:purge])
   end
 
   it "should have a :versionable feature" do
-    Puppet::Type.type(:package).provider_feature(:versionable).should_not be_nil
+    expect(Puppet::Type.type(:package).provider_feature(:versionable)).not_to be_nil
   end
 
   it "should have a :package_settings feature that requires :package_settings_insync?, :package_settings and :package_settings=" do
-    Puppet::Type.type(:package).provider_feature(:package_settings).methods.should == [:package_settings_insync?, :package_settings, :package_settings=]
+    expect(Puppet::Type.type(:package).provider_feature(:package_settings).methods).to eq([:package_settings_insync?, :package_settings, :package_settings=])
   end
 
   it "should default to being installed" do
     pkg = Puppet::Type.type(:package).new(:name => "yay", :provider => :apt)
-    pkg.should(:ensure).should == :present
+    expect(pkg.should(:ensure)).to eq(:present)
   end
 
   describe "when validating attributes" do
-    [:name, :source, :instance, :status, :adminfile, :responsefile, :configfiles, :category, :platform, :root, :vendor, :description, :allowcdrom, :allow_virtual].each do |param|
+    [:name, :source, :instance, :status, :adminfile, :responsefile, :configfiles, :category, :platform, :root, :vendor, :description, :allowcdrom, :allow_virtual, :reinstall_on_refresh].each do |param|
       it "should have a #{param} parameter" do
-        Puppet::Type.type(:package).attrtype(param).should == :param
+        expect(Puppet::Type.type(:package).attrtype(param)).to eq(:param)
       end
     end
 
     it "should have an ensure property" do
-      Puppet::Type.type(:package).attrtype(:ensure).should == :property
+      expect(Puppet::Type.type(:package).attrtype(:ensure)).to eq(:property)
     end
 
     it "should have a package_settings property" do
-      Puppet::Type.type(:package).attrtype(:package_settings).should == :property
+      expect(Puppet::Type.type(:package).attrtype(:package_settings)).to eq(:property)
     end
   end
 
@@ -72,7 +76,7 @@ describe Puppet::Type.type(:package) do
 
     it "should alias :installed to :present as a value to :ensure" do
       pkg = Puppet::Type.type(:package).new(:name => "yay", :ensure => :installed)
-      pkg.should(:ensure).should == :present
+      expect(pkg.should(:ensure)).to eq(:present)
     end
 
     it "should support :absent as a value to :ensure" do
@@ -248,7 +252,7 @@ describe Puppet::Type.type(:package) do
       [:purged, :absent].each do |state|
         it "should install if it is #{state.to_s}" do
           @provider.stubs(:properties).returns(:ensure => state)
-          @package.property(:ensure).insync?(state).should be_false
+          expect(@package.property(:ensure).insync?(state)).to be_falsey
           @provider.expects(:install)
           @catalog.apply
         end
@@ -256,14 +260,14 @@ describe Puppet::Type.type(:package) do
 
       it "should do nothing if the current version is equal to the desired version" do
         @provider.stubs(:properties).returns(:ensure => "1.0")
-        @package.property(:ensure).insync?('1.0').should be_true
+        expect(@package.property(:ensure).insync?('1.0')).to be_truthy
         @provider.expects(:install).never
         @catalog.apply
       end
 
       it "should install if the current version is not equal to the specified version" do
         @provider.stubs(:properties).returns(:ensure => "2.0")
-        @package.property(:ensure).insync?('2.0').should be_false
+        expect(@package.property(:ensure).insync?('2.0')).to be_falsey
         @provider.expects(:install)
         @catalog.apply
       end
@@ -277,14 +281,14 @@ describe Puppet::Type.type(:package) do
 
         it "should install if value not in the array" do
           @package[:ensure] = "1.5"
-          @package.property(:ensure).insync?(installed_versions).should be_false
+          expect(@package.property(:ensure).insync?(installed_versions)).to be_falsey
           @provider.expects(:install)
           @catalog.apply
         end
 
         it "should not install if value is in the array" do
           @package[:ensure] = "2.0"
-          @package.property(:ensure).insync?(installed_versions).should be_true
+          expect(@package.property(:ensure).insync?(installed_versions)).to be_truthy
           @provider.expects(:install).never
           @catalog.apply
         end
@@ -293,12 +297,77 @@ describe Puppet::Type.type(:package) do
           it "should not install if the value is in the array" do
             @provider.expects(:latest).returns("3.0")
             @package[:ensure] = "latest"
-            @package.property(:ensure).insync?(installed_versions).should be_true
+            expect(@package.property(:ensure).insync?(installed_versions)).to be_truthy
             @provider.expects(:install).never
             @catalog.apply
           end
         end
       end
     end
+
+    describe Puppet::Type.type(:package), "when responding to refresh" do
+      include PackageEvaluationTesting
+
+      it "should support :true as a value to :reinstall_on_refresh" do
+        srv = Puppet::Type.type(:package).new(:name => "yay", :reinstall_on_refresh => :true)
+        expect(srv[:reinstall_on_refresh]).to eq(:true)
+      end
+
+      it "should support :false as a value to :reinstall_on_refresh" do
+        srv = Puppet::Type.type(:package).new(:name => "yay", :reinstall_on_refresh => :false)
+        expect(srv[:reinstall_on_refresh]).to eq(:false)
+      end
+
+      it "should specify :false as the default value of :reinstall_on_refresh" do
+        srv = Puppet::Type.type(:package).new(:name => "yay")
+        expect(srv[:reinstall_on_refresh]).to eq(:false)
+      end
+
+      [:latest, :present, :installed].each do |state|
+        it "should reinstall if it should be #{state.to_s} and reinstall_on_refresh is true" do
+          @package[:ensure] = state
+          @package[:reinstall_on_refresh] = :true
+          @provider.stubs(:reinstallable?).returns(true)
+          @provider.expects(:reinstall).once
+          @package.refresh
+        end
+
+        it "should reinstall if it should be #{state.to_s} and reinstall_on_refresh is false" do
+          @package[:ensure] = state
+          @package[:reinstall_on_refresh] = :false
+          @provider.stubs(:reinstallable?).returns(true)
+          @provider.expects(:reinstall).never
+          @package.refresh
+        end
+      end
+
+      [:purged, :absent, :held].each do |state|
+        it "should not reinstall if it should be #{state.to_s} and reinstall_on_refresh is true" do
+          @package[:ensure] = state
+          @provider.stubs(:reinstallable?).returns(true)
+          @provider.expects(:reinstall).never
+          @package.refresh
+        end
+
+        it "should not reinstall if it should be #{state.to_s} and reinstall_on_refresh is false" do
+          @package[:ensure] = state
+          @provider.stubs(:reinstallable?).returns(true)
+          @provider.expects(:reinstall).never
+          @package.refresh
+        end
+      end
+    end
+  end
+
+  describe "allow_virtual" do
+    it "defaults to true on platforms that support virtual packages" do
+      pkg = Puppet::Type.type(:package).new(:name => 'yay', :provider => :yum)
+      expect(pkg[:allow_virtual]).to eq true
+    end
+
+    it "defaults to false on platforms that do not support virtual packages" do
+      pkg = Puppet::Type.type(:package).new(:name => 'yay', :provider => :apple)
+      expect(pkg[:allow_virtual]).to be_nil
+    end
   end
 end

data/spec/unit/type/resources_spec.rb

@@ -10,27 +10,27 @@ describe resources do
     described_class.reset_system_users_max_uid!
   end
 
-  describe "when initializing" do
+  context "when initializing" do
     it "should fail if the specified resource type does not exist" do
       Puppet::Type.stubs(:type).with { |x| x.to_s.downcase == "resources"}.returns resources
       Puppet::Type.expects(:type).with("nosuchtype").returns nil
-      lambda { resources.new :name => "nosuchtype" }.should raise_error(Puppet::Error)
+      expect { resources.new :name => "nosuchtype" }.to raise_error(Puppet::Error)
     end
 
     it "should not fail when the specified resource type exists" do
-      lambda { resources.new :name => "file" }.should_not raise_error
+      expect { resources.new :name => "file" }.not_to raise_error
     end
 
     it "should set its :resource_type attribute" do
-      resources.new(:name => "file").resource_type.should == Puppet::Type.type(:file)
+      expect(resources.new(:name => "file").resource_type).to eq(Puppet::Type.type(:file))
     end
   end
 
-  describe :purge do
+  context "purge" do
     let (:instance) { described_class.new(:name => 'file') }
 
     it "defaults to false" do
-      instance[:purge].should be_false
+      expect(instance[:purge]).to be_falsey
     end
 
     it "can be set to false" do
@@ -56,8 +56,8 @@ describe resources do
     end
   end
 
-  describe "#check_user purge behaviour" do
-    describe "with unless_system_user => true" do
+  context "#check_user purge behaviour" do
+    context "with unless_system_user => true" do
       before do
         @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_system_user => true
         @res.catalog = Puppet::Resource::Catalog.new
@@ -66,7 +66,7 @@ describe resources do
 
       it "should never purge hardcoded system users" do
         %w{root nobody bin noaccess daemon sys}.each do |sys_user|
-          @res.user_check(Puppet::Type.type(:user).new(:name => sys_user)).should be_false
+          expect(@res.user_check(Puppet::Type.type(:user).new(:name => sys_user))).to be_falsey
         end
       end
 
@@ -74,14 +74,14 @@ describe resources do
         user_hash = {:name => 'system_user', :uid => 125, :system => true}
         user = Puppet::Type.type(:user).new(user_hash)
         user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
-        @res.user_check(user).should be_false
+        expect(@res.user_check(user)).to be_falsey
       end
 
       it "should purge non-system users if unless_system_user => true" do
         user_hash = {:name => 'system_user', :uid => described_class.system_users_max_uid + 1, :system => true}
         user = Puppet::Type.type(:user).new(user_hash)
         user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
-        @res.user_check(user).should be_true
+        expect(@res.user_check(user)).to be_truthy
       end
 
       it "should not purge system users under 600 if unless_system_user => 600" do
@@ -90,12 +90,12 @@ describe resources do
         user_hash = {:name => 'system_user', :uid => 500, :system => true}
         user = Puppet::Type.type(:user).new(user_hash)
         user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
-        res.user_check(user).should be_false
+        expect(res.user_check(user)).to be_falsey
       end
     end
 
     %w(FreeBSD OpenBSD).each do |os|
-      describe "on #{os}" do
+      context "on #{os}" do
         before :each do
           Facter.stubs(:value).with(:kernel).returns(os)
           Facter.stubs(:value).with(:operatingsystem).returns(os)
@@ -109,19 +109,19 @@ describe resources do
           user_hash = {:name => 'system_user', :uid => 999}
           user = Puppet::Type.type(:user).new(user_hash)
           user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
-          @res.user_check(user).should be_false
+          expect(@res.user_check(user)).to be_falsey
         end
 
         it "should purge users over 999" do
           user_hash = {:name => 'system_user', :uid => 1000}
           user = Puppet::Type.type(:user).new(user_hash)
           user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
-          @res.user_check(user).should be_true
+          expect(@res.user_check(user)).to be_truthy
         end
       end
     end
 
-    describe 'with login.defs present' do
+    context 'with login.defs present' do
       before :each do
         Puppet::FileSystem.expects(:exist?).with('/etc/login.defs').returns true
         Puppet::FileSystem.expects(:each_line).with('/etc/login.defs').yields(' UID_MIN         1234 # UID_MIN comment ')
@@ -133,19 +133,19 @@ describe resources do
         user_hash = {:name => 'system_user', :uid => 1233}
         user = Puppet::Type.type(:user).new(user_hash)
         user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
-        @res.user_check(user).should be_false
+        expect(@res.user_check(user)).to be_falsey
       end
 
       it 'should purge a non-system user' do
         user_hash = {:name => 'system_user', :uid => 1234}
         user = Puppet::Type.type(:user).new(user_hash)
         user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
-        @res.user_check(user).should be_true
+        expect(@res.user_check(user)).to be_truthy
       end
     end
 
-    describe "with unless_uid" do
-      describe "with a uid array" do
+    context "with unless_uid" do
+      context "with a uid array" do
         before do
           @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_uid => [15_000, 15_001, 15_002]
           @res.catalog = Puppet::Resource::Catalog.new
@@ -155,19 +155,19 @@ describe resources do
           user_hash = {:name => 'special_user', :uid => 25_000}
           user = Puppet::Type.type(:user).new(user_hash)
           user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
-          @res.user_check(user).should be_true
+          expect(@res.user_check(user)).to be_truthy
         end
 
         it "should not purge uids that are in a specified array" do
           user_hash = {:name => 'special_user', :uid => 15000}
           user = Puppet::Type.type(:user).new(user_hash)
           user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
-          @res.user_check(user).should be_false
+          expect(@res.user_check(user)).to be_falsey
         end
 
       end
 
-      describe "with a single integer uid" do
+      context "with a single integer uid" do
         before do
           @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_uid => 15_000
           @res.catalog = Puppet::Resource::Catalog.new
@@ -177,18 +177,18 @@ describe resources do
           user_hash = {:name => 'special_user', :uid => 25_000}
           user = Puppet::Type.type(:user).new(user_hash)
           user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
-          @res.user_check(user).should be_true
+          expect(@res.user_check(user)).to be_truthy
         end
 
         it "should not purge uids that are specified" do
           user_hash = {:name => 'special_user', :uid => 15_000}
           user = Puppet::Type.type(:user).new(user_hash)
           user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
-          @res.user_check(user).should be_false
+          expect(@res.user_check(user)).to be_falsey
         end
       end
 
-      describe "with a single string uid" do
+      context "with a single string uid" do
         before do
           @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_uid => '15000'
           @res.catalog = Puppet::Resource::Catalog.new
@@ -198,18 +198,18 @@ describe resources do
           user_hash = {:name => 'special_user', :uid => 25_000}
           user = Puppet::Type.type(:user).new(user_hash)
           user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
-          @res.user_check(user).should be_true
+          expect(@res.user_check(user)).to be_truthy
         end
 
         it "should not purge uids that are specified" do
           user_hash = {:name => 'special_user', :uid => 15_000}
           user = Puppet::Type.type(:user).new(user_hash)
           user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
-          @res.user_check(user).should be_false
+          expect(@res.user_check(user)).to be_falsey
         end
       end
 
-      describe "with a mixed uid array" do
+      context "with a mixed uid array" do
         before do
           @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_uid => ['15000', 16_666]
           @res.catalog = Puppet::Resource::Catalog.new
@@ -219,44 +219,44 @@ describe resources do
           user_hash = {:name => 'special_user', :uid => 15_000}
           user = Puppet::Type.type(:user).new(user_hash)
           user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
-          @res.user_check(user).should be_false
+          expect(@res.user_check(user)).to be_falsey
         end
 
         it "should not purge specified ids" do
           user_hash = {:name => 'special_user', :uid => 16_666}
           user = Puppet::Type.type(:user).new(user_hash)
           user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
-          @res.user_check(user).should be_false
+          expect(@res.user_check(user)).to be_falsey
         end
 
         it "should purge unspecified ids" do
           user_hash = {:name => 'special_user', :uid => 17_000}
           user = Puppet::Type.type(:user).new(user_hash)
           user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
-          @res.user_check(user).should be_true
+          expect(@res.user_check(user)).to be_truthy
         end
       end
 
     end
   end
 
-  describe "#generate" do
+  context "#generate" do
     before do
       @host1 = Puppet::Type.type(:host).new(:name => 'localhost', :ip => '127.0.0.1')
       @catalog = Puppet::Resource::Catalog.new
     end
 
-      describe "when dealing with non-purging resources" do
+      context "when dealing with non-purging resources" do
         before do
           @resources = Puppet::Type.type(:resources).new(:name => 'host')
         end
 
         it "should not generate any resource" do
-          @resources.generate.should be_empty
+          expect(@resources.generate).to be_empty
         end
       end
 
-      describe "when the catalog contains a purging resource" do
+      context "when the catalog contains a purging resource" do
         before do
           @resources = Puppet::Type.type(:resources).new(:name => 'host', :purge => true)
           @purgeable_resource = Puppet::Type.type(:host).new(:name => 'localhost', :ip => '127.0.0.1')
@@ -266,7 +266,7 @@ describe resources do
         it "should not generate a duplicate of that resource" do
           Puppet::Type.type(:host).stubs(:instances).returns [@host1]
           @catalog.add_resource @host1
-          @resources.generate.collect { |r| r.ref }.should_not include(@host1.ref)
+          expect(@resources.generate.collect { |r| r.ref }).not_to include(@host1.ref)
         end
 
         it "should not include the skipped system users" do
@@ -279,38 +279,38 @@ describe resources do
           list = res.generate
 
           names = list.collect { |r| r[:name] }
-          names.should_not be_include("root")
+          expect(names).not_to be_include("root")
         end
 
-        describe "when generating a purgeable resource" do
+        context "when generating a purgeable resource" do
           it "should be included in the generated resources" do
             Puppet::Type.type(:host).stubs(:instances).returns [@purgeable_resource]
-            @resources.generate.collect { |r| r.ref }.should include(@purgeable_resource.ref)
+            expect(@resources.generate.collect { |r| r.ref }).to include(@purgeable_resource.ref)
           end
         end
 
-        describe "when the instance's do not have an ensure property" do
+        context "when the instance's do not have an ensure property" do
           it "should not be included in the generated resources" do
             @no_ensure_resource = Puppet::Type.type(:exec).new(:name => "#{File.expand_path('/usr/bin/env')} echo")
             Puppet::Type.type(:host).stubs(:instances).returns [@no_ensure_resource]
-            @resources.generate.collect { |r| r.ref }.should_not include(@no_ensure_resource.ref)
+            expect(@resources.generate.collect { |r| r.ref }).not_to include(@no_ensure_resource.ref)
           end
         end
 
-        describe "when the instance's ensure property does not accept absent" do
+        context "when the instance's ensure property does not accept absent" do
           it "should not be included in the generated resources" do
             @no_absent_resource = Puppet::Type.type(:service).new(:name => 'foobar')
             Puppet::Type.type(:host).stubs(:instances).returns [@no_absent_resource]
-            @resources.generate.collect { |r| r.ref }.should_not include(@no_absent_resource.ref)
+            expect(@resources.generate.collect { |r| r.ref }).not_to include(@no_absent_resource.ref)
           end
         end
 
-        describe "when checking the instance fails" do
+        context "when checking the instance fails" do
           it "should not be included in the generated resources" do
             @purgeable_resource = Puppet::Type.type(:host).new(:name => 'foobar')
             Puppet::Type.type(:host).stubs(:instances).returns [@purgeable_resource]
             @resources.expects(:check).with(@purgeable_resource).returns(false)
-            @resources.generate.collect { |r| r.ref }.should_not include(@purgeable_resource.ref)
+            expect(@resources.generate.collect { |r| r.ref }).not_to include(@purgeable_resource.ref)
           end
         end
       end