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
|
require File.dirname(__FILE__) + '/abstract_unit'
#require 'dependencies'
class DependenciesTest < Test::Unit::TestCase
def teardown
Dependencies.clear
end
def with_loading(from_dir = nil)
prior_path = $LOAD_PATH.clone
$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/#{from_dir}" if from_dir
old_mechanism, Dependencies.mechanism = Dependencies.mechanism, :load
yield
ensure
$LOAD_PATH.clear
$LOAD_PATH.concat prior_path
Dependencies.mechanism = old_mechanism
end
def test_tracking_loaded_files
require_dependency(File.dirname(__FILE__) + "/dependencies/service_one")
require_dependency(File.dirname(__FILE__) + "/dependencies/service_two")
assert_equal 2, Dependencies.loaded.size
end
def test_tracking_identical_loaded_files
require_dependency(File.dirname(__FILE__) + "/dependencies/service_one")
require_dependency(File.dirname(__FILE__) + "/dependencies/service_one")
assert_equal 1, Dependencies.loaded.size
end
def test_missing_dependency_raises_missing_source_file
assert_raises(MissingSourceFile) { require_dependency("missing_service") }
end
def test_missing_association_raises_nothing
assert_nothing_raised { require_association("missing_model") }
end
def test_dependency_which_raises_exception_isnt_added_to_loaded_set
with_loading do
filename = "#{File.dirname(__FILE__)}/dependencies/raises_exception"
$raises_exception_load_count = 0
5.times do |count|
assert_raises(RuntimeError) { require_dependency filename }
assert_equal count + 1, $raises_exception_load_count
assert !Dependencies.loaded.include?(filename)
assert !Dependencies.history.include?(filename)
end
end
end
def test_warnings_should_be_enabled_on_first_load
with_loading do
old_warnings, Dependencies.warnings_on_first_load = Dependencies.warnings_on_first_load, true
filename = "#{File.dirname(__FILE__)}/dependencies/check_warnings"
$check_warnings_load_count = 0
assert !Dependencies.loaded.include?(filename)
assert !Dependencies.history.include?(filename)
silence_warnings { require_dependency filename }
assert_equal 1, $check_warnings_load_count
assert_equal true, $checked_verbose, 'On first load warnings should be enabled.'
assert Dependencies.loaded.include?(filename)
Dependencies.clear
assert !Dependencies.loaded.include?(filename)
assert Dependencies.history.include?(filename)
silence_warnings { require_dependency filename }
assert_equal 2, $check_warnings_load_count
assert_equal nil, $checked_verbose, 'After first load warnings should be left alone.'
assert Dependencies.loaded.include?(filename)
Dependencies.clear
assert !Dependencies.loaded.include?(filename)
assert Dependencies.history.include?(filename)
enable_warnings { require_dependency filename }
assert_equal 3, $check_warnings_load_count
assert_equal true, $checked_verbose, 'After first load warnings should be left alone.'
assert Dependencies.loaded.include?(filename)
end
end
def test_mutual_dependencies_dont_infinite_loop
with_loading 'dependencies' do
$mutual_dependencies_count = 0
assert_nothing_raised { require_dependency 'mutual_one' }
assert_equal 2, $mutual_dependencies_count
Dependencies.clear
$mutual_dependencies_count = 0
assert_nothing_raised { require_dependency 'mutual_two' }
assert_equal 2, $mutual_dependencies_count
end
end
def test_as_load_path
assert_equal '', DependenciesTest.as_load_path
end
def test_module_loading
with_loading 'autoloading_fixtures' do
assert_kind_of Module, A
assert_kind_of Class, A::B
assert_kind_of Class, A::C::D
assert_kind_of Class, A::C::E::F
end
end
def test_non_existing_const_raises_name_error
with_loading 'autoloading_fixtures' do
assert_raises(NameError) { DoesNotExist }
assert_raises(NameError) { NoModule::DoesNotExist }
assert_raises(NameError) { A::DoesNotExist }
assert_raises(NameError) { A::B::DoesNotExist }
end
end
def test_directories_should_manifest_as_modules
with_loading 'autoloading_fixtures' do
assert_kind_of Module, ModuleFolder
Object.send :remove_const, :ModuleFolder
end
end
def test_nested_class_access
with_loading 'autoloading_fixtures' do
assert_kind_of Class, ModuleFolder::NestedClass
Object.send :remove_const, :ModuleFolder
end
end
def test_nested_class_can_access_sibling
with_loading 'autoloading_fixtures' do
sibling = ModuleFolder::NestedClass.class_eval "NestedSibling"
assert defined?(ModuleFolder::NestedSibling)
assert_equal ModuleFolder::NestedSibling, sibling
Object.send :remove_const, :ModuleFolder
end
end
def failing_test_access_thru_and_upwards_fails
with_loading 'autoloading_fixtures' do
assert ! defined?(ModuleFolder)
assert_raises(NameError) { ModuleFolder::Object }
assert_raises(NameError) { ModuleFolder::NestedClass::Object }
Object.send :remove_const, :ModuleFolder
end
end
def test_non_existing_const_raises_name_error_with_fully_qualified_name
with_loading 'autoloading_fixtures' do
begin
A::DoesNotExist
flunk "No raise!!"
rescue NameError => e
assert_equal "uninitialized constant A::DoesNotExist", e.message
end
begin
A::B::DoesNotExist
flunk "No raise!!"
rescue NameError => e
assert_equal "uninitialized constant A::B::DoesNotExist", e.message
end
end
end
def test_smart_name_error_strings
begin
Object.module_eval "ImaginaryObject"
flunk "No raise!!"
rescue NameError => e
assert e.message.include?("uninitialized constant ImaginaryObject")
end
end
end
|
