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
|
#!/usr/bin/env ruby
require File.dirname(__FILE__) + '/../../spec_helper'
describe Puppet::Parser::TemplateWrapper do
before(:each) do
@known_resource_types = Puppet::Resource::TypeCollection.new("env")
@compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
@compiler.environment.stubs(:known_resource_types).returns @known_resource_types
@scope = Puppet::Parser::Scope.new :compiler => @compiler
@file = "fake_template"
Puppet::Parser::Files.stubs(:find_template).returns("/tmp/fake_template")
FileTest.stubs(:exists?).returns("true")
File.stubs(:read).with("/tmp/fake_template").returns("template content")
@tw = Puppet::Parser::TemplateWrapper.new(@scope)
end
it "should create a new object TemplateWrapper from a scope" do
tw = Puppet::Parser::TemplateWrapper.new(@scope)
tw.should be_a_kind_of(Puppet::Parser::TemplateWrapper)
end
it "should check template file existance and read its content" do
Puppet::Parser::Files.expects(:find_template).with("fake_template", @scope.environment.to_s).returns("/tmp/fake_template")
@tw.file = @file
end
it "should mark the file for watching" do
full_file_name = given_a_template_file("fake_template", "content")
@known_resource_types.expects(:watch_file).with(full_file_name)
@tw.file = @file
end
it "should fail if a template cannot be found" do
Puppet::Parser::Files.expects(:find_template).returns nil
lambda { @tw.file = @file }.should raise_error(Puppet::ParseError)
end
it "should turn into a string like template[name] for file based template" do
@tw.file = @file
@tw.to_s.should eql("template[/tmp/fake_template]")
end
it "should turn into a string like template[inline] for string-based template" do
@tw.to_s.should eql("template[inline]")
end
it "should return the processed template contents with a call to result" do
template_mock = mock("template", :result => "woot!", :filename= => nil)
File.expects(:read).with("/tmp/fake_template").returns("template contents")
ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
@tw.file = @file
@tw.result.should eql("woot!")
end
it "provides access to the name of the template via #file" do
full_file_name = given_a_template_file("fake_template", "<%= file %>")
@tw.file = "fake_template"
@tw.result.should == full_file_name
end
it "should return the processed template contents with a call to result and a string" do
template_mock = mock("template", :result => "woot!", :filename= => nil)
ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
@tw.result("template contents").should eql("woot!")
end
it "should return the contents of a variable if called via method_missing" do
@scope.expects(:lookupvar).with("chicken", false).returns("is good")
tw = Puppet::Parser::TemplateWrapper.new(@scope)
tw.chicken.should eql("is good")
end
it "should throw an exception if a variable is called via method_missing and it does not exist" do
@scope.expects(:lookupvar).with("chicken", false).returns(:undefined)
tw = Puppet::Parser::TemplateWrapper.new(@scope)
lambda { tw.chicken }.should raise_error(Puppet::ParseError)
end
it "should allow you to check whether a variable is defined with has_variable?" do
@scope.expects(:lookupvar).with("chicken", false).returns("is good")
tw = Puppet::Parser::TemplateWrapper.new(@scope)
tw.has_variable?("chicken").should eql(true)
end
it "should allow you to check whether a variable is not defined with has_variable?" do
@scope.expects(:lookupvar).with("chicken", false).returns(:undefined)
tw = Puppet::Parser::TemplateWrapper.new(@scope)
tw.has_variable?("chicken").should eql(false)
end
it "should allow you to retrieve the defined classes with classes" do
catalog = mock 'catalog', :classes => ["class1", "class2"]
@scope.expects(:catalog).returns( catalog )
tw = Puppet::Parser::TemplateWrapper.new(@scope)
tw.classes.should == ["class1", "class2"]
end
it "should allow you to retrieve all the tags with all_tags" do
catalog = mock 'catalog', :tags => ["tag1", "tag2"]
@scope.expects(:catalog).returns( catalog )
tw = Puppet::Parser::TemplateWrapper.new(@scope)
tw.all_tags.should == ["tag1","tag2"]
end
it "should allow you to retrieve the tags defined in the current scope" do
@scope.expects(:tags).returns( ["tag1", "tag2"] )
tw = Puppet::Parser::TemplateWrapper.new(@scope)
tw.tags.should == ["tag1","tag2"]
end
it "should set all of the scope's variables as instance variables" do
template_mock = mock("template", :result => "woot!", :filename= => nil)
ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
@scope.expects(:to_hash).returns("one" => "foo")
@tw.result("template contents")
@tw.instance_variable_get("@one").should == "foo"
end
it "should not error out if one of the variables is a symbol" do
template_mock = mock("template", :result => "woot!", :filename= => nil)
ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
@scope.expects(:to_hash).returns(:_timestamp => "1234")
@tw.result("template contents")
end
%w{! . ; :}.each do |badchar|
it "should translate #{badchar} to _ when setting the instance variables" do
template_mock = mock("template", :result => "woot!", :filename= => nil)
ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
@scope.expects(:to_hash).returns("one#{badchar}" => "foo")
@tw.result("template contents")
@tw.instance_variable_get("@one_").should == "foo"
end
end
def given_a_template_file(name, contents)
full_name = "/full/path/to/#{name}"
Puppet::Parser::Files.stubs(:find_template).
with(name, anything()).
returns(full_name)
File.stubs(:read).with(full_name).returns(contents)
full_name
end
end
|
