puppet 5.5.22 → 6.0.0

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

data/spec/unit/util/json_lockfile_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/json_lockfile'
@@ -29,20 +30,21 @@ describe Puppet::Util::JsonLockfile do
 
     it "returns nil if the file read returned nil" do
       @lock.lock
-      allow(File).to receive(:read).and_return(nil)
+      File.stubs(:read).returns nil
       expect(@lock.lock_data).to be_nil
     end
 
     it "returns nil if the file was empty" do
       @lock.lock
-      allow(File).to receive(:read).and_return('')
+      File.stubs(:read).returns ''
       expect(@lock.lock_data).to be_nil
     end
 
     it "returns nil if the file was not in PSON" do
       @lock.lock
-      allow(File).to receive(:read).and_return('][')
+      File.stubs(:read).returns ']['
       expect(@lock.lock_data).to be_nil
     end
+
   end
 end

data/spec/unit/util/ldap/connection_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/ldap/connection'
@@ -19,15 +20,13 @@ end
 
 describe Puppet::Util::Ldap::Connection do
   before do
-    allow(Puppet.features).to receive(:ldap?).and_return(true)
+    Puppet.features.stubs(:ldap?).returns true
 
-    @ldapconn = double(
-      'ldap',
-      set_option: nil,
-      simple_bind: nil,
-    )
-    allow(LDAP::Conn).to receive(:new).and_return(@ldapconn)
-    allow(LDAP::SSLConn).to receive(:new).and_return(@ldapconn)
+    @ldapconn = mock 'ldap'
+    LDAP::Conn.stubs(:new).returns(@ldapconn)
+    LDAP::SSLConn.stubs(:new).returns(@ldapconn)
+
+    @ldapconn.stub_everything
 
     @connection = Puppet::Util::Ldap::Connection.new("host", "port")
   end
@@ -51,19 +50,19 @@ describe Puppet::Util::Ldap::Connection do
     end
 
     it "should fail if ldap is unavailable" do
-      expect(Puppet.features).to receive(:ldap?).and_return(false)
+      Puppet.features.expects(:ldap?).returns(false)
 
       expect { Puppet::Util::Ldap::Connection.new("host", "port") }.to raise_error(Puppet::Error)
     end
 
     it "should use neither ssl nor tls by default" do
-      expect(LDAP::Conn).to receive(:new).with("host", "port").and_return(@ldapconn)
+      LDAP::Conn.expects(:new).with("host", "port").returns(@ldapconn)
 
       @connection.start
     end
 
     it "should use LDAP::SSLConn if ssl is requested" do
-      expect(LDAP::SSLConn).to receive(:new).with("host", "port").and_return(@ldapconn)
+      LDAP::SSLConn.expects(:new).with("host", "port").returns(@ldapconn)
 
       @connection.ssl = true
 
@@ -71,7 +70,7 @@ describe Puppet::Util::Ldap::Connection do
     end
 
     it "should use LDAP::SSLConn and tls if tls is requested" do
-      expect(LDAP::SSLConn).to receive(:new).with("host", "port", true).and_return(@ldapconn)
+      LDAP::SSLConn.expects(:new).with("host", "port", true).returns(@ldapconn)
 
       @connection.ssl = :tls
 
@@ -79,31 +78,31 @@ describe Puppet::Util::Ldap::Connection do
     end
 
     it "should set the protocol version to 3 and enable referrals" do
-      expect(@ldapconn).to receive(:set_option).with(LDAP::LDAP_OPT_PROTOCOL_VERSION, 3)
-      expect(@ldapconn).to receive(:set_option).with(LDAP::LDAP_OPT_REFERRALS, LDAP::LDAP_OPT_ON)
+      @ldapconn.expects(:set_option).with(LDAP::LDAP_OPT_PROTOCOL_VERSION, 3)
+      @ldapconn.expects(:set_option).with(LDAP::LDAP_OPT_REFERRALS, LDAP::LDAP_OPT_ON)
       @connection.start
     end
 
     it "should bind with the provided user and password" do
       @connection.user = "myuser"
       @connection.password = "mypassword"
-      expect(@ldapconn).to receive(:simple_bind).with("myuser", "mypassword")
+      @ldapconn.expects(:simple_bind).with("myuser", "mypassword")
 
       @connection.start
     end
 
     it "should bind with no user and password if none has been provided" do
-      expect(@ldapconn).to receive(:simple_bind).with(nil, nil)
+      @ldapconn.expects(:simple_bind).with(nil, nil)
       @connection.start
     end
   end
 
   describe "when closing connections" do
     it "should not close connections that are not open" do
-      allow(@connection).to receive(:connection).and_return(@ldapconn)
+      @connection.stubs(:connection).returns(@ldapconn)
 
-      expect(@ldapconn).to receive(:bound?).and_return(false)
-      expect(@ldapconn).not_to receive(:unbind)
+      @ldapconn.expects(:bound?).returns false
+      @ldapconn.expects(:unbind).never
 
       @connection.close
     end
@@ -116,46 +115,46 @@ describe Puppet::Util::Ldap::Connection do
   describe "when creating a default connection" do
     it "should use the :ldapserver setting to determine the host" do
       Puppet[:ldapserver] = "myserv"
-      expect(Puppet::Util::Ldap::Connection).to receive(:new).with("myserv", anything, anything)
+      Puppet::Util::Ldap::Connection.expects(:new).with { |host, port, options| host == "myserv" }
       Puppet::Util::Ldap::Connection.instance
     end
 
     it "should use the :ldapport setting to determine the port" do
       Puppet[:ldapport] = "456"
-      expect(Puppet::Util::Ldap::Connection).to receive(:new).with(anything, "456", anything)
+      Puppet::Util::Ldap::Connection.expects(:new).with { |host, port, options| port == "456" }
       Puppet::Util::Ldap::Connection.instance
     end
 
     it "should set ssl to :tls if tls is enabled" do
       Puppet[:ldaptls] = true
-      expect(Puppet::Util::Ldap::Connection).to receive(:new).with(anything, anything, hash_including(ssl: :tls))
+      Puppet::Util::Ldap::Connection.expects(:new).with { |host, port, options| options[:ssl] == :tls }
       Puppet::Util::Ldap::Connection.instance
     end
 
     it "should set ssl to 'true' if ssl is enabled and tls is not" do
       Puppet[:ldaptls] = false
       Puppet[:ldapssl] = true
-      expect(Puppet::Util::Ldap::Connection).to receive(:new).with(anything, anything, hash_including(ssl: true))
+      Puppet::Util::Ldap::Connection.expects(:new).with { |host, port, options| options[:ssl] == true }
       Puppet::Util::Ldap::Connection.instance
     end
 
     it "should set ssl to false if neither ssl nor tls are enabled" do
       Puppet[:ldaptls] = false
       Puppet[:ldapssl] = false
-      expect(Puppet::Util::Ldap::Connection).to receive(:new).with(anything, anything, hash_including(ssl: false))
+      Puppet::Util::Ldap::Connection.expects(:new).with { |host, port, options| options[:ssl] == false }
       Puppet::Util::Ldap::Connection.instance
     end
 
     it "should set the ldapuser if one is set" do
       Puppet[:ldapuser] = "foo"
-      expect(Puppet::Util::Ldap::Connection).to receive(:new).with(anything, anything, hash_including(user: "foo"))
+      Puppet::Util::Ldap::Connection.expects(:new).with { |host, port, options| options[:user] == "foo" }
       Puppet::Util::Ldap::Connection.instance
     end
 
     it "should set the ldapuser and ldappassword if both is set" do
       Puppet[:ldapuser] = "foo"
       Puppet[:ldappassword] = "bar"
-      expect(Puppet::Util::Ldap::Connection).to receive(:new).with(anything, anything, hash_including(user: "foo", password: "bar"))
+      Puppet::Util::Ldap::Connection.expects(:new).with { |host, port, options| options[:user] == "foo" and options[:password] == "bar" }
       Puppet::Util::Ldap::Connection.instance
     end
   end

data/spec/unit/util/ldap/generator_spec.rb

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

data/spec/unit/util/ldap/manager_spec.rb

@@ -1,23 +1,9 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/ldap/manager'
 
-# If the ldap classes aren't available, go ahead and
-# create some, so our tests will pass.
-unless defined?(LDAP::Mod)
-  class LDAP
-    LDAP_MOD_ADD = :adding
-    LDAP_MOD_REPLACE = :replacing
-    LDAP_MOD_DELETE = :deleting
-    class ResultError < RuntimeError; end
-    class Mod
-      def initialize(*args)
-      end
-    end
-  end
-end
-
-describe Puppet::Util::Ldap::Manager do
+describe Puppet::Util::Ldap::Manager, :if => Puppet.features.ldap? do
   before do
     @manager = Puppet::Util::Ldap::Manager.new
   end
@@ -60,13 +46,13 @@ describe Puppet::Util::Ldap::Manager do
 
   describe "when generating attributes" do
     before do
-      @generator = double('generator', :source => "one", :name => "myparam")
+      @generator = stub 'generator', :source => "one", :name => "myparam"
 
-      allow(Puppet::Util::Ldap::Generator).to receive(:new).with(:myparam).and_return(@generator)
+      Puppet::Util::Ldap::Generator.stubs(:new).with(:myparam).returns @generator
     end
 
     it "should create a generator to do the parameter generation" do
-      expect(Puppet::Util::Ldap::Generator).to receive(:new).with(:myparam).and_return(@generator)
+      Puppet::Util::Ldap::Generator.expects(:new).with(:myparam).returns @generator
       @manager.generates(:myparam)
     end
 
@@ -78,7 +64,7 @@ describe Puppet::Util::Ldap::Manager do
       @manager.generates(:myparam)
 
       attrs = {"myparam" => "testing"}
-      expect(@generator).not_to receive(:generate)
+      @generator.expects(:generate).never
 
       @manager.generate attrs
 
@@ -87,7 +73,7 @@ describe Puppet::Util::Ldap::Manager do
 
     it "should look for the parameter as a string, not a symbol" do
       @manager.generates(:myparam)
-      expect(@generator).to receive(:generate).with("yay").and_return(%w{double yay})
+      @generator.expects(:generate).with("yay").returns %w{double yay}
       attrs = {"one" => "yay"}
       @manager.generate attrs
 
@@ -101,19 +87,19 @@ describe Puppet::Util::Ldap::Manager do
 
     it "should use the source value to generate the new value if a source attribute is specified" do
       @manager.generates(:myparam)
-      expect(@generator).to receive(:generate).with("yay").and_return(%w{double yay})
+      @generator.expects(:generate).with("yay").returns %w{double yay}
       @manager.generate "one" => "yay"
     end
 
     it "should not pass in any value if no source attribute is specified" do
-      allow(@generator).to receive(:source).and_return(nil)
+      @generator.stubs(:source).returns nil
       @manager.generates(:myparam)
-      expect(@generator).to receive(:generate).and_return(%w{double yay})
+      @generator.expects(:generate).with.returns %w{double yay}
       @manager.generate "one" => "yay"
     end
 
     it "should convert any results to arrays of strings if necessary" do
-      expect(@generator).to receive(:generate).and_return(:test)
+      @generator.expects(:generate).returns :test
       @manager.generates(:myparam)
 
       attrs = {"one" => "two"}
@@ -122,7 +108,7 @@ describe Puppet::Util::Ldap::Manager do
     end
 
     it "should add the result to the passed-in attribute hash" do
-      expect(@generator).to receive(:generate).and_return(%w{test})
+      @generator.expects(:generate).returns %w{test}
       @manager.generates(:myparam)
 
       attrs = {"one" => "two"}
@@ -243,9 +229,9 @@ describe Puppet::Util::Ldap::Manager do
 
   describe "when using an ldap connection" do
     before do
-      @ldapconn = double('ldapconn')
-      @conn = double('connection', :connection => @ldapconn, :start => nil, :close => nil)
-      allow(Puppet::Util::Ldap::Connection).to receive(:new).and_return(@conn)
+      @ldapconn = mock 'ldapconn'
+      @conn = stub 'connection', :connection => @ldapconn, :start => nil, :close => nil
+      Puppet::Util::Ldap::Connection.stubs(:new).returns(@conn)
     end
 
     it "should fail unless a block is given" do
@@ -254,148 +240,144 @@ describe Puppet::Util::Ldap::Manager do
 
     it "should open the connection with its server set to :ldapserver" do
       Puppet[:ldapserver] = "myserver"
-      expect(Puppet::Util::Ldap::Connection).to receive(:new).with("myserver", anything, anything).and_return(@conn)
+      Puppet::Util::Ldap::Connection.expects(:new).with { |*args| args[0] == "myserver" }.returns @conn
 
       @manager.connect { |c| }
     end
 
     it "should open the connection with its port set to the :ldapport" do
       Puppet[:ldapport] = "28"
-      expect(Puppet::Util::Ldap::Connection).to receive(:new).with(anything, "28", anything).and_return(@conn)
+      Puppet::Util::Ldap::Connection.expects(:new).with { |*args| args[1] == "28" }.returns @conn
 
       @manager.connect { |c| }
     end
 
     it "should open the connection with no user if :ldapuser is not set" do
       Puppet[:ldapuser] = ""
-      expect(Puppet::Util::Ldap::Connection).to receive(:new).with(anything, anything, hash_excluding(:user)).and_return(@conn)
+      Puppet::Util::Ldap::Connection.expects(:new).with { |*args| args[2][:user].nil? }.returns @conn
 
       @manager.connect { |c| }
     end
 
     it "should open the connection with its user set to the :ldapuser if it is set" do
       Puppet[:ldapuser] = "mypass"
-      expect(Puppet::Util::Ldap::Connection).to receive(:new).with(anything, anything, hash_including(user: "mypass")).and_return(@conn)
+      Puppet::Util::Ldap::Connection.expects(:new).with { |*args| args[2][:user] == "mypass" }.returns @conn
 
       @manager.connect { |c| }
     end
 
     it "should open the connection with no password if :ldappassword is not set" do
       Puppet[:ldappassword] = ""
-      expect(Puppet::Util::Ldap::Connection).to receive(:new).with(anything, anything, hash_excluding(:password)).and_return(@conn)
+      Puppet::Util::Ldap::Connection.expects(:new).with { |*args| args[2][:password].nil? }.returns @conn
 
       @manager.connect { |c| }
     end
 
     it "should open the connection with its password set to the :ldappassword if it is set" do
       Puppet[:ldappassword] = "mypass"
-      expect(Puppet::Util::Ldap::Connection).to receive(:new).with(anything, anything, hash_including(password: "mypass")).and_return(@conn)
+      Puppet::Util::Ldap::Connection.expects(:new).with { |*args| args[2][:password] == "mypass" }.returns @conn
 
       @manager.connect { |c| }
     end
 
     it "should set ssl to :tls if ldaptls is enabled" do
       Puppet[:ldaptls] = true
-      expect(Puppet::Util::Ldap::Connection).to receive(:new).with(anything, anything, hash_including(ssl: :tls)).and_return(@conn)
+      Puppet::Util::Ldap::Connection.expects(:new).with { |*args| args[2][:ssl] == :tls }.returns @conn
 
       @manager.connect { |c| }
     end
 
     it "should set ssl to true if ldapssl is enabled" do
       Puppet[:ldapssl] = true
-      expect(Puppet::Util::Ldap::Connection).to receive(:new).with(anything, anything, hash_including(ssl: true)).and_return(@conn)
+      Puppet::Util::Ldap::Connection.expects(:new).with { |*args| args[2][:ssl] == true }.returns @conn
 
       @manager.connect { |c| }
     end
 
     it "should set ssl to false if neither ldaptls nor ldapssl is enabled" do
       Puppet[:ldapssl] = false
-      expect(Puppet::Util::Ldap::Connection).to receive(:new).with(anything, anything, hash_including(ssl: false)).and_return(@conn)
+      Puppet::Util::Ldap::Connection.expects(:new).with { |*args| args[2][:ssl] == false }.returns @conn
 
       @manager.connect { |c| }
     end
 
     it "should open, yield, and then close the connection" do
-      expect(@conn).to receive(:start)
-      expect(@conn).to receive(:close)
-      expect(Puppet::Util::Ldap::Connection).to receive(:new).and_return(@conn)
-      expect(@ldapconn).to receive(:test)
+      @conn.expects(:start)
+      @conn.expects(:close)
+      Puppet::Util::Ldap::Connection.expects(:new).returns(@conn)
+      @ldapconn.expects(:test)
       @manager.connect { |c| c.test }
     end
 
     it "should close the connection even if there's an exception in the passed block" do
-      expect(@conn).to receive(:close)
+      @conn.expects(:close)
       expect { @manager.connect { |c| raise ArgumentError } }.to raise_error(ArgumentError)
     end
   end
 
   describe "when using ldap" do
     before do
-      @conn = double('connection')
-      allow(@manager).to receive(:connect).and_yield(@conn)
-      allow(@manager).to receive(:objectclasses).and_return([:oc1, :oc2])
+      @conn = mock 'connection'
+      @manager.stubs(:connect).yields @conn
+      @manager.stubs(:objectclasses).returns [:oc1, :oc2]
       @manager.maps :one => :uno, :two => :dos, :three => :tres, :four => :quatro
     end
 
     describe "to create entries" do
       it "should convert the first argument to its :create method to a full dn and pass the resulting argument list to its connection" do
-        expect(@manager).to receive(:dn).with("myname").and_return("mydn")
-        expect(@conn).to receive(:add).with("mydn", anything)
+        @manager.expects(:dn).with("myname").returns "mydn"
+        @conn.expects(:add).with { |name, attrs| name == "mydn" }
 
         @manager.create("myname", {"attr" => "myattrs"})
       end
 
       it "should add the objectclasses to the attributes" do
-        expect(@manager).to receive(:dn).with("myname").and_return("mydn")
-        expect(@conn).to receive(:add) do |_, attrs|
-          expect(attrs["objectClass"]).to include("oc1", "oc2")
-        end
+        @manager.expects(:dn).with("myname").returns "mydn"
+        @conn.expects(:add).with { |name, attrs| attrs["objectClass"].include?("oc1") and attrs["objectClass"].include?("oc2") }
 
         @manager.create("myname", {:one => :testing})
       end
 
       it "should add the rdn to the attributes" do
-        expect(@manager).to receive(:dn).with("myname").and_return("mydn")
-        expect(@conn).to receive(:add).with(anything, hash_including("cn" => %w{myname}))
+        @manager.expects(:dn).with("myname").returns "mydn"
+        @conn.expects(:add).with { |name, attrs| attrs["cn"] == %w{myname} }
 
         @manager.create("myname", {:one => :testing})
       end
 
       it "should add 'top' to the objectclasses if it is not listed" do
-        expect(@manager).to receive(:dn).with("myname").and_return("mydn")
-        expect(@conn).to receive(:add) do |_, attrs|
-          expect(attrs["objectClass"]).to include("top")
-        end
+        @manager.expects(:dn).with("myname").returns "mydn"
+        @conn.expects(:add).with { |name, attrs| attrs["objectClass"].include?("top") }
 
         @manager.create("myname", {:one => :testing})
       end
 
       it "should add any generated values that are defined" do
-        generator = double('generator', :source => :one, :name => "myparam")
+        generator = stub 'generator', :source => :one, :name => "myparam"
 
-        expect(Puppet::Util::Ldap::Generator).to receive(:new).with(:myparam).and_return(generator)
+        Puppet::Util::Ldap::Generator.expects(:new).with(:myparam).returns generator
 
         @manager.generates(:myparam)
 
-        allow(@manager).to receive(:dn).with("myname").and_return("mydn")
+        @manager.stubs(:dn).with("myname").returns "mydn"
 
-        expect(generator).to receive(:generate).with(:testing).and_return(["generated value"])
-        expect(@conn).to receive(:add).with(anything, hash_including("myparam" => ["generated value"]))
+        generator.expects(:generate).with(:testing).returns ["generated value"]
+        @conn.expects(:add).with { |name, attrs| attrs["myparam"] == ["generated value"] }
 
         @manager.create("myname", {:one => :testing})
       end
 
       it "should convert any generated values to arrays of strings if necessary" do
-        generator = double('generator', :source => :one, :name => "myparam")
+        generator = stub 'generator', :source => :one, :name => "myparam"
 
-        expect(Puppet::Util::Ldap::Generator).to receive(:new).with(:myparam).and_return(generator)
+        Puppet::Util::Ldap::Generator.expects(:new).with(:myparam).returns generator
 
         @manager.generates(:myparam)
 
-        allow(@manager).to receive(:dn).and_return("mydn")
+        @manager.stubs(:dn).returns "mydn"
 
-        expect(generator).to receive(:generate).and_return(:generated)
-        expect(@conn).to receive(:add).with(anything, hash_including("myparam" => ["generated"]))
+        generator.expects(:generate).returns :generated
+        @conn.expects(:add).with { |name, attrs| attrs["myparam"] == ["generated"] }
 
         @manager.create("myname", {:one => :testing})
       end
@@ -403,8 +385,8 @@ describe Puppet::Util::Ldap::Manager do
 
     describe "do delete entries" do
       it "should convert the first argument to its :delete method to a full dn and pass the resulting argument list to its connection" do
-        expect(@manager).to receive(:dn).with("myname").and_return("mydn")
-        expect(@conn).to receive(:delete).with("mydn")
+        @manager.expects(:dn).with("myname").returns "mydn"
+        @conn.expects(:delete).with("mydn")
 
         @manager.delete("myname")
       end
@@ -412,8 +394,8 @@ describe Puppet::Util::Ldap::Manager do
 
     describe "to modify entries" do
       it "should convert the first argument to its :modify method to a full dn and pass the resulting argument list to its connection" do
-        expect(@manager).to receive(:dn).with("myname").and_return("mydn")
-        expect(@conn).to receive(:modify).with("mydn", :mymods)
+        @manager.expects(:dn).with("myname").returns "mydn"
+        @conn.expects(:modify).with("mydn", :mymods)
 
         @manager.modify("myname", :mymods)
       end
@@ -421,25 +403,25 @@ describe Puppet::Util::Ldap::Manager do
 
     describe "to find a single entry" do
       it "should use the dn of the provided name as the search base, a scope of 0, and 'objectclass=*' as the filter for a search2 call" do
-        expect(@manager).to receive(:dn).with("myname").and_return("mydn")
-        expect(@conn).to receive(:search2).with("mydn", 0, "objectclass=*")
+        @manager.expects(:dn).with("myname").returns "mydn"
+        @conn.expects(:search2).with("mydn", 0, "objectclass=*")
 
         @manager.find("myname")
       end
 
       it "should return nil if an exception is thrown because no result is found" do
-        expect(@manager).to receive(:dn).with("myname").and_return("mydn")
-        expect(@conn).to receive(:search2).and_raise(LDAP::ResultError)
+        @manager.expects(:dn).with("myname").returns "mydn"
+        @conn.expects(:search2).raises LDAP::ResultError
 
         expect(@manager.find("myname")).to be_nil
       end
 
       it "should return a converted provider hash if the result is found" do
-        expect(@manager).to receive(:dn).with("myname").and_return("mydn")
+        @manager.expects(:dn).with("myname").returns "mydn"
         result = {"one" => "two"}
-        expect(@conn).to receive(:search2).and_yield(result)
+        @conn.expects(:search2).yields result
 
-        expect(@manager).to receive(:entry2provider).with(result).and_return("myprovider")
+        @manager.expects(:entry2provider).with(result).returns "myprovider"
 
         expect(@manager.find("myname")).to eq("myprovider")
       end
@@ -447,38 +429,38 @@ describe Puppet::Util::Ldap::Manager do
 
     describe "to search for multiple entries" do
       before do
-        allow(@manager).to receive(:filter).and_return("myfilter")
+        @manager.stubs(:filter).returns "myfilter"
       end
 
       it "should use the manager's search base as the dn of the provided name as the search base" do
-        expect(@manager).to receive(:base).and_return("mybase")
-        expect(@conn).to receive(:search2).with("mybase", anything, anything)
+        @manager.expects(:base).returns "mybase"
+        @conn.expects(:search2).with { |base, scope, filter| base == "mybase" }
 
         @manager.search
       end
 
       it "should use a scope of 1" do
-        expect(@conn).to receive(:search2).with(anything, 1, anything)
+        @conn.expects(:search2).with { |base, scope, filter| scope == 1 }
 
         @manager.search
       end
 
       it "should use any specified search filter" do
-        expect(@manager).not_to receive(:filter)
-        expect(@conn).to receive(:search2).with(anything, anything, "boo")
+        @manager.expects(:filter).never
+        @conn.expects(:search2).with { |base, scope, filter| filter == "boo" }
 
         @manager.search("boo")
       end
 
       it "should turn its objectclass list into its search filter if one is not specified" do
-        expect(@manager).to receive(:filter).and_return("yay")
-        expect(@conn).to receive(:search2).with(anything, anything, "yay")
+        @manager.expects(:filter).returns "yay"
+        @conn.expects(:search2).with { |base, scope, filter| filter == "yay" }
 
         @manager.search
       end
 
       it "should return nil if no result is found" do
-        expect(@conn).to receive(:search2)
+        @conn.expects(:search2)
 
         expect(@manager.search).to be_nil
       end
@@ -486,9 +468,9 @@ describe Puppet::Util::Ldap::Manager do
       it "should return an array of the found results converted to provider hashes" do
         # LAK: AFAICT, it's impossible to yield multiple times in an expectation.
         one = {"dn" => "cn=one,dc=madstop,dc=com", "one" => "two"}
-        expect(@conn).to receive(:search2).and_yield(one)
+        @conn.expects(:search2).yields(one)
 
-        expect(@manager).to receive(:entry2provider).with(one).and_return("myprov")
+        @manager.expects(:entry2provider).with(one).returns "myprov"
 
         expect(@manager.search).to eq(["myprov"])
       end
@@ -503,29 +485,29 @@ describe Puppet::Util::Ldap::Manager do
 
     describe "is being updated" do
       it "should get created if the current attribute list is empty and the desired attribute list has :ensure == :present" do
-        expect(@manager).to receive(:create)
+        @manager.expects(:create)
         @manager.update(@name, {}, {:ensure => :present})
       end
 
       it "should get created if the current attribute list has :ensure == :absent and the desired attribute list has :ensure == :present" do
-        expect(@manager).to receive(:create)
+        @manager.expects(:create)
         @manager.update(@name, {:ensure => :absent}, {:ensure => :present})
       end
 
       it "should get deleted if the current attribute list has :ensure == :present and the desired attribute list has :ensure == :absent" do
-        expect(@manager).to receive(:delete)
+        @manager.expects(:delete)
         @manager.update(@name, {:ensure => :present}, {:ensure => :absent})
       end
 
       it "should get modified if both attribute lists have :ensure == :present" do
-        expect(@manager).to receive(:modify)
+        @manager.expects(:modify)
         @manager.update(@name, {:ensure => :present, :one => :two}, {:ensure => :present, :one => :three})
       end
     end
 
     describe "is being deleted" do
       it "should call the :delete method with its name and manager" do
-        expect(@manager).to receive(:delete).with(@name)
+        @manager.expects(:delete).with(@name)
 
         @manager.update(@name, {}, {:ensure => :absent})
       end
@@ -538,59 +520,59 @@ describe Puppet::Util::Ldap::Manager do
       end
 
       it "should call the :create method with its name" do
-        expect(@manager).to receive(:create).with(@name, anything)
+        @manager.expects(:create).with { |name, attrs| name == @name }
         @manager.update(@name, @is, @should)
       end
 
       it "should call the :create method with its property hash converted to ldap attribute names" do
-        expect(@manager).to receive(:create).with(anything, hash_including("uno" => ["yay"]))
+        @manager.expects(:create).with { |name, attrs| attrs["uno"] == ["yay"] }
         @manager.update(@name, @is, @should)
       end
 
       it "should convert the property names to strings" do
-        expect(@manager).to receive(:create).with(anything, hash_including("uno" => ["yay"]))
+        @manager.expects(:create).with { |name, attrs| attrs["uno"] == ["yay"] }
         @manager.update(@name, @is, @should)
       end
 
       it "should convert the property values to arrays if necessary" do
-        expect(@manager).to receive(:create).with(anything, hash_including("uno" => ["yay"]))
+        @manager.expects(:create).with { |name, attrs| attrs["uno"] == ["yay"] }
         @manager.update(@name, @is, @should)
       end
 
       it "should convert the property values to strings if necessary" do
-        expect(@manager).to receive(:create).with(anything, hash_including("uno" => ["yay"]))
+        @manager.expects(:create).with { |name, attrs| attrs["uno"] == ["yay"] }
         @manager.update(@name, @is, @should)
       end
 
       it "should not include :ensure in the properties sent" do
-        expect(@manager).to receive(:create).with(anything, hash_excluding(:ensure))
+        @manager.expects(:create).with { |*args| args[1][:ensure].nil? }
         @manager.update(@name, @is, @should)
       end
 
       it "should not include attributes set to :absent in the properties sent" do
-        expect(@manager).to receive(:create).with(anything, hash_excluding(:dos))
+        @manager.expects(:create).with { |*args| args[1][:dos].nil? }
         @manager.update(@name, @is, @should)
       end
     end
 
     describe "is being modified" do
       it "should call the :modify method with its name and an array of LDAP::Mod instances" do
-        allow(LDAP::Mod).to receive(:new).and_return("whatever")
+        LDAP::Mod.stubs(:new).returns "whatever"
 
         @is = {:one => :yay}
         @should = {:one => :yay, :two => :foo}
 
-        expect(@manager).to receive(:modify).with(@name, anything)
+        @manager.expects(:modify).with { |name, mods| name == @name }
         @manager.update(@name, @is, @should)
       end
 
       it "should create the LDAP::Mod with the property name converted to the ldap name as a string" do
         @is = {:one => :yay}
         @should = {:one => :yay, :two => :foo}
-        mod = double('module')
-        expect(LDAP::Mod).to receive(:new).with(anything, "dos", anything).and_return(mod)
+        mod = mock 'module'
+        LDAP::Mod.expects(:new).with { |form, name, value| name == "dos" }.returns mod
 
-        allow(@manager).to receive(:modify)
+        @manager.stubs(:modify)
 
         @manager.update(@name, @is, @should)
       end
@@ -598,10 +580,10 @@ describe Puppet::Util::Ldap::Manager do
       it "should create an LDAP::Mod instance of type LDAP_MOD_ADD for each attribute being added, with the attribute value converted to a string of arrays" do
         @is = {:one => :yay}
         @should = {:one => :yay, :two => :foo}
-        mod = double('module')
-        expect(LDAP::Mod).to receive(:new).with(LDAP::LDAP_MOD_ADD, "dos", ["foo"]).and_return(mod)
+        mod = mock 'module'
+        LDAP::Mod.expects(:new).with(LDAP::LDAP_MOD_ADD, "dos", ["foo"]).returns mod
 
-        allow(@manager).to receive(:modify)
+        @manager.stubs(:modify)
 
         @manager.update(@name, @is, @should)
       end
@@ -609,10 +591,10 @@ describe Puppet::Util::Ldap::Manager do
       it "should create an LDAP::Mod instance of type LDAP_MOD_DELETE for each attribute being deleted" do
         @is = {:one => :yay, :two => :foo}
         @should = {:one => :yay, :two => :absent}
-        mod = double('module')
-        expect(LDAP::Mod).to receive(:new).with(LDAP::LDAP_MOD_DELETE, "dos", []).and_return(mod)
+        mod = mock 'module'
+        LDAP::Mod.expects(:new).with(LDAP::LDAP_MOD_DELETE, "dos", []).returns mod
 
-        allow(@manager).to receive(:modify)
+        @manager.stubs(:modify)
 
         @manager.update(@name, @is, @should)
       end
@@ -620,10 +602,10 @@ describe Puppet::Util::Ldap::Manager do
       it "should create an LDAP::Mod instance of type LDAP_MOD_REPLACE for each attribute being modified, with the attribute converted to a string of arrays" do
         @is = {:one => :yay, :two => :four}
         @should = {:one => :yay, :two => :five}
-        mod = double('module')
-        expect(LDAP::Mod).to receive(:new).with(LDAP::LDAP_MOD_REPLACE, "dos", ["five"]).and_return(mod)
+        mod = mock 'module'
+        LDAP::Mod.expects(:new).with(LDAP::LDAP_MOD_REPLACE, "dos", ["five"]).returns mod
 
-        allow(@manager).to receive(:modify)
+        @manager.stubs(:modify)
 
         @manager.update(@name, @is, @should)
       end
@@ -631,9 +613,11 @@ describe Puppet::Util::Ldap::Manager do
       it "should pass all created Mod instances to the modify method" do
         @is = {:one => :yay, :two => :foo, :three => :absent}
         @should = {:one => :yay, :two => :foe, :three => :fee, :four => :fie}
-        expect(LDAP::Mod).to receive(:new).exactly(3).times().and_return("mod1", "mod2", "mod3")
+        LDAP::Mod.expects(:new).times(3).returns("mod1").then.returns("mod2").then.returns("mod3")
 
-        expect(@manager).to receive(:modify).with(anything, contain_exactly(*%w{mod1 mod2 mod3}))
+        @manager.expects(:modify).with do |name, mods|
+          mods.sort == %w{mod1 mod2 mod3}.sort
+        end
 
         @manager.update(@name, @is, @should)
       end