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
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
|
#!/usr/bin/env ruby
$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
require 'puppettest'
require 'facter'
class TestProvider < Test::Unit::TestCase
include PuppetTest
def echo
echo = Puppet::Util.binary("echo")
unless echo
raise "Could not find 'echo' binary; cannot complete test"
end
return echo
end
def newprovider
# Create our provider
provider = Class.new(Puppet::Provider) do
@name = :fakeprovider
end
provider.initvars
return provider
end
def test_confine
provider = newprovider
assert(provider.suitable?,
"Marked unsuitable with no confines")
{
{:true => true} => true,
{:true => false} => false,
{:false => false} => true,
{:false => true} => false,
{:operatingsystem => Facter.value(:operatingsystem)} => true,
{:operatingsystem => :yayness} => false,
{:nothing => :yayness} => false,
{:exists => echo} => true,
{:exists => "/this/file/does/not/exist"} => false,
}.each do |hash, result|
# First test :true
hash.each do |test, val|
assert_nothing_raised do
provider.confine test => val
end
end
assert_equal(result, provider.suitable?,
"Failed for %s" % [hash.inspect])
provider.initvars
end
# Make sure multiple confines don't overwrite each other
provider.confine :true => false
assert(! provider.suitable?)
provider.confine :true => true
assert(! provider.suitable?)
provider.initvars
# Make sure we test multiple of them, and that a single false wins
provider.confine :true => true, :false => false
assert(provider.suitable?)
provider.confine :true => false
assert(! provider.suitable?)
end
def test_command
provider = newprovider
assert_nothing_raised do
provider.commands :echo => "echo"
end
assert_equal(echo, provider.command(:echo))
assert(provider.method_defined?(:echo), "Instance method not defined")
assert(provider.respond_to?(:echo), "Class method not defined")
# Now make sure they both work
inst = provider.new(nil)
assert_nothing_raised do
[provider, inst].each do |thing|
out = thing.echo "some", "text"
assert_equal("some text\n", out)
end
end
assert(provider.suitable?, "Provider considered unsuitable")
# Now add an invalid command
assert_nothing_raised do
provider.commands :fake => "nosuchcommanddefinitely"
end
assert(! provider.suitable?, "Provider considered suitable")
assert_raise(Puppet::Error) do
provider.command(:fake)
end
Puppet[:trace] = false
assert_raise(Puppet::DevError) do
provider.command(:nosuchcmd)
end
# Lastly, verify that we can find our superclass commands
newprov = Class.new(provider)
newprov.initvars
assert_equal(echo, newprov.command(:echo))
end
def test_default?
provider = newprovider
assert(! provider.default?, "Was considered default with no settings")
assert_nothing_raised do
provider.defaultfor :operatingsystem => Facter.value(:operatingsystem)
end
assert(provider.default?, "Was not considered default")
# Make sure any true value is sufficient.
assert_nothing_raised do
provider.defaultfor :operatingsystem => [
:yayness, :rahness,
Facter.value(:operatingsystem)
]
end
assert(provider.default?, "Was not considered default")
# Now make sure that a random setting returns false.
assert_nothing_raised do
provider.defaultfor :operatingsystem => :yayness
end
assert(! provider.default?, "Was considered default")
end
# Make sure that failed commands get their output in the error.
def test_outputonfailure
provider = newprovider
dir = tstdir()
file = File.join(dir, "mycmd")
sh = Puppet::Util.binary("sh")
File.open(file, "w") { |f|
f.puts %{#!#{sh}
echo A Failure >&2
exit 2
}
}
File.chmod(0755, file)
provider.commands :cmd => file
inst = provider.new(nil)
assert_raise(Puppet::ExecutionFailure) do
inst.cmd "some", "arguments"
end
out = nil
begin
inst.cmd "some", "arguments"
rescue Puppet::ExecutionFailure => detail
out = detail.to_s
end
assert(out =~ /A Failure/,
"Did not receive command output on failure")
assert(out =~ /Execution of/,
"Did not receive info wrapper on failure")
end
def test_mkmodelmethods
prov = newprovider
modeltype = Struct.new(:validproperties, :parameters)
m = modeltype.new([:prop1, :prop2], [:param1, :param2])
prov.model = m
assert_nothing_raised("could not call mkmodelmethods") do
prov.mkmodelmethods
end
obj = prov.new(nil)
%w{prop1 prop2 param1 param2}.each do |param|
assert(prov.public_method_defined?(param), "no getter for %s" % param)
assert(prov.public_method_defined?(param + "="), "no setter for %s" % param)
assert_equal(:absent, obj.send(param),
"%s did not default to :absent")
val = "testing %s" % param
assert_nothing_raised("Could not call setter for %s" % param) do
obj.send(param + "=", val)
end
assert_equal(val, obj.send(param),
"did not get correct value for %s" % param)
end
end
end
# $Id$
|
