puppet 6.0.10-x64-mingw32 → 6.1.0-x64-mingw32

data/spec/unit/util/execution_stub_spec.rb

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

data/spec/unit/util/feature_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/feature'
@@ -5,7 +6,7 @@ require 'puppet/util/feature'
 describe Puppet::Util::Feature do
   before do
     @features = Puppet::Util::Feature.new("features")
-    allow(@features).to receive(:warn)
+    @features.stubs(:warn)
   end
 
   it "should not call associated code when adding a feature" do
@@ -76,38 +77,30 @@ 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})
-    expect(@features).to receive(:require).with("foo")
-    expect(@features).to receive(:require).with("bar")
+    @features.expects(:require).with("foo")
+    @features.expects(: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})
-    expect(@features).to receive(:require).with("foo").and_raise(LoadError)
-    allow(@features).to receive(:require).with("bar")
+    @features.expects(:require).with("foo").raises(LoadError)
+    @features.stubs(:require).with("bar")
 
-    expect(Puppet).to receive(:debug)
+    Puppet.expects(:debug)
 
     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})
-    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)
-    expect_any_instance_of(Puppet::Util::RubyGems::Gems18Source).to receive(:clear_paths).exactly(3).times()
-
-    expect(Puppet).to receive(:debug)
+    @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)
+
+    Puppet.expects(:debug)
 
     expect(@features).not_to be_myfeature
     expect(@features).to be_myfeature
@@ -117,7 +110,7 @@ describe Puppet::Util::Feature do
     Puppet[:always_retry_plugins] = false
 
     @features.add(:myfeature, :libs => %w{foo bar})
-    expect(@features).to receive(:require).with("foo").and_raise(LoadError)
+    @features.expects(:require).with("foo").raises(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,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/filetype'
@@ -15,15 +16,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
-        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")
+        Puppet::FileSystem.expects(:exist?).with(path).returns true
+        Puppet::FileSystem.expects(:read).with(path, :encoding => Encoding.default_external).returns "my text"
 
         expect(file.read).to eq("my text")
       end
 
       it "should unlink the file when asked to remove it" do
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-        expect(Puppet::FileSystem).to receive(:unlink).with(path)
+        Puppet::FileSystem.expects(:exist?).with(path).returns true
+        Puppet::FileSystem.expects(:unlink).with(path)
 
         file.remove
       end
@@ -31,58 +32,57 @@ 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
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(false)
+        Puppet::FileSystem.expects(:exist?).with(path).returns false
 
         expect(file.read).to eq("")
       end
     end
 
     describe "when writing the file" do
-      let(:tempfile) { double('tempfile', :print => nil, :close => nil, :flush => nil, :path => "/other/file") }
-
+      let(:tempfile) { stub 'tempfile', :print => nil, :close => nil, :flush => nil, :path => "/other/file" }
       before do
-        allow(FileUtils).to receive(:cp)
-        allow(Tempfile).to receive(:new).and_return(tempfile)
+        FileUtils.stubs(:cp)
+        Tempfile.stubs(:new).returns tempfile
       end
 
       it "should first create a temp file and copy its contents over to the file location" do
-        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)
+        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)
 
         file.write "my text"
       end
 
       it "should set the selinux default context on the file" do
-        expect(file).to receive(:set_selinux_default_context).with(path)
+        file.expects(: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
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(false)
-        expect(file).not_to receive(:bucket)
+        Puppet::FileSystem.expects(:exist?).with(path).returns false
+        file.expects(:bucket).never
         file.backup
       end
 
       it "should use its filebucket to backup the file if it exists" do
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
+        Puppet::FileSystem.expects(:exist?).with(path).returns true
 
-        bucket = double('bucket')
-        expect(bucket).to receive(:backup).with(path)
+        bucket = mock 'bucket'
+        bucket.expects(:backup).with(path)
 
-        expect(file).to receive(:bucket).and_return(bucket)
+        file.expects(:bucket).returns bucket
         file.backup
       end
 
       it "should use the default filebucket" do
-        bucket = double('bucket')
-        expect(bucket).to receive(:bucket).and_return("mybucket")
+        bucket = mock 'bucket'
+        bucket.expects(:bucket).returns "mybucket"
 
-        expect(Puppet::Type.type(:filebucket)).to receive(:mkdefaultbucket).and_return(bucket)
+        Puppet::Type.type(:filebucket).expects(:mkdefaultbucket).returns 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
-      allow(Puppet::Util::SUIDManager).to receive(:uid).and_return(1234)
+      Puppet::Util::SUIDManager.stubs(:uid).returns 1234
     end
 
     describe "#read" do
       before(:each) do
-        allow(Puppet::Util).to receive(:uid).with(uid).and_return(9000)
+        Puppet::Util.stubs(:uid).with(uid).returns 9000
       end
 
       it "should run crontab -l as the target user" do
-        expect(Puppet::Util::Execution).to receive(:execute)
+        Puppet::Util::Execution.expects(:execute)
           .with(['crontab', '-l'], user_options)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new(crontab, 0))
+          .returns(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
-        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))
+        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(cron.read).to eq(crontab)
       end
 
       it "should treat an absent crontab as empty" do
-        expect(Puppet::Util::Execution).to receive(:execute).with(['crontab', '-l'], user_options).and_raise(Puppet::ExecutionFailure, absent_crontab)
+        Puppet::Util::Execution.expects(:execute).with(['crontab', '-l'], user_options).raises(Puppet::ExecutionFailure, absent_crontab)
         expect(cron.read).to eq('')
       end
 
       it "should treat a nonexistent user's crontab as empty" do
-        expect(Puppet::Util).to receive(:uid).with(uid).and_return(nil)
+        Puppet::Util.expects(:uid).with(uid).returns nil
 
         expect(cron.read).to eq('')
       end
 
       it "should return empty if the user is not authorized to use cron" do
-        expect(Puppet::Util::Execution).to receive(:execute).with(['crontab', '-l'], user_options).and_raise(Puppet::ExecutionFailure, unauthorized_crontab)
+        Puppet::Util::Execution.expects(:execute).with(['crontab', '-l'], user_options).raises(Puppet::ExecutionFailure, unauthorized_crontab)
         expect(cron.read).to eq('')
       end
     end
 
     describe "#remove" do
       it "should run crontab -r as the target user" do
-        expect(Puppet::Util::Execution).to receive(:execute).with(['crontab', '-r'], user_options)
+        Puppet::Util::Execution.expects(:execute).with(['crontab', '-r'], user_options)
         cron.remove
       end
 
       it "should not switch user if current user is the target user" do
-        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)
+        Puppet::Util.expects(:uid).with(uid).returns 9000
+        Puppet::Util::SUIDManager.expects(:uid).returns 9000
+        Puppet::Util::Execution.expects(: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
-        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)
+        Puppet::Util.stubs(:uid).with(uid).returns 9000
+        Tempfile.expects(:new).with("puppet_#{name}", :encoding => Encoding.default_external).returns @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
-        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)
+        File.expects(:chown).with(9000, nil, @tmp_cron_path)
+        Puppet::Util::Execution.expects(:execute).with(["crontab", @tmp_cron_path], user_options)
 
-        expect(@tmp_cron).to receive(:print).with("foo\n")
+        @tmp_cron.expects(:print).with("foo\n")
         cron.write "foo\n"
       end
 
       it "should not switch user if current user is the target user" do
-        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)
+        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(@tmp_cron).to receive(:print).with("foo\n")
+        @tmp_cron.expects(: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) { double('http ok', :code => 200, :message => 'HTTP OK') }
+    let(:http_ok) { stub('http ok', :code => 200, :message => 'HTTP OK') }
 
     it 'generates accept and accept-encoding headers' do
-      allow_any_instance_of(Net::HTTP).to receive(:head).and_return(http_ok)
-      expect_any_instance_of(Net::HTTP).to receive(:get) do |_, _, headers|
+      Net::HTTP.any_instance.stubs(:head).returns(http_ok)
+      Net::HTTP.any_instance.expects(:get).with 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.and_return(http_ok)
+      end.returns(http_ok)
 
       subject.request_with_redirects(dest, :get, 0)
     end
 
     it 'can return a compressed response body' do
-      allow_any_instance_of(Net::HTTP).to receive(:head).and_return(http_ok)
+      Net::HTTP.any_instance.stubs(:head).returns(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 = 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)
+      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)
 
       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
-      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|
+      Net::HTTP.any_instance.stubs(:head).returns(http_ok)
+      Net::HTTP.any_instance.expects(:request_get).with 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.and_return(http_ok)
+      end.returns(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
-      expect_any_instance_of(Net::HTTP).to receive(:head).with(anything, anything).and_return(http_ok)
+      Net::HTTP.any_instance.expects(:head).with(anything, anything).returns(http_ok)
 
       subject.request_with_redirects(dest, :head, 0)
     end

data/spec/unit/util/inifile_spec.rb

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