1require "rss-testcase"
2
3require "rss/atom"
4
5module RSS
6  class TestParserAtomFeed < TestCase
7    def test_feed_validation
8      assert_ns("", Atom::URI) do
9        Parser.parse(<<-EOA)
10<feed/>
11EOA
12      end
13
14      assert_ns("", Atom::URI) do
15        Parser.parse(<<-EOA)
16<feed xmlns="hoge"/>
17EOA
18      end
19
20      assert_parse(<<-EOA, :missing_tag, "id", "feed") do
21<feed xmlns="#{Atom::URI}"/>
22EOA
23      end
24
25      assert_parse(<<-EOA, :missing_tag, "title", "feed") do
26<feed xmlns="#{Atom::URI}">
27  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
28</feed>
29EOA
30      end
31
32      assert_parse(<<-EOA, :missing_tag, "updated", "feed") do
33<feed xmlns="#{Atom::URI}">
34  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
35  <title>Example Feed</title>
36</feed>
37EOA
38      end
39
40      assert_parse(<<-EOA, :missing_tag, "author", "feed") do
41<feed xmlns="#{Atom::URI}">
42  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
43  <title>Example Feed</title>
44  <updated>2003-12-13T18:30:02Z</updated>
45</feed>
46EOA
47      end
48
49      assert_parse(<<-EOA, :nothing_raised) do
50<feed xmlns="#{Atom::URI}">
51  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
52  <title>Example Feed</title>
53  <updated>2003-12-13T18:30:02Z</updated>
54  <author>
55    <name>A person</name>
56  </author>
57</feed>
58EOA
59      end
60    end
61
62    def test_lang
63      feed = RSS::Parser.parse(<<-EOA)
64<feed xmlns="#{Atom::URI}" xml:lang="ja">
65  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
66  <title xml:lang="en">Example Feed</title>
67  <updated>2003-12-13T18:30:02Z</updated>
68  <author xml:lang="en">
69    <name>A person</name>
70  </author>
71</feed>
72EOA
73
74      assert_equal("ja", feed.lang)
75      assert_equal("ja", feed.id.lang)
76      assert_equal("en", feed.title.lang)
77      assert_equal("ja", feed.updated.lang)
78      assert_equal("en", feed.author.lang)
79      assert_equal("en", feed.author.name.lang)
80    end
81
82    def test_base
83      feed = RSS::Parser.parse(<<-EOA)
84<feed xmlns="#{Atom::URI}" xml:base="http://example.com/">
85  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
86  <title xml:lang="en">Example Feed</title>
87  <updated>2003-12-13T18:30:02Z</updated>
88  <generator uri="generator">Generator</generator>
89  <link hreflang="ja" href="http://example.org/link1"/>
90  <link hreflang="en" href="link2"/>
91  <link hreflang="fr" xml:base="http://example.net/" href="link3"/>
92  <author>
93    <name>A person</name>
94    <uri>person</uri>
95  </author>
96</feed>
97EOA
98
99      assert_equal("http://example.com/", feed.base)
100      assert_equal("http://example.com/", feed.id.base)
101      assert_equal("http://example.com/", feed.title.base)
102      assert_equal("http://example.com/", feed.updated.base)
103      assert_equal("http://example.com/", feed.generator.base)
104      assert_equal("http://example.com/generator", feed.generator.uri)
105
106      assert_equal("http://example.com/", feed.links[0].base)
107      assert_equal("http://example.org/link1", feed.links[0].href)
108      assert_equal("http://example.com/", feed.links[1].base)
109      assert_equal("http://example.com/link2", feed.links[1].href)
110      assert_equal("http://example.net/", feed.links[2].base)
111      assert_equal("http://example.net/link3", feed.links[2].href)
112      assert_equal("http://example.com/person", feed.author.uri.content)
113    end
114
115    def test_feed_author
116      assert_atom_person("author", method(:make_feed)) do |feed|
117        assert_equal(2, feed.authors.size)
118        feed.authors[1]
119      end
120    end
121
122    def test_entry_author
123      generator = method(:make_feed_with_open_entry)
124      assert_atom_person("author", generator) do |feed|
125        assert_equal(1, feed.entries.size)
126        assert_equal(1, feed.entry.authors.size)
127        feed.entry.author
128      end
129    end
130
131    def test_feed_category
132      assert_atom_category(method(:make_feed)) do |feed|
133        assert_equal(1, feed.categories.size)
134        feed.category
135      end
136    end
137
138    def test_entry_category
139      assert_atom_category(method(:make_feed_with_open_entry)) do |feed|
140        assert_equal(1, feed.entries.size)
141        assert_equal(1, feed.entry.categories.size)
142        feed.entry.category
143      end
144    end
145
146    def test_entry_content
147      assert_atom_content(method(:make_feed_with_open_entry)) do |feed|
148        assert_equal(1, feed.entries.size)
149        feed.entry.content
150      end
151    end
152
153    def test_feed_contributor
154      assert_atom_person("contributor", method(:make_feed)) do |feed|
155        assert_equal(1, feed.contributors.size)
156        feed.contributor
157      end
158    end
159
160    def test_entry_contributor
161      generator = method(:make_feed_with_open_entry)
162      assert_atom_person("contributor", generator) do |feed|
163        assert_equal(1, feed.entries.size)
164        assert_equal(1, feed.entry.contributors.size)
165        feed.entry.contributor
166      end
167    end
168
169    def test_feed_generator
170      assert_atom_generator(method(:make_feed)) do |feed|
171        feed.generator
172      end
173    end
174
175    def test_feed_icon
176      assert_atom_icon(method(:make_feed)) do |feed|
177        feed.icon
178      end
179    end
180
181    def test_feed_id
182      feed = RSS::Parser.parse(make_feed(''))
183      assert_equal(FEED_ID, feed.id.content)
184    end
185
186    def test_entry_id
187      feed = RSS::Parser.parse(make_feed(''))
188      assert_equal(ENTRY_ID, feed.entry.id.content)
189    end
190
191    def test_feed_link
192      assert_atom_link(method(:make_feed)) do |feed|
193        assert_equal(1, feed.links.size)
194        feed.link
195      end
196    end
197
198    def test_entry_link
199      assert_atom_link(method(:make_feed_with_open_entry)) do |feed|
200        assert_equal(1, feed.entries.size)
201        assert_equal(1, feed.entry.links.size)
202        feed.entry.link
203      end
204    end
205
206    def test_feed_logo
207      assert_atom_logo(method(:make_feed)) do |feed|
208        feed.logo
209      end
210    end
211
212    def test_feed_rights
213      assert_atom_text_construct("rights", method(:make_feed)) do |feed|
214        feed.rights
215      end
216    end
217
218    def test_entry_rights
219      generator = method(:make_feed_with_open_entry)
220      assert_atom_text_construct("rights", generator) do |feed|
221        assert_equal(1, feed.entries.size)
222        feed.entry.rights
223      end
224    end
225
226    def test_entry_source
227      assert_atom_source(method(:make_feed_with_open_entry_source)) do |feed|
228        assert_equal(1, feed.entries.size)
229        assert_not_nil(feed.entry.source)
230        feed.entry.source
231      end
232    end
233
234    def test_feed_subtitle
235      assert_atom_text_construct("subtitle", method(:make_feed)) do |feed|
236        feed.subtitle
237      end
238    end
239
240    def test_feed_title
241      feed = RSS::Parser.parse(make_feed(''))
242      assert_equal(FEED_TITLE, feed.title.content)
243    end
244
245    def test_entry_title
246      feed = RSS::Parser.parse(make_feed(''))
247      assert_equal(ENTRY_TITLE, feed.entry.title.content)
248    end
249
250    def test_feed_updated
251      feed = RSS::Parser.parse(make_feed(''))
252      assert_equal(Time.parse(FEED_UPDATED), feed.updated.content)
253    end
254
255    def test_entry_updated
256      feed = RSS::Parser.parse(make_feed(''))
257      assert_equal(Time.parse(ENTRY_UPDATED), feed.entry.updated.content)
258    end
259
260    def test_entry_published
261      generator = method(:make_feed_with_open_entry)
262      assert_atom_date_construct("published", generator) do |feed|
263        assert_equal(1, feed.entries.size)
264        feed.entry.published
265      end
266    end
267
268    def test_entry_summary
269      generator = method(:make_feed_with_open_entry)
270      assert_atom_text_construct("summary", generator) do |feed|
271        assert_equal(1, feed.entries.size)
272        feed.entry.summary
273      end
274    end
275  end
276end
277