← Back to branch summary

~ubuntu-branches/ubuntu/hardy/ruby1.8/hardy-updates

« back to all changes in this revision

Viewing changes to test/rss/rss-assertions.rb

  • Committer: Bazaar Package Importer
  • Author(s): akira yamada
  • Date: 2007-03-13 22:11:58 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20070313221158-h3oql37brlaf2go2
Tags: 1.8.6-1
http://bugs.debian.org/410018
* new upstream version, 1.8.6.
* libruby1.8 conflicts with libopenssl-ruby1.8 (< 1.8.6) (closes: #410018)
* changed packaging style to cdbs from dbs.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/rss/rss-assertions.rb
 
1
module Test
 
2
  module Unit
 
3
    module Assertions
 
4
      # For backward compatibility
 
5
      unless instance_methods.include?("assert_raise")
 
6
        def assert_raise(*args, &block)
 
7
          assert_raises(*args, &block)
 
8
        end
 
9
      end
 
10
    end
 
11
  end
 
12
end
 
13
 
 
14
module RSS
 
15
  module Assertions
 
16
    
 
17
    def assert_parse(rss, assert_method, *args)
 
18
      __send__("assert_#{assert_method}", *args) do
 
19
        ::RSS::Parser.parse(rss)
 
20
      end
 
21
      __send__("assert_#{assert_method}", *args) do
 
22
        ::RSS::Parser.parse(rss, false).validate
 
23
      end
 
24
    end
 
25
    
 
26
    def assert_ns(prefix, uri)
 
27
      _wrap_assertion do
 
28
        begin
 
29
          yield
 
30
          flunk("Not raise NSError")
 
31
        rescue ::RSS::NSError => e
 
32
          assert_equal(prefix, e.prefix)
 
33
          assert_equal(uri, e.uri)
 
34
        end
 
35
      end
 
36
    end
 
37
    
 
38
    def assert_missing_tag(tag, parent)
 
39
      _wrap_assertion do
 
40
        begin
 
41
          yield
 
42
          flunk("Not raise MissingTagError")
 
43
        rescue ::RSS::MissingTagError => e
 
44
          assert_equal(tag, e.tag)
 
45
          assert_equal(parent, e.parent)
 
46
        end
 
47
      end
 
48
    end
 
49
    
 
50
    def assert_too_much_tag(tag, parent)
 
51
      _wrap_assertion do
 
52
        begin
 
53
          yield
 
54
          flunk("Not raise TooMuchTagError")
 
55
        rescue ::RSS::TooMuchTagError => e
 
56
          assert_equal(tag, e.tag)
 
57
          assert_equal(parent, e.parent)
 
58
        end
 
59
      end
 
60
    end
 
61
    
 
62
    def assert_missing_attribute(tag, attrname)
 
63
      _wrap_assertion do
 
64
        begin
 
65
          yield
 
66
          flunk("Not raise MissingAttributeError")
 
67
        rescue ::RSS::MissingAttributeError => e
 
68
          assert_equal(tag, e.tag)
 
69
          assert_equal(attrname, e.attribute)
 
70
        end
 
71
      end
 
72
    end
 
73
    
 
74
    def assert_not_expected_tag(tag, uri, parent)
 
75
      _wrap_assertion do
 
76
        begin
 
77
          yield
 
78
          flunk("Not raise NotExpectedTagError")
 
79
        rescue ::RSS::NotExpectedTagError => e
 
80
          assert_equal(tag, e.tag)
 
81
          assert_equal(uri, e.uri)
 
82
          assert_equal(parent, e.parent)
 
83
        end
 
84
      end
 
85
    end
 
86
    
 
87
    def assert_not_available_value(tag, value, attribute=nil)
 
88
      _wrap_assertion do
 
89
        begin
 
90
          yield
 
91
          flunk("Not raise NotAvailableValueError")
 
92
        rescue ::RSS::NotAvailableValueError => e
 
93
          assert_equal(tag, e.tag)
 
94
          assert_equal(value, e.value)
 
95
          assert_equal(attribute, e.attribute)
 
96
        end
 
97
      end
 
98
    end
 
99
 
 
100
    def assert_not_set_error(name, variables)
 
101
      _wrap_assertion do
 
102
        begin
 
103
          yield
 
104
          flunk("Not raise NotSetError")
 
105
        rescue ::RSS::NotSetError => e
 
106
          assert_equal(name, e.name)
 
107
          assert_equal(variables.sort, e.variables.sort)
 
108
        end
 
109
      end
 
110
    end
 
111
    
 
112
    def assert_xml_declaration(version, encoding, standalone, rss)
 
113
      _wrap_assertion do
 
114
        assert_equal(version, rss.version)
 
115
        assert_equal(encoding, rss.encoding)
 
116
        assert_equal(standalone, rss.standalone)
 
117
      end
 
118
    end
 
119
    
 
120
    def assert_xml_stylesheet_attrs(attrs, xsl)
 
121
      _wrap_assertion do
 
122
        n_attrs = normalized_attrs(attrs)
 
123
        ::RSS::XMLStyleSheet::ATTRIBUTES.each do |name|
 
124
          assert_equal(n_attrs[name], xsl.__send__(name))
 
125
        end
 
126
      end
 
127
    end
 
128
    
 
129
    def assert_xml_stylesheet(target, attrs, xsl)
 
130
      _wrap_assertion do
 
131
        if attrs.has_key?(:href)
 
132
          if !attrs.has_key?(:type) and attrs.has_key?(:guess_type)
 
133
            attrs[:type] = attrs[:guess_type]
 
134
          end
 
135
          assert_equal("xml-stylesheet", target)
 
136
          assert_xml_stylesheet_attrs(attrs, xsl)
 
137
        else
 
138
          assert_nil(target)
 
139
          assert_equal("", xsl.to_s)
 
140
        end
 
141
      end
 
142
    end
 
143
    
 
144
    def assert_xml_stylesheet_pis(attrs_ary, rss=nil)
 
145
      _wrap_assertion do
 
146
        rss ||= ::RSS::RDF.new()
 
147
        xss_strs = []
 
148
        attrs_ary.each do |attrs|
 
149
          xss = ::RSS::XMLStyleSheet.new(*attrs)
 
150
          xss_strs.push(xss.to_s)
 
151
          rss.xml_stylesheets.push(xss)
 
152
        end
 
153
        pi_str = rss.to_s.gsub(/<\?xml .*\n/, "").gsub(/\s*<[^\?].*\z/m, "")
 
154
        assert_equal(xss_strs.join("\n"), pi_str)
 
155
      end
 
156
    end
 
157
 
 
158
    def assert_xml_stylesheets(attrs, xss)
 
159
      _wrap_assertion do
 
160
        xss.each_with_index do |xs, i|
 
161
          assert_xml_stylesheet_attrs(attrs[i], xs)
 
162
        end
 
163
      end
 
164
    end
 
165
 
 
166
    
 
167
    def assert_channel10(attrs, channel)
 
168
      _wrap_assertion do
 
169
        n_attrs = normalized_attrs(attrs)
 
170
        
 
171
        names = %w(about title link description)
 
172
        assert_attributes(attrs, names, channel)
 
173
 
 
174
        %w(image items textinput).each do |name|
 
175
          value = n_attrs[name]
 
176
          if value
 
177
            target = channel.__send__(name)
 
178
            __send__("assert_channel10_#{name}", value, target)
 
179
          end
 
180
        end
 
181
      end
 
182
    end
 
183
 
 
184
    def assert_channel10_image(attrs, image)
 
185
      _wrap_assertion do
 
186
        assert_attributes(attrs, %w(resource), image)
 
187
      end
 
188
    end
 
189
    
 
190
    def assert_channel10_textinput(attrs, textinput)
 
191
      _wrap_assertion do
 
192
        assert_attributes(attrs, %w(resource), textinput)
 
193
      end
 
194
    end
 
195
 
 
196
    def assert_channel10_items(attrs, items)
 
197
      _wrap_assertion do
 
198
        assert_equal(items.resources, items.Seq.lis.collect {|x| x.resource})
 
199
        items.Seq.lis.each_with_index do |li, i|
 
200
          assert_attributes(attrs[i], %w(resource), li)
 
201
        end
 
202
      end
 
203
    end
 
204
 
 
205
    def assert_image10(attrs, image)
 
206
      _wrap_assertion do
 
207
        names = %w(about title url link)
 
208
        assert_attributes(attrs, names, image)
 
209
      end
 
210
    end
 
211
 
 
212
    def assert_items10(attrs, items)
 
213
      _wrap_assertion do
 
214
        names = %w(about title link description)
 
215
        items.each_with_index do |item, i|
 
216
          assert_attributes(attrs[i], names, item)
 
217
        end
 
218
      end
 
219
    end
 
220
 
 
221
    def assert_textinput10(attrs, textinput)
 
222
      _wrap_assertion do
 
223
        names = %w(about title description name link)
 
224
        assert_attributes(attrs, names, textinput)
 
225
      end
 
226
    end
 
227
 
 
228
 
 
229
    def assert_channel09(attrs, channel)
 
230
      _wrap_assertion do
 
231
        n_attrs = normalized_attrs(attrs)
 
232
 
 
233
        names = %w(title description link language rating
 
234
                   copyright pubDate lastBuildDate docs
 
235
                   managingEditor webMaster)
 
236
        assert_attributes(attrs, names, channel)
 
237
        
 
238
        %w(skipHours skipDays).each do |name|
 
239
          value = n_attrs[name]
 
240
          if value
 
241
            target = channel.__send__(name)
 
242
            __send__("assert_channel09_#{name}", value, target)
 
243
          end
 
244
        end
 
245
      end
 
246
    end
 
247
 
 
248
    def assert_channel09_skipDays(contents, skipDays)
 
249
      _wrap_assertion do
 
250
        days = skipDays.days
 
251
        contents.each_with_index do |content, i|
 
252
          assert_equal(content, days[i].content)
 
253
        end
 
254
      end
 
255
    end
 
256
    
 
257
    def assert_channel09_skipHours(contents, skipHours)
 
258
      _wrap_assertion do
 
259
        hours = skipHours.hours
 
260
        contents.each_with_index do |content, i|
 
261
          assert_equal(content.to_i, hours[i].content)
 
262
        end
 
263
      end
 
264
    end
 
265
    
 
266
    def assert_image09(attrs, image)
 
267
      _wrap_assertion do
 
268
        names = %w(url link title description)
 
269
        names << ["width", :integer]
 
270
        names << ["height", :integer]
 
271
        assert_attributes(attrs, names, image)
 
272
      end
 
273
    end
 
274
 
 
275
    def assert_items09(attrs, items)
 
276
      _wrap_assertion do
 
277
        names = %w(title link description)
 
278
        items.each_with_index do |item, i|
 
279
          assert_attributes(attrs[i], names, item)
 
280
        end
 
281
      end
 
282
    end
 
283
    
 
284
    def assert_textinput09(attrs, textinput)
 
285
      _wrap_assertion do
 
286
        names = %w(title description name link)
 
287
        assert_attributes(attrs, names, textinput)
 
288
      end
 
289
    end
 
290
 
 
291
 
 
292
    def assert_channel20(attrs, channel)
 
293
      _wrap_assertion do
 
294
        n_attrs = normalized_attrs(attrs)
 
295
        
 
296
        names = %w(title link description language copyright
 
297
                   managingEditor webMaster pubDate
 
298
                   lastBuildDate generator docs rating)
 
299
        names << ["ttl", :integer]
 
300
        assert_attributes(attrs, names, channel)
 
301
 
 
302
        %w(cloud categories skipHours skipDays).each do |name|
 
303
          value = n_attrs[name]
 
304
          if value
 
305
            target = channel.__send__(name)
 
306
            __send__("assert_channel20_#{name}", value, target)
 
307
          end
 
308
        end
 
309
      end
 
310
    end
 
311
 
 
312
    def assert_channel20_skipDays(contents, skipDays)
 
313
      assert_channel09_skipDays(contents, skipDays)
 
314
    end
 
315
    
 
316
    def assert_channel20_skipHours(contents, skipHours)
 
317
      assert_channel09_skipHours(contents, skipHours)
 
318
    end
 
319
    
 
320
    def assert_channel20_cloud(attrs, cloud)
 
321
      _wrap_assertion do
 
322
        names = %w(domain path registerProcedure protocol)
 
323
        names << ["port", :integer]
 
324
        assert_attributes(attrs, names, cloud)
 
325
      end
 
326
    end
 
327
    
 
328
    def assert_channel20_categories(attrs, categories)
 
329
      _wrap_assertion do
 
330
        names = %w(domain content)
 
331
        categories.each_with_index do |category, i|
 
332
          assert_attributes(attrs[i], names, category)
 
333
        end
 
334
      end
 
335
    end
 
336
    
 
337
    def assert_image20(attrs, image)
 
338
      _wrap_assertion do
 
339
        names = %w(url link title description)
 
340
        names << ["width", :integer]
 
341
        names << ["height", :integer]
 
342
        assert_attributes(attrs, names, image)
 
343
      end
 
344
    end
 
345
 
 
346
    def assert_items20(attrs, items)
 
347
      _wrap_assertion do
 
348
        names = %w(about title link description)
 
349
        items.each_with_index do |item, i|
 
350
          assert_attributes(attrs[i], names, item)
 
351
 
 
352
          n_attrs = normalized_attrs(attrs[i])
 
353
 
 
354
          %w(source enclosure categories guid).each do |name|
 
355
            value = n_attrs[name]
 
356
            if value
 
357
              target = item.__send__(name)
 
358
              __send__("assert_items20_#{name}", value, target)
 
359
            end
 
360
          end
 
361
        end
 
362
      end
 
363
    end
 
364
 
 
365
    def assert_items20_source(attrs, source)
 
366
      _wrap_assertion do
 
367
        assert_attributes(attrs, %w(url content), source)
 
368
      end
 
369
    end
 
370
    
 
371
    def assert_items20_enclosure(attrs, enclosure)
 
372
      _wrap_assertion do
 
373
        names = ["url", ["length", :integer], "type"]
 
374
        assert_attributes(attrs, names, enclosure)
 
375
      end
 
376
    end
 
377
    
 
378
    def assert_items20_categories(attrs, categories)
 
379
      _wrap_assertion do
 
380
        assert_channel20_categories(attrs, categories)
 
381
      end
 
382
    end
 
383
    
 
384
    def assert_items20_guid(attrs, guid)
 
385
      _wrap_assertion do
 
386
        names = [["isPermaLink", :boolean], ["content"]]
 
387
        assert_attributes(attrs, names, guid)
 
388
      end
 
389
    end
 
390
 
 
391
    def assert_textinput20(attrs, textinput)
 
392
      _wrap_assertion do
 
393
        names = %w(title description name link)
 
394
        assert_attributes(attrs, names, textinput)
 
395
      end
 
396
    end
 
397
 
 
398
 
 
399
    def assert_dublin_core(elems, target)
 
400
      _wrap_assertion do
 
401
        elems.each do |name, value|
 
402
          assert_equal(value, target.__send__("dc_#{name}"))
 
403
        end
 
404
      end
 
405
    end
 
406
    
 
407
    def assert_multiple_dublin_core(elems, target)
 
408
      _wrap_assertion do
 
409
        elems.each do |name, values, plural|
 
410
          plural ||= "#{name}s"
 
411
          actual = target.__send__("dc_#{plural}").collect{|x| x.value}
 
412
          assert_equal(values, actual)
 
413
        end
 
414
      end
 
415
    end
 
416
    
 
417
    def assert_syndication(elems, target)
 
418
      _wrap_assertion do
 
419
        elems.each do |name, value|
 
420
          meth = "sy_#{name}"
 
421
          value = value.to_i if meth == "sy_updateFrequency"
 
422
          assert_equal(value, target.__send__(meth ))
 
423
        end
 
424
      end
 
425
    end
 
426
    
 
427
    def assert_content(elems, target)
 
428
      _wrap_assertion do
 
429
        elems.each do |name, value|
 
430
          assert_equal(value, target.__send__("content_#{name}"))
 
431
        end
 
432
      end
 
433
    end
 
434
    
 
435
    def assert_trackback(attrs, target)
 
436
      _wrap_assertion do
 
437
        n_attrs = normalized_attrs(attrs)
 
438
        if n_attrs["ping"]
 
439
          assert_equal(n_attrs["ping"], target.trackback_ping)
 
440
        end
 
441
        if n_attrs["abouts"]
 
442
          n_attrs["abouts"].each_with_index do |about, i|
 
443
            assert_equal(about, target.trackback_abouts[i].value)
 
444
          end
 
445
        end
 
446
      end
 
447
    end
 
448
 
 
449
    def assert_taxo_topic(topics, target)
 
450
      _wrap_assertion do
 
451
        topics.each_with_index do |topic, i|
 
452
          taxo_topic = target.taxo_topics[i]
 
453
          topic.each do |name, value|
 
454
            case name
 
455
            when :link
 
456
              assert_equal(value, taxo_topic.about)
 
457
              assert_equal(value, taxo_topic.taxo_link)
 
458
            when :topics
 
459
              assert_equal(value, taxo_topic.taxo_topics.resources)
 
460
            else
 
461
              assert_equal(value, taxo_topic.__send__("dc_#{name}"))
 
462
            end
 
463
          end
 
464
        end
 
465
      end
 
466
    end
 
467
 
 
468
 
 
469
    def assert_attributes(attrs, names, target)
 
470
      _wrap_assertion do
 
471
        n_attrs = normalized_attrs(attrs)
 
472
        names.each do |info|
 
473
          if info.is_a?(String)
 
474
            name = info
 
475
            type = nil
 
476
          else
 
477
            name, type = info
 
478
          end
 
479
          value = n_attrs[name]
 
480
          if value.is_a?(Time)
 
481
            actual = target.__send__(name)
 
482
            assert_instance_of(Time, actual)
 
483
            assert_equal(value.to_i, actual.to_i)
 
484
          elsif value
 
485
            case type
 
486
            when :integer
 
487
              value = value.to_i
 
488
            when :boolean
 
489
              value = value == "true" if value.is_a?(String)
 
490
            end
 
491
            assert_equal(value, target.__send__(name))
 
492
          end
 
493
        end
 
494
      end
 
495
    end
 
496
    
 
497
    def normalized_attrs(attrs)
 
498
      n_attrs = {}
 
499
      attrs.each do |name, value|
 
500
        n_attrs[name.to_s] = value
 
501
      end
 
502
      n_attrs
 
503
    end
 
504
    
 
505
  end
 
506
end