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

data/spec/unit/provider/cisco_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/provider/cisco'
@@ -9,7 +8,7 @@ describe Puppet::Provider::Cisco do
   end
 
   it "should create a cisco device instance" do
-    Puppet::Util::NetworkDevice::Cisco::Device.expects(:new).returns :device
+    expect(Puppet::Util::NetworkDevice::Cisco::Device).to receive(:new).and_return(:device)
     expect(Puppet::Provider::Cisco.device(:url)).to eq(:device)
   end
 end

data/spec/unit/provider/command_spec.rb

@@ -9,8 +9,8 @@ describe Puppet::Provider::Command do
   let(:executable) { "foo" }
   let(:executable_absolute_path) { "/foo/bar" }
 
-  let(:executor) { mock('executor') }
-  let(:resolver) { mock('resolver') }
+  let(:executor) { double('executor') }
+  let(:resolver) { double('resolver') }
 
   let(:path_resolves_to_itself) do
     resolves = Object.new
@@ -23,37 +23,37 @@ describe Puppet::Provider::Command do
   end
 
   it "executes a simple command" do
-    executor.expects(:execute).with([executable], no_options)
+    expect(executor).to receive(:execute).with([executable], no_options)
 
     command = Puppet::Provider::Command.new(name, executable, path_resolves_to_itself, executor)
     command.execute()
   end
 
   it "executes a command with extra options" do
-    executor.expects(:execute).with([executable], the_options)
+    expect(executor).to receive(:execute).with([executable], the_options)
 
     command = Puppet::Provider::Command.new(name, executable, path_resolves_to_itself, executor, the_options)
     command.execute()
   end
 
   it "executes a command with arguments" do
-    executor.expects(:execute).with([executable, "arg1", "arg2"], no_options)
+    expect(executor).to receive(:execute).with([executable, "arg1", "arg2"], no_options)
 
     command = Puppet::Provider::Command.new(name, executable, path_resolves_to_itself, executor)
     command.execute("arg1", "arg2")
   end
 
   it "resolves to an absolute path for better execution" do
-    resolver.expects(:which).with(executable).returns(executable_absolute_path)
-    executor.expects(:execute).with([executable_absolute_path], no_options)
+    expect(resolver).to receive(:which).with(executable).and_return(executable_absolute_path)
+    expect(executor).to receive(:execute).with([executable_absolute_path], no_options)
 
     command = Puppet::Provider::Command.new(name, executable, resolver, executor)
     command.execute()
   end
 
   it "errors when the executable resolves to nothing" do
-    resolver.expects(:which).with(executable).returns(nil)
-    executor.expects(:execute).never
+    expect(resolver).to receive(:which).with(executable).and_return(nil)
+    expect(executor).not_to receive(:execute)
 
     command = Puppet::Provider::Command.new(name, executable, resolver, executor)
 

data/spec/unit/provider/cron/crontab_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:cron).provider(:crontab) do
@@ -10,7 +9,7 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
 
   def compare_crontab_text(have, want)
     # We should have four header lines, and then the text...
-    expect(have.lines.to_a[0..3]).to be_all {|x| x =~ /^# / }
+    expect(have.lines.to_a[0..3]).to(be_all {|x| x =~ /^# / })
     expect(have.lines.to_a[4..-1].join('')).to eq(want)
   end
 
@@ -127,7 +126,7 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
     let(:resources) { { "test" => resource } }
 
     before :each do
-      subject.stubs(:prefetch_all_targets).returns([record])
+      allow(subject).to receive(:prefetch_all_targets).and_return([record])
     end
 
 # this would be a more fitting test, but I haven't yet
@@ -143,17 +142,17 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
 #    end
 
     it "should not base the new resource's provider on the existing record" do
-      subject.expects(:new).with(record).never
-      subject.stubs(:new)
+      expect(subject).not_to receive(:new).with(record)
+      allow(subject).to receive(:new)
       subject.prefetch(resources)
     end
   end
 
   context "when prefetching an entry now managed for another user" do
     let(:resource) do
-     s = stub(:resource)
-     s.stubs(:[]).with(:user).returns 'root'
-     s.stubs(:[]).with(:target).returns 'root'
+     s = double(:resource)
+     allow(s).to receive(:[]).with(:user).and_return('root')
+     allow(s).to receive(:[]).with(:target).and_return('root')
      s
     end
 
@@ -161,16 +160,16 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
     let(:resources) { { "test" => resource } }
 
     before :each do
-      subject.stubs(:prefetch_all_targets).returns([record])
+      allow(subject).to receive(:prefetch_all_targets).and_return([record])
     end
 
     it "should try and use the match method to find a more fitting record" do
-      subject.expects(:match).with(record, resources)
+      expect(subject).to receive(:match).with(record, resources)
       subject.prefetch(resources)
     end
 
     it "should not match a provider to the resource" do
-      resource.expects(:provider=).never
+      expect(resource).not_to receive(:provider=)
       subject.prefetch(resources)
     end
 

data/spec/unit/provider/cron/parsed_spec.rb

@@ -1,9 +1,6 @@
-#!/usr/bin/env ruby
-
 require 'spec_helper'
 
 describe Puppet::Type.type(:cron).provider(:crontab) do
-
   let :provider do
     described_class.new(:command => '/bin/true')
   end
@@ -66,17 +63,17 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
 
   describe "when determining the correct filetype" do
     it "should use the suntab filetype on Solaris" do
-      Facter.stubs(:value).with(:osfamily).returns 'Solaris'
+      allow(Facter).to receive(:value).with(:osfamily).and_return('Solaris')
       expect(described_class.filetype).to eq(Puppet::Util::FileType::FileTypeSuntab)
     end
 
     it "should use the aixtab filetype on AIX" do
-      Facter.stubs(:value).with(:osfamily).returns 'AIX'
+      allow(Facter).to receive(:value).with(:osfamily).and_return('AIX')
       expect(described_class.filetype).to eq(Puppet::Util::FileType::FileTypeAixtab)
     end
 
     it "should use the crontab filetype on other platforms" do
-      Facter.stubs(:value).with(:osfamily).returns 'Not a real operating system family'
+      allow(Facter).to receive(:value).with(:osfamily).and_return('Not a real operating system family')
       expect(described_class.filetype).to eq(Puppet::Util::FileType::FileTypeCrontab)
     end
   end
@@ -95,17 +92,19 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
 
   describe ".targets" do
     let(:tabs) { [ described_class.default_target ] + %w{foo bar} }
+
     before do
-      File.expects(:readable?).returns true
-      File.stubs(:file?).returns true
-      File.stubs(:writable?).returns true
-    end
-    after do
-      File.unstub :readable?, :file?, :writable?
-      Dir.unstub :foreach
+      expect(File).to receive(:readable?).and_return(true)
+      allow(File).to receive(:file?).and_return(true)
+      allow(File).to receive(:writable?).and_return(true)
     end
+
     it "should add all crontabs as targets" do
-      Dir.expects(:foreach).multiple_yields(*tabs)
+      dir_expectation = receive(:foreach)
+      tabs.each do |tab|
+        dir_expectation = dir_expectation.and_yield(tab)
+      end
+      expect(Dir).to dir_expectation
       expect(described_class.targets).to eq(tabs)
     end
   end
@@ -199,28 +198,28 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
 
   describe ".instances" do
     before :each do
-      described_class.stubs(:default_target).returns 'foobar'
+      allow(described_class).to receive(:default_target).and_return('foobar')
     end
 
     describe "on linux" do
       before do
-        Facter.stubs(:value).with(:osfamily).returns 'Linux'
-        Facter.stubs(:value).with(:operatingsystem)
+        allow(Facter).to receive(:value).with(:osfamily).and_return('Linux')
+        allow(Facter).to receive(:value).with(:operatingsystem)
       end
 
       it "should contain no resources for a user who has no crontab" do
-        Puppet::Util.stubs(:uid).returns(10)
+        allow(Puppet::Util).to receive(:uid).and_return(10)
 
-        Puppet::Util::Execution.expects(:execute)
+        expect(Puppet::Util::Execution).to receive(:execute)
           .with('crontab -u foobar -l', { failonfail: true, combine: true })
-          .returns("")
+          .and_return("")
         expect(described_class.instances.select { |resource|
           resource.get('target') == 'foobar'
         }).to be_empty
       end
 
       it "should contain no resources for a user who is absent" do
-        Puppet::Util.stubs(:uid).returns(nil)
+        allow(Puppet::Util).to receive(:uid).and_return(nil)
 
         expect(described_class.instances.select { |resource|
           resource.get('target') == 'foobar'
@@ -228,7 +227,7 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
       end
 
       it "should be able to create records from not-managed records" do
-        described_class.stubs(:target_object).returns File.new(my_fixture('simple'))
+        allow(described_class).to receive(:target_object).and_return(File.new(my_fixture('simple')))
         parameters = described_class.instances.map do |p|
           h = {:name => p.get(:name)}
           Puppet::Type.type(:cron).validproperties.each do |property|
@@ -264,7 +263,7 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
       end
 
       it "should be able to parse puppet managed cronjobs" do
-        described_class.stubs(:target_object).returns File.new(my_fixture('managed'))
+        allow(described_class).to receive(:target_object).and_return(File.new(my_fixture('managed')))
         expect(described_class.instances.map do |p|
           h = {:name => p.get(:name)}
           Puppet::Type.type(:cron).validproperties.each do |property|
@@ -352,6 +351,5 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
         expect { described_class.match(record,{resource_sparse[:name] => resource_sparse}) }.to_not raise_error
       end
     end
-
   end
 end

data/spec/unit/provider/exec/posix_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix? do
@@ -51,7 +50,7 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
 
       it "should fail if the command isn't executable" do
         FileUtils.touch(command)
-        File.stubs(:executable?).with(command).returns(false)
+        allow(File).to receive(:executable?).with(command).and_return(false)
 
         expect { provider.run(command) }.to raise_error(ArgumentError, "'#{command}' is not executable")
       end
@@ -63,7 +62,7 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
         provider.resource[:path] = [File.dirname(command)]
         filename = File.basename(command)
 
-        Puppet::Util::Execution.expects(:execute).with(filename, instance_of(Hash)).returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
+        expect(Puppet::Util::Execution).to receive(:execute).with(filename, instance_of(Hash)).and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
 
         provider.run(filename)
       end
@@ -77,7 +76,7 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
       it "should fail if the command is in the path but not executable" do
         command = make_exe
         File.chmod(0644, command)
-        FileTest.stubs(:executable?).with(command).returns(false)
+        allow(FileTest).to receive(:executable?).with(command).and_return(false)
         resource[:path] = [File.dirname(command)]
         filename = File.basename(command)
 
@@ -94,7 +93,7 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
       provider.resource[:path] = ['/bogus/bin']
       command = make_exe
 
-      Puppet::Util::Execution.expects(:execute).with("#{command} bar --sillyarg=true --blah", instance_of(Hash)).returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
+      expect(Puppet::Util::Execution).to receive(:execute).with("#{command} bar --sillyarg=true --blah", instance_of(Hash)).and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
 
       provider.run("#{command} bar --sillyarg=true --blah")
     end
@@ -110,7 +109,7 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
       provider.resource[:environment] = ['WHATEVER=/something/else', 'WHATEVER=/foo']
       command = make_exe
 
-      Puppet::Util::Execution.expects(:execute).with(command, instance_of(Hash)).returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
+      expect(Puppet::Util::Execution).to receive(:execute).with(command, instance_of(Hash)).and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
 
       provider.run(command)
 
@@ -119,7 +118,7 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
 
     it "should set umask before execution if umask parameter is in use" do
       provider.resource[:umask] = '0027'
-      Puppet::Util.expects(:withumask).with(0027)
+      expect(Puppet::Util).to receive(:withumask).with(0027)
       provider.run(provider.resource[:command])
     end
 

data/spec/unit/provider/exec/shell_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:exec).provider(:shell), :unless => Puppet.features.microsoft_windows? do

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

@@ -1,5 +1,3 @@
-#! /usr/bin/env ruby
-
 require 'spec_helper'
 
 describe Puppet::Type.type(:exec).provider(:windows), :if => Puppet.features.microsoft_windows? do
@@ -68,12 +66,12 @@ describe Puppet::Type.type(:exec).provider(:windows), :if => Puppet.features.mic
     describe "when the command is relative" do
       describe "and a path is specified" do
         before :each do
-          provider.stubs(:which)
+          allow(provider).to receive(:which)
         end
 
         it "should search for executables with no extension" do
           provider.resource[:path] = [File.expand_path('/bogus/bin')]
-          provider.expects(:which).with('foo').returns('foo')
+          expect(provider).to receive(:which).with('foo').and_return('foo')
 
           provider.checkexe('foo')
         end

data/spec/unit/provider/exec_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/provider/exec'
 

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

@@ -1,5 +1,3 @@
-#! /usr/bin/env ruby
-
 require 'spec_helper'
 
 describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix? do
@@ -41,7 +39,7 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
 
   describe "#uid2name" do
     it "should return the name of the user identified by the id" do
-      Etc.stubs(:getpwuid).with(501).returns(Struct::Passwd.new('jilluser', nil, 501))
+      allow(Etc).to receive(:getpwuid).with(501).and_return(Struct::Passwd.new('jilluser', nil, 501))
 
       expect(provider.uid2name(501)).to eq('jilluser')
     end
@@ -55,7 +53,7 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
     end
 
     it "should return nil if the user doesn't exist" do
-      Etc.expects(:getpwuid).raises(ArgumentError, "can't find user for 999")
+      expect(Etc).to receive(:getpwuid).and_raise(ArgumentError, "can't find user for 999")
 
       expect(provider.uid2name(999)).to eq(nil)
     end
@@ -65,8 +63,8 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
     it "should return the id of the user if it exists" do
       passwd = Struct::Passwd.new('bobbo', nil, 502)
 
-      Etc.stubs(:getpwnam).with('bobbo').returns(passwd)
-      Etc.stubs(:getpwuid).with(502).returns(passwd)
+      allow(Etc).to receive(:getpwnam).with('bobbo').and_return(passwd)
+      allow(Etc).to receive(:getpwuid).with(502).and_return(passwd)
 
       expect(provider.name2uid('bobbo')).to eq(502)
     end
@@ -76,7 +74,7 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
     end
 
     it "should return false if the user doesn't exist" do
-      Etc.stubs(:getpwnam).with('chuck').raises(ArgumentError, "can't find user for chuck")
+      allow(Etc).to receive(:getpwnam).with('chuck').and_raise(ArgumentError, "can't find user for chuck")
 
       expect(provider.name2uid('chuck')).to eq(false)
     end
@@ -95,8 +93,8 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
     end
 
     it "should warn and return :silly if the value is beyond the maximum uid" do
-      stat = stub('stat', :uid => Puppet[:maximum_uid] + 1)
-      resource.stubs(:stat).returns(stat)
+      stat = double('stat', :uid => Puppet[:maximum_uid] + 1)
+      allow(resource).to receive(:stat).and_return(stat)
 
       expect(provider.owner).to eq(:silly)
       expect(@logs).to be_any {|log| log.level == :warning and log.message =~ /Apparently using negative UID/}
@@ -105,27 +103,27 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
 
   describe "#owner=" do
     it "should set the owner but not the group of the file" do
-      File.expects(:lchown).with(15, nil, resource[:path])
+      expect(File).to receive(:lchown).with(15, nil, resource[:path])
 
       provider.owner = 15
     end
 
     it "should chown a link if managing links" do
       resource[:links] = :manage
-      File.expects(:lchown).with(20, nil, resource[:path])
+      expect(File).to receive(:lchown).with(20, nil, resource[:path])
 
       provider.owner = 20
     end
 
     it "should chown a link target if following links" do
       resource[:links] = :follow
-      File.expects(:chown).with(20, nil, resource[:path])
+      expect(File).to receive(:chown).with(20, nil, resource[:path])
 
       provider.owner = 20
     end
 
     it "should pass along any error encountered setting the owner" do
-      File.expects(:lchown).raises(ArgumentError)
+      expect(File).to receive(:lchown).and_raise(ArgumentError)
 
       expect { provider.owner = 25 }.to raise_error(Puppet::Error, /Failed to set owner to '25'/)
     end
@@ -133,7 +131,7 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
 
   describe "#gid2name" do
     it "should return the name of the group identified by the id" do
-      Etc.stubs(:getgrgid).with(501).returns(Struct::Passwd.new('unicorns', nil, nil, 501))
+      allow(Etc).to receive(:getgrgid).with(501).and_return(Struct::Passwd.new('unicorns', nil, nil, 501))
 
       expect(provider.gid2name(501)).to eq('unicorns')
     end
@@ -147,7 +145,7 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
     end
 
     it "should return nil if the group doesn't exist" do
-      Etc.expects(:getgrgid).raises(ArgumentError, "can't find group for 999")
+      expect(Etc).to receive(:getgrgid).and_raise(ArgumentError, "can't find group for 999")
 
       expect(provider.gid2name(999)).to eq(nil)
     end
@@ -157,8 +155,8 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
     it "should return the id of the group if it exists" do
       passwd = Struct::Passwd.new('penguins', nil, nil, 502)
 
-      Etc.stubs(:getgrnam).with('penguins').returns(passwd)
-      Etc.stubs(:getgrgid).with(502).returns(passwd)
+      allow(Etc).to receive(:getgrnam).with('penguins').and_return(passwd)
+      allow(Etc).to receive(:getgrgid).with(502).and_return(passwd)
 
       expect(provider.name2gid('penguins')).to eq(502)
     end
@@ -168,7 +166,7 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
     end
 
     it "should return false if the group doesn't exist" do
-      Etc.stubs(:getgrnam).with('wombats').raises(ArgumentError, "can't find group for wombats")
+      allow(Etc).to receive(:getgrnam).with('wombats').and_raise(ArgumentError, "can't find group for wombats")
 
       expect(provider.name2gid('wombats')).to eq(false)
     end
@@ -188,8 +186,8 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
     end
 
     it "should warn and return :silly if the value is beyond the maximum gid" do
-      stat = stub('stat', :gid => Puppet[:maximum_uid] + 1)
-      resource.stubs(:stat).returns(stat)
+      stat = double('stat', :gid => Puppet[:maximum_uid] + 1)
+      allow(resource).to receive(:stat).and_return(stat)
 
       expect(provider.group).to eq(:silly)
       expect(@logs).to be_any {|log| log.level == :warning and log.message =~ /Apparently using negative GID/}
@@ -198,27 +196,27 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
 
   describe "#group=" do
     it "should set the group but not the owner of the file" do
-      File.expects(:lchown).with(nil, 15, resource[:path])
+      expect(File).to receive(:lchown).with(nil, 15, resource[:path])
 
       provider.group = 15
     end
 
     it "should change the group for a link if managing links" do
       resource[:links] = :manage
-      File.expects(:lchown).with(nil, 20, resource[:path])
+      expect(File).to receive(:lchown).with(nil, 20, resource[:path])
 
       provider.group = 20
     end
 
     it "should change the group for a link target if following links" do
       resource[:links] = :follow
-      File.expects(:chown).with(nil, 20, resource[:path])
+      expect(File).to receive(:chown).with(nil, 20, resource[:path])
 
       provider.group = 20
     end
 
     it "should pass along any error encountered setting the group" do
-      File.expects(:lchown).raises(ArgumentError)
+      expect(File).to receive(:lchown).and_raise(ArgumentError)
 
       expect { provider.group = 25 }.to raise_error(Puppet::Error, /Failed to set group to '25'/)
     end