puppet 3.8.7 → 4.0.0

data/spec/unit/provider/file/posix_spec.rb

@@ -6,7 +6,7 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
   include PuppetSpec::Files
 
   let(:path) { tmpfile('posix_file_spec') }
-  let(:resource) { Puppet::Type.type(:file).new :path => path, :mode => 0777, :provider => described_class.name }
+  let(:resource) { Puppet::Type.type(:file).new :path => path, :mode => '0777', :provider => described_class.name }
   let(:provider) { resource.provider }
 
   describe "#mode" do
@@ -14,11 +14,11 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
       FileUtils.touch(path)
       File.chmod(0644, path)
 
-      provider.mode.should == '644'
+      expect(provider.mode).to eq('0644')
     end
 
     it "should return absent if the file doesn't exist" do
-      provider.mode.should == :absent
+      expect(provider.mode).to eq(:absent)
     end
   end
 
@@ -29,12 +29,12 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
 
       provider.mode = '0755'
 
-      provider.mode.should == '755'
+      expect(provider.mode).to eq('0755')
     end
 
     it "should pass along any errors encountered" do
       expect do
-        provider.mode = '644'
+        provider.mode = '0644'
       end.to raise_error(Puppet::Error, /failed to set mode/)
     end
   end
@@ -43,21 +43,21 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
     it "should return the name of the user identified by the id" do
       Etc.stubs(:getpwuid).with(501).returns(Struct::Passwd.new('jilluser', nil, 501))
 
-      provider.uid2name(501).should == 'jilluser'
+      expect(provider.uid2name(501)).to eq('jilluser')
     end
 
     it "should return the argument if it's already a name" do
-      provider.uid2name('jilluser').should == 'jilluser'
+      expect(provider.uid2name('jilluser')).to eq('jilluser')
     end
 
     it "should return nil if the argument is above the maximum uid" do
-      provider.uid2name(Puppet[:maximum_uid] + 1).should == nil
+      expect(provider.uid2name(Puppet[:maximum_uid] + 1)).to eq(nil)
     end
 
     it "should return nil if the user doesn't exist" do
       Etc.expects(:getpwuid).raises(ArgumentError, "can't find user for 999")
 
-      provider.uid2name(999).should == nil
+      expect(provider.uid2name(999)).to eq(nil)
     end
   end
 
@@ -68,17 +68,17 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
       Etc.stubs(:getpwnam).with('bobbo').returns(passwd)
       Etc.stubs(:getpwuid).with(502).returns(passwd)
 
-      provider.name2uid('bobbo').should == 502
+      expect(provider.name2uid('bobbo')).to eq(502)
     end
 
     it "should return the argument if it's already an id" do
-      provider.name2uid('503').should == 503
+      expect(provider.name2uid('503')).to eq(503)
     end
 
     it "should return false if the user doesn't exist" do
       Etc.stubs(:getpwnam).with('chuck').raises(ArgumentError, "can't find user for chuck")
 
-      provider.name2uid('chuck').should == false
+      expect(provider.name2uid('chuck')).to eq(false)
     end
   end
 
@@ -87,19 +87,19 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
       FileUtils.touch(path)
       owner = Puppet::FileSystem.stat(path).uid
 
-      provider.owner.should == owner
+      expect(provider.owner).to eq(owner)
     end
 
     it "should return absent if the file can't be statted" do
-      provider.owner.should == :absent
+      expect(provider.owner).to eq(:absent)
     end
 
     it "should warn and return :silly if the value is beyond the maximum uid" do
       stat = stub('stat', :uid => Puppet[:maximum_uid] + 1)
       resource.stubs(:stat).returns(stat)
 
-      provider.owner.should == :silly
-      @logs.should be_any {|log| log.level == :warning and log.message =~ /Apparently using negative UID/}
+      expect(provider.owner).to eq(:silly)
+      expect(@logs).to be_any {|log| log.level == :warning and log.message =~ /Apparently using negative UID/}
     end
   end
 
@@ -135,21 +135,21 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
     it "should return the name of the group identified by the id" do
       Etc.stubs(:getgrgid).with(501).returns(Struct::Passwd.new('unicorns', nil, nil, 501))
 
-      provider.gid2name(501).should == 'unicorns'
+      expect(provider.gid2name(501)).to eq('unicorns')
     end
 
     it "should return the argument if it's already a name" do
-      provider.gid2name('leprechauns').should == 'leprechauns'
+      expect(provider.gid2name('leprechauns')).to eq('leprechauns')
     end
 
     it "should return nil if the argument is above the maximum gid" do
-      provider.gid2name(Puppet[:maximum_uid] + 1).should == nil
+      expect(provider.gid2name(Puppet[:maximum_uid] + 1)).to eq(nil)
     end
 
     it "should return nil if the group doesn't exist" do
       Etc.expects(:getgrgid).raises(ArgumentError, "can't find group for 999")
 
-      provider.gid2name(999).should == nil
+      expect(provider.gid2name(999)).to eq(nil)
     end
   end
 
@@ -160,17 +160,17 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
       Etc.stubs(:getgrnam).with('penguins').returns(passwd)
       Etc.stubs(:getgrgid).with(502).returns(passwd)
 
-      provider.name2gid('penguins').should == 502
+      expect(provider.name2gid('penguins')).to eq(502)
     end
 
     it "should return the argument if it's already an id" do
-      provider.name2gid('503').should == 503
+      expect(provider.name2gid('503')).to eq(503)
     end
 
     it "should return false if the group doesn't exist" do
       Etc.stubs(:getgrnam).with('wombats').raises(ArgumentError, "can't find group for wombats")
 
-      provider.name2gid('wombats').should == false
+      expect(provider.name2gid('wombats')).to eq(false)
     end
 
   end
@@ -180,19 +180,19 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
       FileUtils.touch(path)
       group = Puppet::FileSystem.stat(path).gid
 
-      provider.group.should == group
+      expect(provider.group).to eq(group)
     end
 
     it "should return absent if the file can't be statted" do
-      provider.group.should == :absent
+      expect(provider.group).to eq(:absent)
     end
 
     it "should warn and return :silly if the value is beyond the maximum gid" do
       stat = stub('stat', :gid => Puppet[:maximum_uid] + 1)
       resource.stubs(:stat).returns(stat)
 
-      provider.group.should == :silly
-      @logs.should be_any {|log| log.level == :warning and log.message =~ /Apparently using negative GID/}
+      expect(provider.group).to eq(:silly)
+      expect(@logs).to be_any {|log| log.level == :warning and log.message =~ /Apparently using negative GID/}
     end
   end
 

data/spec/unit/provider/file/windows_spec.rb

@@ -12,21 +12,21 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
   include PuppetSpec::Files
 
   let(:path) { tmpfile('windows_file_spec') }
-  let(:resource) { Puppet::Type.type(:file).new :path => path, :mode => 0777, :provider => described_class.name }
+  let(:resource) { Puppet::Type.type(:file).new :path => path, :mode => '0777', :provider => described_class.name }
   let(:provider) { resource.provider }
   let(:sid)      { 'S-1-1-50' }
   let(:account)  { 'quinn' }
 
   describe "#mode" do
-    it "should return a string with the higher-order bits stripped away" do
+    it "should return a string representing the mode in 4-digit octal notation" do
       FileUtils.touch(path)
       WindowsSecurity.set_mode(0644, path)
 
-      provider.mode.should == '644'
+      expect(provider.mode).to eq('0644')
     end
 
     it "should return absent if the file doesn't exist" do
-      provider.mode.should == :absent
+      expect(provider.mode).to eq(:absent)
     end
   end
 
@@ -37,12 +37,12 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
 
       provider.mode = '0755'
 
-      provider.mode.should == '755'
+      expect(provider.mode).to eq('0755')
     end
 
     it "should pass along any errors encountered" do
       expect do
-        provider.mode = '644'
+        provider.mode = '0644'
       end.to raise_error(Puppet::Error, /failed to set mode/)
     end
   end
@@ -52,21 +52,21 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
       Puppet::Util::Windows::SID.expects(:valid_sid?).with(sid).returns(true)
       Puppet::Util::Windows::SID.expects(:sid_to_name).with(sid).returns(account)
 
-      provider.id2name(sid).should == account
+      expect(provider.id2name(sid)).to eq(account)
     end
 
     it "should return the argument if it's already a name" do
       Puppet::Util::Windows::SID.expects(:valid_sid?).with(account).returns(false)
       Puppet::Util::Windows::SID.expects(:sid_to_name).never
 
-      provider.id2name(account).should == account
+      expect(provider.id2name(account)).to eq(account)
     end
 
     it "should return nil if the user doesn't exist" do
       Puppet::Util::Windows::SID.expects(:valid_sid?).with(sid).returns(true)
       Puppet::Util::Windows::SID.expects(:sid_to_name).with(sid).returns(nil)
 
-      provider.id2name(sid).should == nil
+      expect(provider.id2name(sid)).to eq(nil)
     end
   end
 
@@ -74,7 +74,7 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
     it "should delegate to name_to_sid" do
       Puppet::Util::Windows::SID.expects(:name_to_sid).with(account).returns(sid)
 
-      provider.name2id(account).should == sid
+      expect(provider.name2id(account)).to eq(sid)
     end
   end
 
@@ -83,11 +83,11 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
       FileUtils.touch(resource[:path])
       provider.stubs(:get_owner).with(resource[:path]).returns(sid)
 
-      provider.owner.should == sid
+      expect(provider.owner).to eq(sid)
     end
 
     it "should return absent if the file doesn't exist" do
-      provider.owner.should == :absent
+      expect(provider.owner).to eq(:absent)
     end
   end
 
@@ -111,11 +111,11 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
       FileUtils.touch(resource[:path])
       provider.stubs(:get_group).with(resource[:path]).returns(sid)
 
-      provider.group.should == sid
+      expect(provider.group).to eq(sid)
     end
 
     it "should return absent if the file doesn't exist" do
-      provider.group.should == :absent
+      expect(provider.group).to eq(:absent)
     end
   end
 
@@ -135,7 +135,7 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
   end
 
   describe "when validating" do
-    {:owner => 'foo', :group => 'foo', :mode => 0777}.each do |k,v|
+    {:owner => 'foo', :group => 'foo', :mode => '0777'}.each do |k,v|
       it "should fail if the filesystem doesn't support ACLs and we're managing #{k}" do
         described_class.any_instance.stubs(:supports_acl?).returns false
 

data/spec/unit/provider/group/groupadd_spec.rb

@@ -59,7 +59,7 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
       it "should raise an exception for duplicate GID if allowdupe is not set and duplicate GIDs exist" do
         resource[:gid] = 505
         provider.stubs(:findgroup).returns(true)
-        lambda { provider.create }.should raise_error(Puppet::Error, "GID 505 already exists, use allowdupe to force group creation")
+        expect { provider.create }.to raise_error(Puppet::Error, "GID 505 already exists, use allowdupe to force group creation")
      end
     end
 

data/spec/unit/provider/group/ldap_spec.rb

@@ -5,31 +5,31 @@ provider_class = Puppet::Type.type(:group).provider(:ldap)
 
 describe provider_class do
   it "should have the Ldap provider class as its baseclass" do
-    provider_class.superclass.should equal(Puppet::Provider::Ldap)
+    expect(provider_class.superclass).to equal(Puppet::Provider::Ldap)
   end
 
   it "should manage :posixGroup objectclass" do
-    provider_class.manager.objectclasses.should == [:posixGroup]
+    expect(provider_class.manager.objectclasses).to eq([:posixGroup])
   end
 
   it "should use 'ou=Groups' as its relative base" do
-    provider_class.manager.location.should == "ou=Groups"
+    expect(provider_class.manager.location).to eq("ou=Groups")
   end
 
   it "should use :cn as its rdn" do
-    provider_class.manager.rdn.should == :cn
+    expect(provider_class.manager.rdn).to eq(:cn)
   end
 
   it "should map :name to 'cn'" do
-    provider_class.manager.ldap_name(:name).should == 'cn'
+    expect(provider_class.manager.ldap_name(:name)).to eq('cn')
   end
 
   it "should map :gid to 'gidNumber'" do
-    provider_class.manager.ldap_name(:gid).should == 'gidNumber'
+    expect(provider_class.manager.ldap_name(:gid)).to eq('gidNumber')
   end
 
   it "should map :members to 'memberUid', to be used by the user ldap provider" do
-    provider_class.manager.ldap_name(:members).should == 'memberUid'
+    expect(provider_class.manager.ldap_name(:members)).to eq('memberUid')
   end
 
   describe "when being created" do
@@ -75,7 +75,7 @@ describe provider_class do
   end
 
   it "should have a method for converting group names to GIDs" do
-    provider_class.should respond_to(:name2id)
+    expect(provider_class).to respond_to(:name2id)
   end
 
   describe "when converting from a group name to GID" do
@@ -86,16 +86,16 @@ describe provider_class do
 
     it "should return nil if no group is found" do
       provider_class.manager.expects(:search).with("cn=foo").returns nil
-      provider_class.name2id("foo").should be_nil
+      expect(provider_class.name2id("foo")).to be_nil
       provider_class.manager.expects(:search).with("cn=bar").returns []
-      provider_class.name2id("bar").should be_nil
+      expect(provider_class.name2id("bar")).to be_nil
     end
 
     # We shouldn't ever actually have more than one gid, but it doesn't hurt
     # to test for the possibility.
     it "should return the first gid from the first returned group" do
       provider_class.manager.expects(:search).with("cn=foo").returns [{:name => "foo", :gid => [10, 11]}, {:name => :bar, :gid => [20, 21]}]
-      provider_class.name2id("foo").should == 10
+      expect(provider_class.name2id("foo")).to eq(10)
     end
   end
 end

data/spec/unit/provider/group/pw_spec.rb

@@ -20,7 +20,7 @@ describe provider_class do
     end
 
     it "should run pw with no additional flags when no properties are given" do
-      provider.addcmd.must == [provider_class.command(:pw), "groupadd", "testgroup"]
+      expect(provider.addcmd).to eq([provider_class.command(:pw), "groupadd", "testgroup"])
       provider.expects(:execute).with([provider_class.command(:pw), "groupadd", "testgroup"], kind_of(Hash))
       provider.create
     end
@@ -53,7 +53,7 @@ describe provider_class do
   describe "when deleting groups" do
     it "should run pw with no additional flags" do
       provider.expects(:exists?).returns true
-      provider.deletecmd.must == [provider_class.command(:pw), "groupdel", "testgroup"]
+      expect(provider.deletecmd).to eq([provider_class.command(:pw), "groupdel", "testgroup"])
       provider.expects(:execute).with([provider_class.command(:pw), "groupdel", "testgroup"])
       provider.delete
     end
@@ -61,7 +61,7 @@ describe provider_class do
 
   describe "when modifying groups" do
     it "should run pw with the correct arguments" do
-      provider.modifycmd("gid", 12345).must == [provider_class.command(:pw), "groupmod", "testgroup", "-g", 12345]
+      expect(provider.modifycmd("gid", 12345)).to eq([provider_class.command(:pw), "groupmod", "testgroup", "-g", 12345])
       provider.expects(:execute).with([provider_class.command(:pw), "groupmod", "testgroup", "-g", 12345])
       provider.gid = 12345
     end

data/spec/unit/provider/group/windows_adsi_spec.rb

@@ -26,7 +26,7 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
 
       connection.stubs(:execquery).with('select name from win32_group where localaccount = "TRUE"').returns stub_groups
 
-      described_class.instances.map(&:name).should =~ names
+      expect(described_class.instances.map(&:name)).to match(names)
     end
   end
 
@@ -35,76 +35,80 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
     let(:user1) { stub(:account => 'user1', :domain => '.', :to_s => 'user1sid') }
     let(:user2) { stub(:account => 'user2', :domain => '.', :to_s => 'user2sid') }
     let(:user3) { stub(:account => 'user3', :domain => '.', :to_s => 'user3sid') }
-    let(:invalid_user) { SecureRandom.uuid }
 
     before :each do
       Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('user1').returns(user1)
       Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('user2').returns(user2)
       Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('user3').returns(user3)
-      Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with(invalid_user).returns(nil)
     end
 
     describe "#members_insync?" do
       it "should return false when current is nil" do
-        provider.members_insync?(nil, ['user2']).should be_false
+        expect(provider.members_insync?(nil, ['user2'])).to be_falsey
       end
 
       it "should return false when should is nil" do
-        provider.members_insync?(['user1'], nil).should be_false
-      end
-
-      it "should return false for differing lists of members" do
-        provider.members_insync?(['user1'], ['user2']).should be_false
-        provider.members_insync?(['user1'], []).should be_false
-        provider.members_insync?([], ['user2']).should be_false
+        expect(provider.members_insync?(['user1'], nil)).to be_falsey
       end
 
       it "should return true for same lists of members" do
-        provider.members_insync?(['user1', 'user2'], ['user1', 'user2']).should be_true
+        expect(provider.members_insync?(['user1', 'user2'], ['user1', 'user2'])).to be_truthy
       end
 
       it "should return true for same lists of unordered members" do
-        provider.members_insync?(['user1', 'user2'], ['user2', 'user1']).should be_true
+        expect(provider.members_insync?(['user1', 'user2'], ['user2', 'user1'])).to be_truthy
       end
 
       it "should return true for same lists of members irrespective of duplicates" do
-        provider.members_insync?(['user1', 'user2', 'user2'], ['user2', 'user1', 'user1']).should be_true
-      end
-
-      it "should return true when current user(s) and should user(s) are empty lists" do
-        provider.members_insync?([], []).should be_true
+        expect(provider.members_insync?(['user1', 'user2', 'user2'], ['user2', 'user1', 'user1'])).to be_truthy
       end
 
       context "when auth_membership => true" do
         before :each do
-          # this is also the default
           resource[:auth_membership] = true
         end
 
-        it "should return false when should user(s) are not the only items in the current" do
-          provider.members_insync?(['user1', 'user2'], ['user1']).should be_false
+        it "should return false when current contains different users than should" do
+          expect(provider.members_insync?(['user1'], ['user2'])).to be_falsey
+        end
+
+        it "should return false when current contains members and should is empty" do
+          expect(provider.members_insync?(['user1'], [])).to be_falsey
         end
 
-        it "should return false when current user(s) is not empty and should is an empty list" do
-          provider.members_insync?(['user1','user2'], []).should be_false
+        it "should return false when current is empty and should contains members" do
+          expect(provider.members_insync?([], ['user2'])).to be_falsey
+        end
+
+        it "should return false when should user(s) are not the only items in the current" do
+          expect(provider.members_insync?(['user1', 'user2'], ['user1'])).to be_falsey
         end
       end
 
       context "when auth_membership => false" do
         before :each do
+          # this is also the default
           resource[:auth_membership] = false
         end
 
-        it "should return true when current user(s) contains at least the should list" do
-          provider.members_insync?(['user1','user2'], ['user1']).should be_true
+        it "should return false when current contains different users than should" do
+          expect(provider.members_insync?(['user1'], ['user2'])).to be_falsey
+        end
+
+        it "should return true when current contains members and should is empty" do
+          expect(provider.members_insync?(['user1'], [])).to be_truthy
         end
 
-        it "should return true when current user(s) is not empty and should is an empty list" do
-          provider.members_insync?(['user1','user2'], []).should be_true
+        it "should return false when current is empty and should contains members" do
+          expect(provider.members_insync?([], ['user2'])).to be_falsey
         end
 
+        it "should return true when current user(s) contains at least the should list" do
+          expect(provider.members_insync?(['user1','user2'], ['user1'])).to be_truthy
+          end
+
         it "should return true when current user(s) contains at least the should list, even unordered" do
-          provider.members_insync?(['user3','user1','user2'], ['user2','user1']).should be_true
+          expect(provider.members_insync?(['user3','user1','user2'], ['user2','user1'])).to be_truthy
         end
       end
     end
@@ -112,30 +116,31 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
     describe "#members_to_s" do
       it "should return an empty string on non-array input" do
         [Object.new, {}, 1, :symbol, ''].each do |input|
-          provider.members_to_s(input).should be_empty
+          expect(provider.members_to_s(input)).to be_empty
         end
       end
       it "should return an empty string on empty or nil users" do
-        provider.members_to_s([]).should be_empty
-        provider.members_to_s(nil).should be_empty
+        expect(provider.members_to_s([])).to be_empty
+        expect(provider.members_to_s(nil)).to be_empty
       end
       it "should return a user string like DOMAIN\\USER" do
-        provider.members_to_s(['user1']).should == '.\user1'
+        expect(provider.members_to_s(['user1'])).to eq('.\user1')
       end
       it "should return a user string like DOMAIN\\USER,DOMAIN2\\USER2" do
-        provider.members_to_s(['user1', 'user2']).should == '.\user1,.\user2'
-      end
-      it "should return the username when it cannot be resolved to a SID (for the sake of resource_harness error messages)" do
-        expect(provider.members_to_s([invalid_user])).to eq("#{invalid_user}")
+        expect(provider.members_to_s(['user1', 'user2'])).to eq('.\user1,.\user2')
       end
     end
   end
 
   describe "when managing members" do
+    before :each do
+      resource[:auth_membership] = true
+    end
+
     it "should be able to provide a list of members" do
       provider.group.stubs(:members).returns ['user1', 'user2', 'user3']
 
-      provider.members.should =~ ['user1', 'user2', 'user3']
+      expect(provider.members).to match_array(['user1', 'user2', 'user3'])
     end
 
     it "should be able to set group members" do
@@ -168,7 +173,8 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
 
       create = sequence('create')
       group.expects(:commit).in_sequence(create)
-      group.expects(:set_members).with(['user1', 'user2'], true).in_sequence(create)
+      # due to PUP-1967, defaultto false will set the default to nil
+      group.expects(:set_members).with(['user1', 'user2'], nil).in_sequence(create)
 
       provider.create
     end
@@ -179,18 +185,6 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
         /Cannot create group if user 'testers' exists./ )
     end
 
-    it "should fail with an actionable message when trying to create an active directory group" do
-      resource[:name] = 'DOMAIN\testdomaingroup'
-      Puppet::Util::Windows::ADSI::User.expects(:exists?).with(resource[:name]).returns(false)
-      connection.expects(:Create)
-      connection.expects(:SetInfo).raises( WIN32OLERuntimeError.new("(in OLE method `SetInfo': )\n    OLE error code:8007089A in Active Directory\n      The specified username is invalid.\r\n\n    HRESULT error code:0x80020009\n      Exception occurred."))
-
-      expect{ provider.create }.to raise_error(
-                                       Puppet::Error,
-                                       /not able to create\/delete domain groups/
-                                   )
-    end
-
     it 'should commit a newly created group' do
       provider.group.expects( :commit )
 
@@ -201,10 +195,10 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
   it "should be able to test whether a group exists" do
     Puppet::Util::Windows::ADSI.stubs(:sid_uri_safe).returns(nil)
     Puppet::Util::Windows::ADSI.stubs(:connect).returns stub('connection')
-    provider.should be_exists
+    expect(provider).to be_exists
 
     Puppet::Util::Windows::ADSI.stubs(:connect).returns nil
-    provider.should_not be_exists
+    expect(provider).not_to be_exists
   end
 
   it "should be able to delete a group" do
@@ -213,17 +207,9 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
     provider.delete
   end
 
-  it 'should not run commit on a deleted group' do
-    connection.expects(:Delete).with('group', 'testers')
-    connection.expects(:SetInfo).never
-
-    provider.delete
-    provider.flush
-  end
-
   it "should report the group's SID as gid" do
     Puppet::Util::Windows::SID.expects(:name_to_sid).with('testers').returns('S-1-5-32-547')
-    provider.gid.should == 'S-1-5-32-547'
+    expect(provider.gid).to eq('S-1-5-32-547')
   end
 
   it "should fail when trying to manage the gid property" do
@@ -232,6 +218,6 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
   end
 
   it "should prefer the domain component from the resolved SID" do
-    provider.members_to_s(['.\Administrators']).should == 'BUILTIN\Administrators'
+    expect(provider.members_to_s(['.\Administrators'])).to eq('BUILTIN\Administrators')
   end
 end