Changesets can be listed by changeset number.
The Git repository is here.
- Revision:
- 373
- Log:
Initial import of Radiant 0.9.1, which is now packaged as a gem. This is an
import of the tagged 0.9.1 source checked out from GitHub, which isn't quite
the same as the gem distribution - but it doesn't seem to be available in an
archived form and the installed gem already has modifications, so this is
the closest I can get.
- Author:
- rool
- Date:
- Mon Mar 21 13:40:05 +0000 2011
- Size:
- 10521 Bytes
1 | require File.join(File.dirname(__FILE__), 'test_helper') |
2 | |
3 | class RadiusParserTest < Test::Unit::TestCase |
4 | include RadiusTestHelper |
5 | |
6 | def setup |
7 | @context = new_context |
8 | @parser = Radius::Parser.new(@context, :tag_prefix => 'r') |
9 | end |
10 | |
11 | def test_initialize |
12 | @parser = Radius::Parser.new |
13 | assert_kind_of Radius::Context, @parser.context |
14 | end |
15 | |
16 | def test_initialize_with_params |
17 | @parser = Radius::Parser.new(TestContext.new) |
18 | assert_kind_of TestContext, @parser.context |
19 | |
20 | @parser = Radius::Parser.new(:context => TestContext.new) |
21 | assert_kind_of TestContext, @parser.context |
22 | |
23 | @parser = Radius::Parser.new('context' => TestContext.new) |
24 | assert_kind_of TestContext, @parser.context |
25 | |
26 | @parser = Radius::Parser.new(:tag_prefix => 'r') |
27 | assert_kind_of Radius::Context, @parser.context |
28 | assert_equal 'r', @parser.tag_prefix |
29 | |
30 | @parser = Radius::Parser.new(TestContext.new, :tag_prefix => 'r') |
31 | assert_kind_of TestContext, @parser.context |
32 | assert_equal 'r', @parser.tag_prefix |
33 | end |
34 | |
35 | def test_parse_individual_tags_and_parameters |
36 | define_tag "add" do |tag| |
37 | tag.attr["param1"].to_i + tag.attr["param2"].to_i |
38 | end |
39 | assert_parse_output "<3>", %{<<r:add param1="1" param2='2'/>>} |
40 | end |
41 | |
42 | def test_parse_attributes |
43 | attributes = %{{"a"=>"1", "b"=>"2", "c"=>"3", "d"=>"'"}} |
44 | assert_parse_output attributes, %{<r:attr a="1" b='2'c="3"d="'" />} |
45 | assert_parse_output attributes, %{<r:attr a="1" b='2'c="3"d="'"></r:attr>} |
46 | end |
47 | |
48 | def test_parse_attributes_with_slashes_or_angle_brackets |
49 | slash = %{{"slash"=>"/"}} |
50 | angle = %{{"angle"=>">"}} |
51 | assert_parse_output slash, %{<r:attr slash="/"></r:attr>} |
52 | assert_parse_output slash, %{<r:attr slash="/"><r:attr /></r:attr>} |
53 | assert_parse_output angle, %{<r:attr angle=">"></r:attr>} |
54 | end |
55 | |
56 | def test_parse_quotes |
57 | assert_parse_output "test []", %{<r:echo value="test" /> <r:wrap attr="test"></r:wrap>} |
58 | end |
59 | |
60 | def test_things_that_should_be_left_alone |
61 | [ |
62 | %{ test="2"="4" }, |
63 | %{="2" } |
64 | ].each do |middle| |
65 | assert_parsed_is_unchanged "<r:attr#{middle}/>" |
66 | assert_parsed_is_unchanged "<r:attr#{middle}>" |
67 | end |
68 | end |
69 | |
70 | def test_tags_inside_html_tags |
71 | assert_parse_output %{<div class="xzibit">tags in yo tags</div>}, |
72 | %{<div class="<r:reverse>tibizx</r:reverse>">tags in yo tags</div>} |
73 | end |
74 | |
75 | def test_parse_result_is_always_a_string |
76 | define_tag("twelve") { 12 } |
77 | assert_parse_output "12", "<r:twelve />" |
78 | end |
79 | |
80 | def test_parse_double_tags |
81 | assert_parse_output "test".reverse, "<r:reverse>test</r:reverse>" |
82 | assert_parse_output "tset TEST", "<r:reverse>test</r:reverse> <r:capitalize>test</r:capitalize>" |
83 | end |
84 | |
85 | def test_parse_tag_nesting |
86 | define_tag("parent", :for => '') |
87 | define_tag("parent:child", :for => '') |
88 | define_tag("extra", :for => '') |
89 | define_tag("nesting") { |tag| tag.nesting } |
90 | define_tag("extra:nesting") { |tag| tag.nesting.gsub(':', ' > ') } |
91 | define_tag("parent:child:nesting") { |tag| tag.nesting.gsub(':', ' * ') } |
92 | assert_parse_output "nesting", "<r:nesting />" |
93 | assert_parse_output "parent:nesting", "<r:parent:nesting />" |
94 | assert_parse_output "extra > nesting", "<r:extra:nesting />" |
95 | assert_parse_output "parent * child * nesting", "<r:parent:child:nesting />" |
96 | assert_parse_output "parent > extra > nesting", "<r:parent:extra:nesting />" |
97 | assert_parse_output "parent > child > extra > nesting", "<r:parent:child:extra:nesting />" |
98 | assert_parse_output "parent * extra * child * nesting", "<r:parent:extra:child:nesting />" |
99 | assert_parse_output "parent > extra > child > extra > nesting", "<r:parent:extra:child:extra:nesting />" |
100 | assert_parse_output "parent > extra > child > extra > nesting", "<r:parent><r:extra><r:child><r:extra><r:nesting /></r:extra></r:child></r:extra></r:parent>" |
101 | assert_parse_output "extra * parent * child * nesting", "<r:extra:parent:child:nesting />" |
102 | assert_parse_output "extra > parent > nesting", "<r:extra><r:parent:nesting /></r:extra>" |
103 | assert_parse_output "extra * parent * child * nesting", "<r:extra:parent><r:child:nesting /></r:extra:parent>" |
104 | assert_raises(Radius::UndefinedTagError) { @parser.parse("<r:child />") } |
105 | end |
106 | def test_parse_tag_nesting_2 |
107 | define_tag("parent", :for => '') |
108 | define_tag("parent:child", :for => '') |
109 | define_tag("content") { |tag| tag.nesting } |
110 | assert_parse_output 'parent:child:content', '<r:parent><r:child:content /></r:parent>' |
111 | end |
112 | |
113 | def test_parse_tag__binding_do_missing |
114 | define_tag 'test' do |tag| |
115 | tag.missing! |
116 | end |
117 | e = assert_raises(Radius::UndefinedTagError) { @parser.parse("<r:test />") } |
118 | assert_equal "undefined tag `test'", e.message |
119 | end |
120 | |
121 | def test_parse_chirpy_bird |
122 | # :> chirp chirp |
123 | assert_parse_output "<:", "<:" |
124 | end |
125 | |
126 | def test_parse_tag__binding_render_tag |
127 | define_tag('test') { |tag| "Hello #{tag.attr['name']}!" } |
128 | define_tag('hello') { |tag| tag.render('test', tag.attr) } |
129 | assert_parse_output 'Hello John!', '<r:hello name="John" />' |
130 | end |
131 | |
132 | def test_accessing_tag_attributes_through_tag_indexer |
133 | define_tag('test') { |tag| "Hello #{tag['name']}!" } |
134 | assert_parse_output 'Hello John!', '<r:test name="John" />' |
135 | end |
136 | |
137 | def test_parse_tag__binding_render_tag_with_block |
138 | define_tag('test') { |tag| "Hello #{tag.expand}!" } |
139 | define_tag('hello') { |tag| tag.render('test') { tag.expand } } |
140 | assert_parse_output 'Hello John!', '<r:hello>John</r:hello>' |
141 | end |
142 | |
143 | def test_tag_locals |
144 | define_tag "outer" do |tag| |
145 | tag.locals.var = 'outer' |
146 | tag.expand |
147 | end |
148 | define_tag "outer:inner" do |tag| |
149 | tag.locals.var = 'inner' |
150 | tag.expand |
151 | end |
152 | define_tag "outer:var" do |tag| |
153 | tag.locals.var |
154 | end |
155 | assert_parse_output 'outer', "<r:outer><r:var /></r:outer>" |
156 | assert_parse_output 'outer:inner:outer', "<r:outer><r:var />:<r:inner><r:var /></r:inner>:<r:var /></r:outer>" |
157 | assert_parse_output 'outer:inner:outer:inner:outer', "<r:outer><r:var />:<r:inner><r:var />:<r:outer><r:var /></r:outer>:<r:var /></r:inner>:<r:var /></r:outer>" |
158 | assert_parse_output 'outer', "<r:outer:var />" |
159 | end |
160 | |
161 | def test_tag_globals |
162 | define_tag "set" do |tag| |
163 | tag.globals.var = tag.attr['value'] |
164 | '' |
165 | end |
166 | define_tag "var" do |tag| |
167 | tag.globals.var |
168 | end |
169 | assert_parse_output " true false", %{<r:var /> <r:set value="true" /> <r:var /> <r:set value="false" /> <r:var />} |
170 | end |
171 | |
172 | def test_parse_loops |
173 | @item = nil |
174 | define_tag "each" do |tag| |
175 | result = [] |
176 | ["Larry", "Moe", "Curly"].each do |item| |
177 | tag.locals.item = item |
178 | result << tag.expand |
179 | end |
180 | result.join(tag.attr["between"] || "") |
181 | end |
182 | define_tag "each:item" do |tag| |
183 | tag.locals.item |
184 | end |
185 | assert_parse_output %{Three Stooges: "Larry", "Moe", "Curly"}, %{Three Stooges: <r:each between=", ">"<r:item />"</r:each>} |
186 | end |
187 | |
188 | def test_parse_speed |
189 | define_tag "set" do |tag| |
190 | tag.globals.var = tag.attr['value'] |
191 | '' |
192 | end |
193 | define_tag "var" do |tag| |
194 | tag.globals.var |
195 | end |
196 | parts = %w{decima nobis augue at facer processus commodo legentis odio lectorum dolore nulla esse lius qui nonummy ullamcorper erat ii notare} |
197 | multiplier = parts.map{|p| "#{p}=\"#{rand}\""}.join(' ') |
198 | assert_nothing_raised do |
199 | Timeout.timeout(10) do |
200 | assert_parse_output " false", %{<r:set value="false" #{multiplier} /> <r:var />} |
201 | end |
202 | end |
203 | end |
204 | |
205 | def test_tag_option_for |
206 | define_tag 'fun', :for => 'just for kicks' |
207 | assert_parse_output 'just for kicks', '<r:fun />' |
208 | end |
209 | |
210 | def test_tag_expose_option |
211 | define_tag 'user', :for => users.first, :expose => ['name', :age] |
212 | assert_parse_output 'John', '<r:user:name />' |
213 | assert_parse_output '25', '<r:user><r:age /></r:user>' |
214 | e = assert_raises(Radius::UndefinedTagError) { @parser.parse "<r:user:email />" } |
215 | assert_equal "undefined tag `email'", e.message |
216 | end |
217 | |
218 | def test_tag_expose_attributes_option_on_by_default |
219 | define_tag 'user', :for => user_with_attributes |
220 | assert_parse_output 'John', '<r:user:name />' |
221 | end |
222 | def test_tag_expose_attributes_set_to_false |
223 | define_tag 'user_without_attributes', :for => user_with_attributes, :attributes => false |
224 | assert_raises(Radius::UndefinedTagError) { @parser.parse "<r:user_without_attributes:name />" } |
225 | end |
226 | |
227 | def test_tag_options_must_contain_a_for_option_if_methods_are_exposed |
228 | e = assert_raises(ArgumentError) { define_tag('fun', :expose => :today) { 'test' } } |
229 | assert_equal "tag definition must contain a :for option when used with the :expose option", e.message |
230 | end |
231 | |
232 | def test_parse_fail_on_missing_end_tag |
233 | assert_raises(Radius::MissingEndTagError) { @parser.parse("<r:reverse>") } |
234 | end |
235 | |
236 | def test_parse_fail_on_wrong_end_tag |
237 | assert_raises(Radius::WrongEndTagError) { @parser.parse("<r:reverse><r:capitalize></r:reverse>") } |
238 | end |
239 | |
240 | def test_parse_with_default_tag_prefix |
241 | define_tag("hello") { |tag| "Hello world!" } |
242 | @parser = Radius::Parser.new(@context) |
243 | assert_equal "<p>Hello world!</p>", @parser.parse('<p><radius:hello /></p>') |
244 | end |
245 | |
246 | def test_parse_with_other_radius_like_tags |
247 | define_tag('hello') { "hello" } |
248 | @parser = Radius::Parser.new(@context, :tag_prefix => "ralph") |
249 | assert_equal "<r:ralph:hello />", @parser.parse("<r:ralph:hello />") |
250 | end |
251 | |
252 | def test_parse_with_other_namespaces |
253 | @parser = Radius::Parser.new(@context, :tag_prefix => 'r') |
254 | assert_equal "<fb:test>hello world</fb:test>", @parser.parse("<fb:test>hello world</fb:test>") |
255 | end |
256 | |
257 | protected |
258 | |
259 | def assert_parse_output(output, input, message = nil) |
260 | r = @parser.parse(input) |
261 | assert_equal(output, r, message) |
262 | end |
263 | |
264 | def assert_parsed_is_unchanged(something) |
265 | assert_parse_output something, something |
266 | end |
267 | |
268 | class User |
269 | attr_accessor :name, :age, :email, :friend |
270 | def initialize(name, age, email) |
271 | @name, @age, @email = name, age, email |
272 | end |
273 | def <=>(other) |
274 | name <=> other.name |
275 | end |
276 | end |
277 | |
278 | class UserWithAttributes < User |
279 | def attributes |
280 | { :name => name, :age => age, :email => email } |
281 | end |
282 | end |
283 | |
284 | def users |
285 | [ |
286 | User.new('John', 25, 'test@johnwlong.com'), |
287 | User.new('James', 27, 'test@jameslong.com') |
288 | ] |
289 | end |
290 | |
291 | def user_with_attributes |
292 | UserWithAttributes.new('John', 25, 'test@johnwlong.com') |
293 | end |
294 | |
295 | end |