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
|
#!/usr/bin/env rspec
require 'spec_helper'
require 'puppet/parser/files'
describe Puppet::Parser::Files do
before do
@basepath = Puppet.features.posix? ? "/somepath" : "C:/somepath"
end
it "should have a method for finding a template" do
Puppet::Parser::Files.should respond_to(:find_template)
end
it "should have a method for finding manifests" do
Puppet::Parser::Files.should respond_to(:find_manifests)
end
describe "when searching for templates" do
it "should return fully-qualified templates directly" do
Puppet::Parser::Files.expects(:modulepath).never
Puppet::Parser::Files.find_template(@basepath + "/my/template").should == @basepath + "/my/template"
end
it "should return the template from the first found module" do
mod = mock 'module'
Puppet::Node::Environment.new.expects(:module).with("mymod").returns mod
mod.expects(:template).returns("/one/mymod/templates/mytemplate")
Puppet::Parser::Files.find_template("mymod/mytemplate").should == "/one/mymod/templates/mytemplate"
end
it "should return the file in the templatedir if it exists" do
Puppet.settings.expects(:value).with(:templatedir, nil).returns("/my/templates")
Puppet[:modulepath] = "/one:/two"
File.stubs(:directory?).returns(true)
FileTest.stubs(:exist?).returns(true)
Puppet::Parser::Files.find_template("mymod/mytemplate").should == "/my/templates/mymod/mytemplate"
end
it "should not raise an error if no valid templatedir exists and the template exists in a module" do
mod = mock 'module'
Puppet::Node::Environment.new.expects(:module).with("mymod").returns mod
mod.expects(:template).returns("/one/mymod/templates/mytemplate")
Puppet::Parser::Files.stubs(:templatepath).with(nil).returns(nil)
Puppet::Parser::Files.find_template("mymod/mytemplate").should == "/one/mymod/templates/mytemplate"
end
it "should return unqualified templates if they exist in the template dir" do
FileTest.stubs(:exist?).returns true
Puppet::Parser::Files.stubs(:templatepath).with(nil).returns(["/my/templates"])
Puppet::Parser::Files.find_template("mytemplate").should == "/my/templates/mytemplate"
end
it "should only return templates if they actually exist" do
FileTest.expects(:exist?).with("/my/templates/mytemplate").returns true
Puppet::Parser::Files.stubs(:templatepath).with(nil).returns(["/my/templates"])
Puppet::Parser::Files.find_template("mytemplate").should == "/my/templates/mytemplate"
end
it "should return nil when asked for a template that doesn't exist" do
FileTest.expects(:exist?).with("/my/templates/mytemplate").returns false
Puppet::Parser::Files.stubs(:templatepath).with(nil).returns(["/my/templates"])
Puppet::Parser::Files.find_template("mytemplate").should be_nil
end
it "should search in the template directories before modules" do
FileTest.stubs(:exist?).returns true
Puppet::Parser::Files.stubs(:templatepath).with(nil).returns(["/my/templates"])
Puppet::Module.expects(:find).never
Puppet::Parser::Files.find_template("mytemplate")
end
it "should accept relative templatedirs" do
FileTest.stubs(:exist?).returns true
Puppet[:templatedir] = "my/templates"
File.expects(:directory?).with(File.join(Dir.getwd,"my/templates")).returns(true)
Puppet::Parser::Files.find_template("mytemplate").should == File.join(Dir.getwd,"my/templates/mytemplate")
end
it "should use the environment templatedir if no module is found and an environment is specified" do
FileTest.stubs(:exist?).returns true
Puppet::Parser::Files.stubs(:templatepath).with("myenv").returns(["/myenv/templates"])
Puppet::Parser::Files.find_template("mymod/mytemplate", "myenv").should == "/myenv/templates/mymod/mytemplate"
end
it "should use first dir from environment templatedir if no module is found and an environment is specified" do
FileTest.stubs(:exist?).returns true
Puppet::Parser::Files.stubs(:templatepath).with("myenv").returns(["/myenv/templates", "/two/templates"])
Puppet::Parser::Files.find_template("mymod/mytemplate", "myenv").should == "/myenv/templates/mymod/mytemplate"
end
it "should use a valid dir when templatedir is a path for unqualified templates and the first dir contains template" do
Puppet::Parser::Files.stubs(:templatepath).returns(["/one/templates", "/two/templates"])
FileTest.expects(:exist?).with("/one/templates/mytemplate").returns(true)
Puppet::Parser::Files.find_template("mytemplate").should == "/one/templates/mytemplate"
end
it "should use a valid dir when templatedir is a path for unqualified templates and only second dir contains template" do
Puppet::Parser::Files.stubs(:templatepath).returns(["/one/templates", "/two/templates"])
FileTest.expects(:exist?).with("/one/templates/mytemplate").returns(false)
FileTest.expects(:exist?).with("/two/templates/mytemplate").returns(true)
Puppet::Parser::Files.find_template("mytemplate").should == "/two/templates/mytemplate"
end
it "should use the node environment if specified" do
mod = mock 'module'
Puppet::Node::Environment.new("myenv").expects(:module).with("mymod").returns mod
mod.expects(:template).returns("/my/modules/mymod/templates/envtemplate")
Puppet::Parser::Files.find_template("mymod/envtemplate", "myenv").should == "/my/modules/mymod/templates/envtemplate"
end
it "should return nil if no template can be found" do
Puppet::Parser::Files.find_template("foomod/envtemplate", "myenv").should be_nil
end
after { Puppet.settings.clear }
end
describe "when searching for manifests" do
it "should ignore invalid modules" do
mod = mock 'module'
Puppet::Node::Environment.new.expects(:module).with("mymod").raises(Puppet::Module::InvalidName, "name is invalid")
Puppet.expects(:value).with(:modulepath).never
Dir.stubs(:glob).returns %w{foo}
Puppet::Parser::Files.find_manifests("mymod/init.pp")
end
end
describe "when searching for manifests when no module is found" do
before do
File.stubs(:find).returns(nil)
end
it "should not look for modules when paths are fully qualified" do
Puppet.expects(:value).with(:modulepath).never
file = @basepath + "/fully/qualified/file.pp"
Dir.stubs(:glob).with(file).returns([file])
Puppet::Parser::Files.find_manifests(file)
end
it "should return nil and an array of fully qualified files" do
file = @basepath + "/fully/qualified/file.pp"
Dir.stubs(:glob).with(file).returns([file])
Puppet::Parser::Files.find_manifests(file).should == [nil, [file]]
end
it "should match against provided fully qualified patterns" do
pattern = @basepath + "/fully/qualified/pattern/*"
Dir.expects(:glob).with(pattern+'{.pp,.rb}').returns(%w{my file list})
Puppet::Parser::Files.find_manifests(pattern)[1].should == %w{my file list}
end
it "should look for files relative to the current directory" do
cwd = Dir.getwd
Dir.expects(:glob).with("#{cwd}/foobar/init.pp").returns(["#{cwd}/foobar/init.pp"])
Puppet::Parser::Files.find_manifests("foobar/init.pp")[1].should == ["#{cwd}/foobar/init.pp"]
end
it "should only return files, not directories" do
pattern = @basepath + "/fully/qualified/pattern/*"
file = @basepath + "/my/file"
dir = @basepath + "/my/directory"
Dir.expects(:glob).with(pattern+'{.pp,.rb}').returns([file, dir])
FileTest.expects(:directory?).with(file).returns(false)
FileTest.expects(:directory?).with(dir).returns(true)
Puppet::Parser::Files.find_manifests(pattern)[1].should == [file]
end
it "should return files once only" do
pattern = @basepath + "/fully/qualified/pattern/*"
Dir.expects(:glob).with(pattern+'{.pp,.rb}').returns(%w{one two one})
Puppet::Parser::Files.find_manifests(pattern)[1].should == %w{one two}
end
end
describe "when searching for manifests in a found module" do
it "should return the name of the module and the manifests from the first found module" do
mod = Puppet::Module.new("mymod")
Puppet::Node::Environment.new.expects(:module).with("mymod").returns mod
mod.expects(:match_manifests).with("init.pp").returns(%w{/one/mymod/manifests/init.pp})
Puppet::Parser::Files.find_manifests("mymod/init.pp").should == ["mymod", ["/one/mymod/manifests/init.pp"]]
end
it "should use the node environment if specified" do
mod = Puppet::Module.new("mymod")
Puppet::Node::Environment.new("myenv").expects(:module).with("mymod").returns mod
mod.expects(:match_manifests).with("init.pp").returns(%w{/one/mymod/manifests/init.pp})
Puppet::Parser::Files.find_manifests("mymod/init.pp", :environment => "myenv")[1].should == ["/one/mymod/manifests/init.pp"]
end
after { Puppet.settings.clear }
end
end
|
