puppet 5.5.12-universal-darwin → 5.5.13-universal-darwin

data/spec/unit/indirector/json_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/files'
 require 'puppet/indirector/indirector_testing/json'
@@ -17,19 +16,19 @@ describe Puppet::Indirector::JSON do
     end
 
     it "uses the :server_datadir setting if this is the master" do
-      Puppet.run_mode.stubs(:master?).returns(true)
+      allow(Puppet.run_mode).to receive(:master?).and_return(true)
       expected = File.join(Puppet[:server_datadir], 'indirector_testing', 'testing.json')
       expect(subject.path('testing')).to eq(expected)
     end
 
     it "uses the :client_datadir setting if this is not the master" do
-      Puppet.run_mode.stubs(:master?).returns(false)
+      allow(Puppet.run_mode).to receive(:master?).and_return(false)
       expected = File.join(Puppet[:client_datadir], 'indirector_testing', 'testing.json')
       expect(subject.path('testing')).to eq(expected)
     end
 
     it "overrides the default extension with a supplied value" do
-      Puppet.run_mode.stubs(:master?).returns(true)
+      allow(Puppet.run_mode).to receive(:master?).and_return(true)
       expected = File.join(Puppet[:server_datadir], 'indirector_testing', 'testing.not-json')
       expect(subject.path('testing', '.not-json')).to eq(expected)
     end
@@ -51,7 +50,7 @@ describe Puppet::Indirector::JSON do
 
   context "handling requests" do
     before :each do
-      Puppet.run_mode.stubs(:master?).returns(true)
+      allow(Puppet.run_mode).to receive(:master?).and_return(true)
       Puppet[:server_datadir] = tmpdir('jsondir')
       FileUtils.mkdir_p(File.join(Puppet[:server_datadir], 'indirector_testing'))
     end
@@ -81,7 +80,7 @@ describe Puppet::Indirector::JSON do
           # I don't like this, but there isn't a credible alternative that
           # also works on Windows, so a stub it is. At least the expectation
           # will fail if the implementation changes. Sorry to the next dev.
-          Puppet::FileSystem.expects(:read).with(file, anything).raises(Errno::EPERM)
+          expect(Puppet::FileSystem).to receive(:read).with(file, anything).and_raise(Errno::EPERM)
           expect { subject.find(request) }.
             to raise_error Puppet::Error, /Could not read JSON/
         end
@@ -149,18 +148,17 @@ describe Puppet::Indirector::JSON do
       end
 
       it "raises an informative error for other failures" do
-        Puppet::FileSystem.stubs(:unlink).with(file).raises(Errno::EPERM, 'fake permission problem')
+        allow(Puppet::FileSystem).to receive(:unlink).with(file).and_raise(Errno::EPERM, 'fake permission problem')
         with_content('hello') do
           expect { subject.destroy(request) }.to raise_error(Puppet::Error)
         end
-        Puppet::FileSystem.unstub(:unlink)    # thanks, mocha
       end
     end
   end
 
   context "#search" do
     before :each do
-      Puppet.run_mode.stubs(:master?).returns(true)
+      allow(Puppet.run_mode).to receive(:master?).and_return(true)
       Puppet[:server_datadir] = tmpdir('jsondir')
       FileUtils.mkdir_p(File.join(Puppet[:server_datadir], 'indirector_testing'))
     end

data/spec/unit/indirector/key/ca_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/key/ca'
@@ -14,10 +13,10 @@ describe Puppet::SSL::Key::Ca do
   end
 
   it "should store the ca key at the :cakey location" do
-    Puppet.settings.stubs(:use)
+    allow(Puppet.settings).to receive(:use)
     Puppet[:cakey] = "/ca/key"
     file = Puppet::SSL::Key::Ca.new
-    file.stubs(:ca?).returns true
+    allow(file).to receive(:ca?).and_return(true)
     expect(file.path("whatever")).to eq(Puppet[:cakey])
   end
 end

data/spec/unit/indirector/key/disabled_ca_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/indirector/key/disabled_ca'
 
@@ -25,7 +24,7 @@ describe Puppet::SSL::Key::DisabledCa do
       end
 
       it "should forward local #{name} requests" do
-        Puppet::SSL::Key.indirection.terminus(:file).expects(name)
+        expect(Puppet::SSL::Key.indirection.terminus(:file)).to receive(name)
         subject.send(name, request(name, false))
       end
     end

data/spec/unit/indirector/key/file_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/key/file'
@@ -14,30 +13,30 @@ describe Puppet::SSL::Key::File do
   end
 
   it "should store the ca key at the :cakey location" do
-    Puppet.settings.stubs(:use)
+    allow(Puppet.settings).to receive(:use)
     Puppet[:cakey] = File.expand_path("/ca/key")
     file = Puppet::SSL::Key::File.new
-    file.stubs(:ca?).returns true
+    allow(file).to receive(:ca?).and_return(true)
     expect(file.path("whatever")).to eq(Puppet[:cakey])
   end
 
   describe "when choosing the path for the public key" do
     it "should use the :capub setting location if the key is for the certificate authority" do
       Puppet[:capub] = File.expand_path("/ca/pubkey")
-      Puppet.settings.stubs(:use)
+      allow(Puppet.settings).to receive(:use)
 
       @searcher = Puppet::SSL::Key::File.new
-      @searcher.stubs(:ca?).returns true
+      allow(@searcher).to receive(:ca?).and_return(true)
       expect(@searcher.public_key_path("whatever")).to eq(Puppet[:capub])
     end
 
     it "should use the host name plus '.pem' in :publickeydir for normal hosts" do
       Puppet[:privatekeydir] = File.expand_path("/private/key/dir")
       Puppet[:publickeydir] = File.expand_path("/public/key/dir")
-      Puppet.settings.stubs(:use)
+      allow(Puppet.settings).to receive(:use)
 
       @searcher = Puppet::SSL::Key::File.new
-      @searcher.stubs(:ca?).returns false
+      allow(@searcher).to receive(:ca?).and_return(false)
       expect(@searcher.public_key_path("whatever")).to eq(File.expand_path("/public/key/dir/whatever.pem"))
     end
   end
@@ -49,26 +48,26 @@ describe Puppet::SSL::Key::File do
       @private_key_path = File.join("/fake/key/path")
       @public_key_path = File.join("/other/fake/key/path")
 
-      @searcher.stubs(:public_key_path).returns @public_key_path
-      @searcher.stubs(:path).returns @private_key_path
+      allow(@searcher).to receive(:public_key_path).and_return(@public_key_path)
+      allow(@searcher).to receive(:path).and_return(@private_key_path)
 
-      FileTest.stubs(:directory?).returns true
-      FileTest.stubs(:writable?).returns true
+      allow(FileTest).to receive(:directory?).and_return(true)
+      allow(FileTest).to receive(:writable?).and_return(true)
 
-      @public_key = stub 'public_key'
-      @real_key = stub 'sslkey', :public_key => @public_key
+      @public_key = double('public_key')
+      @real_key = double('sslkey', :public_key => @public_key)
 
-      @key = stub 'key', :name => "myname", :content => @real_key
+      @key = double('key', :name => "myname", :content => @real_key)
 
-      @request = stub 'request', :key => "myname", :instance => @key
+      @request = double('request', :key => "myname", :instance => @key)
     end
 
     it "should save the public key when saving the private key" do
       fh = StringIO.new
 
-      Puppet.settings.setting(:publickeydir).expects(:open_file).with(@public_key_path, 'w:ASCII').yields fh
-      Puppet.settings.setting(:privatekeydir).stubs(:open_file)
-      @public_key.expects(:to_pem).returns "my pem"
+      expect(Puppet.settings.setting(:publickeydir)).to receive(:open_file).with(@public_key_path, 'w:ASCII').and_yield(fh)
+      allow(Puppet.settings.setting(:privatekeydir)).to receive(:open_file)
+      expect(@public_key).to receive(:to_pem).and_return("my pem")
 
       @searcher.save(@request)
 
@@ -76,20 +75,20 @@ describe Puppet::SSL::Key::File do
     end
 
     it "should destroy the public key when destroying the private key" do
-      Puppet::FileSystem.expects(:unlink).with(Puppet::FileSystem.pathname(@private_key_path))
-      Puppet::FileSystem.expects(:exist?).with(Puppet::FileSystem.pathname(@private_key_path)).returns true
-      Puppet::FileSystem.expects(:exist?).with(Puppet::FileSystem.pathname(@public_key_path)).returns true
-      Puppet::FileSystem.expects(:unlink).with(Puppet::FileSystem.pathname(@public_key_path))
+      expect(Puppet::FileSystem).to receive(:unlink).with(Puppet::FileSystem.pathname(@private_key_path))
+      expect(Puppet::FileSystem).to receive(:exist?).with(Puppet::FileSystem.pathname(@private_key_path)).and_return(true)
+      expect(Puppet::FileSystem).to receive(:exist?).with(Puppet::FileSystem.pathname(@public_key_path)).and_return(true)
+      expect(Puppet::FileSystem).to receive(:unlink).with(Puppet::FileSystem.pathname(@public_key_path))
 
       @searcher.destroy(@request)
     end
 
     it "should not fail if the public key does not exist when deleting the private key" do
-      Puppet::FileSystem.stubs(:unlink).with(Puppet::FileSystem.pathname(@private_key_path))
+      allow(Puppet::FileSystem).to receive(:unlink).with(Puppet::FileSystem.pathname(@private_key_path))
 
-      Puppet::FileSystem.stubs(:exist?).with(Puppet::FileSystem.pathname(@private_key_path)).returns true
-      Puppet::FileSystem.expects(:exist?).with(Puppet::FileSystem.pathname(@public_key_path)).returns false
-      Puppet::FileSystem.expects(:unlink).with(Puppet::FileSystem.pathname(@public_key_path)).never
+      allow(Puppet::FileSystem).to receive(:exist?).with(Puppet::FileSystem.pathname(@private_key_path)).and_return(true)
+      expect(Puppet::FileSystem).to receive(:exist?).with(Puppet::FileSystem.pathname(@public_key_path)).and_return(false)
+      expect(Puppet::FileSystem).not_to receive(:unlink).with(Puppet::FileSystem.pathname(@public_key_path))
 
       @searcher.destroy(@request)
     end

data/spec/unit/indirector/ldap_spec.rb

@@ -1,36 +1,35 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/ldap'
 
 describe Puppet::Indirector::Ldap do
   before do
-    @indirection = stub 'indirection', :name => :testing
-    Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
+    @indirection = double('indirection', :name => :testing)
+    allow(Puppet::Indirector::Indirection).to receive(:instance).and_return(@indirection)
     module Testing; end
     @ldap_class = class Testing::MyLdap < Puppet::Indirector::Ldap
       self
     end
 
-    @connection = mock 'ldap'
+    @connection = double('ldap')
   end
 
   describe "when instantiating ldap" do
     it "should be deprecated" do
-      Puppet.expects(:deprecation_warning).with("Puppet::Indirector::Ldap is deprecated and will be removed in a future release of Puppet.")
+      expect(Puppet).to receive(:deprecation_warning).with("Puppet::Indirector::Ldap is deprecated and will be removed in a future release of Puppet.")
 
       @ldap_class.new
     end
 
     it "should not emit a deprecation warning when they are disabled" do
-      Puppet.expects(:warning).with(regexp_matches(/Puppet::Indirector::Ldap is deprecated/)).never
+      expect(Puppet).not_to receive(:warning).with(/Puppet::Indirector::Ldap is deprecated/)
       Puppet[:disable_warnings] = ['deprecations']
 
       @ldap_class.new
     end
 
     it "should only emit the deprecation warning once" do
-      Puppet.expects(:warning).with(regexp_matches(/Puppet::Indirector::Ldap is deprecated/)).once
+      expect(Puppet).to receive(:warning).with(/Puppet::Indirector::Ldap is deprecated/).once
 
       @ldap_class.new
       @ldap_class.new
@@ -42,17 +41,17 @@ describe Puppet::Indirector::Ldap do
       @searcher = @ldap_class.new
       # Stub everything, and we can selectively replace with an expect as
       # we need to for testing.
-      @searcher.stubs(:connection).returns(@connection)
-      @searcher.stubs(:search_filter).returns(:filter)
-      @searcher.stubs(:search_base).returns(:base)
-      @searcher.stubs(:process)
+      allow(@searcher).to receive(:connection).and_return(@connection)
+      allow(@searcher).to receive(:search_filter).and_return(:filter)
+      allow(@searcher).to receive(:search_base).and_return(:base)
+      allow(@searcher).to receive(:process)
 
-      @request = stub 'request', :key => "yay"
+      @request = double('request', :key => "yay")
     end
 
     it "should call the ldapsearch method with the search filter" do
-      @searcher.expects(:search_filter).with("yay").returns("yay's filter")
-      @searcher.expects(:ldapsearch).with("yay's filter")
+      expect(@searcher).to receive(:search_filter).with("yay").and_return("yay's filter")
+      expect(@searcher).to receive(:ldapsearch).with("yay's filter")
       @searcher.find @request
     end
 
@@ -61,11 +60,9 @@ describe Puppet::Indirector::Ldap do
     end
 
     it "should use the results of the ldapbase method as the ldap search base" do
-      @searcher.stubs(:search_base).returns("mybase")
-      @connection.expects(:search).with do |*args|
-        expect(args[0]).to eq("mybase")
-        true
-      end
+      allow(@searcher).to receive(:search_base).and_return("mybase")
+      expect(@connection).to receive(:search).with("mybase", anything, anything, anything)
+
       @searcher.find @request
     end
 
@@ -76,46 +73,42 @@ describe Puppet::Indirector::Ldap do
     end
 
     it "should use the results of the :search_attributes method as the list of attributes to return" do
-      @searcher.stubs(:search_attributes).returns(:myattrs)
-      @connection.expects(:search).with do |*args|
-        expect(args[3]).to eq(:myattrs)
-        true
-      end
+      allow(@searcher).to receive(:search_attributes).and_return(:myattrs)
+      expect(@connection).to receive(:search).with(anything, anything, anything, :myattrs)
+
       @searcher.find @request
     end
 
     it "should use depth 2 when searching" do
-      @connection.expects(:search).with do |*args|
-        expect(args[1]).to eq(2)
-        true
-      end
+      expect(@connection).to receive(:search).with(anything, 2, anything, anything)
+
       @searcher.find @request
     end
 
     it "should call process() on the first found entry" do
-      @connection.expects(:search).yields("myresult")
-      @searcher.expects(:process).with("myresult")
+      expect(@connection).to receive(:search).and_yield("myresult")
+      expect(@searcher).to receive(:process).with("myresult")
       @searcher.find @request
     end
 
     it "should reconnect and retry the search if there is a failure" do
       run = false
-      @connection.stubs(:search).with do |*args|
+      allow(@connection).to receive(:search) do |*args|
         if run
           true
         else
           run = true
           raise "failed"
         end
-      end.yields("myresult")
-      @searcher.expects(:process).with("myresult")
+      end.and_yield("myresult")
+      expect(@searcher).to receive(:process).with("myresult")
 
       @searcher.find @request
     end
 
     it "should not reconnect on failure more than once" do
       count = 0
-      @connection.stubs(:search).with do |*args|
+      allow(@connection).to receive(:search) do |*_|
         count += 1
         raise ArgumentError, "yay"
       end
@@ -124,29 +117,29 @@ describe Puppet::Indirector::Ldap do
     end
 
     it "should return true if an entry is found" do
-      @connection.expects(:search).yields("result")
+      expect(@connection).to receive(:search).and_yield("result")
       expect(@searcher.ldapsearch("whatever") { |r| }).to be_truthy
     end
   end
 
   describe "when connecting to ldap", :if => Puppet.features.ldap? do
     it "should create and start a Util::Ldap::Connection instance" do
-      conn = double 'connection', :connection => "myconn", :start => nil
-      Puppet::Util::Ldap::Connection.expects(:instance).returns conn
+      conn = double('connection', :connection => "myconn", :start => nil)
+      expect(Puppet::Util::Ldap::Connection).to receive(:instance).and_return(conn)
 
       expect(@searcher.connection).to eq("myconn")
     end
 
     it "should only create the ldap connection when asked for it the first time" do
-      conn = double 'connection', :connection => "myconn", :start => nil
-      Puppet::Util::Ldap::Connection.expects(:instance).returns conn
+      conn = double('connection', :connection => "myconn", :start => nil)
+      expect(Puppet::Util::Ldap::Connection).to receive(:instance).and_return(conn)
 
       @searcher.connection
     end
 
     it "should cache the connection" do
-      conn = double 'connection', :connection => "myconn", :start => nil
-      Puppet::Util::Ldap::Connection.expects(:instance).returns conn
+      conn = double('connection', :connection => "myconn", :start => nil)
+      expect(Puppet::Util::Ldap::Connection).to receive(:instance).and_return(conn)
 
       expect(@searcher.connection).to equal(@searcher.connection)
     end

data/spec/unit/indirector/memory_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/indirector/memory'
 
@@ -8,10 +7,10 @@ describe Puppet::Indirector::Memory do
   it_should_behave_like "A Memory Terminus"
 
   before do
-    Puppet::Indirector::Terminus.stubs(:register_terminus_class)
-    @model = mock 'model'
-    @indirection = stub 'indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model
-    Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
+    allow(Puppet::Indirector::Terminus).to receive(:register_terminus_class)
+    @model = double('model')
+    @indirection = double('indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model)
+    allow(Puppet::Indirector::Indirection).to receive(:instance).and_return(@indirection)
 
     module Testing; end
     @memory_class = class Testing::MyMemory < Puppet::Indirector::Memory
@@ -20,8 +19,8 @@ describe Puppet::Indirector::Memory do
 
     @searcher = @memory_class.new
     @name = "me"
-    @instance = stub 'instance', :name => @name
+    @instance = double('instance', :name => @name)
 
-    @request = stub 'request', :key => @name, :instance => @instance
+    @request = double('request', :key => @name, :instance => @instance)
   end
 end

data/spec/unit/indirector/msgpack_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/files'
 require 'puppet/indirector/indirector_testing/msgpack'
@@ -17,19 +16,19 @@ describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
     end
 
     it "uses the :server_datadir setting if this is the master" do
-      Puppet.run_mode.stubs(:master?).returns(true)
+      allow(Puppet.run_mode).to receive(:master?).and_return(true)
       expected = File.join(Puppet[:server_datadir], 'indirector_testing', 'testing.msgpack')
       expect(subject.path('testing')).to eq(expected)
     end
 
     it "uses the :client_datadir setting if this is not the master" do
-      Puppet.run_mode.stubs(:master?).returns(false)
+      allow(Puppet.run_mode).to receive(:master?).and_return(false)
       expected = File.join(Puppet[:client_datadir], 'indirector_testing', 'testing.msgpack')
       expect(subject.path('testing')).to eq(expected)
     end
 
     it "overrides the default extension with a supplied value" do
-      Puppet.run_mode.stubs(:master?).returns(true)
+      allow(Puppet.run_mode).to receive(:master?).and_return(true)
       expected = File.join(Puppet[:server_datadir], 'indirector_testing', 'testing.not-msgpack')
       expect(subject.path('testing', '.not-msgpack')).to eq(expected)
     end
@@ -51,7 +50,7 @@ describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
 
   context "handling requests" do
     before :each do
-      Puppet.run_mode.stubs(:master?).returns(true)
+      allow(Puppet.run_mode).to receive(:master?).and_return(true)
       Puppet[:server_datadir] = tmpdir('msgpackdir')
       FileUtils.mkdir_p(File.join(Puppet[:server_datadir], 'indirector_testing'))
     end
@@ -91,7 +90,7 @@ describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
           # I don't like this, but there isn't a credible alternative that
           # also works on Windows, so a stub it is. At least the expectation
           # will fail if the implementation changes. Sorry to the next dev.
-          Puppet::FileSystem.expects(:read).with(file, {:encoding => 'utf-8'}).raises(Errno::EPERM)
+          expect(Puppet::FileSystem).to receive(:read).with(file, {:encoding => 'utf-8'}).and_raise(Errno::EPERM)
           expect { subject.find(request) }.
             to raise_error Puppet::Error, /Could not read MessagePack/
         end
@@ -149,18 +148,17 @@ describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
       end
 
       it "raises an informative error for other failures" do
-        Puppet::FileSystem.stubs(:unlink).with(file).raises(Errno::EPERM, 'fake permission problem')
+        allow(Puppet::FileSystem).to receive(:unlink).with(file).and_raise(Errno::EPERM, 'fake permission problem')
         with_content('hello') do
           expect { subject.destroy(request) }.to raise_error(Puppet::Error)
         end
-        Puppet::FileSystem.unstub(:unlink)    # thanks, mocha
       end
     end
   end
 
   context "#search" do
     before :each do
-      Puppet.run_mode.stubs(:master?).returns(true)
+      allow(Puppet.run_mode).to receive(:master?).and_return(true)
       Puppet[:server_datadir] = tmpdir('msgpackdir')
       FileUtils.mkdir_p(File.join(Puppet[:server_datadir], 'indirector_testing'))
     end