1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
require 'spec_helper'
require 'puppet/indirector/ldap'
describe Puppet::Indirector::Ldap do
before do
@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 = double('ldap')
end
describe "when instantiating ldap" do
it "should be deprecated" do
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
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
expect(Puppet).to receive(:warning).with(/Puppet::Indirector::Ldap is deprecated/).once
@ldap_class.new
@ldap_class.new
end
end
describe "when searching ldap" do
before do
@searcher = @ldap_class.new
# Stub everything, and we can selectively replace with an expect as
# we need to for testing.
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 = double('request', :key => "yay")
end
it "should call the ldapsearch method with the search filter" do
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
it "should fail if no block is passed to the ldapsearch method" do
expect { @searcher.ldapsearch("blah") }.to raise_error(ArgumentError)
end
it "should use the results of the ldapbase method as the ldap search base" do
allow(@searcher).to receive(:search_base).and_return("mybase")
expect(@connection).to receive(:search).with("mybase", anything, anything, anything)
@searcher.find @request
end
it "should default to the value of the :search_base setting as the result of the ldapbase method" do
Puppet[:ldapbase] = "myldapbase"
searcher = @ldap_class.new
expect(searcher.search_base).to eq("myldapbase")
end
it "should use the results of the :search_attributes method as the list of attributes to return" do
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
expect(@connection).to receive(:search).with(anything, 2, anything, anything)
@searcher.find @request
end
it "should call process() on the first found entry" do
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
allow(@connection).to receive(:search) do |*args|
if run
true
else
run = true
raise "failed"
end
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
allow(@connection).to receive(:search) do |*_|
count += 1
raise ArgumentError, "yay"
end
expect { @searcher.find(@request) }.to raise_error(Puppet::Error)
expect(count).to eq(2)
end
it "should return true if an entry is found" do
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)
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)
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)
expect(Puppet::Util::Ldap::Connection).to receive(:instance).and_return(conn)
expect(@searcher.connection).to equal(@searcher.connection)
end
end
describe "when reconnecting to ldap", :if => (Puppet.features.root? and Facter.value("hostname") == "culain") do
it "should reconnect to ldap when connections are lost"
end
end
|
