puppet 5.5.12-x64-mingw32 → 5.5.13-x64-mingw32

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

@@ -1,5 +1,3 @@
-#! /usr/bin/env ruby
-
 require 'spec_helper'
 if Puppet.features.microsoft_windows?
   require 'puppet/util/windows'
@@ -49,22 +47,22 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
 
   describe "#id2name" do
     it "should return the name of the user identified by the sid" do
-      Puppet::Util::Windows::SID.expects(:valid_sid?).with(sid).returns(true)
-      Puppet::Util::Windows::SID.expects(:sid_to_name).with(sid).returns(account)
+      expect(Puppet::Util::Windows::SID).to receive(:valid_sid?).with(sid).and_return(true)
+      expect(Puppet::Util::Windows::SID).to receive(:sid_to_name).with(sid).and_return(account)
 
       expect(provider.id2name(sid)).to eq(account)
     end
 
     it "should return the argument if it's already a name" do
-      Puppet::Util::Windows::SID.expects(:valid_sid?).with(account).returns(false)
-      Puppet::Util::Windows::SID.expects(:sid_to_name).never
+      expect(Puppet::Util::Windows::SID).to receive(:valid_sid?).with(account).and_return(false)
+      expect(Puppet::Util::Windows::SID).not_to receive(:sid_to_name)
 
       expect(provider.id2name(account)).to eq(account)
     end
 
     it "should return nil if the user doesn't exist" do
-      Puppet::Util::Windows::SID.expects(:valid_sid?).with(sid).returns(true)
-      Puppet::Util::Windows::SID.expects(:sid_to_name).with(sid).returns(nil)
+      expect(Puppet::Util::Windows::SID).to receive(:valid_sid?).with(sid).and_return(true)
+      expect(Puppet::Util::Windows::SID).to receive(:sid_to_name).with(sid).and_return(nil)
 
       expect(provider.id2name(sid)).to eq(nil)
     end
@@ -72,7 +70,7 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
 
   describe "#name2id" do
     it "should delegate to name_to_sid" do
-      Puppet::Util::Windows::SID.expects(:name_to_sid).with(account).returns(sid)
+      expect(Puppet::Util::Windows::SID).to receive(:name_to_sid).with(account).and_return(sid)
 
       expect(provider.name2id(account)).to eq(sid)
     end
@@ -81,7 +79,7 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
   describe "#owner" do
     it "should return the sid of the owner if the file does exist" do
       FileUtils.touch(resource[:path])
-      provider.stubs(:get_owner).with(resource[:path]).returns(sid)
+      allow(provider).to receive(:get_owner).with(resource[:path]).and_return(sid)
 
       expect(provider.owner).to eq(sid)
     end
@@ -93,12 +91,12 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
 
   describe "#owner=" do
     it "should set the owner to the specified value" do
-      provider.expects(:set_owner).with(sid, resource[:path])
+      expect(provider).to receive(:set_owner).with(sid, resource[:path])
       provider.owner = sid
     end
 
     it "should propagate any errors encountered when setting the owner" do
-      provider.stubs(:set_owner).raises(ArgumentError)
+      allow(provider).to receive(:set_owner).and_raise(ArgumentError)
 
       expect {
         provider.owner = sid
@@ -109,7 +107,7 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
   describe "#group" do
     it "should return the sid of the group if the file does exist" do
       FileUtils.touch(resource[:path])
-      provider.stubs(:get_group).with(resource[:path]).returns(sid)
+      allow(provider).to receive(:get_group).with(resource[:path]).and_return(sid)
 
       expect(provider.group).to eq(sid)
     end
@@ -121,12 +119,12 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
 
   describe "#group=" do
     it "should set the group to the specified value" do
-      provider.expects(:set_group).with(sid, resource[:path])
+      expect(provider).to receive(:set_group).with(sid, resource[:path])
       provider.group = sid
     end
 
     it "should propagate any errors encountered when setting the group" do
-      provider.stubs(:set_group).raises(ArgumentError)
+      allow(provider).to receive(:set_group).and_raise(ArgumentError)
 
       expect {
         provider.group = sid
@@ -137,7 +135,7 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
   describe "when validating" do
     {:owner => 'foo', :group => 'foo', :mode => '0777'}.each do |k,v|
       it "should fail if the filesystem doesn't support ACLs and we're managing #{k}" do
-        described_class.any_instance.stubs(:supports_acl?).returns false
+        allow_any_instance_of(described_class).to receive(:supports_acl?).and_return(false)
 
         expect {
           Puppet::Type.type(:file).new :path => path, k => v
@@ -146,7 +144,7 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
     end
 
     it "should not fail if the filesystem doesn't support ACLs and we're not managing permissions" do
-      described_class.any_instance.stubs(:supports_acl?).returns false
+      allow_any_instance_of(described_class).to receive(:supports_acl?).and_return(false)
 
       Puppet::Type.type(:file).new :path => path
     end

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

@@ -9,6 +9,7 @@ describe 'Puppet::Type::Group::Provider::Aix' do
       :ensure => :present
     )
   end
+
   let(:provider) do
     provider_class.new(resource)
   end
@@ -33,7 +34,7 @@ describe 'Puppet::Type::Group::Provider::Aix' do
     end
 
     before(:each) do
-      provider_class.stubs(:list_all).with(ia_module_args).returns(groups)
+      allow(provider_class).to receive(:list_all).with(ia_module_args).and_return(groups)
     end
 
     it 'raises an ArgumentError if the group does not exist' do
@@ -78,7 +79,7 @@ describe 'Puppet::Type::Group::Provider::Aix' do
       before(:each) do
         resource[:auth_membership] = false
 
-        provider.stubs(:members).returns(['user3', 'user1'])
+        allow(provider).to receive(:members).and_return(['user3', 'user1'])
       end
 
       it 'adds the passed-in members to the current list of members, filtering out any duplicates' do

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

@@ -1,14 +1,15 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
+RSpec::Matchers.define_negated_matcher :excluding, :include
+
 describe Puppet::Type.type(:group).provider(:groupadd) do
   before do
-    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'
+    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')
   end
 
   let(:resource) { Puppet::Type.type(:group).new(:name => 'mygroup', :provider => provider) }
@@ -16,19 +17,19 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
 
   describe "#create" do
     before do
-       provider.stubs(:exists?).returns(false)
+       allow(provider).to receive(:exists?).and_return(false)
     end
 
     it "should add -o when allowdupe is enabled and the group is being created" do
       resource[:allowdupe] = :true
-      provider.expects(:execute).with(['/usr/sbin/groupadd', '-o', 'mygroup'], kind_of(Hash))
+      expect(provider).to receive(: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
-        provider.expects(:execute).with(['/usr/sbin/groupadd', '-r', 'mygroup'], kind_of(Hash))
+        expect(provider).to receive(:execute).with(['/usr/sbin/groupadd', '-r', 'mygroup'], kind_of(Hash))
         provider.create
       end
     end
@@ -36,7 +37,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
-        provider.expects(:execute).with(['/usr/sbin/groupadd', 'mygroup'], kind_of(Hash))
+        expect(provider).to receive(:execute).with(['/usr/sbin/groupadd', 'mygroup'], kind_of(Hash))
         provider.create
       end
     end
@@ -48,29 +49,29 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
       end
  
       it "should use lgroupadd instead of groupadd" do
-        provider.expects(:execute).with(includes('/usr/sbin/lgroupadd'), has_entry(:custom_environment, has_key('LIBUSER_CONF')))
+        expect(provider).to receive(:execute).with(including('/usr/sbin/lgroupadd'), hash_including(:custom_environment => hash_including('LIBUSER_CONF')))
         provider.create
       end
 
       it "should NOT pass -o to lgroupadd" do
         resource[:allowdupe] = :true
-        provider.expects(:execute).with(Not(includes('-o')), has_entry(:custom_environment, has_key('LIBUSER_CONF')))
+        expect(provider).to receive(:execute).with(excluding('-o'), hash_including(:custom_environment => hash_including('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
-        provider.stubs(:findgroup).returns(true)
+        allow(provider).to receive(:findgroup).and_return(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
-       provider.stubs(:exists?).returns(true)
+       allow(provider).to receive(:exists?).and_return(true)
     end
+
     describe "on systems with the libuser and forcelocal=false" do
       before do
         described_class.has_feature(:libuser)
@@ -78,16 +79,17 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
       end
 
       it "should use groupmod" do
-        provider.expects(:execute).with(['/usr/sbin/groupmod', '-g', 150, 'mygroup'], has_entries({:failonfail => true, :combine => true, :custom_environment => {}}))
+        expect(provider).to receive(:execute).with(['/usr/sbin/groupmod', '-g', 150, 'mygroup'], hash_including({:failonfail => true, :combine => true, :custom_environment => {}}))
         provider.gid = 150
       end
 
       it "should pass -o to groupmod" do
         resource[:allowdupe] = :true
-        provider.expects(:execute).with(['/usr/sbin/groupmod', '-g', 150, '-o', 'mygroup'], has_entries({:failonfail => true, :combine => true, :custom_environment => {}}))
+        expect(provider).to receive(:execute).with(['/usr/sbin/groupmod', '-g', 150, '-o', 'mygroup'], hash_including({: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)
@@ -95,19 +97,20 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
       end
 
       it "should use lgroupmod instead of groupmod" do
-        provider.expects(:execute).with(['/usr/sbin/lgroupmod', '-g', 150, 'mygroup'], has_entry(:custom_environment, has_key('LIBUSER_CONF')))
+        expect(provider).to receive(:execute).with(['/usr/sbin/lgroupmod', '-g', 150, 'mygroup'], hash_including(:custom_environment => hash_including('LIBUSER_CONF')))
         provider.gid = 150
       end
 
       it "should NOT pass -o to lgroupmod" do
         resource[:allowdupe] = :true
-        provider.expects(:execute).with(['/usr/sbin/lgroupmod', '-g', 150, 'mygroup'], has_entry(:custom_environment, has_key('LIBUSER_CONF')))
+        expect(provider).to receive(:execute).with(['/usr/sbin/lgroupmod', '-g', 150, 'mygroup'], hash_including(:custom_environment => hash_including('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
-        provider.stubs(:findgroup).returns(true)
+        allow(provider).to receive(:findgroup).and_return(true)
         expect { provider.gid = 150 }.to raise_error(Puppet::Error, "GID 150 already exists, use allowdupe to force group creation")
      end
     end
@@ -116,15 +119,16 @@ 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
-      provider.expects(:execute).with(['/usr/sbin/groupmod', '-g', 150, '-o', 'mygroup'], has_entries({:failonfail => true, :combine => true, :custom_environment => {}}))
+      expect(provider).to receive(:execute).with(['/usr/sbin/groupmod', '-g', 150, '-o', 'mygroup'], hash_including({:failonfail => true, :combine => true, :custom_environment => {}}))
       provider.gid = 150
     end
   end
 
   describe "#delete" do
     before do
-       provider.stubs(:exists?).returns(true)
+      allow(provider).to receive(:exists?).and_return(true)
     end
+
     describe "on systems with the libuser and forcelocal=false" do
       before do
         described_class.has_feature(:libuser)
@@ -132,10 +136,11 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
       end
 
       it "should use groupdel" do
-        provider.expects(:execute).with(['/usr/sbin/groupdel', 'mygroup'], has_entries({:failonfail => true, :combine => true, :custom_environment => {}}))
+        expect(provider).to receive(:execute).with(['/usr/sbin/groupdel', 'mygroup'], hash_including({: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)
@@ -143,10 +148,9 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
       end
 
       it "should use lgroupdel instead of groupdel" do
-        provider.expects(:execute).with(['/usr/sbin/lgroupdel', 'mygroup'], has_entry(:custom_environment, has_key('LIBUSER_CONF')))
+        expect(provider).to receive(:execute).with(['/usr/sbin/lgroupdel', 'mygroup'], hash_including(:custom_environment => hash_including('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 = mock 'connection'
-      described_class.manager.stubs(:connect).yields @connection
+      @connection = double('connection')
+      allow(described_class.manager).to receive(:connect).and_yield(@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"]}
-        described_class.manager.expects(:search).returns([low, high])
+        expect(described_class.manager).to receive(:search).and_return([low, high])
 
-        resource = stub 'resource', :should => %w{whatever}
-        resource.stubs(:should).with(:gid).returns nil
-        resource.stubs(:should).with(:ensure).returns :present
+        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)
         instance = described_class.new(:name => "luke", :ensure => :absent)
-        instance.stubs(:resource).returns resource
+        allow(instance).to receive(:resource).and_return(resource)
 
-        @connection.expects(:add).with { |dn, attrs| attrs["gidNumber"] == ["641"] }
+        expect(@connection).to receive(:add).with(anything, hash_including("gidNumber" => ["641"]))
 
         instance.create
         instance.flush
       end
 
       it "should pick '501' as its GID if no groups are found" do
-        described_class.manager.expects(:search).returns nil
+        expect(described_class.manager).to receive(:search).and_return(nil)
 
-        resource = stub 'resource', :should => %w{whatever}
-        resource.stubs(:should).with(:gid).returns nil
-        resource.stubs(:should).with(:ensure).returns :present
+        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)
         instance = described_class.new(:name => "luke", :ensure => :absent)
-        instance.stubs(:resource).returns resource
+        allow(instance).to receive(:resource).and_return(resource)
 
-        @connection.expects(:add).with { |dn, attrs| attrs["gidNumber"] == ["501"] }
+        expect(@connection).to receive(:add).with(anything, hash_including("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
-      described_class.manager.expects(:search).with("cn=foo")
+      expect(described_class.manager).to receive(:search).with("cn=foo")
       described_class.name2id("foo")
     end
 
     it "should return nil if no group is found" do
-      described_class.manager.expects(:search).with("cn=foo").returns nil
+      expect(described_class.manager).to receive(:search).with("cn=foo").and_return(nil)
       expect(described_class.name2id("foo")).to be_nil
-      described_class.manager.expects(:search).with("cn=bar").returns []
+      expect(described_class.manager).to receive(:search).with("cn=bar").and_return([])
       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
-      described_class.manager.expects(:search).with("cn=foo").returns [{:name => "foo", :gid => [10, 11]}, {:name => :bar, :gid => [20, 21]}]
+      expect(described_class.manager).to receive(:search).with("cn=foo").and_return([{: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
-      prov.expects(:exists?).returns nil
+      expect(prov).to receive(:exists?).and_return(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"])
-      provider.expects(:execute).with([described_class.command(:pw), "groupadd", "testgroup"], kind_of(Hash))
+      expect(provider).to receive(: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
-      provider.expects(:execute).with(includes("-o"), kind_of(Hash))
+      expect(provider).to receive(:execute).with(include("-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
-      provider.expects(:execute).with(all_of(includes("-g"), includes(12345)), kind_of(Hash))
+      expect(provider).to receive(:execute).with(include("-g") & include(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"
-      provider.expects(:execute).with(all_of(includes("-M"), includes("user1")), kind_of(Hash))
+      expect(provider).to receive(:execute).with(include("-M") & include("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"]
-      provider.expects(:execute).with(all_of(includes("-M"), includes("user1,user2")), kind_of(Hash))
+      expect(provider).to receive(:execute).with(include("-M") & include("user1,user2"), kind_of(Hash))
       provider.create
     end
   end
 
   describe "when deleting groups" do
     it "should run pw with no additional flags" do
-      provider.expects(:exists?).returns true
+      expect(provider).to receive(:exists?).and_return(true)
       expect(provider.deletecmd).to eq([described_class.command(:pw), "groupdel", "testgroup"])
-      provider.expects(:execute).with([described_class.command(:pw), "groupdel", "testgroup"], has_entry(:custom_environment, {}))
+      expect(provider).to receive(:execute).with([described_class.command(:pw), "groupdel", "testgroup"], hash_including(: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])
-      provider.expects(:execute).with([described_class.command(:pw), "groupmod", "testgroup", "-g", 12345], has_entry(:custom_environment, {}))
+      expect(provider).to receive(:execute).with([described_class.command(:pw), "groupmod", "testgroup", "-g", 12345], hash_including(:custom_environment => {}))
       provider.gid = 12345
     end
 
     it "should use -M with the correct argument when the members property is changed" do
       resource[:members] = "user1"
-      provider.expects(:execute).with(all_of(includes("-M"), includes("user2")), has_entry(:custom_environment, {}))
+      expect(provider).to receive(:execute).with(include("-M") & include("user2"), hash_including(: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"]
-      provider.expects(:execute).with(all_of(includes("-M"), includes("user3,user4")), has_entry(:custom_environment, {}))
+      expect(provider).to receive(:execute).with(include("-M") & include("user3,user4"), hash_including(:custom_environment, {}))
       provider.members = ["user3", "user4"]
     end
   end