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
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
#!/usr/bin/env ruby
$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
require 'puppettest'
require 'puppet/network/handler/configuration'
class TestHandlerConfiguration < Test::Unit::TestCase
include PuppetTest
Config = Puppet::Network::Handler.handler(:configuration)
# Check all of the setup stuff.
def test_initialize
config = nil
assert_nothing_raised("Could not create local config") do
config = Config.new(:Local => true)
end
assert(config.local?, "Config is not considered local after being started that way")
end
# Make sure we create the node handler when necessary.
def test_node_handler
config = Config.new
handler = nil
assert_nothing_raised("Could not create node handler") do
handler = config.send(:node_handler)
end
assert_instance_of(Puppet::Network::Handler.handler(:node), handler, "Did not create node handler")
# Now make sure we get the same object back again
assert_equal(handler.object_id, config.send(:node_handler).object_id, "Did not cache node handler")
end
# Test creation/returning of the interpreter
def test_interpreter
config = Config.new
# First test the defaults
args = {}
config.instance_variable_set("@options", args)
config.expects(:create_interpreter).with(args).returns(:interp)
assert_equal(:interp, config.send(:interpreter), "Did not return the interpreter")
# Now run it again and make sure we get the same thing
assert_equal(:interp, config.send(:interpreter), "Did not cache the interpreter")
end
def test_create_interpreter
config = Config.new(:Local => false)
args = {}
# Try it first with defaults.
Puppet::Parser::Interpreter.expects(:new).with(:Local => config.local?, :Manifest => Puppet[:manifest]).returns(:interp)
assert_equal(:interp, config.send(:create_interpreter, args), "Did not return the interpreter")
# Now reset it and make sure a specified manifest passes through
file = tempfile
args[:Manifest] = file
Puppet::Parser::Interpreter.expects(:new).with(:Local => config.local?, :Manifest => file).returns(:interp)
assert_equal(:interp, config.send(:create_interpreter, args), "Did not return the interpreter")
# And make sure the code does, too
args.delete(:Manifest)
args[:Code] = "yay"
Puppet::Parser::Interpreter.expects(:new).with(:Local => config.local?, :Code => "yay").returns(:interp)
assert_equal(:interp, config.send(:create_interpreter, args), "Did not return the interpreter")
end
# Make sure node objects get appropriate data added to them.
def test_add_node_data
# First with no classes
config = Config.new
fakenode = Object.new
# Set the server facts to something
config.instance_variable_set("@server_facts", :facts)
fakenode.expects(:fact_merge).with(:facts)
config.send(:add_node_data, fakenode)
# Now try it with classes.
config.instance_variable_set("@options", {:Classes => %w{a b}})
list = []
fakenode = Object.new
fakenode.expects(:fact_merge).with(:facts)
fakenode.expects(:classes).returns(list).times(2)
config.send(:add_node_data, fakenode)
assert_equal(%w{a b}, list, "Did not add classes to node")
end
def test_compile
config = Config.new
# First do a local
node = Object.new
node.expects(:name).returns(:mynode)
interp = Object.new
interp.expects(:compile).with(node).returns(:config)
config.expects(:interpreter).returns(interp)
Puppet.expects(:notice) # The log message from benchmarking
assert_equal(:config, config.send(:compile, node), "Did not return config")
# Now try it non-local
config = Config.new(:Local => true)
node = Object.new
node.expects(:name).returns(:mynode)
interp = Object.new
interp.expects(:compile).with(node).returns(:config)
config.expects(:interpreter).returns(interp)
assert_equal(:config, config.send(:compile, node), "Did not return config")
end
def test_set_server_facts
config = Config.new
assert_nothing_raised("Could not call :set_server_facts") do
config.send(:set_server_facts)
end
facts = config.instance_variable_get("@server_facts")
%w{servername serverversion serverip}.each do |fact|
assert(facts.include?(fact), "Config did not set %s fact" % fact)
end
end
def test_translate
# First do a local config
config = Config.new(:Local => true)
assert_equal(:plain, config.send(:translate, :plain), "Attempted to translate local config")
# Now a non-local
config = Config.new(:Local => false)
obj = Object.new
yamld = Object.new
obj.expects(:to_yaml).with(:UseBlock => true).returns(yamld)
CGI.expects(:escape).with(yamld).returns(:translated)
assert_equal(:translated, config.send(:translate, obj), "Did not return translated config")
end
# Check that we're storing the node freshness into the rails db. Hackilicious.
def test_update_node_check
# This is stupid.
config = Config.new
node = Object.new
node.expects(:name).returns(:hostname)
now = Object.new
Time.expects(:now).returns(now)
host = Object.new
host.expects(:last_freshcheck=).with(now)
host.expects(:save)
# Only test the case where rails is there
Puppet[:storeconfigs] = true
Puppet.features.expects(:rails?).returns(true)
Puppet::Rails.expects(:connect)
Puppet::Rails::Host.expects(:find_or_create_by_name).with(:hostname).returns(host)
config.send(:update_node_check, node)
end
def test_version
# First try the case where we can't look up the node
config = Config.new
handler = Object.new
handler.expects(:details).with(:client).returns(false)
config.expects(:node_handler).returns(handler)
interp = Object.new
assert_instance_of(Bignum, config.version(:client), "Did not return configuration version")
# And then when we find the node.
config = Config.new
node = Object.new
handler = Object.new
handler.expects(:details).with(:client).returns(node)
config.expects(:update_node_check).with(node)
config.expects(:node_handler).returns(handler)
interp = Object.new
interp.expects(:configuration_version).returns(:version)
config.expects(:interpreter).returns(interp)
assert_equal(:version, config.version(:client), "Did not return configuration version")
end
end
|