puppet 5.5.22-universal-darwin → 6.0.0-universal-darwin

data/spec/unit/provider/group/windows_adsi_spec.rb

@@ -1,6 +1,8 @@
+#!/usr/bin/env ruby
+
 require 'spec_helper'
 
-describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.features.microsoft_windows? do
+describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet::Util::Platform.windows? do
   let(:resource) do
     Puppet::Type.type(:group).new(
       :title => 'testers',
@@ -9,66 +11,63 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
   end
 
   let(:provider) { resource.provider }
-  let(:connection) { double('connection') }
+
+  let(:connection) { stub 'connection' }
 
   before :each do
-    allow(Puppet::Util::Windows::ADSI).to receive(:computer_name).and_return('testcomputername')
-    allow(Puppet::Util::Windows::ADSI).to receive(:connect).and_return(connection)
+    Puppet::Util::Windows::ADSI.stubs(:computer_name).returns('testcomputername')
+    Puppet::Util::Windows::ADSI.stubs(:connect).returns connection
     # this would normally query the system, but not needed for these tests
-    allow(Puppet::Util::Windows::ADSI::Group).to receive(:localized_domains).and_return([])
+    Puppet::Util::Windows::ADSI::Group.stubs(:localized_domains).returns([])
   end
 
   describe ".instances" do
     it "should enumerate all groups" do
       names = ['group1', 'group2', 'group3']
-      stub_groups = names.map{|n| double(:name => n)}
+      stub_groups = names.map{|n| stub(:name => n)}
 
-      allow(connection).to receive(:execquery).with('select name from win32_group where localaccount = "TRUE"').and_return(stub_groups)
+      connection.stubs(:execquery).with('select name from win32_group where localaccount = "TRUE"').returns stub_groups
 
       expect(described_class.instances.map(&:name)).to match(names)
     end
   end
 
   describe "group type :members property helpers" do
-    let(:user1) { double(:account => 'user1', :domain => '.', :sid => 'user1sid') }
-    let(:user2) { double(:account => 'user2', :domain => '.', :sid => 'user2sid') }
-    let(:user3) { double(:account => 'user3', :domain => '.', :sid => 'user3sid') }
-    let(:user_without_domain) { double(:account => 'user_without_domain', :domain => nil, :sid => 'user_without_domain_sid') }
 
+    let(:user1) { stub(:account => 'user1', :domain => '.', :sid => 'user1sid') }
+    let(:user2) { stub(:account => 'user2', :domain => '.', :sid => 'user2sid') }
+    let(:user3) { stub(:account => 'user3', :domain => '.', :sid => 'user3sid') }
     let(:invalid_user) { SecureRandom.uuid }
-    let(:invalid_user_principal) { double(:account => "#{invalid_user}", :domain => nil, :sid => "#{invalid_user}") }
 
     before :each do
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user1', any_args).and_return(user1)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2', any_args).and_return(user2)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user3', any_args).and_return(user3)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user_without_domain', any_args).and_return(user_without_domain)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with(invalid_user).and_return(nil)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with(invalid_user, true).and_return(invalid_user_principal)
+      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('user1').returns(user1)
+      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('user2').returns(user2)
+      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('user3').returns(user3)
+      Puppet::Util::Windows::SID.stubs(:name_to_principal).with(invalid_user).returns(nil)
     end
 
     describe "#members_insync?" do
       it "should return true for same lists of members" do
         current = [
-          'user1',
-          'user2',
+          Puppet::Util::Windows::SID.name_to_principal('user1'),
+          Puppet::Util::Windows::SID.name_to_principal('user2'),
         ]
         expect(provider.members_insync?(current, ['user1', 'user2'])).to be_truthy
       end
 
       it "should return true for same lists of unordered members" do
         current = [
-          'user1',
-          'user2',
+          Puppet::Util::Windows::SID.name_to_principal('user1'),
+          Puppet::Util::Windows::SID.name_to_principal('user2'),
         ]
         expect(provider.members_insync?(current, ['user2', 'user1'])).to be_truthy
       end
 
       it "should return true for same lists of members irrespective of duplicates" do
         current = [
-          'user1',
-          'user2',
-          'user2',
+          Puppet::Util::Windows::SID.name_to_principal('user1'),
+          Puppet::Util::Windows::SID.name_to_principal('user2'),
+          Puppet::Util::Windows::SID.name_to_principal('user2'),
         ]
         expect(provider.members_insync?(current, ['user2', 'user1', 'user1'])).to be_truthy
       end
@@ -92,9 +91,9 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
 
         it "should return true when current and should contain the same users in a different order" do
           current = [
-            'user1',
-            'user2',
-            'user3',
+            Puppet::Util::Windows::SID.name_to_principal('user1'),
+            Puppet::Util::Windows::SID.name_to_principal('user2'),
+            Puppet::Util::Windows::SID.name_to_principal('user3'),
           ]
           expect(provider.members_insync?(current, ['user3', 'user1', 'user2'])).to be_truthy
         end
@@ -105,21 +104,21 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
 
         it "should return false when should is nil" do
           current = [
-            'user1',
+            Puppet::Util::Windows::SID.name_to_principal('user1'),
           ]
           expect(provider.members_insync?(current, nil)).to be_falsey
         end
 
         it "should return false when current contains different users than should" do
           current = [
-            'user1',
+            Puppet::Util::Windows::SID.name_to_principal('user1'),
           ]
           expect(provider.members_insync?(current, ['user2'])).to be_falsey
         end
 
         it "should return false when current contains members and should is empty" do
           current = [
-            'user1',
+            Puppet::Util::Windows::SID.name_to_principal('user1'),
           ]
           expect(provider.members_insync?(current, [])).to be_falsey
         end
@@ -130,16 +129,16 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
 
         it "should return false when should user(s) are not the only items in the current" do
           current = [
-            'user1',
-            'user2',
+            Puppet::Util::Windows::SID.name_to_principal('user1'),
+            Puppet::Util::Windows::SID.name_to_principal('user2'),
           ]
           expect(provider.members_insync?(current, ['user1'])).to be_falsey
         end
 
         it "should return false when current user(s) is not empty and should is an empty list" do
           current = [
-            'user1',
-            'user2',
+            Puppet::Util::Windows::SID.name_to_principal('user1'),
+            Puppet::Util::Windows::SID.name_to_principal('user2'),
           ]
           expect(provider.members_insync?(current, [])).to be_falsey
         end
@@ -157,21 +156,21 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
 
         it "should return true when should is nil" do
           current = [
-            'user1',
+            Puppet::Util::Windows::SID.name_to_principal('user1'),
           ]
           expect(provider.members_insync?(current, nil)).to be_truthy
         end
 
         it "should return false when current contains different users than should" do
           current = [
-            'user1',
+            Puppet::Util::Windows::SID.name_to_principal('user1'),
           ]
           expect(provider.members_insync?(current, ['user2'])).to be_falsey
         end
 
         it "should return true when current contains members and should is empty" do
           current = [
-            'user1',
+            Puppet::Util::Windows::SID.name_to_principal('user1'),
           ]
           expect(provider.members_insync?(current, [])).to be_truthy
         end
@@ -182,37 +181,29 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
 
         it "should return true when current user(s) contains at least the should list" do
           current = [
-            'user1',
-            'user2',
+            Puppet::Util::Windows::SID.name_to_principal('user1'),
+            Puppet::Util::Windows::SID.name_to_principal('user2'),
           ]
           expect(provider.members_insync?(current, ['user1'])).to be_truthy
         end
 
         it "should return true when current user(s) is not empty and should is an empty list" do
           current = [
-            'user1',
-            'user2',
+            Puppet::Util::Windows::SID.name_to_principal('user1'),
+            Puppet::Util::Windows::SID.name_to_principal('user2'),
           ]
           expect(provider.members_insync?(current, [])).to be_truthy
         end
 
         it "should return true when current user(s) contains at least the should list, even unordered" do
           current = [
-            'user3',
-            'user1',
-            'user2',
+            Puppet::Util::Windows::SID.name_to_principal('user3'),
+            Puppet::Util::Windows::SID.name_to_principal('user1'),
+            Puppet::Util::Windows::SID.name_to_principal('user2'),
           ]
           expect(provider.members_insync?(current, ['user2','user1'])).to be_truthy
         end
-
-      it "should return true even if a current user is unresolvable if should is included" do
-        current = [
-            "#{invalid_user}",
-            'user2',
-          ]
-          expect(provider.members_insync?(current, ['user2'])).to be_truthy
       end
-     end
     end
 
     describe "#members_to_s" do
@@ -221,24 +212,19 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
           expect(provider.members_to_s(input)).to be_empty
         end
       end
-
       it "should return an empty string on empty or nil users" do
         expect(provider.members_to_s([])).to be_empty
         expect(provider.members_to_s(nil)).to be_empty
       end
-
       it "should return a user string like DOMAIN\\USER" do
         expect(provider.members_to_s(['user1'])).to eq('.\user1')
       end
-
       it "should return a user string like DOMAIN\\USER,DOMAIN2\\USER2" do
         expect(provider.members_to_s(['user1', 'user2'])).to eq('.\user1,.\user2')
       end
-
-      it "should return a user string without domain if domain is not set" do
-        expect(provider.members_to_s(['user_without_domain'])).to eq('user_without_domain')
+      it "should return the username when it cannot be resolved to a SID (for the sake of resource_harness error messages)" do
+        expect(provider.members_to_s([invalid_user])).to eq("#{invalid_user}")
       end
-
       it "should return the username when it cannot be resolved to a SID (for the sake of resource_harness error messages)" do
         expect(provider.members_to_s([invalid_user])).to eq("#{invalid_user}")
       end
@@ -246,70 +232,32 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
   end
 
   describe "when managing members" do
-    let(:user1) { double(:account => 'user1', :domain => '.', :sid => 'user1sid') }
-    let(:user2) { double(:account => 'user2', :domain => '.', :sid => 'user2sid') }
-    let(:user3) { double(:account => 'user3', :domain => '.', :sid => 'user3sid') }
-
-    let(:invalid_user) { SecureRandom.uuid }
-    let(:invalid_user_principal) { double(:account => "#{invalid_user}", :domain => nil, :sid => "#{invalid_user}") }
-
     before :each do
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user1', any_args).and_return(user1)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2', any_args).and_return(user2)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user3', any_args).and_return(user3)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with(invalid_user, true).and_return(invalid_user_principal)
-
       resource[:auth_membership] = true
     end
 
     it "should be able to provide a list of members" do
-      allow(provider.group).to receive(:members).and_return([
-        'user1',
-        'user2',
-        'user3',
-      ])
-
-      expected_member_sids = [user1.sid, user2.sid, user3.sid]
-      expected_members = ['user1', 'user2', 'user3']
-      allow(provider).to receive(:members_to_s)
-        .with(expected_member_sids)
-        .and_return(expected_members.join(','))
-
-      expect(provider.members).to match_array(expected_members)
-    end
-
-    it "should be able to handle unresolvable SID in list of members" do
-      allow(provider.group).to receive(:members).and_return([
-        'user1',
-        "#{invalid_user}",
-        'user3',
-      ])
+      provider.group.stubs(:members).returns ['user1', 'user2', 'user3']
 
-      expected_member_sids = [user1.sid, invalid_user_principal.sid, user3.sid]
-      expected_members = ['user1', "#{invalid_user}", 'user3']
-      allow(provider).to receive(:members_to_s)
-        .with(expected_member_sids)
-        .and_return(expected_members.join(','))
-
-      expect(provider.members).to match_array(expected_members)
+      expect(provider.members).to match_array(['user1', 'user2', 'user3'])
     end
 
     it "should be able to set group members" do
-      allow(provider.group).to receive(:members).and_return(['user1', 'user2'])
+      provider.group.stubs(:members).returns ['user1', 'user2']
 
       member_sids = [
-        double(:account => 'user1', :domain => 'testcomputername', :sid => 1),
-        double(:account => 'user2', :domain => 'testcomputername', :sid => 2),
-        double(:account => 'user3', :domain => 'testcomputername', :sid => 3),
+        stub(:account => 'user1', :domain => 'testcomputername', :sid => 1),
+        stub(:account => 'user2', :domain => 'testcomputername', :sid => 2),
+        stub(:account => 'user3', :domain => 'testcomputername', :sid => 3),
       ]
 
-      allow(provider.group).to receive(:member_sids).and_return(member_sids[0..1])
+      provider.group.stubs(:member_sids).returns(member_sids[0..1])
 
-      expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2', any_args).and_return(member_sids[1])
-      expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user3', any_args).and_return(member_sids[2])
+      Puppet::Util::Windows::SID.expects(:name_to_principal).with('user2').returns(member_sids[1])
+      Puppet::Util::Windows::SID.expects(:name_to_principal).with('user3').returns(member_sids[2])
 
-      expect(provider.group).to receive(:remove_member_sids).with(member_sids[0])
-      expect(provider.group).to receive(:add_member_sids).with(member_sids[2])
+      provider.group.expects(:remove_member_sids).with(member_sids[0])
+      provider.group.expects(:add_member_sids).with(member_sids[2])
 
       provider.members = ['user2', 'user3']
     end
@@ -319,68 +267,72 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
     it "should be able to create a group" do
       resource[:members] = ['user1', 'user2']
 
-      group = double('group')
-      expect(Puppet::Util::Windows::ADSI::Group).to receive(:create).with('testers').and_return(group)
+      group = stub 'group'
+      Puppet::Util::Windows::ADSI::Group.expects(:create).with('testers').returns group
 
-      expect(group).to receive(:commit).ordered
+      create = sequence('create')
+      group.expects(:commit).in_sequence(create)
       # due to PUP-1967, defaultto false will set the default to nil
-      expect(group).to receive(:set_members).with(['user1', 'user2'], nil).ordered
+      group.expects(:set_members).with(['user1', 'user2'], nil).in_sequence(create)
 
       provider.create
     end
 
     it 'should not create a group if a user by the same name exists' do
-      expect(Puppet::Util::Windows::ADSI::Group).to receive(:create).with('testers').and_raise(Puppet::Error.new("Cannot create group if user 'testers' exists."))
+      Puppet::Util::Windows::ADSI::Group.expects(:create).with('testers').raises( Puppet::Error.new("Cannot create group if user 'testers' exists.") )
       expect{ provider.create }.to raise_error( Puppet::Error,
         /Cannot create group if user 'testers' exists./ )
     end
 
     it "should fail with an actionable message when trying to create an active directory group" do
       resource[:name] = 'DOMAIN\testdomaingroup'
-      expect(Puppet::Util::Windows::ADSI::User).to receive(:exists?).with(resource[:name]).and_return(false)
-      expect(connection).to receive(:Create)
-      expect(connection).to receive(:SetInfo).and_raise( WIN32OLERuntimeError.new("(in OLE method `SetInfo': )\n    OLE error code:8007089A in Active Directory\n      The specified username is invalid.\r\n\n    HRESULT error code:0x80020009\n      Exception occurred."))
-
-      expect{ provider.create }.to raise_error(Puppet::Error)
+      Puppet::Util::Windows::ADSI::User.expects(:exists?).with(resource[:name]).returns(false)
+      connection.expects(:Create)
+      connection.expects(:SetInfo).raises( WIN32OLERuntimeError.new("(in OLE method `SetInfo': )\n    OLE error code:8007089A in Active Directory\n      The specified username is invalid.\r\n\n    HRESULT error code:0x80020009\n      Exception occurred."))
+
+      expect{ provider.create }.to raise_error(
+                                       Puppet::Error,
+                                       /not able to create\/delete domain groups/
+                                   )
     end
 
     it 'should commit a newly created group' do
-      expect(provider.group).to receive( :commit )
+      provider.group.expects( :commit )
 
       provider.flush
     end
   end
 
   it "should be able to test whether a group exists" do
-    allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).and_return(nil)
-    allow(Puppet::Util::Windows::ADSI).to receive(:connect).and_return(double('connection', :Class => 'Group'))
+    Puppet::Util::Windows::SID.stubs(:name_to_principal).returns(nil)
+    Puppet::Util::Windows::ADSI.stubs(:connect).returns stub('connection', :Class => 'Group')
     expect(provider).to be_exists
 
-    allow(Puppet::Util::Windows::ADSI).to receive(:connect).and_return(nil)
+    Puppet::Util::Windows::ADSI.stubs(:connect).returns nil
     expect(provider).not_to be_exists
   end
 
   it "should be able to delete a group" do
-    expect(connection).to receive(:Delete).with('group', 'testers')
+    connection.expects(:Delete).with('group', 'testers')
 
     provider.delete
   end
 
   it 'should not run commit on a deleted group' do
-    expect(connection).to receive(:Delete).with('group', 'testers')
-    expect(connection).not_to receive(:SetInfo)
+    connection.expects(:Delete).with('group', 'testers')
+    connection.expects(:SetInfo).never
 
     provider.delete
     provider.flush
   end
 
   it "should report the group's SID as gid" do
-    expect(Puppet::Util::Windows::SID).to receive(:name_to_sid).with('testers').and_return('S-1-5-32-547')
+    Puppet::Util::Windows::SID.expects(:name_to_sid).with('testers').returns('S-1-5-32-547')
     expect(provider.gid).to eq('S-1-5-32-547')
   end
 
   it "should fail when trying to manage the gid property" do
-    expect(provider).to receive(:fail).with(/gid is read-only/)
+    provider.expects(:fail).with { |msg| msg =~ /gid is read-only/ }
     provider.send(:gid=, 500)
   end
 

data/spec/unit/provider/ldap_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/provider/ldap'
@@ -8,10 +9,10 @@ describe Puppet::Provider::Ldap do
   end
 
   it "should be able to define its manager" do
-    manager = double('manager')
-    expect(Puppet::Util::Ldap::Manager).to receive(:new).and_return(manager)
-    allow(@class).to receive(:mk_resource_methods)
-    expect(manager).to receive(:manages).with(:one)
+    manager = mock 'manager'
+    Puppet::Util::Ldap::Manager.expects(:new).returns manager
+    @class.stubs :mk_resource_methods
+    manager.expects(:manages).with(:one)
     expect(@class.manages(:one)).to equal(manager)
     expect(@class.manager).to equal(manager)
   end
@@ -21,10 +22,10 @@ describe Puppet::Provider::Ldap do
   end
 
   it "should create its resource getter/setter methods when the manager is defined" do
-    manager = double('manager')
-    expect(Puppet::Util::Ldap::Manager).to receive(:new).and_return(manager)
-    expect(@class).to receive(:mk_resource_methods)
-    allow(manager).to receive(:manages)
+    manager = mock 'manager'
+    Puppet::Util::Ldap::Manager.expects(:new).returns manager
+    @class.expects :mk_resource_methods
+    manager.stubs(:manages)
     expect(@class.manages(:one)).to equal(manager)
   end
 
@@ -34,14 +35,14 @@ describe Puppet::Provider::Ldap do
 
   describe "when providing a list of instances" do
     it "should convert all results returned from the manager's :search method into provider instances" do
-      manager = double('manager')
-      allow(@class).to receive(:manager).and_return(manager)
+      manager = mock 'manager'
+      @class.stubs(:manager).returns manager
 
-      expect(manager).to receive(:search).and_return(%w{one two three})
+      manager.expects(:search).returns %w{one two three}
 
-      expect(@class).to receive(:new).with("one").and_return(1)
-      expect(@class).to receive(:new).with("two").and_return(2)
-      expect(@class).to receive(:new).with("three").and_return(3)
+      @class.expects(:new).with("one").returns(1)
+      @class.expects(:new).with("two").returns(2)
+      @class.expects(:new).with("three").returns(3)
 
       expect(@class.instances).to eq([1,2,3])
     end
@@ -53,29 +54,29 @@ describe Puppet::Provider::Ldap do
 
   describe "when prefetching" do
     before do
-      @manager = double('manager')
-      allow(@class).to receive(:manager).and_return(@manager)
+      @manager = mock 'manager'
+      @class.stubs(:manager).returns @manager
 
-      @resource = double('resource')
+      @resource = mock 'resource'
 
       @resources = {"one" => @resource}
     end
 
     it "should find an entry for each passed resource" do
-      expect(@manager).to receive(:find).with("one").and_return(nil)
+      @manager.expects(:find).with("one").returns nil
 
-      allow(@class).to receive(:new)
-      allow(@resource).to receive(:provider=)
+      @class.stubs(:new)
+      @resource.stubs(:provider=)
       @class.prefetch(@resources)
     end
 
     describe "resources that do not exist" do
       it "should create a provider with :ensure => :absent" do
-        expect(@manager).to receive(:find).with("one").and_return(nil)
+        @manager.expects(:find).with("one").returns nil
 
-        expect(@class).to receive(:new).with(:ensure => :absent).and_return("myprovider")
+        @class.expects(:new).with(:ensure => :absent).returns "myprovider"
 
-        expect(@resource).to receive(:provider=).with("myprovider")
+        @resource.expects(:provider=).with("myprovider")
 
         @class.prefetch(@resources)
       end
@@ -83,21 +84,21 @@ describe Puppet::Provider::Ldap do
 
     describe "resources that exist" do
       it "should create a provider with the results of the find" do
-        expect(@manager).to receive(:find).with("one").and_return("one" => "two")
+        @manager.expects(:find).with("one").returns("one" => "two")
 
-        expect(@class).to receive(:new).with("one" => "two", :ensure => :present).and_return("myprovider")
+        @class.expects(:new).with("one" => "two", :ensure => :present).returns "myprovider"
 
-        expect(@resource).to receive(:provider=).with("myprovider")
+        @resource.expects(:provider=).with("myprovider")
 
         @class.prefetch(@resources)
       end
 
       it "should set :ensure to :present in the returned values" do
-        expect(@manager).to receive(:find).with("one").and_return("one" => "two")
+        @manager.expects(:find).with("one").returns("one" => "two")
 
-        expect(@class).to receive(:new).with("one" => "two", :ensure => :present).and_return("myprovider")
+        @class.expects(:new).with("one" => "two", :ensure => :present).returns "myprovider"
 
-        expect(@resource).to receive(:provider=).with("myprovider")
+        @resource.expects(:provider=).with("myprovider")
 
         @class.prefetch(@resources)
       end
@@ -110,22 +111,22 @@ describe Puppet::Provider::Ldap do
     end
 
     it "should fail if the manager is invalid" do
-      manager = double("manager", :valid? => false)
-      allow(@class).to receive(:manager).and_return(manager)
+      manager = stub "manager", :valid? => false
+      @class.stubs(:manager).returns manager
       expect { @class.new }.to raise_error(Puppet::DevError)
     end
 
     describe "with a hash" do
       before do
-        @manager = double("manager", :valid? => true)
-        allow(@class).to receive(:manager).and_return(@manager)
+        @manager = stub "manager", :valid? => true
+        @class.stubs(:manager).returns @manager
 
-        @resource_class = double('resource_class')
-        allow(@class).to receive(:resource_type).and_return(@resource_class)
+        @resource_class = mock 'resource_class'
+        @class.stubs(:resource_type).returns @resource_class
 
-        @property_class = double('property_class', :array_matching => :all, :superclass => Puppet::Property)
-        allow(@resource_class).to receive(:attrclass).with(:one).and_return(@property_class)
-        allow(@resource_class).to receive(:valid_parameter?).and_return(true)
+        @property_class = stub 'property_class', :array_matching => :all, :superclass => Puppet::Property
+        @resource_class.stubs(:attrclass).with(:one).returns(@property_class)
+        @resource_class.stubs(:valid_parameter?).returns true
       end
 
       it "should store a copy of the hash as its ldap_properties" do
@@ -134,29 +135,29 @@ describe Puppet::Provider::Ldap do
       end
 
       it "should only store the first value of each value array for those attributes that do not match all values" do
-        expect(@property_class).to receive(:array_matching).and_return(:first)
+        @property_class.expects(:array_matching).returns :first
         instance = @class.new(:one => %w{two three})
         expect(instance.properties).to eq({:one => "two"})
       end
 
       it "should store the whole value array for those attributes that match all values" do
-        expect(@property_class).to receive(:array_matching).and_return(:all)
+        @property_class.expects(:array_matching).returns :all
         instance = @class.new(:one => %w{two three})
         expect(instance.properties).to eq({:one => %w{two three}})
       end
 
       it "should only use the first value for attributes that are not properties" do
         # Yay.  hackish, but easier than mocking everything.
-        expect(@resource_class).to receive(:attrclass).with(:a).and_return(Puppet::Type.type(:user).attrclass(:name))
-        allow(@property_class).to receive(:array_matching).and_return(:all)
+        @resource_class.expects(:attrclass).with(:a).returns Puppet::Type.type(:user).attrclass(:name)
+        @property_class.stubs(:array_matching).returns :all
 
         instance = @class.new(:one => %w{two three}, :a => %w{b c})
         expect(instance.properties).to eq({:one => %w{two three}, :a => "b"})
       end
 
       it "should discard any properties not valid in the resource class" do
-        expect(@resource_class).to receive(:valid_parameter?).with(:a).and_return(false)
-        allow(@property_class).to receive(:array_matching).and_return(:all)
+        @resource_class.expects(:valid_parameter?).with(:a).returns false
+        @property_class.stubs(:array_matching).returns :all
 
         instance = @class.new(:one => %w{two three}, :a => %w{b})
         expect(instance.properties).to eq({:one => %w{two three}})
@@ -166,13 +167,13 @@ describe Puppet::Provider::Ldap do
 
   describe "when an instance" do
     before do
-      @manager = double("manager", :valid? => true)
-      allow(@class).to receive(:manager).and_return(@manager)
+      @manager = stub "manager", :valid? => true
+      @class.stubs(:manager).returns @manager
       @instance = @class.new
 
-      @property_class = double('property_class', :array_matching => :all, :superclass => Puppet::Property)
-      @resource_class = double('resource_class', :attrclass => @property_class, :valid_parameter? => true, :validproperties => [:one, :two])
-      allow(@class).to receive(:resource_type).and_return(@resource_class)
+      @property_class = stub 'property_class', :array_matching => :all, :superclass => Puppet::Property
+      @resource_class = stub 'resource_class', :attrclass => @property_class, :valid_parameter? => true, :validproperties => [:one, :two]
+      @class.stubs(:resource_type).returns @resource_class
     end
 
     it "should have a method for creating the ldap entry" do
@@ -199,22 +200,22 @@ describe Puppet::Provider::Ldap do
 
     describe "is being flushed" do
       it "should call the manager's :update method with its name, current attributes, and desired attributes" do
-        allow(@instance).to receive(:name).and_return("myname")
-        allow(@instance).to receive(:ldap_properties).and_return(:one => :two)
-        allow(@instance).to receive(:properties).and_return(:three => :four)
-        expect(@manager).to receive(:update).with(@instance.name, {:one => :two}, {:three => :four})
+        @instance.stubs(:name).returns "myname"
+        @instance.stubs(:ldap_properties).returns(:one => :two)
+        @instance.stubs(:properties).returns(:three => :four)
+        @manager.expects(:update).with(@instance.name, {:one => :two}, {:three => :four})
         @instance.flush
       end
     end
 
     describe "is being created" do
       before do
-        @rclass = double('resource_class')
-        allow(@rclass).to receive(:validproperties).and_return([:one, :two])
-        @resource = double('resource')
-        allow(@resource).to receive(:class).and_return(@rclass)
-        allow(@resource).to receive(:should).and_return(nil)
-        allow(@instance).to receive(:resource).and_return(@resource)
+        @rclass = mock 'resource_class'
+        @rclass.stubs(:validproperties).returns([:one, :two])
+        @resource = mock 'resource'
+        @resource.stubs(:class).returns @rclass
+        @resource.stubs(:should).returns nil
+        @instance.stubs(:resource).returns @resource
       end
 
       it "should set its :ensure value to :present" do
@@ -223,8 +224,8 @@ describe Puppet::Provider::Ldap do
       end
 
       it "should set all of the other attributes from the resource" do
-        expect(@resource).to receive(:should).with(:one).and_return("oneval")
-        expect(@resource).to receive(:should).with(:two).and_return("twoval")
+        @resource.expects(:should).with(:one).returns "oneval"
+        @resource.expects(:should).with(:two).returns "twoval"
 
         @instance.create
         expect(@instance.properties[:one]).to eq("oneval")