← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/ruby1.9/intrepid-updates

« back to all changes in this revision

Viewing changes to test/rss/test_maker_atom_entry.rb

  • Committer: Bazaar Package Importer
  • Author(s): akira yamada
  • Date: 2007-05-21 14:00:19 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070521140019-ui4zd0v80duktssk
Tags: 1.9.0+20070521-1
http://bugs.debian.org/414856
http://bugs.debian.org/388344
new upstream snapshot. (2006-07-21)  (Closes: #414856, #388344)

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/rss/test_maker_atom_entry.rb
 
1
require "rss-testcase"
 
2
 
 
3
require "rss/maker"
 
4
 
 
5
module RSS
 
6
  class TestMakerAtomEntry < TestCase
 
7
    def test_root_element
 
8
      entry = Maker.make("atom:entry") do |maker|
 
9
        setup_dummy_channel_atom(maker)
 
10
        setup_dummy_item_atom(maker)
 
11
      end
 
12
      assert_equal(["atom", "1.0", "entry"], entry.feed_info)
 
13
 
 
14
      entry = Maker.make("atom:entry") do |maker|
 
15
        setup_dummy_channel_atom(maker)
 
16
        setup_dummy_item_atom(maker)
 
17
        maker.encoding = "EUC-JP"
 
18
      end
 
19
      assert_equal(["atom", "1.0", "entry"], entry.feed_info)
 
20
      assert_equal("EUC-JP", entry.encoding)
 
21
 
 
22
      entry = Maker.make("atom:entry") do |maker|
 
23
        setup_dummy_channel_atom(maker)
 
24
        setup_dummy_item_atom(maker)
 
25
        maker.standalone = "yes"
 
26
      end
 
27
      assert_equal(["atom", "1.0", "entry"], entry.feed_info)
 
28
      assert_equal("yes", entry.standalone)
 
29
 
 
30
      entry = Maker.make("atom:entry") do |maker|
 
31
        setup_dummy_channel_atom(maker)
 
32
        setup_dummy_item_atom(maker)
 
33
        maker.encoding = "EUC-JP"
 
34
        maker.standalone = "yes"
 
35
      end
 
36
      assert_equal(["atom", "1.0", "entry"], entry.feed_info)
 
37
      assert_equal("EUC-JP", entry.encoding)
 
38
      assert_equal("yes", entry.standalone)
 
39
    end
 
40
 
 
41
    def test_invalid_feed
 
42
      assert_not_set_error("maker.item", %w(id title author updated)) do
 
43
        Maker.make("atom:entry") do |maker|
 
44
        end
 
45
      end
 
46
 
 
47
      assert_not_set_error("maker.item", %w(id title updated)) do
 
48
        Maker.make("atom:entry") do |maker|
 
49
          maker.channel.author = "foo"
 
50
        end
 
51
      end
 
52
 
 
53
      assert_not_set_error("maker.item", %w(title updated)) do
 
54
        Maker.make("atom:entry") do |maker|
 
55
          maker.channel.author = "foo"
 
56
          maker.channel.id = "http://example.com"
 
57
        end
 
58
      end
 
59
 
 
60
      assert_not_set_error("maker.item", %w(updated)) do
 
61
        Maker.make("atom:entry") do |maker|
 
62
          maker.channel.author = "foo"
 
63
          maker.channel.id = "http://example.com"
 
64
          maker.channel.title = "Atom Feed"
 
65
        end
 
66
      end
 
67
 
 
68
      assert_not_set_error("maker.item", %w(author)) do
 
69
        Maker.make("atom:entry") do |maker|
 
70
          maker.channel.id = "http://example.com"
 
71
          maker.channel.title = "Atom Feed"
 
72
          maker.channel.updated = Time.now
 
73
        end
 
74
      end
 
75
 
 
76
      entry = Maker.make("atom:entry") do |maker|
 
77
        maker.channel.author = "Foo"
 
78
        maker.channel.id = "http://example.com"
 
79
        maker.channel.title = "Atom Feed"
 
80
        maker.channel.updated = Time.now
 
81
      end
 
82
      assert_not_nil(entry)
 
83
    end
 
84
 
 
85
    def test_author
 
86
      assert_maker_atom_persons("entry",
 
87
                                ["channel", "authors"],
 
88
                                ["authors"],
 
89
                                "maker.channel.author") do |maker|
 
90
        setup_dummy_channel_atom(maker)
 
91
        setup_dummy_item_atom(maker)
 
92
      end
 
93
 
 
94
      assert_maker_atom_persons("entry",
 
95
                                ["items", "first", "authors"],
 
96
                                ["authors"],
 
97
                                "maker.item.author",
 
98
                                "maker.item", ["author"]) do |maker|
 
99
        setup_dummy_channel_atom(maker)
 
100
        setup_dummy_item_atom(maker)
 
101
        maker.channel.authors.clear
 
102
        maker.items.first.authors.clear
 
103
      end
 
104
 
 
105
      assert_maker_atom_persons("entry",
 
106
                                ["items", "first", "source", "authors"],
 
107
                                ["source", "authors"],
 
108
                                "maker.item.source.author") do |maker|
 
109
        setup_dummy_channel_atom(maker)
 
110
        setup_dummy_item_atom(maker)
 
111
      end
 
112
    end
 
113
 
 
114
    def test_category
 
115
      assert_maker_atom_categories("entry",
 
116
                                   ["channel", "categories"],
 
117
                                   ["categories"],
 
118
                                   "maker.channel.category") do |maker|
 
119
        setup_dummy_channel_atom(maker)
 
120
        setup_dummy_item_atom(maker)
 
121
      end
 
122
 
 
123
      assert_maker_atom_categories("entry",
 
124
                                   ["items", "first", "categories"],
 
125
                                   ["categories"],
 
126
                                   "maker.item.category") do |maker|
 
127
        setup_dummy_channel_atom(maker)
 
128
        setup_dummy_item_atom(maker)
 
129
      end
 
130
 
 
131
      assert_maker_atom_categories("entry",
 
132
                                   ["items", "first", "source", "categories"],
 
133
                                   ["source", "categories"],
 
134
                                   "maker.item.source.category") do |maker|
 
135
        setup_dummy_channel_atom(maker)
 
136
        setup_dummy_item_atom(maker)
 
137
      end
 
138
    end
 
139
 
 
140
    def test_content
 
141
      assert_maker_atom_content("entry",
 
142
                                ["items", "first", "content"],
 
143
                                ["content"],
 
144
                                "maker.item.content") do |maker|
 
145
        setup_dummy_channel_atom(maker)
 
146
        setup_dummy_item_atom(maker)
 
147
      end
 
148
    end
 
149
 
 
150
    def test_contributor
 
151
      assert_maker_atom_persons("entry",
 
152
                                ["channel", "contributors"],
 
153
                                ["contributors"],
 
154
                                "maker.channel.contributor") do |maker|
 
155
        setup_dummy_channel_atom(maker)
 
156
        setup_dummy_item_atom(maker)
 
157
      end
 
158
 
 
159
      assert_maker_atom_persons("entry",
 
160
                                ["items", "first", "contributors"],
 
161
                                ["contributors"],
 
162
                                "maker.item.contributor") do |maker|
 
163
        setup_dummy_channel_atom(maker)
 
164
        setup_dummy_item_atom(maker)
 
165
      end
 
166
 
 
167
      assert_maker_atom_persons("entry",
 
168
                                ["items", "first", "source", "contributors"],
 
169
                                ["source", "contributors"],
 
170
                                "maker.item.source.contributor") do |maker|
 
171
        setup_dummy_channel_atom(maker)
 
172
        setup_dummy_item_atom(maker)
 
173
      end
 
174
    end
 
175
 
 
176
    def test_link
 
177
      assert_maker_atom_links("entry",
 
178
                              ["channel", "links"],
 
179
                              ["links"],
 
180
                              "maker.channel.link") do |maker|
 
181
        setup_dummy_channel_atom(maker)
 
182
        setup_dummy_item_atom(maker)
 
183
        maker.channel.links.clear
 
184
        maker.items.first.links.clear
 
185
      end
 
186
 
 
187
      assert_maker_atom_links("entry",
 
188
                              ["items", "first", "links"],
 
189
                              ["links"],
 
190
                              "maker.item.link") do |maker|
 
191
        setup_dummy_channel_atom(maker)
 
192
        setup_dummy_item_atom(maker)
 
193
        maker.channel.links.clear
 
194
        maker.items.first.links.clear
 
195
      end
 
196
 
 
197
      assert_maker_atom_links("entry",
 
198
                              ["items", "first", "source", "links"],
 
199
                              ["source", "links"],
 
200
                              "maker.item.source.link", true) do |maker|
 
201
        setup_dummy_channel_atom(maker)
 
202
        setup_dummy_item_atom(maker)
 
203
      end
 
204
    end
 
205
 
 
206
    def test_published
 
207
      assert_maker_atom_date_construct("entry",
 
208
                                       ["items", "first", "published"],
 
209
                                       ["published"]
 
210
                                       ) do |maker|
 
211
        setup_dummy_channel_atom(maker)
 
212
        setup_dummy_item_atom(maker)
 
213
      end
 
214
    end
 
215
 
 
216
    def test_rights
 
217
      assert_maker_atom_text_construct("entry",
 
218
                                       ["channel", "copyright"],
 
219
                                       ["rights"]) do |maker|
 
220
        setup_dummy_channel_atom(maker)
 
221
        setup_dummy_item_atom(maker)
 
222
      end
 
223
 
 
224
      assert_maker_atom_text_construct("entry",
 
225
                                       ["items", "first", "rights"],
 
226
                                       ["rights"],
 
227
                                       nil, nil, "maker.item.rights"
 
228
                                       ) do |maker|
 
229
        setup_dummy_channel_atom(maker)
 
230
        setup_dummy_item_atom(maker)
 
231
      end
 
232
 
 
233
      assert_maker_atom_text_construct("entry",
 
234
                                       ["items", "first", "source", "rights"],
 
235
                                       ["source", "rights"],
 
236
                                       nil, nil, "maker.item.source.rights"
 
237
                                       ) do |maker|
 
238
        setup_dummy_channel_atom(maker)
 
239
        setup_dummy_item_atom(maker)
 
240
      end
 
241
    end
 
242
 
 
243
 
 
244
    def test_source_generator
 
245
      assert_maker_atom_generator("entry",
 
246
                                  ["items", "first", "source", "generator"],
 
247
                                  ["source", "generator"],
 
248
                                  "maker.item.source.generator") do |maker|
 
249
        setup_dummy_channel_atom(maker)
 
250
        setup_dummy_item_atom(maker)
 
251
      end
 
252
    end
 
253
 
 
254
    def test_source_icon
 
255
      assert_maker_atom_icon("entry",
 
256
                             ["items", "first", "source", "icon"],
 
257
                             ["source", "icon"],
 
258
                             nil, "maker.item.source.icon") do |maker|
 
259
        setup_dummy_channel_atom(maker)
 
260
        setup_dummy_item_atom(maker)
 
261
      end
 
262
    end
 
263
 
 
264
    def test_source_id
 
265
      assert_maker_atom_id("entry",
 
266
                           ["items", "first", "source"],
 
267
                           ["source"],
 
268
                           "maker.item.source") do |maker|
 
269
        setup_dummy_channel_atom(maker)
 
270
        setup_dummy_item_atom(maker)
 
271
      end
 
272
    end
 
273
 
 
274
    def test_source_logo
 
275
      assert_maker_atom_logo("entry",
 
276
                             ["items", "first", "source", "logo"],
 
277
                             ["source", "logo"],
 
278
                             nil,
 
279
                             "maker.item.source.logo") do |maker|
 
280
        setup_dummy_channel_atom(maker)
 
281
        setup_dummy_item_atom(maker)
 
282
      end
 
283
    end
 
284
 
 
285
    def test_source_subtitle
 
286
      assert_maker_atom_text_construct("entry",
 
287
                                       ["items", "first", "source", "subtitle"],
 
288
                                       ["source", "subtitle"],
 
289
                                       nil, nil,
 
290
                                       "maker.item.source.subtitle") do |maker|
 
291
        setup_dummy_channel_atom(maker)
 
292
        setup_dummy_item_atom(maker)
 
293
      end
 
294
    end
 
295
 
 
296
    def test_summary
 
297
      assert_maker_atom_text_construct("entry",
 
298
                                       ["items", "first", "description"],
 
299
                                       ["summary"],
 
300
                                       nil, nil, "maker.item.description"
 
301
                                       ) do |maker|
 
302
        setup_dummy_channel_atom(maker)
 
303
        setup_dummy_item_atom(maker)
 
304
      end
 
305
    end
 
306
 
 
307
    def test_title
 
308
      assert_maker_atom_text_construct("entry",
 
309
                                       ["channel", "title"], ["title"],
 
310
                                       "maker.item", ["title"],
 
311
                                       "maker.channel.title") do |maker|
 
312
        setup_dummy_channel_atom(maker)
 
313
        setup_dummy_item_atom(maker)
 
314
        maker.channel.title = nil
 
315
        maker.items.first.title = nil
 
316
      end
 
317
 
 
318
      assert_maker_atom_text_construct("entry",
 
319
                                       ["items", "first", "title"],
 
320
                                       ["title"],
 
321
                                       "maker.item", ["title"],
 
322
                                       "maker.item.title") do |maker|
 
323
        setup_dummy_channel_atom(maker)
 
324
        setup_dummy_item_atom(maker)
 
325
        maker.channel.title = nil
 
326
        maker.items.first.title = nil
 
327
      end
 
328
 
 
329
      assert_maker_atom_text_construct("entry",
 
330
                                       ["items", "first", "source", "title"],
 
331
                                       ["source", "title"],
 
332
                                       nil, nil, "maker.item.source.title"
 
333
                                       ) do |maker|
 
334
        setup_dummy_channel_atom(maker)
 
335
        setup_dummy_item_atom(maker)
 
336
      end
 
337
    end
 
338
 
 
339
    def test_updated
 
340
      assert_maker_atom_date_construct("entry",
 
341
                                       ["channel", "updated"], ["updated"],
 
342
                                       "maker.item", ["updated"]) do |maker|
 
343
        setup_dummy_channel_atom(maker)
 
344
        setup_dummy_item_atom(maker)
 
345
        maker.channel.updated = nil
 
346
        maker.items.first.updated = nil
 
347
      end
 
348
 
 
349
      assert_maker_atom_date_construct("entry",
 
350
                                       ["items", "first", "updated"],
 
351
                                       ["updated"],
 
352
                                       "maker.item", ["updated"]) do |maker|
 
353
        setup_dummy_channel_atom(maker)
 
354
        setup_dummy_item_atom(maker)
 
355
        maker.channel.updated = nil
 
356
        maker.items.first.updated = nil
 
357
      end
 
358
 
 
359
      assert_maker_atom_date_construct("entry",
 
360
                                       ["items", "first", "source", "updated"],
 
361
                                       ["source", "updated"]) do |maker|
 
362
        setup_dummy_channel_atom(maker)
 
363
        setup_dummy_item_atom(maker)
 
364
      end
 
365
    end
 
366
  end
 
367
end