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
|
#!/usr/bin/env ruby
require File.dirname(__FILE__) + '/../../../spec_helper'
describe Puppet::Parser::Resource::Reference do
before do
@type = Puppet::Parser::Resource::Reference
end
it "should get its environment from its scope" do
env = stub 'environment'
scope = stub 'scope', :environment => env
@type.new(:title => "foo", :type => "bar", :scope => scope).environment.should equal(env)
end
it "should use the resource type collection helper to find its known resource types" do
Puppet::Parser::Resource::Reference.ancestors.should include(Puppet::Resource::TypeCollectionHelper)
end
it "should use the file lookup module" do
Puppet::Parser::Resource::Reference.ancestors.should be_include(Puppet::FileCollection::Lookup)
end
it "should require a type" do
proc { @type.new(:title => "yay") }.should raise_error(Puppet::DevError)
end
it "should require a title" do
proc { @type.new(:type => "file") }.should raise_error(Puppet::DevError)
end
it "should know when it refers to a builtin type" do
ref = @type.new(:type => "file", :title => "/tmp/yay")
ref.builtin?.should be_true
ref.builtintype.should equal(Puppet::Type.type(:file))
end
it "should return a downcased relationship-style resource reference for defined types" do
ref = @type.new(:type => "file", :title => "/tmp/yay")
ref.to_ref.should == ["file", "/tmp/yay"]
end
it "should return a capitalized relationship-style resource reference for defined types" do
ref = @type.new(:type => "whatever", :title => "/tmp/yay")
ref.to_ref.should == ["Whatever", "/tmp/yay"]
end
it "should return a resource reference string when asked" do
ref = @type.new(:type => "file", :title => "/tmp/yay")
ref.to_s.should == "File[/tmp/yay]"
end
it "should canonize resource reference types" do
ref = @type.new(:type => "foo::bar", :title => "/tmp/yay")
ref.to_s.should == "Foo::Bar[/tmp/yay]"
end
it "should canonize resource reference values" do
ref = @type.new(:type => "file", :title => "/tmp/yay/")
ref.to_s.should == "File[/tmp/yay]"
end
it "should canonize resource reference values without order dependencies" do
args = [[:title, "/tmp/yay/"], [:type, "file"]]
ref = @type.new(args)
ref.to_s.should == "File[/tmp/yay]"
end
end
describe Puppet::Parser::Resource::Reference, " when modeling defined types" do
def newclass(name)
@known_resource_types.add Puppet::Resource::Type.new(:hostclass, name)
end
def newdefine(name)
@known_resource_types.add Puppet::Resource::Type.new(:definition, name)
end
def newnode(name)
@known_resource_types.add Puppet::Resource::Type.new(:node, name)
end
before do
@type = Puppet::Parser::Resource::Reference
@known_resource_types = Puppet::Resource::TypeCollection.new("myenv")
@definition = newdefine("mydefine")
@class = newclass("myclass")
@nodedef = newnode("mynode")
@node = Puppet::Node.new("yaynode")
@compiler = Puppet::Parser::Compiler.new(@node)
@compiler.environment.stubs(:known_resource_types).returns @known_resource_types
end
it "should be able to find defined types" do
ref = @type.new(:type => "mydefine", :title => "/tmp/yay", :scope => @compiler.topscope)
ref.builtin?.should be_false
ref.definedtype.should equal(@definition)
end
it "should be able to find classes" do
ref = @type.new(:type => "class", :title => "myclass", :scope => @compiler.topscope)
ref.builtin?.should be_false
ref.definedtype.should equal(@class)
end
it "should be able to find nodes" do
ref = @type.new(:type => "node", :title => "mynode", :scope => @compiler.topscope)
ref.builtin?.should be_false
ref.definedtype.object_id.should == @nodedef.object_id
end
it "should only look for fully qualified classes" do
top = newclass "top"
sub = newclass "other::top"
scope = @compiler.topscope.class.new(:parent => @compiler.topscope, :namespace => "other", :compiler => @compiler)
ref = @type.new(:type => "class", :title => "top", :scope => scope)
ref.definedtype.name.should equal(top.name)
end
it "should only look for fully qualified definitions" do
top = newdefine "top"
sub = newdefine "other::top"
scope = @compiler.topscope.class.new(:parent => @compiler.topscope, :namespace => "other", :compiler => @compiler)
ref = @type.new(:type => "top", :title => "foo", :scope => scope)
ref.definedtype.name.should equal(top.name)
end
end
|
