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
188
189
190
191
192
193
|
#!/usr/bin/env ruby
$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
require 'puppettest'
require 'puppet/parser/interpreter'
require 'puppet/parser/parser'
require 'puppettest/resourcetesting'
require 'puppettest/parsertesting'
require 'puppettest/support/collection'
class TestAST < Test::Unit::TestCase
include PuppetTest::ParserTesting
include PuppetTest::ResourceTesting
include PuppetTest::Support::Collection
def test_if
astif = nil
astelse = nil
fakeelse = FakeAST.new(:else)
faketest = FakeAST.new(true)
fakeif = FakeAST.new(:if)
assert_nothing_raised {
astelse = AST::Else.new(:statements => fakeelse)
}
assert_nothing_raised {
astif = AST::IfStatement.new(
:test => faketest,
:statements => fakeif,
:else => astelse
)
}
# We initialized it to true, so we should get that first
ret = nil
assert_nothing_raised {
ret = astif.evaluate(:scope => "yay")
}
assert_equal(:if, ret)
# Now set it to false and check that
faketest.evaluate = false
assert_nothing_raised {
ret = astif.evaluate(:scope => "yay")
}
assert_equal(:else, ret)
end
# Make sure our override object behaves "correctly"
def test_override
interp, scope, source = mkclassframing
ref = nil
assert_nothing_raised do
ref = resourceoverride("resource", "yaytest", "one" => "yay", "two" => "boo")
end
ret = nil
assert_nothing_raised do
ret = ref.evaluate :scope => scope
end
assert_instance_of(Puppet::Parser::Resource, ret)
assert(ret.override?, "Resource was not an override resource")
assert(scope.overridetable[ret.ref].include?(ret),
"Was not stored in the override table")
end
# make sure our resourcedefaults ast object works correctly.
def test_resourcedefaults
interp, scope, source = mkclassframing
# Now make some defaults for files
args = {:source => "/yay/ness", :group => "yayness"}
assert_nothing_raised do
obj = defaultobj "file", args
obj.evaluate :scope => scope
end
hash = nil
assert_nothing_raised do
hash = scope.lookupdefaults("file")
end
hash.each do |name, value|
assert_instance_of(Symbol, name) # params always convert
assert_instance_of(Puppet::Parser::Resource::Param, value)
end
args.each do |name, value|
assert(hash[name], "Did not get default %s" % name)
assert_equal(value, hash[name].value)
end
end
def test_node
interp = mkinterp
scope = mkscope(:interp => interp)
# Define a base node
basenode = interp.newnode "basenode", :code => AST::ASTArray.new(:children => [
resourcedef("file", "/tmp/base", "owner" => "root")
])
# Now define a subnode
nodes = interp.newnode ["mynode", "othernode"],
:code => AST::ASTArray.new(:children => [
resourcedef("file", "/tmp/mynode", "owner" => "root"),
resourcedef("file", "/tmp/basenode", "owner" => "daemon")
])
assert_instance_of(Array, nodes)
# Make sure we can find them all.
%w{mynode othernode}.each do |node|
assert(interp.nodesearch_code(node), "Could not find %s" % node)
end
mynode = interp.nodesearch_code("mynode")
# Now try evaluating the node
assert_nothing_raised do
mynode.evaluate :scope => scope
end
# Make sure that we can find each of the files
myfile = scope.findresource "File[/tmp/mynode]"
assert(myfile, "Could not find file from node")
assert_equal("root", myfile[:owner])
basefile = scope.findresource "File[/tmp/basenode]"
assert(basefile, "Could not find file from base node")
assert_equal("daemon", basefile[:owner])
# Now make sure we can evaluate nodes with parents
child = interp.newnode(%w{child}, :parent => "basenode").shift
newscope = mkscope :interp => interp
assert_nothing_raised do
child.evaluate :scope => newscope
end
assert(newscope.findresource("File[/tmp/base]"),
"Could not find base resource")
end
def test_collection
interp = mkinterp
scope = mkscope(:interp => interp)
coll = nil
assert_nothing_raised do
coll = AST::Collection.new(:type => "file", :form => :virtual)
end
assert_instance_of(AST::Collection, coll)
ret = nil
assert_nothing_raised do
ret = coll.evaluate :scope => scope
end
assert_instance_of(Puppet::Parser::Collector, ret)
# Now make sure we get it back from the scope
assert_equal([ret], scope.collections)
end
def test_virtual_collexp
@interp, @scope, @source = mkclassframing
# make a resource
resource = mkresource(:type => "file", :title => "/tmp/testing",
:params => {:owner => "root", :group => "bin", :mode => "644"})
run_collection_queries(:virtual) do |string, result, query|
code = nil
assert_nothing_raised do
str, code = query.evaluate :scope => @scope
end
assert_instance_of(Proc, code)
assert_nothing_raised do
assert_equal(result, code.call(resource),
"'#{string}' failed")
end
end
end
end
# $Id$
|
