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

data/spec/unit/util/execution_stub_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Util::ExecutionStub do

data/spec/unit/util/feature_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/feature'
@@ -6,7 +5,7 @@ require 'puppet/util/feature'
 describe Puppet::Util::Feature do
   before do
     @features = Puppet::Util::Feature.new("features")
-    @features.stubs(:warn)
+    allow(@features).to receive(:warn)
   end
 
   it "should not call associated code when adding a feature" do
@@ -77,40 +76,50 @@ describe Puppet::Util::Feature do
 
   it "should consider a feature to be present if all of its libraries are present" do
     @features.add(:myfeature, :libs => %w{foo bar})
-    @features.expects(:require).with("foo")
-    @features.expects(:require).with("bar")
+    expect(@features).to receive(:require).with("foo")
+    expect(@features).to receive(:require).with("bar")
 
     expect(@features).to be_myfeature
   end
 
   it "should log and consider a feature to be absent if any of its libraries are absent" do
     @features.add(:myfeature, :libs => %w{foo bar})
-    @features.expects(:require).with("foo").raises(LoadError)
-    @features.stubs(:require).with("bar")
+    expect(@features).to receive(:require).with("foo").and_raise(LoadError)
+    allow(@features).to receive(:require).with("bar")
 
-    @features.expects(:debug_once)
+    expect(@features).to receive(:debug_once)
 
     expect(@features).not_to be_myfeature
   end
 
   it "should change the feature to be present when its libraries become available" do
     @features.add(:myfeature, :libs => %w{foo bar})
-    @features.expects(:require).twice().with("foo").raises(LoadError).then.returns(nil)
-    @features.stubs(:require).with("bar")
-    Puppet::Util::RubyGems::Source.stubs(:source).returns(Puppet::Util::RubyGems::Gems18Source)
-    Puppet::Util::RubyGems::Gems18Source.any_instance.expects(:clear_paths).times(3)
-
-    @features.expects(:debug_once)
+    times_feature_require_called = 0
+    expect(@features).to receive(:require).twice().with("foo") do
+      times_feature_require_called += 1
+      if times_feature_require_called == 1
+        raise LoadError
+      else
+        nil
+      end
+    end
+    allow(@features).to receive(:require).with("bar")
+    allow(Puppet::Util::RubyGems::Source).to receive(:source).and_return(Puppet::Util::RubyGems::Gems18Source)
+    times_clear_paths_called = 0
+    allow_any_instance_of(Puppet::Util::RubyGems::Gems18Source).to receive(:clear_paths) { times_clear_paths_called += 1 }
+
+    expect(@features).to receive(:debug_once)
 
     expect(@features).not_to be_myfeature
     expect(@features).to be_myfeature
+    expect(times_clear_paths_called).to eq(3)
   end
 
   it "should cache load failures when configured to do so" do
     Puppet[:always_retry_plugins] = false
 
     @features.add(:myfeature, :libs => %w{foo bar})
-    @features.expects(:require).with("foo").raises(LoadError)
+    expect(@features).to receive(:require).with("foo").and_raise(LoadError)
 
     expect(@features).not_to be_myfeature
     # second call would cause an expectation exception if 'require' was

data/spec/unit/util/filetype_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/filetype'
@@ -16,15 +15,15 @@ describe Puppet::Util::FileType do
 
     describe "when the file already exists" do
       it "should return the file's contents when asked to read it" do
-        Puppet::FileSystem.expects(:exist?).with(path).returns true
-        Puppet::FileSystem.expects(:read).with(path, :encoding => Encoding.default_external).returns "my text"
+        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
+        expect(Puppet::FileSystem).to receive(:read).with(path, :encoding => Encoding.default_external).and_return("my text")
 
         expect(file.read).to eq("my text")
       end
 
       it "should unlink the file when asked to remove it" do
-        Puppet::FileSystem.expects(:exist?).with(path).returns true
-        Puppet::FileSystem.expects(:unlink).with(path)
+        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
+        expect(Puppet::FileSystem).to receive(:unlink).with(path)
 
         file.remove
       end
@@ -32,57 +31,58 @@ describe Puppet::Util::FileType do
 
     describe "when the file does not exist" do
       it "should return an empty string when asked to read the file" do
-        Puppet::FileSystem.expects(:exist?).with(path).returns false
+        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(false)
 
         expect(file.read).to eq("")
       end
     end
 
     describe "when writing the file" do
-      let(:tempfile) { stub 'tempfile', :print => nil, :close => nil, :flush => nil, :path => "/other/file" }
+      let(:tempfile) { double('tempfile', :print => nil, :close => nil, :flush => nil, :path => "/other/file") }
+
       before do
-        FileUtils.stubs(:cp)
-        Tempfile.stubs(:new).returns tempfile
+        allow(FileUtils).to receive(:cp)
+        allow(Tempfile).to receive(:new).and_return(tempfile)
       end
 
       it "should first create a temp file and copy its contents over to the file location" do
-        Tempfile.expects(:new).with("puppet", :encoding => Encoding.default_external).returns tempfile
-        tempfile.expects(:print).with("my text")
-        tempfile.expects(:flush)
-        tempfile.expects(:close)
-        FileUtils.expects(:cp).with(tempfile.path, path)
+        expect(Tempfile).to receive(:new).with("puppet", :encoding => Encoding.default_external).and_return(tempfile)
+        expect(tempfile).to receive(:print).with("my text")
+        expect(tempfile).to receive(:flush)
+        expect(tempfile).to receive(:close)
+        expect(FileUtils).to receive(:cp).with(tempfile.path, path)
 
         file.write "my text"
       end
 
       it "should set the selinux default context on the file" do
-        file.expects(:set_selinux_default_context).with(path)
+        expect(file).to receive(:set_selinux_default_context).with(path)
         file.write "eh"
       end
     end
 
     describe "when backing up a file" do
       it "should do nothing if the file does not exist" do
-        Puppet::FileSystem.expects(:exist?).with(path).returns false
-        file.expects(:bucket).never
+        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(false)
+        expect(file).not_to receive(:bucket)
         file.backup
       end
 
       it "should use its filebucket to backup the file if it exists" do
-        Puppet::FileSystem.expects(:exist?).with(path).returns true
+        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
 
-        bucket = mock 'bucket'
-        bucket.expects(:backup).with(path)
+        bucket = double('bucket')
+        expect(bucket).to receive(:backup).with(path)
 
-        file.expects(:bucket).returns bucket
+        expect(file).to receive(:bucket).and_return(bucket)
         file.backup
       end
 
       it "should use the default filebucket" do
-        bucket = mock 'bucket'
-        bucket.expects(:bucket).returns "mybucket"
+        bucket = double('bucket')
+        expect(bucket).to receive(:bucket).and_return("mybucket")
 
-        Puppet::Type.type(:filebucket).expects(:mkdefaultbucket).returns bucket
+        expect(Puppet::Type.type(:filebucket)).to receive(:mkdefaultbucket).and_return(bucket)
 
         expect(file.bucket).to eq("mybucket")
       end
@@ -103,57 +103,57 @@ describe Puppet::Util::FileType do
     # make Puppet::Util::SUIDManager return something deterministic, not the
     # uid of the user running the tests, except where overridden below.
     before :each do
-      Puppet::Util::SUIDManager.stubs(:uid).returns 1234
+      allow(Puppet::Util::SUIDManager).to receive(:uid).and_return(1234)
     end
 
     describe "#read" do
       before(:each) do
-        Puppet::Util.stubs(:uid).with(uid).returns 9000
+        allow(Puppet::Util).to receive(:uid).with(uid).and_return(9000)
       end
 
       it "should run crontab -l as the target user" do
-        Puppet::Util::Execution.expects(:execute)
+        expect(Puppet::Util::Execution).to receive(:execute)
           .with(['crontab', '-l'], user_options)
-          .returns(Puppet::Util::Execution::ProcessOutput.new(crontab, 0))
+          .and_return(Puppet::Util::Execution::ProcessOutput.new(crontab, 0))
         expect(cron.read).to eq(crontab)
       end
 
       it "should not switch user if current user is the target user" do
-        Puppet::Util.expects(:uid).with(uid).twice.returns 9000
-        Puppet::Util::SUIDManager.expects(:uid).returns 9000
-        Puppet::Util::Execution
-          .expects(:execute).with(['crontab', '-l'], options)
-          .returns(Puppet::Util::Execution::ProcessOutput.new(crontab, 0))
+        expect(Puppet::Util).to receive(:uid).with(uid).twice.and_return(9000)
+        expect(Puppet::Util::SUIDManager).to receive(:uid).and_return(9000)
+        expect(Puppet::Util::Execution).to receive(:execute)
+          .with(['crontab', '-l'], options)
+          .and_return(Puppet::Util::Execution::ProcessOutput.new(crontab, 0))
         expect(cron.read).to eq(crontab)
       end
 
       it "should treat an absent crontab as empty" do
-        Puppet::Util::Execution.expects(:execute).with(['crontab', '-l'], user_options).raises(Puppet::ExecutionFailure, absent_crontab)
+        expect(Puppet::Util::Execution).to receive(:execute).with(['crontab', '-l'], user_options).and_raise(Puppet::ExecutionFailure, absent_crontab)
         expect(cron.read).to eq('')
       end
 
       it "should treat a nonexistent user's crontab as empty" do
-        Puppet::Util.expects(:uid).with(uid).returns nil
+        expect(Puppet::Util).to receive(:uid).with(uid).and_return(nil)
 
         expect(cron.read).to eq('')
       end
 
       it "should return empty if the user is not authorized to use cron" do
-        Puppet::Util::Execution.expects(:execute).with(['crontab', '-l'], user_options).raises(Puppet::ExecutionFailure, unauthorized_crontab)
+        expect(Puppet::Util::Execution).to receive(:execute).with(['crontab', '-l'], user_options).and_raise(Puppet::ExecutionFailure, unauthorized_crontab)
         expect(cron.read).to eq('')
       end
     end
 
     describe "#remove" do
       it "should run crontab -r as the target user" do
-        Puppet::Util::Execution.expects(:execute).with(['crontab', '-r'], user_options)
+        expect(Puppet::Util::Execution).to receive(:execute).with(['crontab', '-r'], user_options)
         cron.remove
       end
 
       it "should not switch user if current user is the target user" do
-        Puppet::Util.expects(:uid).with(uid).returns 9000
-        Puppet::Util::SUIDManager.expects(:uid).returns 9000
-        Puppet::Util::Execution.expects(:execute).with(['crontab','-r'], options)
+        expect(Puppet::Util).to receive(:uid).with(uid).and_return(9000)
+        expect(Puppet::Util::SUIDManager).to receive(:uid).and_return(9000)
+        expect(Puppet::Util::Execution).to receive(:execute).with(['crontab','-r'], options)
         cron.remove
       end
     end
@@ -162,8 +162,8 @@ describe Puppet::Util::FileType do
       before :each do
         @tmp_cron = Tempfile.new("puppet_crontab_spec")
         @tmp_cron_path = @tmp_cron.path
-        Puppet::Util.stubs(:uid).with(uid).returns 9000
-        Tempfile.expects(:new).with("puppet_#{name}", :encoding => Encoding.default_external).returns @tmp_cron
+        allow(Puppet::Util).to receive(:uid).with(uid).and_return(9000)
+        expect(Tempfile).to receive(:new).with("puppet_#{name}", :encoding => Encoding.default_external).and_return(@tmp_cron)
       end
 
       after :each do
@@ -171,19 +171,19 @@ describe Puppet::Util::FileType do
       end
 
       it "should run crontab as the target user on a temporary file" do
-        File.expects(:chown).with(9000, nil, @tmp_cron_path)
-        Puppet::Util::Execution.expects(:execute).with(["crontab", @tmp_cron_path], user_options)
+        expect(File).to receive(:chown).with(9000, nil, @tmp_cron_path)
+        expect(Puppet::Util::Execution).to receive(:execute).with(["crontab", @tmp_cron_path], user_options)
 
-        @tmp_cron.expects(:print).with("foo\n")
+        expect(@tmp_cron).to receive(:print).with("foo\n")
         cron.write "foo\n"
       end
 
       it "should not switch user if current user is the target user" do
-        Puppet::Util::SUIDManager.expects(:uid).returns 9000
-        File.expects(:chown).with(9000, nil, @tmp_cron_path)
-        Puppet::Util::Execution.expects(:execute).with(["crontab", @tmp_cron_path], options)
+        expect(Puppet::Util::SUIDManager).to receive(:uid).and_return(9000)
+        expect(File).to receive(:chown).with(9000, nil, @tmp_cron_path)
+        expect(Puppet::Util::Execution).to receive(:execute).with(["crontab", @tmp_cron_path], options)
 
-        @tmp_cron.expects(:print).with("foo\n")
+        expect(@tmp_cron).to receive(:print).with("foo\n")
         cron.write "foo\n"
       end
     end

data/spec/unit/util/http_proxy_spec.rb

@@ -218,22 +218,22 @@ describe Puppet::Util::HttpProxy do
 
   describe '.request_with_redirects' do
     let(:dest) { URI.parse('http://mydomain.com/some/path') }
-    let(:http_ok) { stub('http ok', :code => 200, :message => 'HTTP OK') }
+    let(:http_ok) { double('http ok', :code => 200, :message => 'HTTP OK') }
 
     it 'generates accept and accept-encoding headers' do
-      Net::HTTP.any_instance.stubs(:head).returns(http_ok)
-      Net::HTTP.any_instance.expects(:get).with do |_, headers|
+      allow_any_instance_of(Net::HTTP).to receive(:head).and_return(http_ok)
+      expect_any_instance_of(Net::HTTP).to receive(:get) do |_, _, headers|
         expect(headers)
           .to match({'Accept' => '*/*',
                      'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
                      'User-Agent' => /Puppet/})
-      end.returns(http_ok)
+      end.and_return(http_ok)
 
       subject.request_with_redirects(dest, :get, 0)
     end
 
     it 'can return a compressed response body' do
-      Net::HTTP.any_instance.stubs(:head).returns(http_ok)
+      allow_any_instance_of(Net::HTTP).to receive(:head).and_return(http_ok)
 
       compressed_body = [
         0x1f, 0x8b, 0x08, 0x08, 0xe9, 0x08, 0x7a, 0x5a, 0x00, 0x03,
@@ -241,9 +241,9 @@ describe Puppet::Util::HttpProxy do
         0x00, 0x7a, 0x7a, 0x6f, 0xed, 0x03, 0x00, 0x00, 0x00
       ].pack('C*')
 
-      response = stub('http ok', :code => 200, :message => 'HTTP OK', :body => compressed_body)
-      response.stubs(:[]).with('content-encoding').returns('gzip')
-      Net::HTTP.any_instance.expects(:get).returns(response)
+      response = double('http ok', :code => 200, :message => 'HTTP OK', :body => compressed_body)
+      allow(response).to receive(:[]).with('content-encoding').and_return('gzip')
+      expect_any_instance_of(Net::HTTP).to receive(:get).and_return(response)
 
       expect(
         uncompress_body(subject.request_with_redirects(dest, :get, 0))
@@ -251,13 +251,13 @@ describe Puppet::Util::HttpProxy do
     end
 
     it 'generates accept and accept-encoding headers when a block is provided' do
-      Net::HTTP.any_instance.stubs(:head).returns(http_ok)
-      Net::HTTP.any_instance.expects(:request_get).with do |_, headers, &block|
+      allow_any_instance_of(Net::HTTP).to receive(:head).and_return(http_ok)
+      expect_any_instance_of(Net::HTTP).to receive(:request_get) do |_, _, headers, &block|
         expect(headers)
           .to match({'Accept' => '*/*',
                      'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
                      'User-Agent' => /Puppet/})
-      end.returns(http_ok)
+      end.and_return(http_ok)
 
       subject.request_with_redirects(dest, :get, 0) do
         # unused
@@ -265,7 +265,7 @@ describe Puppet::Util::HttpProxy do
     end
 
     it 'only makes a single HEAD request' do
-      Net::HTTP.any_instance.expects(:head).with(anything, anything).returns(http_ok)
+      expect_any_instance_of(Net::HTTP).to receive(:head).with(anything, anything).and_return(http_ok)
 
       subject.request_with_redirects(dest, :head, 0)
     end

data/spec/unit/util/inifile_spec.rb

@@ -111,19 +111,18 @@ describe Puppet::Util::IniConfig::PhysicalFile do
 
   describe "when reading a file" do
     it "raises an error if the file does not exist" do
-      subject.filetype.stubs(:read)
+      allow(subject.filetype).to receive(:read)
       expect {
         subject.read
       }.to raise_error(%r[Cannot read nonexistent file .*/some/nonexistent/file])
     end
 
     it "passes the contents of the file to #parse" do
-      subject.filetype.stubs(:read).returns "[section]"
-      subject.expects(:parse).with("[section]")
+      allow(subject.filetype).to receive(:read).and_return("[section]")
+      expect(subject).to receive(:parse).with("[section]")
 
       subject.read
     end
-
   end
 
   describe "when parsing a file" do
@@ -148,7 +147,7 @@ describe Puppet::Util::IniConfig::PhysicalFile do
       end
 
       it "raises an error if a section is redefined in the file collection" do
-        subject.file_collection = stub('file collection', :get_section => true)
+        subject.file_collection = double('file collection', :get_section => true)
         text = "[mysect]\n[mysect]\n"
 
         expect {
@@ -156,7 +155,6 @@ describe Puppet::Util::IniConfig::PhysicalFile do
         }.to raise_error(Puppet::Util::IniConfig::IniParseError,
                          /Section "mysect" is already defined, cannot redefine/)
       end
-
     end
 
     describe 'parsing properties' do
@@ -211,7 +209,6 @@ INIFILE
     end
 
     describe "parsing line continuations" do
-
       it "adds the continued line to the last parsed property" do
         text = "[main]\nkey=val\n moreval"
 
@@ -283,7 +280,6 @@ INIFILE
   end
 
   describe "formatting" do
-
     it "concatenates each formatted section in order" do
       subject.contents << first_sect << second_sect
 
@@ -326,7 +322,7 @@ INIFILE
       describe "and destroy_empty is true" do
         before { subject.destroy_empty = true }
         it "removes the file if there are no sections" do
-          File.expects(:unlink)
+          expect(File).to receive(:unlink)
           subject.store
         end
 
@@ -335,7 +331,7 @@ INIFILE
           first_sect.destroy = true
           second_sect.destroy = true
 
-          File.expects(:unlink)
+          expect(File).to receive(:unlink)
           subject.store
         end
 
@@ -344,8 +340,8 @@ INIFILE
           first_sect.destroy = true
           second_sect.destroy = false
 
-          File.expects(:unlink).never
-          subject.filetype.stubs(:write)
+          expect(File).not_to receive(:unlink)
+          allow(subject.filetype).to receive(:write)
           subject.store
         end
       end
@@ -355,9 +351,9 @@ INIFILE
         first_sect.destroy = true
         second_sect.destroy = true
 
-        File.expects(:unlink).never
-        subject.stubs(:format).returns "formatted"
-        subject.filetype.expects(:write).with("formatted")
+        expect(File).not_to receive(:unlink)
+        allow(subject).to receive(:format).and_return("formatted")
+        expect(subject.filetype).to receive(:write).with("formatted")
         subject.store
       end
     end
@@ -367,8 +363,8 @@ INIFILE
       first_sect.mark_dirty
       second_sect.mark_clean
 
-      subject.stubs(:format).returns "formatted"
-      subject.filetype.expects(:write).with("formatted")
+      allow(subject).to receive(:format).and_return("formatted")
+      expect(subject.filetype).to receive(:write).with("formatted")
       subject.store
     end
 
@@ -377,15 +373,14 @@ INIFILE
       first_sect.mark_clean
       second_sect.mark_clean
 
-      subject.stubs(:format).returns "formatted"
-      subject.filetype.expects(:write).never
+      allow(subject).to receive(:format).and_return("formatted")
+      expect(subject.filetype).not_to receive(:write)
       subject.store
     end
   end
 end
 
 describe Puppet::Util::IniConfig::FileCollection do
-
   let(:path_a) { '/some/nonexistent/file/a' }
   let(:path_b) { '/some/nonexistent/file/b' }
 
@@ -404,20 +399,20 @@ describe Puppet::Util::IniConfig::FileCollection do
   end
 
   describe "reading a file" do
-    let(:stub_file) { stub('Physical file') }
+    let(:stub_file) { double('Physical file') }
 
     it "creates a new PhysicalFile and uses that to read the file" do
-      stub_file.expects(:read)
-      stub_file.expects(:file_collection=)
-      Puppet::Util::IniConfig::PhysicalFile.expects(:new).with(path_a).returns stub_file
+      expect(stub_file).to receive(:read)
+      expect(stub_file).to receive(:file_collection=)
+      expect(Puppet::Util::IniConfig::PhysicalFile).to receive(:new).with(path_a).and_return(stub_file)
 
       subject.read(path_a)
     end
 
     it "stores the PhysicalFile and the path to the file" do
-      stub_file.stubs(:read)
-      stub_file.stubs(:file_collection=)
-      Puppet::Util::IniConfig::PhysicalFile.stubs(:new).with(path_a).returns stub_file
+      allow(stub_file).to receive(:read)
+      allow(stub_file).to receive(:file_collection=)
+      allow(Puppet::Util::IniConfig::PhysicalFile).to receive(:new).with(path_a).and_return(stub_file)
       subject.read(path_a)
 
       path, physical_file = subject.files.first
@@ -434,8 +429,8 @@ describe Puppet::Util::IniConfig::FileCollection do
     end
 
     it "stores all files in the collection" do
-      file_a.expects(:store).once
-      file_b.expects(:store).once
+      expect(file_a).to receive(:store).once
+      expect(file_b).to receive(:store).once
 
       subject.store
     end
@@ -449,7 +444,7 @@ describe Puppet::Util::IniConfig::FileCollection do
 
     it "yields every section from every file" do
       [sect_a1, sect_a2, sect_b1, sect_b2].each do |sect|
-        sect.expects(:touch).once
+        expect(sect).to receive(:touch).once
       end
 
       subject.each_section do |sect|
@@ -516,7 +511,7 @@ describe Puppet::Util::IniConfig::FileCollection do
     end
 
     it "adds the section to the appropriate file" do
-      file_a.expects(:add_section).with('newsect')
+      expect(file_a).to receive(:add_section).with('newsect')
       subject.add_section('newsect', path_a)
     end
   end