puppet 6.4.0-x64-mingw32 → 6.4.1-x64-mingw32

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

@@ -1,5 +1,3 @@
-#!/usr/bin/env ruby
-
 require 'spec_helper'
 
 describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet::Util::Platform.windows? do
@@ -13,20 +11,20 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet::Util::
 
   let(:provider) { resource.provider }
 
-  let(:connection) { stub 'connection' }
+  let(:connection) { double('connection') }
 
   before :each do
-    Puppet::Util::Windows::ADSI.stubs(:computer_name).returns('testcomputername')
-    Puppet::Util::Windows::ADSI.stubs(:connect).returns connection
+    allow(Puppet::Util::Windows::ADSI).to receive(:computer_name).and_return('testcomputername')
+    allow(Puppet::Util::Windows::ADSI).to receive(:connect).and_return(connection)
     # this would normally query the system, but not needed for these tests
-    Puppet::Util::Windows::ADSI::User.stubs(:localized_domains).returns([])
+    allow(Puppet::Util::Windows::ADSI::User).to receive(:localized_domains).and_return([])
   end
 
   describe ".instances" do
     it "should enumerate all users" do
       names = ['user1', 'user2', 'user3']
-      stub_users = names.map{|n| stub(:name => n)}
-      connection.stubs(:execquery).with('select name from win32_useraccount where localaccount = "TRUE"').returns(stub_users)
+      stub_users = names.map {|n| double(:name => n)}
+      allow(connection).to receive(:execquery).with('select name from win32_useraccount where localaccount = "TRUE"').and_return(stub_users)
 
       expect(described_class.instances.map(&:name)).to match(names)
     end
@@ -39,8 +37,8 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet::Util::
   describe "when retrieving the password property" do
     context "when the resource has a nil password" do
       it "should never issue a logon attempt" do
-        resource.stubs(:[]).with(any_of(:name, :password)).returns(nil)
-        Puppet::Util::Windows::User.expects(:logon_user).never
+        allow(resource).to receive(:[]).with(eq(:name).or(eq(:password))).and_return(nil)
+        expect(Puppet::Util::Windows::User).not_to receive(:logon_user)
         provider.password
       end
     end
@@ -48,42 +46,41 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet::Util::
 
   describe "when managing groups" do
     it 'should return the list of groups as an array of strings' do
-      provider.user.stubs(:groups).returns nil
+      allow(provider.user).to receive(:groups).and_return(nil)
       groups = {'group1' => nil, 'group2' => nil, 'group3' => nil}
-      Puppet::Util::Windows::ADSI::Group.expects(:name_sid_hash).returns(groups)
+      expect(Puppet::Util::Windows::ADSI::Group).to receive(:name_sid_hash).and_return(groups)
 
       expect(provider.groups).to eq(groups.keys)
     end
 
     it "should return an empty array if there are no groups" do
-      provider.user.stubs(:groups).returns []
+      allow(provider.user).to receive(:groups).and_return([])
 
       expect(provider.groups).to eq([])
     end
 
     it 'should be able to add a user to a set of groups' do
       resource[:membership] = :minimum
-      provider.user.expects(:set_groups).with('group1,group2', true)
+      expect(provider.user).to receive(:set_groups).with('group1,group2', true)
 
       provider.groups = 'group1,group2'
 
       resource[:membership] = :inclusive
-      provider.user.expects(:set_groups).with('group1,group2', false)
+      expect(provider.user).to receive(:set_groups).with('group1,group2', false)
 
       provider.groups = 'group1,group2'
     end
   end
 
   describe "#groups_insync?" do
-
-    let(:group1) { stub(:account => 'group1', :domain => '.', :sid => 'group1sid') }
-    let(:group2) { stub(:account => 'group2', :domain => '.', :sid => 'group2sid') }
-    let(:group3) { stub(:account => 'group3', :domain => '.', :sid => 'group3sid') }
+    let(:group1) { double(:account => 'group1', :domain => '.', :sid => 'group1sid') }
+    let(:group2) { double(:account => 'group2', :domain => '.', :sid => 'group2sid') }
+    let(:group3) { double(:account => 'group3', :domain => '.', :sid => 'group3sid') }
 
     before :each do
-      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('group1').returns(group1)
-      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('group2').returns(group2)
-      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('group3').returns(group3)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('group1').and_return(group1)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('group2').and_return(group2)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('group3').and_return(group3)
     end
 
     it "should return true for same lists of members" do
@@ -191,17 +188,16 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet::Util::
       resource[:comment]    = 'a test user'
       resource[:home]       = 'C:\Users\testuser'
 
-      user = stub 'user'
-      Puppet::Util::Windows::ADSI::User.expects(:create).with('testuser').returns user
+      user = double('user')
+      expect(Puppet::Util::Windows::ADSI::User).to receive(:create).with('testuser').and_return(user)
 
-      user.stubs(:groups).returns(['group2', 'group3'])
+      allow(user).to receive(:groups).and_return(['group2', 'group3'])
 
-      create = sequence('create')
-      user.expects(:password=).in_sequence(create)
-      user.expects(:commit).in_sequence(create)
-      user.expects(:set_groups).with('group1,group2', false).in_sequence(create)
-      user.expects(:[]=).with('Description', 'a test user')
-      user.expects(:[]=).with('HomeDirectory', 'C:\Users\testuser')
+      expect(user).to receive(:password=).ordered
+      expect(user).to receive(:commit).ordered
+      expect(user).to receive(:set_groups).with('group1,group2', false).ordered
+      expect(user).to receive(:[]=).with('Description', 'a test user')
+      expect(user).to receive(:[]=).with('HomeDirectory', 'C:\Users\testuser')
 
       provider.create
     end
@@ -210,25 +206,28 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet::Util::
       resource[:password] = '0xDeadBeef'
       resource[:managehome] = true
 
-      user = stub_everything 'user'
-      Puppet::Util::Windows::ADSI::User.expects(:create).with('testuser').returns user
-      Puppet::Util::Windows::User.expects(:load_profile).with('testuser', '0xDeadBeef')
+      user = double('user')
+      allow(user).to receive(:password=)
+      allow(user).to receive(:commit)
+      allow(user).to receive(:[]=)
+      expect(Puppet::Util::Windows::ADSI::User).to receive(:create).with('testuser').and_return(user)
+      expect(Puppet::Util::Windows::User).to receive(:load_profile).with('testuser', '0xDeadBeef')
 
       provider.create
     end
 
     it "should set a user's password" do
-      provider.user.expects(:disabled?).returns(false)
-      provider.user.expects(:locked_out?).returns(false)
-      provider.user.expects(:expired?).returns(false)
-      provider.user.expects(:password=).with('plaintextbad')
+      expect(provider.user).to receive(:disabled?).and_return(false)
+      expect(provider.user).to receive(:locked_out?).and_return(false)
+      expect(provider.user).to receive(:expired?).and_return(false)
+      expect(provider.user).to receive(:password=).with('plaintextbad')
 
       provider.password = "plaintextbad"
     end
 
     it "should test a valid user password" do
       resource[:password] = 'plaintext'
-      provider.user.expects(:password_is?).with('plaintext').returns true
+      expect(provider.user).to receive(:password_is?).with('plaintext').and_return(true)
 
       expect(provider.password).to eq('plaintext')
 
@@ -236,54 +235,54 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet::Util::
 
     it "should test a bad user password" do
       resource[:password] = 'plaintext'
-      provider.user.expects(:password_is?).with('plaintext').returns false
+      expect(provider.user).to receive(:password_is?).with('plaintext').and_return(false)
 
       expect(provider.password).to be_nil
     end
 
     it "should test a blank user password" do
       resource[:password] = ''
-      provider.user.expects(:password_is?).with('').returns true
+      expect(provider.user).to receive(:password_is?).with('').and_return(true)
 
       expect(provider.password).to eq('')
     end
 
     it 'should not create a user if a group by the same name exists' do
-      Puppet::Util::Windows::ADSI::User.expects(:create).with('testuser').raises( Puppet::Error.new("Cannot create user if group 'testuser' exists.") )
+      expect(Puppet::Util::Windows::ADSI::User).to receive(:create).with('testuser').and_raise(Puppet::Error.new("Cannot create user if group 'testuser' exists."))
       expect{ provider.create }.to raise_error( Puppet::Error,
         /Cannot create user if group 'testuser' exists./ )
     end
 
     it "should fail with an actionable message when trying to create an active directory user" do
       resource[:name] = 'DOMAIN\testdomainuser'
-      Puppet::Util::Windows::ADSI::Group.expects(:exists?).with(resource[:name]).returns(false)
-      connection.expects(:Create)
-      connection.expects(:Get).with('UserFlags')
-      connection.expects(:Put).with('UserFlags', true)
-      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(Puppet::Util::Windows::ADSI::Group).to receive(:exists?).with(resource[:name]).and_return(false)
+      expect(connection).to receive(:Create)
+      expect(connection).to receive(:Get).with('UserFlags')
+      expect(connection).to receive(:Put).with('UserFlags', true)
+      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."))
 
       expect{ provider.create }.to raise_error(Puppet::Error)
     end
   end
 
   it 'should be able to test whether a user exists' do
-    Puppet::Util::Windows::SID.stubs(:name_to_principal).returns(nil)
-    Puppet::Util::Windows::ADSI.stubs(:connect).returns stub('connection', :Class => 'User')
+    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 => 'User'))
     expect(provider).to be_exists
 
-    Puppet::Util::Windows::ADSI.stubs(:connect).returns nil
+    allow(Puppet::Util::Windows::ADSI).to receive(:connect).and_return(nil)
     expect(provider).not_to be_exists
   end
 
   it 'should be able to delete a user' do
-    connection.expects(:Delete).with('user', 'testuser')
+    expect(connection).to receive(:Delete).with('user', 'testuser')
 
     provider.delete
   end
 
   it 'should not run commit on a deleted user' do
-    connection.expects(:Delete).with('user', 'testuser')
-    connection.expects(:SetInfo).never
+    expect(connection).to receive(:Delete).with('user', 'testuser')
+    expect(connection).not_to receive(:SetInfo)
 
     provider.delete
     provider.flush
@@ -293,33 +292,33 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet::Util::
     resource[:managehome] = true
 
     sid = 'S-A-B-C'
-    Puppet::Util::Windows::SID.expects(:name_to_sid).with('testuser').returns(sid)
-    Puppet::Util::Windows::ADSI::UserProfile.expects(:delete).with(sid)
-    connection.expects(:Delete).with('user', 'testuser')
+    expect(Puppet::Util::Windows::SID).to receive(:name_to_sid).with('testuser').and_return(sid)
+    expect(Puppet::Util::Windows::ADSI::UserProfile).to receive(:delete).with(sid)
+    expect(connection).to receive(:Delete).with('user', 'testuser')
 
     provider.delete
   end
 
   it "should commit the user when flushed" do
-    provider.user.expects(:commit)
+    expect(provider.user).to receive(:commit)
 
     provider.flush
   end
 
   it "should return the user's SID as uid" do
-    Puppet::Util::Windows::SID.expects(:name_to_sid).with('testuser').returns('S-1-5-21-1362942247-2130103807-3279964888-1111')
+    expect(Puppet::Util::Windows::SID).to receive(:name_to_sid).with('testuser').and_return('S-1-5-21-1362942247-2130103807-3279964888-1111')
 
     expect(provider.uid).to eq('S-1-5-21-1362942247-2130103807-3279964888-1111')
   end
 
   it "should fail when trying to manage the uid property" do
-    provider.expects(:fail).with { |msg| msg =~ /uid is read-only/ }
+    expect(provider).to receive(:fail).with(/uid is read-only/)
     provider.send(:uid=, 500)
   end
 
   [:gid, :shell].each do |prop|
     it "should fail when trying to manage the #{prop} property" do
-      provider.expects(:fail).with { |msg| msg =~ /No support for managing property #{prop}/ }
+      expect(provider).to receive(:fail).with(/No support for managing property #{prop}/)
       provider.send("#{prop}=", 'foo')
     end
   end

data/spec/unit/provider_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 def existing_command
@@ -150,13 +149,13 @@ describe Puppet::Provider do
     # otherwise is to assign it to a constant, and that hurts more here in
     # testing world. --daniel 2012-01-29
     a = Class.new(Puppet::Provider).new(res)
-    a.class.stubs(:name).returns "Puppet::Provider::Notify::A"
+    allow(a.class).to receive(:name).and_return("Puppet::Provider::Notify::A")
 
     b = Class.new(Puppet::Provider).new(res)
-    b.class.stubs(:name).returns "Puppet::Provider::Notify::B"
+    allow(b.class).to receive(:name).and_return("Puppet::Provider::Notify::B")
 
     c = Class.new(Puppet::Provider).new(res)
-    c.class.stubs(:name).returns "Puppet::Provider::Notify::C"
+    allow(c.class).to receive(:name).and_return("Puppet::Provider::Notify::C")
 
     [[a, b, c], [a, c, b], [b, a, c], [b, c, a], [c, a, b], [c, b, a]].each do |this|
       expect(this.sort).to eq([a, b, c])
@@ -282,7 +281,7 @@ describe Puppet::Provider do
 
     describe "regex matches" do
       it "should match a singular regex" do
-        Facter.expects(:value).with(:osfamily).at_least_once.returns "solaris"
+        expect(Facter).to receive(:value).with(:osfamily).at_least(:once).and_return("solaris")
 
         one = type.provide(:one) do
           defaultfor :osfamily => /solaris/
@@ -292,7 +291,7 @@ describe Puppet::Provider do
       end
 
       it "should not match a non-matching regex " do
-        Facter.expects(:value).with(:osfamily).at_least_once.returns "redhat"
+        expect(Facter).to receive(:value).with(:osfamily).at_least(:once).and_return("redhat")
 
         one = type.provide(:one) do
           defaultfor :osfamily => /solaris/
@@ -303,8 +302,8 @@ describe Puppet::Provider do
 
       it "should allow a mix of regex and string" do
 
-        Facter.expects(:value).with(:operatingsystem).at_least_once.returns "fedora"
-        Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns "24"
+        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return("fedora")
+        expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("24")
 
         one = type.provide(:one) do
           defaultfor :operatingsystem => "fedora", :operatingsystemmajrelease => /^2[2-9]$/
@@ -328,14 +327,14 @@ describe Puppet::Provider do
       let(:alternate) { type.provide(:alternate) {} }
 
       it "should be default for the first defaultfor" do
-        Facter.expects(:value).with(:operatingsystem).at_least_once.returns :os1
+        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os1)
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
       end
 
       it "should be default for the last defaultfor" do
-        Facter.expects(:value).with(:operatingsystem).at_least_once.returns :os2
+        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os2)
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
@@ -352,23 +351,23 @@ describe Puppet::Provider do
       let(:alternate) { type.provide(:alternate) {} }
 
       it "should be default for a more specific, but matching, defaultfor" do
-        Facter.expects(:value).with(:operatingsystem).at_least_once.returns :os2
-        Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns "42"
+        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os2)
+        expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("42")
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
       end
 
       it "should be default for a more specific, but matching, defaultfor with regex" do
-        Facter.expects(:value).with(:operatingsystem).at_least_once.returns :os3
-        Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns "42"
+        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os3)
+        expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("42")
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
       end
 
       it "should be default for a less specific, but matching, defaultfor" do
-        Facter.expects(:value).with(:operatingsystem).at_least_once.returns :os1
+        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os1)
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
@@ -392,8 +391,8 @@ describe Puppet::Provider do
     end
 
     it "should not be default if the notdefaultfor does match" do
-      Facter.expects(:value).with(:operatingsystem).at_least_once.returns "fedora"
-      Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns "24"
+      expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return("fedora")
+      expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("24")
 
       one = type.provide(:one) do
         defaultfor :operatingsystem => "fedora"
@@ -404,8 +403,8 @@ describe Puppet::Provider do
     end
 
     it "should be default if the notdefaultfor doesn't match" do
-      Facter.expects(:value).with(:operatingsystem).at_least_once.returns "fedora"
-      Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns "24"
+      expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return("fedora")
+      expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("24")
 
       one = type.provide(:one) do
         defaultfor :operatingsystem => "fedora"
@@ -520,9 +519,9 @@ describe Puppet::Provider do
         end
 
         it "with the specification: %{spec}" % { spec: thisspec.join(', ') } do
-          Facter.stubs(:value).with(:osfamily).returns "redhat"
-          Facter.stubs(:value).with(:operatingsystem).returns "centos"
-          Facter.stubs(:value).with(:operatingsystemrelease).returns "27"
+          allow(Facter).to receive(:value).with(:osfamily).and_return("redhat")
+          allow(Facter).to receive(:value).with(:operatingsystem).and_return("centos")
+          allow(Facter).to receive(:value).with(:operatingsystemrelease).and_return("27")
 
           one = type.provide(:one) do
             if defaultforspec[:one].key?(:defaultfor)
@@ -551,7 +550,7 @@ describe Puppet::Provider do
           end
 
           if defaultforspec[:expect_one] then
-            Puppet.expects(:warning).with(regexp_matches(/Found multiple default providers/))
+            expect(Puppet).to receive(:warning).with(/Found multiple default providers/)
             expect(type.defaultprovider).to eq(one)
           else
             expect(type.defaultprovider).to eq(two)
@@ -607,7 +606,7 @@ describe Puppet::Provider do
       subject.commands :testing => "puppet-bug-1197"
       expect(subject.command(:testing)).to be_nil
 
-      subject.stubs(:which).with("puppet-bug-1197").returns("/puppet-bug-1197")
+      allow(subject).to receive(:which).with("puppet-bug-1197").and_return("/puppet-bug-1197")
       expect(subject.command(:testing)).to eq("/puppet-bug-1197")
 
       # Ideally, we would also test that `suitable?` returned the right thing
@@ -643,43 +642,43 @@ describe Puppet::Provider do
 
   context "execution" do
     before :each do
-      Puppet.expects(:deprecation_warning).never
+      expect(Puppet).not_to receive(:deprecation_warning)
     end
 
     it "delegates instance execute to Puppet::Util::Execution" do
-      Puppet::Util::Execution.expects(:execute).with("a_command", { :option => "value" })
+      expect(Puppet::Util::Execution).to receive(:execute).with("a_command", { :option => "value" })
 
       provider.new.send(:execute, "a_command", { :option => "value" })
     end
 
     it "delegates class execute to Puppet::Util::Execution" do
-      Puppet::Util::Execution.expects(:execute).with("a_command", { :option => "value" })
+      expect(Puppet::Util::Execution).to receive(:execute).with("a_command", { :option => "value" })
 
       provider.send(:execute, "a_command", { :option => "value" })
     end
 
     it "delegates instance execpipe to Puppet::Util::Execution" do
       block = Proc.new { }
-      Puppet::Util::Execution.expects(:execpipe).with("a_command", true, block)
+      expect(Puppet::Util::Execution).to receive(:execpipe).with("a_command", true, block)
 
       provider.new.send(:execpipe, "a_command", true, block)
     end
 
     it "delegates class execpipe to Puppet::Util::Execution" do
       block = Proc.new { }
-      Puppet::Util::Execution.expects(:execpipe).with("a_command", true, block)
+      expect(Puppet::Util::Execution).to receive(:execpipe).with("a_command", true, block)
 
       provider.send(:execpipe, "a_command", true, block)
     end
 
     it "delegates instance execfail to Puppet::Util::Execution" do
-      Puppet::Util::Execution.expects(:execfail).with("a_command", "an exception to raise")
+      expect(Puppet::Util::Execution).to receive(:execfail).with("a_command", "an exception to raise")
 
       provider.new.send(:execfail, "a_command", "an exception to raise")
     end
 
     it "delegates class execfail to Puppet::Util::Execution" do
-      Puppet::Util::Execution.expects(:execfail).with("a_command", "an exception to raise")
+      expect(Puppet::Util::Execution).to receive(:execfail).with("a_command", "an exception to raise")
 
       provider.send(:execfail, "a_command", "an exception to raise")
     end
@@ -903,16 +902,17 @@ describe Puppet::Provider do
 
   def expect_command_executed(name, path, *args)
     command = Puppet::Provider::Command.new(name, path, Puppet::Util, Puppet::Util::Execution)
-    command.expects(:execute).with(*args)
+    args = [no_args] if args.empty?
+    expect(command).to receive(:execute).with(*args)
     command
   end
 
   def allow_creation_of(command, environment = {})
-      Puppet::Provider::Command.stubs(:new).with(command.name, command.executable, Puppet::Util, Puppet::Util::Execution, { :failonfail => true, :combine => true, :custom_environment => environment }).returns(command)
+      allow(Puppet::Provider::Command).to receive(:new).with(command.name, command.executable, Puppet::Util, Puppet::Util::Execution, { :failonfail => true, :combine => true, :custom_environment => environment }).and_return(command)
   end
 
   def file_exists_and_is_executable(path)
-    FileTest.expects(:file?).with(path).returns(true)
-    FileTest.expects(:executable?).with(path).returns(true)
+    expect(FileTest).to receive(:file?).with(path).and_return(true)
+    expect(FileTest).to receive(:executable?).with(path).and_return(true)
   end
 end