puppet 5.5.12 → 5.5.13

data/spec/unit/face/parser_spec.rb

@@ -226,11 +226,11 @@ describe Puppet::Face[:parser, :current] do
   end
 
   def from_an_interactive_terminal
-    STDIN.stubs(:tty?).returns(true)
+    allow(STDIN).to receive(:tty?).and_return(true)
   end
 
   def from_a_piped_input_of(contents)
-    STDIN.stubs(:tty?).returns(false)
-    STDIN.stubs(:read).returns(contents)
+    allow(STDIN).to receive(:tty?).and_return(false)
+    allow(STDIN).to receive(:read).and_return(contents)
   end
 end

data/spec/unit/face/plugin_spec.rb

@@ -1,9 +1,7 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/face'
 
 describe Puppet::Face[:plugin, :current] do
-
   let(:pluginface) { described_class }
   let(:action) { pluginface.get_action(:download) }
 
@@ -18,22 +16,38 @@ describe Puppet::Face[:plugin, :current] do
     end
 
     it "downloads plugins, external facts, and locales" do
-      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(3).returns([])
+      receive_count = 0
+      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1 }.and_return([])
 
       pluginface.download
+      expect(receive_count).to eq(3)
     end
 
     it "renders 'No plugins downloaded' if nothing was downloaded" do
-      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(3).returns([])
+      receive_count = 0
+      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1 }.and_return([])
 
       result = pluginface.download
+      expect(receive_count).to eq(3)
       expect(render(result)).to eq('No plugins downloaded.')
     end
 
     it "renders comma separate list of downloaded file names" do
-      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(3).returns(%w[/a]).then.returns(%w[/b]).then.returns(%w[/c])
+      receive_count = 0
+      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
+        receive_count += 1
+        case receive_count
+        when 1
+          %w[/a]
+        when 2
+          %w[/b]
+        when 3
+          %w[/c]
+        end
+      end
 
       result = pluginface.download
+      expect(receive_count).to eq(3)
       expect(render(result)).to eq('Downloaded these plugins: /a, /b, /c')
     end
   end
@@ -45,15 +59,21 @@ describe Puppet::Face[:plugin, :current] do
     end
 
     it "downloads plugins, and external facts, but not locales" do
-      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns([])
+      receive_count = 0
+      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1}.and_return([])
 
       pluginface.download
     end
 
     it "renders comma separate list of downloaded file names that does not include locales" do
-      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns(%w[/a]).then.returns(%w[/b])
+      receive_count = 0
+      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
+        receive_count += 1
+        receive_count == 1 ? %w[/a] : %w[/b]
+      end
 
       result = pluginface.download
+      expect(receive_count).to eq(2)
       expect(render(result)).to eq('Downloaded these plugins: /a, /b')
     end
   end
@@ -66,15 +86,22 @@ describe Puppet::Face[:plugin, :current] do
     end
 
     it "downloads plugins, and external facts, but not locales" do
-      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns([])
+      receive_count = 0
+      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { receive_count += 1 }.and_return([])
 
       pluginface.download
+      expect(receive_count).to eq(2)
     end
 
     it "renders comma separate list of downloaded file names that does not include locales" do
-      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns(%w[/a]).then.returns(%w[/b])
+      receive_count = 0
+      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
+        receive_count += 1
+        receive_count == 1 ? %w[/a] : %w[/b]
+      end
 
       result = pluginface.download
+      expect(receive_count).to eq(2)
       expect(render(result)).to eq('Downloaded these plugins: /a, /b')
     end
   end

data/spec/unit/face/status_spec.rb

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

data/spec/unit/file_bucket/dipper_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'pathname'
@@ -16,7 +15,12 @@ shared_examples_for "a restorable file" do
       it "should restore the file" do
         request = nil
 
-        klass.any_instance.expects(:find).with { |r| request = r }.returns(Puppet::FileBucket::File.new(plaintext))
+        # With the *_any_instance_of form of using a block on receive, the
+        # first argument to the block is which instance is currently being
+        # dealt with, and the remaining arguments are the arguments to the
+        # method, instead of the block only getting the arguments to the
+        # method.
+        expect_any_instance_of(klass).to receive(:find) { |_,r| request = r }.and_return(Puppet::FileBucket::File.new(plaintext))
 
         expect(dipper.restore(dest, checksum)).to eq(checksum)
         expect(digest(Puppet::FileSystem.binread(dest))).to eq(checksum)
@@ -29,12 +33,12 @@ shared_examples_for "a restorable file" do
       it "should skip restoring if existing file has the same checksum" do
         File.open(dest, 'wb') {|f| f.print(plaintext) }
 
-        dipper.expects(:getfile).never
+        expect(dipper).not_to receive(:getfile)
         expect(dipper.restore(dest, checksum)).to be_nil
       end
 
       it "should overwrite existing file if it has different checksum" do
-        klass.any_instance.expects(:find).returns(Puppet::FileBucket::File.new(plaintext))
+        expect_any_instance_of(klass).to receive(:find).and_return(Puppet::FileBucket::File.new(plaintext))
 
         File.open(dest, 'wb') {|f| f.print('other contents') }
 
@@ -57,7 +61,7 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
     @dipper = Puppet::FileBucket::Dipper.new(:Path => make_absolute("/my/bucket"))
 
     file = make_tmp_file('contents')
-    Puppet::FileBucket::File.indirection.expects(:head).raises ArgumentError
+    expect(Puppet::FileBucket::File.indirection).to receive(:head).and_raise(ArgumentError)
 
     expect { @dipper.backup(file) }.to raise_error(Puppet::Error)
   end
@@ -66,8 +70,8 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
     @dipper = Puppet::FileBucket::Dipper.new(:Path => make_absolute("/my/bucket"))
 
     file = make_tmp_file('contents')
-    Puppet::FileBucket::File.indirection.expects(:head).returns false
-    Puppet::FileBucket::File.indirection.expects(:save).raises ArgumentError
+    expect(Puppet::FileBucket::File.indirection).to receive(:head).and_return(false)
+    expect(Puppet::FileBucket::File.indirection).to receive(:save).and_raise(ArgumentError)
 
     expect { @dipper.backup(file) }.to raise_error(Puppet::Error)
   end
@@ -118,9 +122,9 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
           expect(@dipper.diff(checksum2, nil, nil, file1)).to include(diff21)
           expect(@dipper.diff(nil, checksum1, file2, nil)).to include(diff21)
           expect(@dipper.diff(nil, nil, file2, file1)).to include(diff21)
-
         end
       end
+
       describe "in windows environment", :if => Puppet.features.microsoft_windows? do
         it "should fail in an informative way when trying to diff" do
           @dipper = Puppet::FileBucket::Dipper.new(:Path => tmpdir("bucket"))
@@ -135,9 +139,10 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
       end
     end
   end
+
   it "should fail in an informative way when there are failures listing files on the server" do
     @dipper = Puppet::FileBucket::Dipper.new(:Path => "/unexistent/bucket")
-    Puppet::FileBucket::File.indirection.expects(:find).returns nil
+    expect(Puppet::FileBucket::File.indirection).to receive(:find).and_return(nil)
 
     expect { @dipper.list(nil, nil) }.to raise_error(Puppet::Error)
   end
@@ -256,7 +261,7 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
           @dipper = Puppet::FileBucket::Dipper.new(:Server => "puppetmaster", :Port => "31337")
           wrong_checksum = "DEADBEEF"
 
-          Puppet::FileBucketFile::Rest.any_instance.expects(:find).returns(nil)
+          expect_any_instance_of(Puppet::FileBucketFile::Rest).to receive(:find).and_return(nil)
           expect { @dipper.diff(wrong_checksum, "WEIRDCKSM", nil, nil) }.to raise_error(Puppet::Error, "Failed to diff files")
 
         end
@@ -264,7 +269,7 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
         it "should properly diff files on the filebucket" do
           @dipper = Puppet::FileBucket::Dipper.new(:Server => "puppetmaster", :Port => "31337")
 
-          Puppet::FileBucketFile::Rest.any_instance.expects(:find).returns("Probably valid diff")
+          expect_any_instance_of(Puppet::FileBucketFile::Rest).to receive(:find).and_return("Probably valid diff")
 
           expect(@dipper.diff("checksum1", "checksum2", nil, nil)).to eq("Probably valid diff")
         end
@@ -316,10 +321,10 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
 
         file = make_tmp_file(plaintext)
 
-        Puppet::FileBucket::File.indirection.expects(:head).with(
-          regexp_matches(%r{#{digest_algorithm}/#{checksum}}), :bucket_path => "/my/bucket"
-        ).returns true
-        Puppet::FileBucket::File.indirection.expects(:save).never
+        expect(Puppet::FileBucket::File.indirection).to receive(:head).with(
+          %r{#{digest_algorithm}/#{checksum}}, :bucket_path => "/my/bucket"
+        ).and_return(true)
+        expect(Puppet::FileBucket::File.indirection).not_to receive(:save)
         expect(@dipper.backup(file)).to eq(checksum)
       end
 
@@ -328,7 +333,7 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
 
         request = nil
 
-        Puppet::FileBucketFile::File.any_instance.expects(:find).with{ |r| request = r }.once.returns(Puppet::FileBucket::File.new(plaintext))
+        expect_any_instance_of(Puppet::FileBucketFile::File).to receive(:find) { |_,r| request = r }.once.and_return(Puppet::FileBucket::File.new(plaintext))
 
         expect(@dipper.getfile(checksum)).to eq(plaintext)
 
@@ -349,8 +354,8 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
         request1 = nil
         request2 = nil
 
-        Puppet::FileBucketFile::Rest.any_instance.expects(:head).with { |r| request1 = r }.once.returns(nil)
-        Puppet::FileBucketFile::Rest.any_instance.expects(:save).with { |r| request2 = r }.once
+        expect_any_instance_of(Puppet::FileBucketFile::Rest).to receive(:head) { |_,r| request1 = r }.once.and_return(nil)
+        expect_any_instance_of(Puppet::FileBucketFile::Rest).to receive(:save) { |_,r| request2 = r }.once
 
         expect(@dipper.backup(file)).to eq(checksum)
         [request1, request2].each do |r|
@@ -365,7 +370,7 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
 
         request = nil
 
-        Puppet::FileBucketFile::Rest.any_instance.expects(:find).with { |r| request = r }.returns(Puppet::FileBucket::File.new(plaintext))
+        expect_any_instance_of(Puppet::FileBucketFile::Rest).to receive(:find) { |_,r| request = r }.and_return(Puppet::FileBucket::File.new(plaintext))
 
         expect(@dipper.getfile(checksum)).to eq(plaintext)
 
@@ -377,7 +382,6 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
   end
 
   describe "#restore" do
-
     describe "when restoring from a remote server" do
       let(:klass) { Puppet::FileBucketFile::Rest }
       let(:server) { "puppetmaster" }

data/spec/unit/file_bucket/file_spec.rb

@@ -1,8 +1,6 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/file_bucket/file'
 
-
 describe Puppet::FileBucket::File, :uses_checksums => true do
   include PuppetSpec::Files
 

data/spec/unit/file_serving/base_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/file_serving/base'
@@ -42,12 +41,12 @@ describe Puppet::FileServing::Base do
   end
 
   it "should allow specification of a path" do
-    Puppet::FileSystem.stubs(:exist?).returns(true)
+    allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
     expect(Puppet::FileServing::Base.new(path, :path => file).path).to eq(file)
   end
 
   it "should allow specification of a relative path" do
-    Puppet::FileSystem.stubs(:exist?).returns(true)
+    allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
     expect(Puppet::FileServing::Base.new(path, :relative_path => "my/file").relative_path).to eq("my/file")
   end
 
@@ -56,19 +55,19 @@ describe Puppet::FileServing::Base do
   end
 
   it "should correctly indicate if the file is present" do
-    Puppet::FileSystem.expects(:lstat).with(file).returns stub('stat')
+    expect(Puppet::FileSystem).to receive(:lstat).with(file).and_return(double('stat'))
     expect(Puppet::FileServing::Base.new(file).exist?).to be_truthy
   end
 
   it "should correctly indicate if the file is absent" do
-    Puppet::FileSystem.expects(:lstat).with(file).raises RuntimeError
+    expect(Puppet::FileSystem).to receive(:lstat).with(file).and_raise(RuntimeError)
     expect(Puppet::FileServing::Base.new(file).exist?).to be_falsey
   end
 
   describe "when setting the relative path" do
     it "should require that the relative path be unqualified" do
       @file = Puppet::FileServing::Base.new(path)
-      Puppet::FileSystem.stubs(:exist?).returns(true)
+      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
       expect { @file.relative_path = File.expand_path("/qualified/file") }.to raise_error(ArgumentError)
     end
   end
@@ -107,12 +106,12 @@ describe Puppet::FileServing::Base do
     let(:file) { Puppet::FileServing::Base.new(path) }
 
     it "should preserve double slashes at the beginning of the path" do
-      Puppet.features.stubs(:microsoft_windows?).returns(true)
+      allow(Puppet.features).to receive(:microsoft_windows?).and_return(true)
       expect(file.full_path).to eq(path)
     end
 
     it "should strip double slashes not at the beginning of the path" do
-      Puppet.features.stubs(:microsoft_windows?).returns(true)
+      allow(Puppet.features).to receive(:microsoft_windows?).and_return(true)
       file = Puppet::FileServing::Base.new('//server//share//filename')
       expect(file.full_path).to eq(path)
     end
@@ -122,26 +121,26 @@ describe Puppet::FileServing::Base do
   describe "when stat'ing files" do
     let(:path) { File.expand_path('/this/file') }
     let(:file) { Puppet::FileServing::Base.new(path) }
-    let(:stat) { stub('stat', :ftype => 'file' ) }
-    let(:stubbed_file) { stub(path, :stat => stat, :lstat => stat)}
+    let(:stat) { double('stat', :ftype => 'file' ) }
+    let(:stubbed_file) { double(path, :stat => stat, :lstat => stat)}
 
     it "should stat the file's full path" do
-      Puppet::FileSystem.expects(:lstat).with(path).returns stat
+      expect(Puppet::FileSystem).to receive(:lstat).with(path).and_return(stat)
       file.stat
     end
 
     it "should fail if the file does not exist" do
-      Puppet::FileSystem.expects(:lstat).with(path).raises(Errno::ENOENT)
+      expect(Puppet::FileSystem).to receive(:lstat).with(path).and_raise(Errno::ENOENT)
       expect { file.stat }.to raise_error(Errno::ENOENT)
     end
 
     it "should use :lstat if :links is set to :manage" do
-      Puppet::FileSystem.expects(:lstat).with(path).returns stubbed_file
+      expect(Puppet::FileSystem).to receive(:lstat).with(path).and_return(stubbed_file)
       file.stat
     end
 
     it "should use :stat if :links is set to :follow" do
-      Puppet::FileSystem.expects(:stat).with(path).returns stubbed_file
+      expect(Puppet::FileSystem).to receive(:stat).with(path).and_return(stubbed_file)
       file.links = :follow
       file.stat
     end
@@ -153,14 +152,14 @@ describe Puppet::FileServing::Base do
     end
 
     it "should accept Windows paths on Windows" do
-      Puppet.features.stubs(:microsoft_windows?).returns(true)
-      Puppet.features.stubs(:posix?).returns(false)
+      allow(Puppet.features).to receive(:microsoft_windows?).and_return(true)
+      allow(Puppet.features).to receive(:posix?).and_return(false)
 
       expect(Puppet::FileServing::Base).to be_absolute('c:/foo')
     end
 
     it "should reject Windows paths on POSIX" do
-      Puppet.features.stubs(:microsoft_windows?).returns(false)
+      allow(Puppet.features).to receive(:microsoft_windows?).and_return(false)
 
       expect(Puppet::FileServing::Base).not_to be_absolute('c:/foo')
     end

data/spec/unit/file_serving/configuration/parser_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/file_serving/configuration/parser'
@@ -34,10 +33,10 @@ describe Puppet::FileServing::Configuration::Parser do
     end
 
     it "should return a hash of the created mounts" do
-      mount1 = mock 'one', :validate => true
-      mount2 = mock 'two', :validate => true
-      Puppet::FileServing::Mount::File.expects(:new).with("one").returns(mount1)
-      Puppet::FileServing::Mount::File.expects(:new).with("two").returns(mount2)
+      mount1 = double('one', :validate => true)
+      mount2 = double('two', :validate => true)
+      expect(Puppet::FileServing::Mount::File).to receive(:new).with("one").and_return(mount1)
+      expect(Puppet::FileServing::Mount::File).to receive(:new).with("two").and_return(mount2)
       write_config_file "[one]\n[two]\n"
 
       result = @parser.parse
@@ -56,21 +55,21 @@ describe Puppet::FileServing::Configuration::Parser do
     end
 
     it "should validate each created mount" do
-      mount1 = mock 'one'
-      Puppet::FileServing::Mount::File.expects(:new).with("one").returns(mount1)
+      mount1 = double('one')
+      expect(Puppet::FileServing::Mount::File).to receive(:new).with("one").and_return(mount1)
       write_config_file "[one]\n"
 
-      mount1.expects(:validate)
+      expect(mount1).to receive(:validate)
 
       @parser.parse
     end
 
     it "should fail if any mount does not pass validation" do
-      mount1 = mock 'one'
-      Puppet::FileServing::Mount::File.expects(:new).with("one").returns(mount1)
+      mount1 = double('one')
+      expect(Puppet::FileServing::Mount::File).to receive(:new).with("one").and_return(mount1)
       write_config_file "[one]\n"
 
-      mount1.expects(:validate).raises RuntimeError
+      expect(mount1).to receive(:validate).and_raise(RuntimeError)
 
       expect { @parser.parse }.to raise_error(RuntimeError)
     end
@@ -86,15 +85,15 @@ describe Puppet::FileServing::Configuration::Parser do
     include FSConfigurationParserTesting
 
     before do
-      @mount = stub 'testmount', :name => "one", :validate => true
-      Puppet::FileServing::Mount::File.expects(:new).with("one").returns(@mount)
-      @parser.stubs(:add_modules_mount)
+      @mount = double('testmount', :name => "one", :validate => true)
+      expect(Puppet::FileServing::Mount::File).to receive(:new).with("one").and_return(@mount)
+      allow(@parser).to receive(:add_modules_mount)
     end
 
     it "should set the mount path to the path attribute from that section" do
       write_config_file "[one]\npath /some/path\n"
 
-      @mount.expects(:path=).with("/some/path")
+      expect(@mount).to receive(:path=).with("/some/path")
       @parser.parse
     end
 
@@ -102,16 +101,16 @@ describe Puppet::FileServing::Configuration::Parser do
       it "should support inline comments in #{acl_type}" do
         write_config_file "[one]\n#{acl_type} something \# will it work?\n"
 
-      @mount.expects(:info)
-      @mount.expects(acl_type).with("something")
+      expect(@mount).to receive(:info)
+      expect(@mount).to receive(acl_type).with("something")
       @parser.parse
       end
 
       it "should tell the mount to #{acl_type} from ACLs with varying spacing around commas" do
         write_config_file "[one]\n#{acl_type} someone,sometwo, somethree , somefour ,somefive\n"
 
-        @mount.expects(:info).times(5)
-        @mount.expects(acl_type).times(5).with(any_of('someone','sometwo','somethree','somefour','somefive'))
+        expect(@mount).to receive(:info).exactly(5).times
+        expect(@mount).to receive(acl_type).exactly(5).times.with(eq('someone').or eq('sometwo').or eq('somethree').or eq('somefour').or eq('somefive'))
         @parser.parse
       end
 
@@ -120,8 +119,8 @@ describe Puppet::FileServing::Configuration::Parser do
         it "should tell the mount to #{acl_type} from ACLs with glob at #{ip_pattern}" do
           write_config_file "[one]\n#{acl_type} #{ip_pattern}\n"
 
-          @mount.expects(:info)
-          @mount.expects(acl_type).with(ip_pattern)
+          expect(@mount).to receive(:info)
+          expect(@mount).to receive(acl_type).with(ip_pattern)
           @parser.parse
         end
       }
@@ -138,21 +137,21 @@ describe Puppet::FileServing::Configuration::Parser do
     include FSConfigurationParserTesting
 
     before do
-      @mount = stub 'modulesmount', :name => "modules", :validate => true
+      @mount = double('modulesmount', :name => "modules", :validate => true)
     end
 
     it "should create an instance of the Modules Mount class" do
       write_config_file "[modules]\n"
 
-      Puppet::FileServing::Mount::Modules.expects(:new).with("modules").returns @mount
+      expect(Puppet::FileServing::Mount::Modules).to receive(:new).with("modules").and_return(@mount)
       @parser.parse
     end
 
     it "should warn if a path is set" do
       write_config_file "[modules]\npath /some/path\n"
-      Puppet::FileServing::Mount::Modules.expects(:new).with("modules").returns(@mount)
+      expect(Puppet::FileServing::Mount::Modules).to receive(:new).with("modules").and_return(@mount)
 
-      Puppet.expects(:warning)
+      expect(Puppet).to receive(:warning)
       @parser.parse
     end
   end
@@ -161,20 +160,20 @@ describe Puppet::FileServing::Configuration::Parser do
     include FSConfigurationParserTesting
 
     before do
-      @mount = stub 'pluginsmount', :name => "plugins", :validate => true
+      @mount = double('pluginsmount', :name => "plugins", :validate => true)
     end
 
     it "should create an instance of the Plugins Mount class" do
       write_config_file "[plugins]\n"
 
-      Puppet::FileServing::Mount::Plugins.expects(:new).with("plugins").returns @mount
+      expect(Puppet::FileServing::Mount::Plugins).to receive(:new).with("plugins").and_return(@mount)
       @parser.parse
     end
 
     it "should warn if a path is set" do
       write_config_file "[plugins]\npath /some/path\n"
 
-      Puppet.expects(:warning)
+      expect(Puppet).to receive(:warning)
       @parser.parse
     end
   end