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

data/spec/unit/util/symbolic_file_mode_spec.rb

@@ -17,13 +17,13 @@ describe Puppet::Util::SymbolicFileMode do
          755 0755
     }.each do |input|
       it "should treat #{input.inspect} as valid" do
-        valid_symbolic_mode?(input).should be_true
+        expect(valid_symbolic_mode?(input)).to be_truthy
       end
     end
 
     [0000, 0111, 0640, 0755, 0777].each do |input|
       it "should treat the int #{input.to_s(8)} as value" do
-        valid_symbolic_mode?(input).should be_true
+        expect(valid_symbolic_mode?(input)).to be_truthy
       end
     end
 
@@ -33,30 +33,30 @@ describe Puppet::Util::SymbolicFileMode do
          u g o a ug uo ua ag
     }.each do |input|
       it "should treat #{input.inspect} as invalid" do
-        valid_symbolic_mode?(input).should be_false
+        expect(valid_symbolic_mode?(input)).to be_falsey
       end
     end
   end
 
   describe "#normalize_symbolic_mode" do
     it "should turn an int into a string" do
-      normalize_symbolic_mode(12).should be_an_instance_of String
+      expect(normalize_symbolic_mode(12)).to be_an_instance_of String
     end
 
     it "should not add a leading zero to an int" do
-      normalize_symbolic_mode(12).should_not =~ /^0/
+      expect(normalize_symbolic_mode(12)).not_to match(/^0/)
     end
 
     it "should not add a leading zero to a string with a number" do
-      normalize_symbolic_mode("12").should_not =~ /^0/
+      expect(normalize_symbolic_mode("12")).not_to match(/^0/)
     end
 
     it "should string a leading zero from a number" do
-      normalize_symbolic_mode("012").should == '12'
+      expect(normalize_symbolic_mode("012")).to eq('12')
     end
 
     it "should pass through any other string" do
-      normalize_symbolic_mode("u=rwx").should == 'u=rwx'
+      expect(normalize_symbolic_mode("u=rwx")).to eq('u=rwx')
     end
   end
 
@@ -68,7 +68,6 @@ describe Puppet::Util::SymbolicFileMode do
       "a+r"             => 00444,
       "a+x"             => 00111,
       "o+t"             => 01000,
-      "o+t"             => 01000,
       ["o-t", 07777]    => 06777,
       ["a-x", 07777]    => 07666,
       ["a-rwx", 07777]  => 07000,
@@ -123,7 +122,7 @@ describe Puppet::Util::SymbolicFileMode do
     }.each do |input, result|
       from = input.is_a?(Array) ? "#{input[0]}, 0#{input[1].to_s(8)}" : input
       it "should map #{from.inspect} to #{result.inspect}" do
-        symbolic_mode_to_int(*input).should == result
+        expect(symbolic_mode_to_int(*input)).to eq(result)
       end
     end
 
@@ -165,18 +164,18 @@ describe Puppet::Util::SymbolicFileMode do
     end
 
     it "should set the execute bit on a directory, without exec in original" do
-      symbolic_mode_to_int("u+X", 0444, true).to_s(8).should == "544"
-      symbolic_mode_to_int("g+X", 0444, true).to_s(8).should == "454"
-      symbolic_mode_to_int("o+X", 0444, true).to_s(8).should == "445"
-      symbolic_mode_to_int("+X",  0444, true).to_s(8).should == "555"
+      expect(symbolic_mode_to_int("u+X", 0444, true).to_s(8)).to eq("544")
+      expect(symbolic_mode_to_int("g+X", 0444, true).to_s(8)).to eq("454")
+      expect(symbolic_mode_to_int("o+X", 0444, true).to_s(8)).to eq("445")
+      expect(symbolic_mode_to_int("+X",  0444, true).to_s(8)).to eq("555")
     end
 
     it "should set the execute bit on a file with exec in the original" do
-      symbolic_mode_to_int("+X", 0544).to_s(8).should == "555"
+      expect(symbolic_mode_to_int("+X", 0544).to_s(8)).to eq("555")
     end
 
     it "should not set the execute bit on a file without exec on the original even if set by earlier DSL" do
-      symbolic_mode_to_int("u+x,go+X", 0444).to_s(8).should == "544"
+      expect(symbolic_mode_to_int("u+x,go+X", 0444).to_s(8)).to eq("544")
     end
   end
 end

data/spec/unit/util/tag_set_spec.rb

@@ -8,7 +8,7 @@ RSpec::Matchers.define :be_one_of do |*expected|
     expected.include? actual
   end
 
-  failure_message_for_should do |actual|
+  failure_message do |actual|
     "expected #{actual.inspect} to be one of #{expected.map(&:inspect).join(' or ')}"
   end
 end
@@ -20,13 +20,13 @@ describe Puppet::Util::TagSet do
     array = ['a', :b, 1, 5.4]
     set.merge(array)
 
-    Set.new(YAML.load(set.to_yaml)).should == Set.new(array)
+    expect(Set.new(YAML.load(set.to_yaml))).to eq(Set.new(array))
   end
 
   it 'deserializes from a yaml array' do
     array = ['a', :b, 1, 5.4]
 
-    Puppet::Util::TagSet.from_yaml(array.to_yaml).should == Puppet::Util::TagSet.new(array)
+    expect(Puppet::Util::TagSet.from_yaml(array.to_yaml)).to eq(Puppet::Util::TagSet.new(array))
   end
 
   it 'round trips through pson' do
@@ -34,13 +34,13 @@ describe Puppet::Util::TagSet do
     set.merge(array)
 
     tes = Puppet::Util::TagSet.from_data_hash(PSON.parse(set.to_pson))
-    tes.should == set
+    expect(tes).to eq(set)
   end
 
   it 'can join its elements with a string separator' do
     array = ['a', 'b']
     set.merge(array)
 
-    set.join(', ').should be_one_of('a, b', 'b, a')
+    expect(set.join(', ')).to be_one_of('a, b', 'b, a')
   end
 end

data/spec/unit/util/terminal_spec.rb

@@ -9,34 +9,34 @@ describe Puppet::Util::Terminal do
     it 'should invoke `stty` and return the width' do
       height, width = 100, 200
       subject.expects(:`).with('stty size 2>/dev/null').returns("#{height} #{width}\n")
-      subject.width.should == width
+      expect(subject.width).to eq(width)
     end
 
     it 'should use `tput` if `stty` is unavailable' do
       width = 200
       subject.expects(:`).with('stty size 2>/dev/null').returns("\n")
       subject.expects(:`).with('tput cols 2>/dev/null').returns("#{width}\n")
-      subject.width.should == width
+      expect(subject.width).to eq(width)
     end
 
     it 'should default to 80 columns if `tput` and `stty` are unavailable' do
       width = 80
       subject.expects(:`).with('stty size 2>/dev/null').returns("\n")
       subject.expects(:`).with('tput cols 2>/dev/null').returns("\n")
-      subject.width.should == width
+      expect(subject.width).to eq(width)
     end
 
     it 'should default to 80 columns if `tput` or `stty` raise exceptions' do
       width = 80
       subject.expects(:`).with('stty size 2>/dev/null').raises()
       subject.stubs(:`).with('tput cols 2>/dev/null').returns("#{width + 1000}\n")
-      subject.width.should == width
+      expect(subject.width).to eq(width)
     end
 
     it 'should default to 80 columns if not in a POSIX environment' do
       width = 80
       Puppet.features.stubs(:posix?).returns(false)
-      subject.width.should == width
+      expect(subject.width).to eq(width)
     end
   end
 end

data/spec/unit/util/user_attr_spec.rb

@@ -11,15 +11,15 @@ describe UserAttr do
 
   describe "when getting attributes by name" do
     it "should return nil if there is no entry for that name" do
-      UserAttr.get_attributes_by_name('baz').should == nil
+      expect(UserAttr.get_attributes_by_name('baz')).to eq(nil)
     end
 
     it "should return a hash if there is an entry in /etc/user_attr" do
-      UserAttr.get_attributes_by_name('foo').class.should == Hash
+      expect(UserAttr.get_attributes_by_name('foo').class).to eq(Hash)
     end
 
     it "should return a hash with the name value from /etc/user_attr" do
-      UserAttr.get_attributes_by_name('foo')[:name].should == 'foo'
+      expect(UserAttr.get_attributes_by_name('foo')[:name]).to eq('foo')
     end
 
     #this test is contrived
@@ -27,19 +27,19 @@ describe UserAttr do
     #the role/normal is just a the convention of the file
     describe "when the name is a role" do
       it "should contain :type = role" do
-        UserAttr.get_attributes_by_name('foo')[:type].should == 'role'
+        expect(UserAttr.get_attributes_by_name('foo')[:type]).to eq('role')
       end
     end
 
     describe "when the name is not a role" do
       it "should contain :type = normal" do
-        UserAttr.get_attributes_by_name('bar')[:type].should == 'normal'
+        expect(UserAttr.get_attributes_by_name('bar')[:type]).to eq('normal')
       end
     end
 
     describe "when the name has more attributes" do
       it "should contain all the attributes" do
-        UserAttr.get_attributes_by_name('bar')[:profile].should == 'foobar'
+        expect(UserAttr.get_attributes_by_name('bar')[:profile]).to eq('foobar')
       end
     end
   end

data/spec/unit/util/warnings_spec.rb

@@ -7,10 +7,18 @@ describe Puppet::Util::Warnings do
     @msg2 = "more booness"
   end
 
+  before(:each) do
+    Puppet.debug = true
+  end
+
+  after (:each) do
+    Puppet.debug = false
+  end
+
   {:notice => "notice_once", :warning => "warnonce", :debug => "debug_once"}.each do |log, method|
     describe "when registring '#{log}' messages" do
       it "should always return nil" do
-        Puppet::Util::Warnings.send(method, @msg1).should be(nil)
+        expect(Puppet::Util::Warnings.send(method, @msg1)).to be(nil)
       end
 
       it "should issue a warning" do

data/spec/unit/util/watcher_spec.rb

@@ -29,7 +29,7 @@ describe Puppet::Util::Watcher do
       watcher
     end
 
-    it "is intially unchanged" do
+    it "is initially unchanged" do
       expect(after_reading_the_sequence(ctime(20))).to_not be_changed
     end
 

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