puppet 6.0.10-x86-mingw32 → 6.1.0-x86-mingw32

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

@@ -1,15 +1,14 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
-RSpec::Matchers.define_negated_matcher :excluding, :include
-
 describe Puppet::Type.type(:group).provider(:groupadd) do
   before do
-    allow(described_class).to receive(:command).with(:add).and_return('/usr/sbin/groupadd')
-    allow(described_class).to receive(:command).with(:delete).and_return('/usr/sbin/groupdel')
-    allow(described_class).to receive(:command).with(:modify).and_return('/usr/sbin/groupmod')
-    allow(described_class).to receive(:command).with(:localadd).and_return('/usr/sbin/lgroupadd')
-    allow(described_class).to receive(:command).with(:localdelete).and_return('/usr/sbin/lgroupdel')
-    allow(described_class).to receive(:command).with(:localmodify).and_return('/usr/sbin/lgroupmod')
+    described_class.stubs(:command).with(:add).returns '/usr/sbin/groupadd'
+    described_class.stubs(:command).with(:delete).returns '/usr/sbin/groupdel'
+    described_class.stubs(:command).with(:modify).returns '/usr/sbin/groupmod'
+    described_class.stubs(:command).with(:localadd).returns '/usr/sbin/lgroupadd'
+    described_class.stubs(:command).with(:localdelete).returns '/usr/sbin/lgroupdel'
+    described_class.stubs(:command).with(:localmodify).returns '/usr/sbin/lgroupmod'
   end
 
   let(:resource) { Puppet::Type.type(:group).new(:name => 'mygroup', :provider => provider) }
@@ -17,19 +16,19 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
 
   describe "#create" do
     before do
-       allow(provider).to receive(:exists?).and_return(false)
+       provider.stubs(:exists?).returns(false)
     end
 
     it "should add -o when allowdupe is enabled and the group is being created" do
       resource[:allowdupe] = :true
-      expect(provider).to receive(:execute).with(['/usr/sbin/groupadd', '-o', 'mygroup'], kind_of(Hash))
+      provider.expects(:execute).with(['/usr/sbin/groupadd', '-o', 'mygroup'], kind_of(Hash))
       provider.create
     end
 
     describe "on system that feature system_groups", :if => described_class.system_groups? do
       it "should add -r when system is enabled and the group is being created" do
         resource[:system] = :true
-        expect(provider).to receive(:execute).with(['/usr/sbin/groupadd', '-r', 'mygroup'], kind_of(Hash))
+        provider.expects(:execute).with(['/usr/sbin/groupadd', '-r', 'mygroup'], kind_of(Hash))
         provider.create
       end
     end
@@ -37,7 +36,7 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
     describe "on system that do not feature system_groups", :unless => described_class.system_groups? do
       it "should not add -r when system is enabled and the group is being created" do
         resource[:system] = :true
-        expect(provider).to receive(:execute).with(['/usr/sbin/groupadd', 'mygroup'], kind_of(Hash))
+        provider.expects(:execute).with(['/usr/sbin/groupadd', 'mygroup'], kind_of(Hash))
         provider.create
       end
     end
@@ -49,29 +48,29 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
       end
  
       it "should use lgroupadd instead of groupadd" do
-        expect(provider).to receive(:execute).with(including('/usr/sbin/lgroupadd'), hash_including(:custom_environment => hash_including('LIBUSER_CONF')))
+        provider.expects(:execute).with(includes('/usr/sbin/lgroupadd'), has_entry(:custom_environment, has_key('LIBUSER_CONF')))
         provider.create
       end
 
       it "should NOT pass -o to lgroupadd" do
         resource[:allowdupe] = :true
-        expect(provider).to receive(:execute).with(excluding('-o'), hash_including(:custom_environment => hash_including('LIBUSER_CONF')))
+        provider.expects(:execute).with(Not(includes('-o')), has_entry(:custom_environment, has_key('LIBUSER_CONF')))
         provider.create
       end
 
       it "should raise an exception for duplicate GID if allowdupe is not set and duplicate GIDs exist" do
         resource[:gid] = 505
-        allow(provider).to receive(:findgroup).and_return(true)
+        provider.stubs(:findgroup).returns(true)
         expect { provider.create }.to raise_error(Puppet::Error, "GID 505 already exists, use allowdupe to force group creation")
      end
     end
+
   end
 
   describe "#modify" do
     before do
-       allow(provider).to receive(:exists?).and_return(true)
+       provider.stubs(:exists?).returns(true)
     end
-
     describe "on systems with the libuser and forcelocal=false" do
       before do
         described_class.has_feature(:libuser)
@@ -79,17 +78,16 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
       end
 
       it "should use groupmod" do
-        expect(provider).to receive(:execute).with(['/usr/sbin/groupmod', '-g', 150, 'mygroup'], hash_including({:failonfail => true, :combine => true, :custom_environment => {}}))
+        provider.expects(:execute).with(['/usr/sbin/groupmod', '-g', 150, 'mygroup'], has_entries({:failonfail => true, :combine => true, :custom_environment => {}}))
         provider.gid = 150
       end
 
       it "should pass -o to groupmod" do
         resource[:allowdupe] = :true
-        expect(provider).to receive(:execute).with(['/usr/sbin/groupmod', '-g', 150, '-o', 'mygroup'], hash_including({:failonfail => true, :combine => true, :custom_environment => {}}))
+        provider.expects(:execute).with(['/usr/sbin/groupmod', '-g', 150, '-o', 'mygroup'], has_entries({:failonfail => true, :combine => true, :custom_environment => {}}))
         provider.gid = 150
       end
     end
-
     describe "on systems with the libuser and forcelocal=true" do
       before do
         described_class.has_feature(:libuser)
@@ -97,20 +95,19 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
       end
 
       it "should use lgroupmod instead of groupmod" do
-        expect(provider).to receive(:execute).with(['/usr/sbin/lgroupmod', '-g', 150, 'mygroup'], hash_including(:custom_environment => hash_including('LIBUSER_CONF')))
+        provider.expects(:execute).with(['/usr/sbin/lgroupmod', '-g', 150, 'mygroup'], has_entry(:custom_environment, has_key('LIBUSER_CONF')))
         provider.gid = 150
       end
 
       it "should NOT pass -o to lgroupmod" do
         resource[:allowdupe] = :true
-        expect(provider).to receive(:execute).with(['/usr/sbin/lgroupmod', '-g', 150, 'mygroup'], hash_including(:custom_environment => hash_including('LIBUSER_CONF')))
+        provider.expects(:execute).with(['/usr/sbin/lgroupmod', '-g', 150, 'mygroup'], has_entry(:custom_environment, has_key('LIBUSER_CONF')))
         provider.gid = 150
       end
-
       it "should raise an exception for duplicate GID if allowdupe is not set and duplicate GIDs exist" do
         resource[:gid] = 150
         resource[:allowdupe] = :false
-        allow(provider).to receive(:findgroup).and_return(true)
+        provider.stubs(:findgroup).returns(true)
         expect { provider.gid = 150 }.to raise_error(Puppet::Error, "GID 150 already exists, use allowdupe to force group creation")
      end
     end
@@ -119,16 +116,15 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
   describe "#gid=" do
     it "should add -o when allowdupe is enabled and the gid is being modified" do
       resource[:allowdupe] = :true
-      expect(provider).to receive(:execute).with(['/usr/sbin/groupmod', '-g', 150, '-o', 'mygroup'], hash_including({:failonfail => true, :combine => true, :custom_environment => {}}))
+      provider.expects(:execute).with(['/usr/sbin/groupmod', '-g', 150, '-o', 'mygroup'], has_entries({:failonfail => true, :combine => true, :custom_environment => {}}))
       provider.gid = 150
     end
   end
 
   describe "#delete" do
     before do
-      allow(provider).to receive(:exists?).and_return(true)
+       provider.stubs(:exists?).returns(true)
     end
-
     describe "on systems with the libuser and forcelocal=false" do
       before do
         described_class.has_feature(:libuser)
@@ -136,11 +132,10 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
       end
 
       it "should use groupdel" do
-        expect(provider).to receive(:execute).with(['/usr/sbin/groupdel', 'mygroup'], hash_including({:failonfail => true, :combine => true, :custom_environment => {}}))
+        provider.expects(:execute).with(['/usr/sbin/groupdel', 'mygroup'], has_entries({:failonfail => true, :combine => true, :custom_environment => {}}))
         provider.delete
       end
     end
-
     describe "on systems with the libuser and forcelocal=true" do
       before do
         described_class.has_feature(:libuser)
@@ -148,9 +143,10 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
       end
 
       it "should use lgroupdel instead of groupdel" do
-        expect(provider).to receive(:execute).with(['/usr/sbin/lgroupdel', 'mygroup'], hash_including(:custom_environment => hash_including('LIBUSER_CONF')))
+        provider.expects(:execute).with(['/usr/sbin/lgroupdel', 'mygroup'], has_entry(:custom_environment, has_key('LIBUSER_CONF')))
         provider.delete
       end
     end
   end
 end
+

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

@@ -32,38 +32,38 @@ describe Puppet::Type.type(:group).provider(:ldap) do
   describe "when being created" do
     before do
       # So we don't try to actually talk to ldap
-      @connection = double('connection')
-      allow(described_class.manager).to receive(:connect).and_yield(@connection)
+      @connection = mock 'connection'
+      described_class.manager.stubs(:connect).yields @connection
     end
 
     describe "with no gid specified" do
       it "should pick the first available GID after the largest existing GID" do
         low = {:name=>["luke"], :gid=>["600"]}
         high = {:name=>["testing"], :gid=>["640"]}
-        expect(described_class.manager).to receive(:search).and_return([low, high])
+        described_class.manager.expects(:search).returns([low, high])
 
-        resource = double('resource', :should => %w{whatever})
-        allow(resource).to receive(:should).with(:gid).and_return(nil)
-        allow(resource).to receive(:should).with(:ensure).and_return(:present)
+        resource = stub 'resource', :should => %w{whatever}
+        resource.stubs(:should).with(:gid).returns nil
+        resource.stubs(:should).with(:ensure).returns :present
         instance = described_class.new(:name => "luke", :ensure => :absent)
-        allow(instance).to receive(:resource).and_return(resource)
+        instance.stubs(:resource).returns resource
 
-        expect(@connection).to receive(:add).with(anything, hash_including("gidNumber" => ["641"]))
+        @connection.expects(:add).with { |dn, attrs| attrs["gidNumber"] == ["641"] }
 
         instance.create
         instance.flush
       end
 
       it "should pick '501' as its GID if no groups are found" do
-        expect(described_class.manager).to receive(:search).and_return(nil)
+        described_class.manager.expects(:search).returns nil
 
-        resource = double('resource', :should => %w{whatever})
-        allow(resource).to receive(:should).with(:gid).and_return(nil)
-        allow(resource).to receive(:should).with(:ensure).and_return(:present)
+        resource = stub 'resource', :should => %w{whatever}
+        resource.stubs(:should).with(:gid).returns nil
+        resource.stubs(:should).with(:ensure).returns :present
         instance = described_class.new(:name => "luke", :ensure => :absent)
-        allow(instance).to receive(:resource).and_return(resource)
+        instance.stubs(:resource).returns resource
 
-        expect(@connection).to receive(:add).with(anything, hash_including("gidNumber" => ["501"]))
+        @connection.expects(:add).with { |dn, attrs| attrs["gidNumber"] == ["501"] }
 
         instance.create
         instance.flush
@@ -77,21 +77,21 @@ describe Puppet::Type.type(:group).provider(:ldap) do
 
   describe "when converting from a group name to GID" do
     it "should use the ldap manager to look up the GID" do
-      expect(described_class.manager).to receive(:search).with("cn=foo")
+      described_class.manager.expects(:search).with("cn=foo")
       described_class.name2id("foo")
     end
 
     it "should return nil if no group is found" do
-      expect(described_class.manager).to receive(:search).with("cn=foo").and_return(nil)
+      described_class.manager.expects(:search).with("cn=foo").returns nil
       expect(described_class.name2id("foo")).to be_nil
-      expect(described_class.manager).to receive(:search).with("cn=bar").and_return([])
+      described_class.manager.expects(:search).with("cn=bar").returns []
       expect(described_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
-      expect(described_class.manager).to receive(:search).with("cn=foo").and_return([{:name => "foo", :gid => [10, 11]}, {:name => :bar, :gid => [20, 21]}])
+      described_class.manager.expects(:search).with("cn=foo").returns [{:name => "foo", :gid => [10, 11]}, {:name => :bar, :gid => [20, 21]}]
       expect(described_class.name2id("foo")).to eq(10)
     end
   end

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

@@ -12,46 +12,46 @@ describe Puppet::Type.type(:group).provider(:pw) do
   describe "when creating groups" do
     let :provider do
       prov = resource.provider
-      expect(prov).to receive(:exists?).and_return(nil)
+      prov.expects(:exists?).returns nil
       prov
     end
 
     it "should run pw with no additional flags when no properties are given" do
       expect(provider.addcmd).to eq([described_class.command(:pw), "groupadd", "testgroup"])
-      expect(provider).to receive(:execute).with([described_class.command(:pw), "groupadd", "testgroup"], kind_of(Hash))
+      provider.expects(:execute).with([described_class.command(:pw), "groupadd", "testgroup"], kind_of(Hash))
       provider.create
     end
 
     it "should use -o when allowdupe is enabled" do
       resource[:allowdupe] = true
-      expect(provider).to receive(:execute).with(include("-o"), kind_of(Hash))
+      provider.expects(:execute).with(includes("-o"), kind_of(Hash))
       provider.create
     end
 
     it "should use -g with the correct argument when the gid property is set" do
       resource[:gid] = 12345
-      expect(provider).to receive(:execute).with(include("-g") & include(12345), kind_of(Hash))
+      provider.expects(:execute).with(all_of(includes("-g"), includes(12345)), kind_of(Hash))
       provider.create
     end
 
     it "should use -M with the correct argument when the members property is set" do
       resource[:members] = "user1"
-      expect(provider).to receive(:execute).with(include("-M") & include("user1"), kind_of(Hash))
+      provider.expects(:execute).with(all_of(includes("-M"), includes("user1")), kind_of(Hash))
       provider.create
     end
 
     it "should use -M with all the given users when the members property is set to an array" do
       resource[:members] = ["user1", "user2"]
-      expect(provider).to receive(:execute).with(include("-M") & include("user1,user2"), kind_of(Hash))
+      provider.expects(:execute).with(all_of(includes("-M"), includes("user1,user2")), kind_of(Hash))
       provider.create
     end
   end
 
   describe "when deleting groups" do
     it "should run pw with no additional flags" do
-      expect(provider).to receive(:exists?).and_return(true)
+      provider.expects(:exists?).returns true
       expect(provider.deletecmd).to eq([described_class.command(:pw), "groupdel", "testgroup"])
-      expect(provider).to receive(:execute).with([described_class.command(:pw), "groupdel", "testgroup"], hash_including(:custom_environment => {}))
+      provider.expects(:execute).with([described_class.command(:pw), "groupdel", "testgroup"], has_entry(:custom_environment, {}))
       provider.delete
     end
   end
@@ -59,19 +59,19 @@ describe Puppet::Type.type(:group).provider(:pw) do
   describe "when modifying groups" do
     it "should run pw with the correct arguments" do
       expect(provider.modifycmd("gid", 12345)).to eq([described_class.command(:pw), "groupmod", "testgroup", "-g", 12345])
-      expect(provider).to receive(:execute).with([described_class.command(:pw), "groupmod", "testgroup", "-g", 12345], hash_including(:custom_environment => {}))
+      provider.expects(:execute).with([described_class.command(:pw), "groupmod", "testgroup", "-g", 12345], has_entry(:custom_environment, {}))
       provider.gid = 12345
     end
 
     it "should use -M with the correct argument when the members property is changed" do
       resource[:members] = "user1"
-      expect(provider).to receive(:execute).with(include("-M") & include("user2"), hash_including(:custom_environment, {}))
+      provider.expects(:execute).with(all_of(includes("-M"), includes("user2")), has_entry(:custom_environment, {}))
       provider.members = "user2"
     end
 
     it "should use -M with all the given users when the members property is changed with an array" do
       resource[:members] = ["user1", "user2"]
-      expect(provider).to receive(:execute).with(include("-M") & include("user3,user4"), hash_including(:custom_environment, {}))
+      provider.expects(:execute).with(all_of(includes("-M"), includes("user3,user4")), has_entry(:custom_environment, {}))
       provider.members = ["user3", "user4"]
     end
   end

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

@@ -1,3 +1,5 @@
+#!/usr/bin/env ruby
+
 require 'spec_helper'
 
 describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util::Platform.windows? do
@@ -9,37 +11,39 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
   end
 
   let(:provider) { resource.provider }
-  let(:connection) { double('connection') }
+
+  let(:connection) { stub 'connection' }
 
   before :each do
-    allow(Puppet::Util::Windows::ADSI).to receive(:computer_name).and_return('testcomputername')
-    allow(Puppet::Util::Windows::ADSI).to receive(:connect).and_return(connection)
+    Puppet::Util::Windows::ADSI.stubs(:computer_name).returns('testcomputername')
+    Puppet::Util::Windows::ADSI.stubs(:connect).returns connection
     # this would normally query the system, but not needed for these tests
-    allow(Puppet::Util::Windows::ADSI::Group).to receive(:localized_domains).and_return([])
+    Puppet::Util::Windows::ADSI::Group.stubs(:localized_domains).returns([])
   end
 
   describe ".instances" do
     it "should enumerate all groups" do
       names = ['group1', 'group2', 'group3']
-      stub_groups = names.map{|n| double(:name => n)}
+      stub_groups = names.map{|n| stub(:name => n)}
 
-      allow(connection).to receive(:execquery).with('select name from win32_group where localaccount = "TRUE"').and_return(stub_groups)
+      connection.stubs(:execquery).with('select name from win32_group where localaccount = "TRUE"').returns stub_groups
 
       expect(described_class.instances.map(&:name)).to match(names)
     end
   end
 
   describe "group type :members property helpers" do
-    let(:user1) { double(:account => 'user1', :domain => '.', :sid => 'user1sid') }
-    let(:user2) { double(:account => 'user2', :domain => '.', :sid => 'user2sid') }
-    let(:user3) { double(:account => 'user3', :domain => '.', :sid => 'user3sid') }
+
+    let(:user1) { stub(:account => 'user1', :domain => '.', :sid => 'user1sid') }
+    let(:user2) { stub(:account => 'user2', :domain => '.', :sid => 'user2sid') }
+    let(:user3) { stub(:account => 'user3', :domain => '.', :sid => 'user3sid') }
     let(:invalid_user) { SecureRandom.uuid }
 
     before :each do
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user1').and_return(user1)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2').and_return(user2)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user3').and_return(user3)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with(invalid_user).and_return(nil)
+      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('user1').returns(user1)
+      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('user2').returns(user2)
+      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('user3').returns(user3)
+      Puppet::Util::Windows::SID.stubs(:name_to_principal).with(invalid_user).returns(nil)
     end
 
     describe "#members_insync?" do
@@ -208,24 +212,19 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
           expect(provider.members_to_s(input)).to be_empty
         end
       end
-
       it "should return an empty string on empty or nil users" do
         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
         expect(provider.members_to_s(['user1'])).to eq('.\user1')
       end
-
       it "should return a user string like DOMAIN\\USER,DOMAIN2\\USER2" do
         expect(provider.members_to_s(['user1', 'user2'])).to eq('.\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}")
       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}")
       end
@@ -233,50 +232,44 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
   end
 
   describe "when managing members" do
-    let(:user1) { double(:account => 'user1', :domain => '.', :sid => 'user1sid') }
-    let(:user2) { double(:account => 'user2', :domain => '.', :sid => 'user2sid') }
-    let(:user3) { double(:account => 'user3', :domain => '.', :sid => 'user3sid') }
+    let(:user1) { stub(:account => 'user1', :domain => '.', :sid => 'user1sid') }
+    let(:user2) { stub(:account => 'user2', :domain => '.', :sid => 'user2sid') }
+    let(:user3) { stub(:account => 'user3', :domain => '.', :sid => 'user3sid') }
 
     before :each do
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user1').and_return(user1)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2').and_return(user2)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user3').and_return(user3)
+      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('user1').returns(user1)
+      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('user2').returns(user2)
+      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('user3').returns(user3)
 
       resource[:auth_membership] = true
     end
 
     it "should be able to provide a list of members" do
-      allow(provider.group).to receive(:members).and_return([
+      provider.group.stubs(:members).returns [
         'user1',
         'user2',
         'user3',
-      ])
-
-      expected_member_sids = [user1.sid, user2.sid, user3.sid]
-      expected_members = ['user1', 'user2', 'user3']
-      allow(provider).to receive(:members_to_s)
-        .with(expected_member_sids)
-        .and_return(expected_members.join(','))
+      ]
 
-      expect(provider.members).to match_array(expected_members)
+      expect(provider.members).to match_array([user1.sid, user2.sid, user3.sid])
     end
 
     it "should be able to set group members" do
-      allow(provider.group).to receive(:members).and_return(['user1', 'user2'])
+      provider.group.stubs(:members).returns ['user1', 'user2']
 
       member_sids = [
-        double(:account => 'user1', :domain => 'testcomputername', :sid => 1),
-        double(:account => 'user2', :domain => 'testcomputername', :sid => 2),
-        double(:account => 'user3', :domain => 'testcomputername', :sid => 3),
+        stub(:account => 'user1', :domain => 'testcomputername', :sid => 1),
+        stub(:account => 'user2', :domain => 'testcomputername', :sid => 2),
+        stub(:account => 'user3', :domain => 'testcomputername', :sid => 3),
       ]
 
-      allow(provider.group).to receive(:member_sids).and_return(member_sids[0..1])
+      provider.group.stubs(:member_sids).returns(member_sids[0..1])
 
-      expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2').and_return(member_sids[1])
-      expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user3').and_return(member_sids[2])
+      Puppet::Util::Windows::SID.expects(:name_to_principal).with('user2').returns(member_sids[1])
+      Puppet::Util::Windows::SID.expects(:name_to_principal).with('user3').returns(member_sids[2])
 
-      expect(provider.group).to receive(:remove_member_sids).with(member_sids[0])
-      expect(provider.group).to receive(:add_member_sids).with(member_sids[2])
+      provider.group.expects(:remove_member_sids).with(member_sids[0])
+      provider.group.expects(:add_member_sids).with(member_sids[2])
 
       provider.members = ['user2', 'user3']
     end
@@ -286,68 +279,69 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util:
     it "should be able to create a group" do
       resource[:members] = ['user1', 'user2']
 
-      group = double('group')
-      expect(Puppet::Util::Windows::ADSI::Group).to receive(:create).with('testers').and_return(group)
+      group = stub 'group'
+      Puppet::Util::Windows::ADSI::Group.expects(:create).with('testers').returns group
 
-      expect(group).to receive(:commit).ordered
+      create = sequence('create')
+      group.expects(:commit).in_sequence(create)
       # due to PUP-1967, defaultto false will set the default to nil
-      expect(group).to receive(:set_members).with(['user1', 'user2'], nil).ordered
+      group.expects(:set_members).with(['user1', 'user2'], nil).in_sequence(create)
 
       provider.create
     end
 
     it 'should not create a group if a user by the same name exists' do
-      expect(Puppet::Util::Windows::ADSI::Group).to receive(:create).with('testers').and_raise(Puppet::Error.new("Cannot create group if user 'testers' exists."))
+      Puppet::Util::Windows::ADSI::Group.expects(:create).with('testers').raises( Puppet::Error.new("Cannot create group if user 'testers' exists.") )
       expect{ provider.create }.to raise_error( Puppet::Error,
         /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'
-      expect(Puppet::Util::Windows::ADSI::User).to receive(:exists?).with(resource[:name]).and_return(false)
-      expect(connection).to receive(:Create)
-      expect(connection).to receive(:SetInfo).and_raise( 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."))
+      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)
     end
 
     it 'should commit a newly created group' do
-      expect(provider.group).to receive( :commit )
+      provider.group.expects( :commit )
 
       provider.flush
     end
   end
 
   it "should be able to test whether a group exists" do
-    allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).and_return(nil)
-    allow(Puppet::Util::Windows::ADSI).to receive(:connect).and_return(double('connection', :Class => 'Group'))
+    Puppet::Util::Windows::SID.stubs(:name_to_principal).returns(nil)
+    Puppet::Util::Windows::ADSI.stubs(:connect).returns stub('connection', :Class => 'Group')
     expect(provider).to be_exists
 
-    allow(Puppet::Util::Windows::ADSI).to receive(:connect).and_return(nil)
+    Puppet::Util::Windows::ADSI.stubs(:connect).returns nil
     expect(provider).not_to be_exists
   end
 
   it "should be able to delete a group" do
-    expect(connection).to receive(:Delete).with('group', 'testers')
+    connection.expects(:Delete).with('group', 'testers')
 
     provider.delete
   end
 
   it 'should not run commit on a deleted group' do
-    expect(connection).to receive(:Delete).with('group', 'testers')
-    expect(connection).not_to receive(:SetInfo)
+    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
-    expect(Puppet::Util::Windows::SID).to receive(:name_to_sid).with('testers').and_return('S-1-5-32-547')
+    Puppet::Util::Windows::SID.expects(:name_to_sid).with('testers').returns('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
-    expect(provider).to receive(:fail).with(/gid is read-only/)
+    provider.expects(:fail).with { |msg| msg =~ /gid is read-only/ }
     provider.send(:gid=, 500)
   end