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
|
#!/usr/bin/env ruby
require File.dirname(__FILE__) + '/../lib/puppettest'
require 'puppet'
require 'puppet/util/autoload'
require 'puppettest'
class TestAutoload < Test::Unit::TestCase
include PuppetTest
@things = []
def self.newthing(name)
@things << name
end
def self.thing?(name)
@things.include? name
end
def self.clear
@things.clear
end
def mkfile(name, path)
# Now create a file to load
File.open(path, "w") do |f|
f.puts %{
TestAutoload.newthing(:#{name.to_s})
}
end
end
def mk_loader(name)
dir = tempfile()
$: << dir
cleanup do
$:.delete(dir)
end
Dir.mkdir(dir)
rbdir = File.join(dir, name.to_s)
Dir.mkdir(rbdir)
loader = nil
assert_nothing_raised {
loader = Puppet::Util::Autoload.new(self.class, name)
}
return rbdir, loader
end
def test_load
dir, loader = mk_loader(:yayness)
assert_equal(loader.object_id, Puppet::Util::Autoload[self.class].object_id,
"Did not retrieve loader object by class")
# Make sure we don't fail on missing files
assert_nothing_raised {
assert_equal(false, loader.load(:mything),
"got incorrect return on failed load")
}
# Now create a couple of files for testing
path = File.join(dir, "mything.rb")
mkfile(:mything, path)
opath = File.join(dir, "othing.rb")
mkfile(:othing, opath)
# Now try to actually load it.
assert_nothing_raised {
assert_equal(true, loader.load(:mything),
"got incorrect return on load")
}
assert(loader.loaded?(:mything), "Not considered loaded")
assert(self.class.thing?(:mything),
"Did not get loaded thing")
self.class.clear
[:mything, :othing].each do |thing|
loader.load(thing)
assert(loader.loaded?(thing), "#{thing.to_s} not considered loaded")
assert(loader.loaded?("%s.rb" % thing), "#{thing.to_s} not considered loaded with .rb")
assert(Puppet::Util::Autoload.loaded?("yayness/%s" % thing), "%s not considered loaded by the main class" % thing)
assert(Puppet::Util::Autoload.loaded?("yayness/%s.rb" % thing), "%s not considered loaded by the main class with .rb" % thing)
assert(self.class.thing?(thing),
"Did not get loaded #{thing.to_s}")
end
end
# Make sure that autoload dynamically modifies $: with the libdir as
# appropriate.
def test_searchpath
dir = Puppet[:libdir]
loader = Puppet::Util::Autoload.new(self, "testing")
assert(loader.send(:searchpath).include?(dir), "searchpath does not include the libdir")
end
# This causes very strange behaviour in the tests. We need to make sure we
# require the same path that a user would use, otherwise we'll result in
# a reload of the
def test_require_does_not_cause_reload
loadname = "testing"
loader = Puppet::Util::Autoload.new(self.class, loadname)
basedir = "/some/dir"
dir = File.join(basedir, loadname)
loader.expects(:eachdir).yields(dir)
subname = "instance"
file = File.join(dir, subname) + ".rb"
Dir.expects(:glob).with("#{dir}/*.rb").returns(file)
Kernel.expects(:require).with(File.join(loadname, subname))
loader.loadall
end
def test_searchpath_includes_plugin_dirs
moddir = "/what/ever"
libdir = "/other/dir"
Puppet.settings.stubs(:value).with(:modulepath).returns(moddir)
Puppet.settings.stubs(:value).with(:libdir).returns(libdir)
loadname = "testing"
loader = Puppet::Util::Autoload.new(self.class, loadname)
# Currently, include both plugins and libs.
paths = %w{plugins lib}.inject({}) { |hash, d| hash[d] = File.join(moddir, "testing", d); FileTest.stubs(:directory?).with(hash[d]).returns(true); hash }
Dir.expects(:glob).with("#{moddir}/*/{plugins,lib}").returns(paths.values)
searchpath = loader.searchpath
paths.each do |dir, path|
assert(searchpath.include?(path), "search path did not include path for %s" % dir)
end
end
end
|
