puppet 3.8.7 → 4.0.0

data/spec/unit/util/windows/access_control_entry_spec.rb

@@ -10,37 +10,37 @@ describe "Puppet::Util::Windows::AccessControlEntry", :if => Puppet.features.mic
   it "creates an access allowed ace" do
     ace = klass.new(sid, mask)
 
-    ace.type.should == klass::ACCESS_ALLOWED_ACE_TYPE
+    expect(ace.type).to eq(klass::ACCESS_ALLOWED_ACE_TYPE)
   end
 
   it "creates an access denied ace" do
     ace = klass.new(sid, mask, 0, klass::ACCESS_DENIED_ACE_TYPE)
 
-    ace.type.should == klass::ACCESS_DENIED_ACE_TYPE
+    expect(ace.type).to eq(klass::ACCESS_DENIED_ACE_TYPE)
   end
 
   it "creates a non-inherited ace by default" do
     ace = klass.new(sid, mask)
 
-    ace.should_not be_inherited
+    expect(ace).not_to be_inherited
   end
 
   it "creates an inherited ace" do
     ace = klass.new(sid, mask, klass::INHERITED_ACE)
 
-    ace.should be_inherited
+    expect(ace).to be_inherited
   end
 
   it "creates a non-inherit-only ace by default" do
     ace = klass.new(sid, mask)
 
-    ace.should_not be_inherit_only
+    expect(ace).not_to be_inherit_only
   end
 
   it "creates an inherit-only ace" do
     ace = klass.new(sid, mask, klass::INHERIT_ONLY_ACE)
 
-    ace.should be_inherit_only
+    expect(ace).to be_inherit_only
   end
 
   context "when comparing aces" do
@@ -48,12 +48,12 @@ describe "Puppet::Util::Windows::AccessControlEntry", :if => Puppet.features.mic
     let(:ace2) { klass.new(sid, mask, klass::INHERIT_ONLY_ACE, klass::ACCESS_DENIED_ACE_TYPE) }
 
     it "returns true if different objects have the same set of values" do
-    ace1.should == ace2
+    expect(ace1).to eq(ace2)
     end
 
     it "returns false if different objects have different sets of values" do
       ace = klass.new(sid, mask)
-      ace.should_not == ace1
+      expect(ace).not_to eq(ace1)
     end
 
     it "returns true when testing if two objects are eql?" do
@@ -61,7 +61,7 @@ describe "Puppet::Util::Windows::AccessControlEntry", :if => Puppet.features.mic
     end
 
     it "returns false when comparing object identity" do
-      ace1.should_not be_equal(ace2)
+      expect(ace1).not_to be_equal(ace2)
     end
   end
 end

data/spec/unit/util/windows/access_control_list_spec.rb

@@ -21,13 +21,13 @@ describe "Puppet::Util::Windows::AccessControlList", :if => Puppet.features.micr
   it "constructs an empty list" do
     acl = klass.new
 
-    acl.to_a.should be_empty
+    expect(acl.to_a).to be_empty
   end
 
   it "supports copy constructor" do
     aces = klass.new([system_ace]).to_a
 
-    aces.to_a.should == [system_ace]
+    expect(aces.to_a).to eq([system_ace])
   end
 
   context "appending" do
@@ -35,14 +35,14 @@ describe "Puppet::Util::Windows::AccessControlList", :if => Puppet.features.micr
       acl = klass.new
       acl.allow(system_sid, 0x1, 0x2)
 
-      acl.first.type.should == klass::ACCESS_ALLOWED_ACE_TYPE
+      expect(acl.first.type).to eq(klass::ACCESS_ALLOWED_ACE_TYPE)
     end
 
     it "appends a deny ace" do
       acl = klass.new
       acl.deny(system_sid, 0x1, 0x2)
 
-      acl.first.type.should == klass::ACCESS_DENIED_ACE_TYPE
+      expect(acl.first.type).to eq(klass::ACCESS_DENIED_ACE_TYPE)
     end
 
     it "always appends, never overwrites an ACE" do
@@ -50,11 +50,11 @@ describe "Puppet::Util::Windows::AccessControlList", :if => Puppet.features.micr
       acl.allow(admins_sid, admins_ace.mask, admins_ace.flags)
 
       aces = acl.to_a
-      aces.size.should == 2
-      aces[0].should == system_ace
-      aces[1].sid.should == admins_sid
-      aces[1].mask.should == admins_ace.mask
-      aces[1].flags.should == admins_ace.flags
+      expect(aces.size).to eq(2)
+      expect(aces[0]).to eq(system_ace)
+      expect(aces[1].sid).to eq(admins_sid)
+      expect(aces[1].mask).to eq(admins_ace.mask)
+      expect(aces[1].flags).to eq(admins_ace.flags)
     end
   end
 
@@ -65,8 +65,8 @@ describe "Puppet::Util::Windows::AccessControlList", :if => Puppet.features.micr
       dacl.reassign!(system_ace.sid, admins_ace.sid)
       # we removed system, so ignore prepended ace
       ace = dacl.to_a[1]
-      ace.sid.should == admins_sid
-      ace.mask.should == system_ace.mask
+      expect(ace.sid).to eq(admins_sid)
+      expect(ace.mask).to eq(system_ace.mask)
     end
 
     it "matches multiple sids" do
@@ -75,9 +75,9 @@ describe "Puppet::Util::Windows::AccessControlList", :if => Puppet.features.micr
       dacl.reassign!(system_ace.sid, admins_ace.sid)
       # we removed system, so ignore prepended ace
       aces = dacl.to_a
-      aces.size.should == 3
+      expect(aces.size).to eq(3)
       aces.to_a[1,2].each do |ace|
-        ace.sid.should == admins_ace.sid
+        expect(ace.sid).to eq(admins_ace.sid)
       end
     end
 
@@ -96,7 +96,7 @@ describe "Puppet::Util::Windows::AccessControlList", :if => Puppet.features.micr
       dacl.reassign!(system_sid, none_sid)
       aces = dacl.to_a
 
-      aces[0].sid.should == system_sid
+      expect(aces[0].sid).to eq(system_sid)
     end
 
     it "prepends an explicit ace for the new sid with the same mask and basic inheritance as the inherited ace" do
@@ -112,13 +112,13 @@ describe "Puppet::Util::Windows::AccessControlList", :if => Puppet.features.micr
       dacl.reassign!(system_sid, none_sid)
       aces = dacl.to_a
 
-      aces.size.should == 2
-      aces[0].sid.should == none_sid
-      aces[0].should_not be_inherited
-      aces[0].flags.should == expected_flags
+      expect(aces.size).to eq(2)
+      expect(aces[0].sid).to eq(none_sid)
+      expect(aces[0]).not_to be_inherited
+      expect(aces[0].flags).to eq(expected_flags)
 
-      aces[1].sid.should == system_sid
-      aces[1].should be_inherited
+      expect(aces[1].sid).to eq(system_sid)
+      expect(aces[1]).to be_inherited
     end
 
     it "makes a copy of the ace prior to modifying it" do
@@ -127,7 +127,7 @@ describe "Puppet::Util::Windows::AccessControlList", :if => Puppet.features.micr
       acl = klass.new(arr)
       acl.reassign!(system_sid, none_sid)
 
-      arr[0].sid.should == system_sid
+      expect(arr[0].sid).to eq(system_sid)
     end
   end
 end

data/spec/unit/util/windows/adsi_spec.rb

@@ -17,45 +17,25 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
   end
 
   it "should generate the correct URI for a resource" do
-    Puppet::Util::Windows::ADSI.uri('test', 'user').should == "WinNT://./test,user"
+    expect(Puppet::Util::Windows::ADSI.uri('test', 'user')).to eq("WinNT://./test,user")
   end
 
   it "should be able to get the name of the computer" do
-    Puppet::Util::Windows::ADSI.computer_name.should == 'testcomputername'
+    expect(Puppet::Util::Windows::ADSI.computer_name).to eq('testcomputername')
   end
 
   it "should be able to provide the correct WinNT base URI for the computer" do
-    Puppet::Util::Windows::ADSI.computer_uri.should == "WinNT://."
+    expect(Puppet::Util::Windows::ADSI.computer_uri).to eq("WinNT://.")
   end
 
   it "should generate a fully qualified WinNT URI" do
-    Puppet::Util::Windows::ADSI.computer_uri('testcomputername').should == "WinNT://testcomputername"
-  end
-
-  describe ".sid_for_account" do
-    it "should return nil if the account does not exist" do
-      Puppet::Util::Windows::SID.expects(:name_to_sid).with('foobar').returns nil
-
-      Puppet::Util::Windows::ADSI.sid_for_account('foobar').should be_nil
-    end
-
-    it "should return a SID for a passed user or group name" do
-      Puppet::Util::Windows::SID.expects(:name_to_sid).with('testers').returns 'S-1-5-32-547'
-
-      Puppet::Util::Windows::ADSI.sid_for_account('testers').should == 'S-1-5-32-547'
-    end
-
-    it "should return a SID for a passed fully-qualified user or group name" do
-      Puppet::Util::Windows::SID.expects(:name_to_sid).with('MACHINE\testers').returns 'S-1-5-32-547'
-
-      Puppet::Util::Windows::ADSI.sid_for_account('MACHINE\testers').should == 'S-1-5-32-547'
-    end
+    expect(Puppet::Util::Windows::ADSI.computer_uri('testcomputername')).to eq("WinNT://testcomputername")
   end
 
   describe ".computer_name" do
     it "should return a non-empty ComputerName string" do
       Puppet::Util::Windows::ADSI.instance_variable_set(:@computer_name, nil)
-      Puppet::Util::Windows::ADSI.computer_name.should_not be_empty
+      expect(Puppet::Util::Windows::ADSI.computer_name).not_to be_empty
     end
   end
 
@@ -70,7 +50,7 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
 
     it "should return a SID uri for a well-known SID (SYSTEM)" do
       sid = Win32::Security::SID.new('SYSTEM')
-      Puppet::Util::Windows::ADSI.sid_uri(sid).should == 'WinNT://S-1-5-18'
+      expect(Puppet::Util::Windows::ADSI.sid_uri(sid)).to eq('WinNT://S-1-5-18')
     end
   end
 
@@ -81,20 +61,20 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
 
     it "should generate the correct URI" do
       Puppet::Util::Windows::ADSI.stubs(:sid_uri_safe).returns(nil)
-      Puppet::Util::Windows::ADSI::User.uri(username).should == "WinNT://./#{username},user"
+      expect(Puppet::Util::Windows::ADSI::User.uri(username)).to eq("WinNT://./#{username},user")
     end
 
     it "should generate the correct URI for a user with a domain" do
       Puppet::Util::Windows::ADSI.stubs(:sid_uri_safe).returns(nil)
-      Puppet::Util::Windows::ADSI::User.uri(username, domain).should == "WinNT://#{domain}/#{username},user"
+      expect(Puppet::Util::Windows::ADSI::User.uri(username, domain)).to eq("WinNT://#{domain}/#{username},user")
     end
 
     it "should be able to parse a username without a domain" do
-      Puppet::Util::Windows::ADSI::User.parse_name(username).should == [username, '.']
+      expect(Puppet::Util::Windows::ADSI::User.parse_name(username)).to eq([username, '.'])
     end
 
     it "should be able to parse a username with a domain" do
-      Puppet::Util::Windows::ADSI::User.parse_name(domain_username).should == [username, domain]
+      expect(Puppet::Util::Windows::ADSI::User.parse_name(domain_username)).to eq([username, domain])
     end
 
     it "should raise an error with a username that contains a /" do
@@ -111,20 +91,20 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
 
       user = Puppet::Util::Windows::ADSI::User.create(username)
 
-      user.should be_a(Puppet::Util::Windows::ADSI::User)
-      user.native_user.should == adsi_user
+      expect(user).to be_a(Puppet::Util::Windows::ADSI::User)
+      expect(user.native_user).to eq(adsi_user)
     end
 
     it "should be able to check the existence of a user" do
       Puppet::Util::Windows::ADSI.stubs(:sid_uri_safe).returns(nil)
       Puppet::Util::Windows::ADSI.expects(:connect).with("WinNT://./#{username},user").returns connection
-      Puppet::Util::Windows::ADSI::User.exists?(username).should be_true
+      expect(Puppet::Util::Windows::ADSI::User.exists?(username)).to be_truthy
     end
 
     it "should be able to check the existence of a domain user" do
       Puppet::Util::Windows::ADSI.stubs(:sid_uri_safe).returns(nil)
       Puppet::Util::Windows::ADSI.expects(:connect).with("WinNT://#{domain}/#{username},user").returns connection
-      Puppet::Util::Windows::ADSI::User.exists?(domain_username).should be_true
+      expect(Puppet::Util::Windows::ADSI::User.exists?(domain_username)).to be_truthy
     end
 
     it "should be able to confirm the existence of a user with a well-known SID" do
@@ -132,7 +112,7 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
       system_user = Win32::Security::SID::LocalSystem
       # ensure that the underlying OS is queried here
       Puppet::Util::Windows::ADSI.unstub(:connect)
-      Puppet::Util::Windows::ADSI::User.exists?(system_user).should be_true
+      expect(Puppet::Util::Windows::ADSI::User.exists?(system_user)).to be_truthy
     end
 
     it "should return nil with an unknown SID" do
@@ -140,7 +120,7 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
       bogus_sid = 'S-1-2-3-4'
       # ensure that the underlying OS is queried here
       Puppet::Util::Windows::ADSI.unstub(:connect)
-      Puppet::Util::Windows::ADSI::User.exists?(bogus_sid).should be_false
+      expect(Puppet::Util::Windows::ADSI::User.exists?(bogus_sid)).to be_falsey
     end
 
     it "should be able to delete a user" do
@@ -162,9 +142,9 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
       Puppet::Util::Windows::ADSI.expects(:connect).with("WinNT://./#{name},user").returns(native_user)
 
       users = Puppet::Util::Windows::ADSI::User.to_a
-      users.length.should == 1
-      users[0].name.should == name
-      users[0]['HomeDirectory'].should == homedir
+      expect(users.length).to eq(1)
+      expect(users[0].name).to eq(name)
+      expect(users[0]['HomeDirectory']).to eq(homedir)
     end
 
     describe "an instance" do
@@ -175,19 +155,19 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
       it "should provide its groups as a list of names" do
         names = ["group1", "group2"]
 
-        groups = names.map { |name| mock('group', :Name => name) }
+        groups = names.map { |name| stub('group', :Name => name) }
 
         adsi_user.expects(:Groups).returns(groups)
 
-        user.groups.should =~ names
+        expect(user.groups).to match(names)
       end
 
       it "should be able to test whether a given password is correct" do
         Puppet::Util::Windows::ADSI::User.expects(:logon).with(username, 'pwdwrong').returns(false)
         Puppet::Util::Windows::ADSI::User.expects(:logon).with(username, 'pwdright').returns(true)
 
-        user.password_is?('pwdwrong').should be_false
-        user.password_is?('pwdright').should be_true
+        expect(user.password_is?('pwdwrong')).to be_falsey
+        expect(user.password_is?('pwdright')).to be_truthy
       end
 
       it "should be able to set a password" do
@@ -203,22 +183,9 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
         user.password = 'pwd'
       end
 
-       it "should be able manage a user without a password" do
-        adsi_user.expects(:SetPassword).with('pwd').never
-        adsi_user.expects(:SetInfo).at_least_once
-
-        flagname = "UserFlags"
-        fADS_UF_DONT_EXPIRE_PASSWD = 0x10000
-
-        adsi_user.expects(:Get).with(flagname).returns(0)
-        adsi_user.expects(:Put).with(flagname, fADS_UF_DONT_EXPIRE_PASSWD)
-
-        user.password = nil
-      end
-
       it "should generate the correct URI" do
         Puppet::Util::Windows::SID.stubs(:octet_string_to_sid_object).returns(sid)
-        user.uri.should == "WinNT://testcomputername/#{username},user"
+        expect(user.uri).to eq("WinNT://testcomputername/#{username},user")
       end
 
       describe "when given a set of groups to which to add the user" do
@@ -268,42 +235,9 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
       let(:group)      { Puppet::Util::Windows::ADSI::Group.new(groupname, adsi_group) }
       let(:someone_sid){ stub(:account => 'someone', :domain => 'testcomputername')}
 
-      it "should be able to add a member (deprecated)" do
-        Puppet.expects(:deprecation_warning).with('Puppet::Util::Windows::ADSI::Group#add_members is deprecated; please use Puppet::Util::Windows::ADSI::Group#add_member_sids')
-
-        Puppet::Util::Windows::SID.expects(:name_to_sid_object).with('someone').returns(someone_sid)
-        Puppet::Util::Windows::ADSI.expects(:sid_uri).with(someone_sid).returns("WinNT://testcomputername/someone,user")
-
-        adsi_group.expects(:Add).with("WinNT://testcomputername/someone,user")
-
-        group.add_member('someone')
-      end
-
-      it "should raise when adding a member that can't resolve to a SID (deprecated)" do
-        expect {
-          group.add_member('foobar')
-        }.to raise_error(Puppet::Error, /Could not resolve username: foobar/)
-      end
-
-      it "should be able to remove a member (deprecated)" do
-        Puppet.expects(:deprecation_warning).with('Puppet::Util::Windows::ADSI::Group#remove_members is deprecated; please use Puppet::Util::Windows::ADSI::Group#remove_member_sids')
-
-        Puppet::Util::Windows::SID.expects(:name_to_sid_object).with('someone').returns(someone_sid)
-        Puppet::Util::Windows::ADSI.expects(:sid_uri).with(someone_sid).returns("WinNT://testcomputername/someone,user")
-
-        adsi_group.expects(:Remove).with("WinNT://testcomputername/someone,user")
-
-        group.remove_member('someone')
-      end
-
-      it "should raise when removing a member that can't resolve to a SID (deprecated)" do
-        expect {
-          group.remove_member('foobar')
-        }.to raise_error(Puppet::Error, /Could not resolve username: foobar/)
-      end
-
       describe "should be able to use SID objects" do
         let(:system)     { Puppet::Util::Windows::SID.name_to_sid_object('SYSTEM') }
+        let(:invalid)    { Puppet::Util::Windows::SID.name_to_sid_object('foobar') }
 
         it "to add a member" do
           adsi_group.expects(:Add).with("WinNT://S-1-5-18")
@@ -311,146 +245,74 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
           group.add_member_sids(system)
         end
 
+        it "and raise when passed a non-SID object to add" do
+          expect{ group.add_member_sids(invalid)}.to raise_error(Puppet::Error, /Must use a valid SID object/)
+        end
+
         it "to remove a member" do
           adsi_group.expects(:Remove).with("WinNT://S-1-5-18")
 
           group.remove_member_sids(system)
         end
+
+        it "and raise when passed a non-SID object to remove" do
+          expect{ group.remove_member_sids(invalid)}.to raise_error(Puppet::Error, /Must use a valid SID object/)
+        end
       end
 
       it "should provide its groups as a list of names" do
         names = ['user1', 'user2']
 
-        users = names.map { |name| mock('user', :Name => name) }
+        users = names.map { |name| stub('user', :Name => name) }
 
         adsi_group.expects(:Members).returns(users)
 
-        group.members.should =~ names
+        expect(group.members).to match(names)
       end
 
-      context "calling .set_members" do
-        it "should set the members of a group to only desired_members when inclusive" do
-          names = ['DOMAIN\user1', 'user2']
-          sids = [
-              stub(:account => 'user1', :domain => 'DOMAIN'),
-              stub(:account => 'user2', :domain => 'testcomputername'),
-              stub(:account => 'user3', :domain => 'DOMAIN2'),
-          ]
-
-          # use stubbed objectSid on member to return stubbed SID
-          Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([0]).returns(sids[0])
-          Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([1]).returns(sids[1])
-
-          Puppet::Util::Windows::SID.expects(:name_to_sid_object).with('user2').returns(sids[1])
-          Puppet::Util::Windows::SID.expects(:name_to_sid_object).with('DOMAIN2\user3').returns(sids[2])
-
-          Puppet::Util::Windows::ADSI.expects(:sid_uri).with(sids[0]).returns("WinNT://DOMAIN/user1,user")
-          Puppet::Util::Windows::ADSI.expects(:sid_uri).with(sids[2]).returns("WinNT://DOMAIN2/user3,user")
-
-          members = names.each_with_index.map{|n,i| stub(:Name => n, :objectSID => [i])}
-          adsi_group.expects(:Members).returns members
-
-          adsi_group.expects(:Remove).with('WinNT://DOMAIN/user1,user')
-          adsi_group.expects(:Add).with('WinNT://DOMAIN2/user3,user')
-
-          group.set_members(['user2', 'DOMAIN2\user3'])
-        end
-
-        it "should add the desired_members to an existing group when not inclusive" do
-          names = ['DOMAIN\user1', 'user2']
-          sids = [
-              stub(:account => 'user1', :domain => 'DOMAIN'),
-              stub(:account => 'user2', :domain => 'testcomputername'),
-              stub(:account => 'user3', :domain => 'DOMAIN2'),
-          ]
-
-          # use stubbed objectSid on member to return stubbed SID
-          Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([0]).returns(sids[0])
-          Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([1]).returns(sids[1])
-
-          Puppet::Util::Windows::SID.expects(:name_to_sid_object).with('user2').returns(sids[1])
-          Puppet::Util::Windows::SID.expects(:name_to_sid_object).with('DOMAIN2\user3').returns(sids[2])
-
-          Puppet::Util::Windows::ADSI.expects(:sid_uri).with(sids[2]).returns("WinNT://DOMAIN2/user3,user")
-
-          members = names.each_with_index.map{|n,i| stub(:Name => n, :objectSID => [i])}
-          adsi_group.expects(:Members).returns members
+      it "should be able to add a list of users to a group" do
+        names = ['DOMAIN\user1', 'user2']
+        sids = [
+          stub(:account => 'user1', :domain => 'DOMAIN'),
+          stub(:account => 'user2', :domain => 'testcomputername'),
+          stub(:account => 'user3', :domain => 'DOMAIN2'),
+        ]
 
-          adsi_group.expects(:Remove).with('WinNT://DOMAIN/user1,user').never
+        # use stubbed objectSid on member to return stubbed SID
+        Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([0]).returns(sids[0])
+        Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([1]).returns(sids[1])
 
-          adsi_group.expects(:Add).with('WinNT://DOMAIN2/user3,user')
+        Puppet::Util::Windows::SID.expects(:name_to_sid_object).with('user2').returns(sids[1])
+        Puppet::Util::Windows::SID.expects(:name_to_sid_object).with('DOMAIN2\user3').returns(sids[2])
 
-          group.set_members(['user2', 'DOMAIN2\user3'],false)
-        end
-
-        it "should return immediately when desired_members is nil" do
-          adsi_group.expects(:Members).never
-
-          adsi_group.expects(:Remove).never
-          adsi_group.expects(:Add).never
-
-          group.set_members(nil)
-        end
-
-        it "should remove all members when desired_members is empty and inclusive" do
-          names = ['DOMAIN\user1', 'user2']
-          sids = [
-              stub(:account => 'user1', :domain => 'DOMAIN'),
-              stub(:account => 'user2', :domain => 'testcomputername')
-          ]
-
-          # use stubbed objectSid on member to return stubbed SID
-          Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([0]).returns(sids[0])
-          Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([1]).returns(sids[1])
-
-          Puppet::Util::Windows::ADSI.expects(:sid_uri).with(sids[0]).returns("WinNT://DOMAIN/user1,user")
-          Puppet::Util::Windows::ADSI.expects(:sid_uri).with(sids[1]).returns("WinNT://testcomputername/user2,user")
-
-          members = names.each_with_index.map{|n,i| stub(:Name => n, :objectSID => [i])}
-          adsi_group.expects(:Members).returns members
+        Puppet::Util::Windows::ADSI.expects(:sid_uri).with(sids[0]).returns("WinNT://DOMAIN/user1,user")
+        Puppet::Util::Windows::ADSI.expects(:sid_uri).with(sids[2]).returns("WinNT://DOMAIN2/user3,user")
 
-          adsi_group.expects(:Remove).with('WinNT://DOMAIN/user1,user')
-          adsi_group.expects(:Remove).with('WinNT://testcomputername/user2,user')
+        members = names.each_with_index.map{|n,i| stub(:Name => n, :objectSID => [i])}
+        adsi_group.expects(:Members).returns members
 
-          group.set_members([])
-        end
-
-        it "should do nothing when desired_members is empty and not inclusive" do
-          names = ['DOMAIN\user1', 'user2']
-          sids = [
-              stub(:account => 'user1', :domain => 'DOMAIN'),
-              stub(:account => 'user2', :domain => 'testcomputername')
-          ]
-          # use stubbed objectSid on member to return stubbed SID
-          Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([0]).returns(sids[0])
-          Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([1]).returns(sids[1])
-
-          members = names.each_with_index.map{|n,i| stub(:Name => n, :objectSID => [i])}
-          adsi_group.expects(:Members).returns members
+        adsi_group.expects(:Remove).with('WinNT://DOMAIN/user1,user')
+        adsi_group.expects(:Add).with('WinNT://DOMAIN2/user3,user')
 
-          adsi_group.expects(:Remove).never
-          adsi_group.expects(:Add).never
-
-          group.set_members([],false)
-        end
+        group.set_members(['user2', 'DOMAIN2\user3'])
+      end
 
-        it "should raise an error when a username does not resolve to a SID" do
-          expect {
-            adsi_group.expects(:Members).returns []
-            group.set_members(['foobar'])
-          }.to raise_error(Puppet::Error, /Could not resolve username: foobar/)
-        end
+      it "should raise an error when a username does not resolve to a SID" do
+        expect {
+          adsi_group.expects(:Members).returns []
+          group.set_members(['foobar'])
+        }.to raise_error(Puppet::Error, /Could not resolve username: foobar/)
       end
 
       it "should generate the correct URI" do
         Puppet::Util::Windows::ADSI.stubs(:sid_uri_safe).returns(nil)
-        group.uri.should == "WinNT://./#{groupname},group"
+        expect(group.uri).to eq("WinNT://./#{groupname},group")
       end
     end
 
     it "should generate the correct URI" do
       Puppet::Util::Windows::ADSI.stubs(:sid_uri_safe).returns(nil)
-      Puppet::Util::Windows::ADSI::Group.uri("people").should == "WinNT://./people,group"
+      expect(Puppet::Util::Windows::ADSI::Group.uri("people")).to eq("WinNT://./people,group")
     end
 
     it "should be able to create a group" do
@@ -461,15 +323,15 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
 
       group = Puppet::Util::Windows::ADSI::Group.create(groupname)
 
-      group.should be_a(Puppet::Util::Windows::ADSI::Group)
-      group.native_group.should == adsi_group
+      expect(group).to be_a(Puppet::Util::Windows::ADSI::Group)
+      expect(group.native_group).to eq(adsi_group)
     end
 
     it "should be able to confirm the existence of a group" do
       Puppet::Util::Windows::ADSI.stubs(:sid_uri_safe).returns(nil)
       Puppet::Util::Windows::ADSI.expects(:connect).with("WinNT://./#{groupname},group").returns connection
 
-      Puppet::Util::Windows::ADSI::Group.exists?(groupname).should be_true
+      expect(Puppet::Util::Windows::ADSI::Group.exists?(groupname)).to be_truthy
     end
 
     it "should be able to confirm the existence of a group with a well-known SID" do
@@ -477,7 +339,7 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
       service_group = Win32::Security::SID::Service
       # ensure that the underlying OS is queried here
       Puppet::Util::Windows::ADSI.unstub(:connect)
-      Puppet::Util::Windows::ADSI::Group.exists?(service_group).should be_true
+      expect(Puppet::Util::Windows::ADSI::Group.exists?(service_group)).to be_truthy
     end
 
     it "should return nil with an unknown SID" do
@@ -485,7 +347,7 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
       bogus_sid = 'S-1-2-3-4'
       # ensure that the underlying OS is queried here
       Puppet::Util::Windows::ADSI.unstub(:connect)
-      Puppet::Util::Windows::ADSI::Group.exists?(bogus_sid).should be_false
+      expect(Puppet::Util::Windows::ADSI::Group.exists?(bogus_sid)).to be_falsey
     end
 
     it "should be able to delete a group" do
@@ -506,9 +368,9 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
       Puppet::Util::Windows::ADSI.expects(:connect).with("WinNT://./#{name},group").returns(native_group)
 
       groups = Puppet::Util::Windows::ADSI::Group.to_a
-      groups.length.should == 1
-      groups[0].name.should == name
-      groups[0].members.should == ['Administrator']
+      expect(groups.length).to eq(1)
+      expect(groups[0].name).to eq(name)
+      expect(groups[0].members).to eq(['Administrator'])
     end
   end
 
@@ -519,7 +381,7 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
     end
 
     it "should warn on 2003" do
-      connection.expects(:Delete).raises(WIN32OLERuntimeError,
+      connection.expects(:Delete).raises(RuntimeError,
  "Delete (WIN32OLERuntimeError)
     OLE error code:80041010 in SWbemServicesEx
       Invalid class