1require "rexml/document"
2
3require "rss-testcase"
4
5require "rss/1.0"
6
7module RSS
8  class TestRSS10Core < TestCase
9
10    def setup
11      @rdf_prefix = "rdf"
12      @rdf_uri = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
13      @uri = "http://purl.org/rss/1.0/"
14    end
15
16    def test_RDF
17      version = "1.0"
18      encoding = "UTF-8"
19      standalone = false
20
21      rdf = RDF.new(version, encoding, standalone)
22      setup_rss10(rdf)
23      doc = REXML::Document.new(rdf.to_s)
24
25      xmldecl = doc.xml_decl
26
27      assert_equal(version, xmldecl.version)
28      assert_equal(encoding, xmldecl.encoding.to_s)
29      assert_equal(standalone, !xmldecl.standalone.nil?)
30
31      assert_equal(@rdf_uri, doc.root.namespace)
32    end
33
34    def test_not_displayed_xml_stylesheets
35      rdf = RDF.new()
36      plain_rdf = rdf.to_s
37      3.times do
38        rdf.xml_stylesheets.push(XMLStyleSheet.new)
39        assert_equal(plain_rdf, rdf.to_s)
40      end
41    end
42
43    def test_xml_stylesheets
44      [
45        [{:href => "a.xsl", :type => "text/xsl"}],
46        [
47          {:href => "a.xsl", :type => "text/xsl"},
48          {:href => "a.css", :type => "text/css"},
49        ],
50      ].each do |attrs_ary|
51        assert_xml_stylesheet_pis(attrs_ary)
52      end
53    end
54
55    def test_channel
56      about = "http://hoge.com"
57      resource = "http://hoge.com/hoge.png"
58
59      item_title = "item title"
60      item_link = "http://hoge.com/item"
61
62      image = RDF::Channel::Image.new(resource)
63      items = RDF::Channel::Items.new
64      items.Seq.lis << items.class::Seq::Li.new(item_link)
65      textinput = RDF::Channel::Textinput.new(resource)
66
67      rss_item = RDF::Item.new
68      rss_item.title = item_title
69      rss_item.link = item_link
70      rss_item.about = item_link
71
72      h = {
73        'title' => "fugafuga",
74        'link' => "http://hoge.com",
75        'description' => "fugafugafugafuga",
76        'image' => image,
77        'items' => items,
78        'textinput' => textinput,
79      }
80
81      channel = RDF::Channel.new(about)
82      %w(title link description image items textinput).each do |x|
83        channel.__send__("#{x}=", h[x])
84      end
85
86      doc = REXML::Document.new(make_RDF(<<-EOR))
87#{channel}
88<items>
89#{rss_item}
90</items>
91EOR
92      c = doc.root.elements[1]
93
94      assert_equal(about, c.attributes["about"])
95      %w(title link description image textinput).each do |x|
96        elem = c.elements[x]
97        assert_equal(x, elem.name)
98        assert_equal(@uri, elem.namespace)
99        if x == "image" or x == "textinput"
100          excepted = resource
101          res = elem.attributes.get_attribute("resource")
102          assert_equal(@rdf_uri, res.namespace)
103          value = res.value
104        else
105          excepted = h[x]
106          value = elem.text
107        end
108        assert_equal(excepted, value)
109      end
110      assert_equal(@uri, c.elements["items"].namespace)
111      assert_equal("items", c.elements["items"].name)
112    end
113
114    def test_channel_image
115      resource = "http://hoge.com/hoge.png"
116      image = RDF::Channel::Image.new(resource)
117
118      doc = REXML::Document.new(make_RDF(image.to_s))
119      i = doc.root.elements[1]
120
121      assert_equal("image", i.name)
122      assert_equal(@uri, i.namespace)
123
124      res = i.attributes.get_attribute("resource")
125
126      assert_equal(@rdf_uri, res.namespace)
127      assert_equal(resource, res.value)
128    end
129
130    def test_channel_textinput
131      resource = "http://hoge.com/hoge.png"
132      textinput = RDF::Channel::Textinput.new(resource)
133
134      doc = REXML::Document.new(make_RDF(textinput.to_s))
135      t = doc.root.elements[1]
136
137      assert_equal("textinput", t.name)
138      assert_equal(@uri, t.namespace)
139
140      res = t.attributes.get_attribute("resource")
141
142      assert_equal(@rdf_uri, res.namespace)
143      assert_equal(resource, res.value)
144    end
145
146    def test_channel_items
147      item_link = "http://example.com/item"
148
149      items = RDF::Channel::Items.new
150      li = items.Seq.class::Li.new(item_link)
151      items.Seq.lis << li
152
153      doc = REXML::Document.new(make_RDF(items.to_s))
154      i = doc.root.elements[1]
155
156      assert_equal("items", i.name)
157      assert_equal(@uri, i.namespace)
158
159      assert_equal(1, i.elements.size)
160      seq = i.elements[1]
161      assert_equal("Seq", seq.name)
162      assert_equal(@rdf_uri, seq.namespace)
163
164      assert_equal(1, seq.elements.size)
165      l = seq.elements[1]
166      assert_equal("li", l.name)
167      assert_equal(@rdf_uri, l.namespace)
168      assert_equal(item_link, l.attributes["resource"])
169    end
170
171    def test_seq
172      item_link = "http://example.com/item"
173      seq = RDF::Seq.new
174      li = seq.class::Li.new(item_link)
175      seq.lis << li
176
177      doc = REXML::Document.new(make_RDF(seq.to_s))
178      s = doc.root.elements[1]
179
180      assert_equal("Seq", s.name)
181      assert_equal(@rdf_uri, s.namespace)
182
183      assert_equal(1, s.elements.size)
184      l = s.elements[1]
185      assert_equal("li", l.name)
186      assert_equal(@rdf_uri, l.namespace)
187      assert_equal(item_link, l.attributes["resource"])
188    end
189
190    def test_li
191      resource = "http://hoge.com/"
192      li = RDF::Li.new(resource)
193
194      doc = REXML::Document.new(make_RDF(li.to_s))
195      l = doc.root.elements[1]
196
197      assert_equal("li", l.name)
198      assert_equal(@rdf_uri, l.namespace(l.prefix))
199
200      res = l.attributes.get_attribute("resource")
201
202      assert_equal('', res.instance_eval("@prefix"))
203      assert_equal(resource, res.value)
204    end
205
206    def test_image
207      about = "http://hoge.com"
208      h = {
209        'title' => "fugafuga",
210        'url' => "http://hoge.com/hoge",
211        'link' => "http://hoge.com/fuga",
212      }
213
214      image = RDF::Image.new(about)
215      %w(title url link).each do |x|
216        image.__send__("#{x}=", h[x])
217      end
218
219      doc = REXML::Document.new(make_RDF(image.to_s))
220      i = doc.root.elements[1]
221
222      assert_equal(about, i.attributes["about"])
223      %w(title url link).each do |x|
224        elem = i.elements[x]
225        assert_equal(x, elem.name)
226        assert_equal(@uri, elem.namespace)
227        assert_equal(h[x], elem.text)
228      end
229    end
230
231    def test_item
232      about = "http://hoge.com"
233      h = {
234        'title' => "fugafuga",
235        'link' => "http://hoge.com/fuga",
236        'description' => "hogehogehoge",
237      }
238
239      item = RDF::Item.new(about)
240      %w(title link description).each do |x|
241        item.__send__("#{x}=", h[x])
242      end
243
244      doc = REXML::Document.new(make_RDF(item.to_s))
245      i = doc.root.elements[1]
246
247      assert_equal(about, i.attributes["about"])
248      %w(title link description).each do |x|
249        elem = i.elements[x]
250        assert_equal(x, elem.name)
251        assert_equal(@uri, elem.namespace)
252        assert_equal(h[x], elem.text)
253      end
254    end
255
256    def test_textinput
257      about = "http://hoge.com"
258      h = {
259        'title' => "fugafuga",
260        'link' => "http://hoge.com/fuga",
261        'name' => "foo",
262        'description' => "hogehogehoge",
263      }
264
265      textinput = RDF::Textinput.new(about)
266      %w(title link name description).each do |x|
267        textinput.__send__("#{x}=", h[x])
268      end
269
270      doc = REXML::Document.new(make_RDF(textinput.to_s))
271      t = doc.root.elements[1]
272
273      assert_equal(about, t.attributes["about"])
274      %w(title link name description).each do |x|
275        elem = t.elements[x]
276        assert_equal(x, elem.name)
277        assert_equal(@uri, elem.namespace)
278        assert_equal(h[x], elem.text)
279      end
280    end
281
282    def test_to_xml
283      rss = RSS::Parser.parse(make_sample_RDF)
284      assert_equal(rss.to_s, rss.to_xml)
285      assert_equal(rss.to_s, rss.to_xml("1.0"))
286      rss09 = rss.to_xml("0.91") do |maker|
287        maker.channel.language = "en-us"
288      end
289      rss09 = RSS::Parser.parse(rss09)
290      assert_equal("0.91", rss09.rss_version)
291      assert_equal(["rss", "0.91", nil], rss09.feed_info)
292      rss20 = RSS::Parser.parse(rss.to_xml("2.0"))
293      assert_equal("2.0", rss20.rss_version)
294      assert_equal(["rss", "2.0", nil], rss20.feed_info)
295
296      atom_xml = rss.to_xml("atom") do |maker|
297        maker.channel.author = "Alice"
298        maker.channel.updated ||= Time.now
299        maker.items.each do |item|
300          item.updated ||= Time.now
301        end
302      end
303      atom = RSS::Parser.parse(atom_xml)
304      assert_equal(["atom", "1.0", "feed"], atom.feed_info)
305    end
306  end
307end
308