rss 0.2.8 → 0.2.9

data/test/test_parser_2.0.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: false
+require_relative "rss-testcase"
+
+require "rss/2.0"
+
+module RSS
+  class TestParser20 < TestCase
+    def test_rss20
+      assert_parse(make_rss20(<<-EOR), :missing_tag, "channel", "rss")
+EOR
+
+      assert_parse(make_rss20(<<-EOR), :nothing_raised)
+#{make_channel20("")}
+EOR
+    end
+
+    def test_cloud20
+      attrs = [
+        ["domain", CLOUD_DOMAIN],
+        ["port", CLOUD_PORT],
+        ["path", CLOUD_PATH],
+        ["registerProcedure", CLOUD_REGISTER_PROCEDURE],
+        ["protocol", CLOUD_PROTOCOL],
+      ]
+
+      (attrs.size + 1).times do |i|
+        missing_attr = attrs[i]
+        if missing_attr
+          meth = :missing_attribute
+          args = ["cloud", missing_attr[0]]
+        else
+          meth = :nothing_raised
+          args = []
+        end
+
+        cloud_attrs = []
+        attrs.each_with_index do |attr, j|
+          unless i == j
+            cloud_attrs << %Q[#{attr[0]}="#{attr[1]}"]
+          end
+        end
+
+        assert_parse(make_rss20(<<-EOR), meth, *args)
+#{make_channel20(%Q[<cloud #{cloud_attrs.join("\n")}/>])}
+EOR
+      end
+    end
+
+    def test_source20
+        assert_parse(make_rss20(<<-EOR), :missing_attribute, "source", "url")
+#{make_channel20(make_item20(%Q[<source>Example</source>]))}
+EOR
+
+        assert_parse(make_rss20(<<-EOR), :nothing_raised)
+#{make_channel20(make_item20(%Q[<source url="http://example.com/" />]))}
+EOR
+
+        assert_parse(make_rss20(<<-EOR), :nothing_raised)
+#{make_channel20(make_item20(%Q[<source url="http://example.com/">Example</source>]))}
+EOR
+    end
+
+    def test_enclosure20
+      attrs = [
+        ["url", ENCLOSURE_URL],
+        ["length", ENCLOSURE_LENGTH],
+        ["type", ENCLOSURE_TYPE],
+      ]
+
+      (attrs.size + 1).times do |i|
+        missing_attr = attrs[i]
+        if missing_attr
+          meth = :missing_attribute
+          args = ["enclosure", missing_attr[0]]
+        else
+          meth = :nothing_raised
+          args = []
+        end
+
+        enclosure_attrs = []
+        attrs.each_with_index do |attr, j|
+          unless i == j
+            enclosure_attrs << %Q[#{attr[0]}="#{attr[1]}"]
+          end
+        end
+
+        assert_parse(make_rss20(<<-EOR), meth, *args)
+#{make_channel20(%Q[
+#{make_item20(%Q[
+<enclosure
+  #{enclosure_attrs.join("\n")} />
+    ])}
+  ])}
+EOR
+      end
+    end
+
+    def test_category20
+      values = [nil, CATEGORY_DOMAIN]
+      values.each do |value|
+        domain = ""
+        domain << %Q[domain="#{value}"] if value
+
+        ["", "Example Text"].each do |text|
+          rss_src = make_rss20(<<-EOR)
+#{make_channel20(%Q[
+#{make_item20(%Q[
+<category #{domain}>#{text}</category>
+    ])}
+  ])}
+EOR
+          assert_parse(rss_src, :nothing_raised)
+
+          rss = RSS::Parser.parse(rss_src)
+          category = rss.items.last.categories.first
+          assert_equal(value, category.domain)
+          assert_equal(text, category.content)
+        end
+      end
+    end
+  end
+end
+

data/test/test_parser_atom_entry.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: false
+require_relative "rss-testcase"
+
+require "rss/atom"
+
+module RSS
+  class TestParserAtom < TestCase
+    def test_entry_validation
+      assert_ns("", Atom::URI) do
+        Parser.parse(<<-EOA)
+<entry/>
+EOA
+      end
+
+      assert_ns("", Atom::URI) do
+        Parser.parse(<<-EOA)
+<entry xmlns="hoge"/>
+EOA
+      end
+
+      assert_parse(<<-EOA, :missing_tag, "id", "entry") do
+<entry xmlns="#{Atom::URI}"/>
+EOA
+      end
+
+      assert_parse(<<-EOA, :missing_tag, "title", "entry") do
+<entry xmlns="#{Atom::URI}">
+  <id>urn:uuid:506e336c-a26e-4457-917b-b89dca7ae746</id>
+</entry>
+EOA
+      end
+
+      assert_parse(<<-EOA, :missing_tag, "updated", "entry") do
+<entry xmlns="#{Atom::URI}">
+  <id>urn:uuid:506e336c-a26e-4457-917b-b89dca7ae746</id>
+  <title>Example Entry</title>
+</entry>
+EOA
+      end
+
+      assert_parse(<<-EOA, :missing_tag, "author", "entry") do
+<entry xmlns="#{Atom::URI}">
+  <id>urn:uuid:506e336c-a26e-4457-917b-b89dca7ae746</id>
+  <title>Example Entry</title>
+  <updated>2003-10-10T18:30:02Z</updated>
+</entry>
+EOA
+      end
+
+      assert_parse(<<-EOA, :nothing_raised) do
+<entry xmlns="#{Atom::URI}">
+  <id>urn:uuid:506e336c-a26e-4457-917b-b89dca7ae746</id>
+  <title>Example Entry</title>
+  <updated>2003-10-10T18:30:02Z</updated>
+  <author>
+    <name>A person</name>
+  </author>
+</entry>
+EOA
+      end
+    end
+
+    def test_entry
+      entry = RSS::Parser.parse(<<-EOA)
+<?xml version="1.0" encoding="utf-8"?>
+<entry xmlns="http://www.w3.org/2005/Atom">
+  <author>
+    <name>A person</name>
+  </author>
+  <title>Atom-Powered Robots Run Amok</title>
+  <link href="http://example.org/2003/12/13/atom03"/>
+  <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a</id>
+  <updated>2003-12-13T18:30:02Z</updated>
+  <summary>Some text.</summary>
+</entry>
+EOA
+      assert_not_nil(entry)
+      assert_equal("Atom-Powered Robots Run Amok", entry.title.content)
+      assert_equal("http://example.org/2003/12/13/atom03", entry.link.href)
+      assert_equal("urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a",
+                   entry.id.content)
+      assert_equal(Time.parse("2003-12-13T18:30:02Z"), entry.updated.content)
+      assert_equal("Some text.", entry.summary.content)
+    end
+
+    def test_entry_author
+      assert_atom_person("author", method(:make_entry_document)) do |entry|
+        assert_equal(2, entry.authors.size)
+        entry.authors.last
+      end
+    end
+
+    def test_entry_category
+      assert_atom_category(method(:make_entry_document)) do |entry|
+        assert_equal(1, entry.categories.size)
+        entry.category
+      end
+    end
+
+    def test_entry_content_text
+      assert_atom_content(method(:make_entry_document)) do |entry|
+        entry.content
+      end
+    end
+
+    def test_entry_contributor
+      assert_atom_person("contributor", method(:make_entry_document)) do |entry|
+        assert_equal(1, entry.contributors.size)
+        entry.contributor
+      end
+    end
+
+    def test_entry_id
+      entry = RSS::Parser.parse(make_entry_document)
+      assert_equal(ENTRY_ID, entry.id.content)
+    end
+
+    def test_entry_link
+      assert_atom_link(method(:make_entry_document)) do |entry|
+        assert_equal(1, entry.links.size)
+        entry.link
+      end
+    end
+
+    def test_published
+      generator = method(:make_entry_document)
+      assert_atom_date_construct("published", generator) do |entry|
+        entry.published
+      end
+    end
+
+    def test_entry_rights
+      generator = method(:make_entry_document)
+      assert_atom_text_construct("rights", generator) do |entry|
+        entry.rights
+      end
+    end
+
+    def test_entry_source
+      generator = method(:make_entry_document_with_open_source)
+      assert_atom_source(generator) do |entry|
+        assert_not_nil(entry.source)
+        entry.source
+      end
+    end
+
+    def test_entry_summary
+      generator = method(:make_entry_document)
+      assert_atom_text_construct("summary", generator) do |entry|
+        entry.summary
+      end
+    end
+
+    def test_entry_title
+      entry = RSS::Parser.parse(make_entry_document)
+      assert_equal(ENTRY_TITLE, entry.title.content)
+    end
+
+    def test_entry_updated
+      entry = RSS::Parser.parse(make_entry_document)
+      assert_equal(Time.parse(ENTRY_UPDATED), entry.updated.content)
+    end
+  end
+end

data/test/test_parser_atom_feed.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: false
+require_relative "rss-testcase"
+
+require "rss/atom"
+
+module RSS
+  class TestParserAtomFeed < TestCase
+    def test_feed_validation
+      assert_ns("", Atom::URI) do
+        Parser.parse(<<-EOA)
+<feed/>
+EOA
+      end
+
+      assert_ns("", Atom::URI) do
+        Parser.parse(<<-EOA)
+<feed xmlns="hoge"/>
+EOA
+      end
+
+      assert_parse(<<-EOA, :missing_tag, "id", "feed") do
+<feed xmlns="#{Atom::URI}"/>
+EOA
+      end
+
+      assert_parse(<<-EOA, :missing_tag, "title", "feed") do
+<feed xmlns="#{Atom::URI}">
+  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
+</feed>
+EOA
+      end
+
+      assert_parse(<<-EOA, :missing_tag, "updated", "feed") do
+<feed xmlns="#{Atom::URI}">
+  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
+  <title>Example Feed</title>
+</feed>
+EOA
+      end
+
+      assert_parse(<<-EOA, :missing_tag, "author", "feed") do
+<feed xmlns="#{Atom::URI}">
+  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
+  <title>Example Feed</title>
+  <updated>2003-12-13T18:30:02Z</updated>
+</feed>
+EOA
+      end
+
+      assert_parse(<<-EOA, :nothing_raised) do
+<feed xmlns="#{Atom::URI}">
+  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
+  <title>Example Feed</title>
+  <updated>2003-12-13T18:30:02Z</updated>
+  <author>
+    <name>A person</name>
+  </author>
+</feed>
+EOA
+      end
+    end
+
+    def test_lang
+      feed = RSS::Parser.parse(<<-EOA)
+<feed xmlns="#{Atom::URI}" xml:lang="ja">
+  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
+  <title xml:lang="en">Example Feed</title>
+  <updated>2003-12-13T18:30:02Z</updated>
+  <author xml:lang="en">
+    <name>A person</name>
+  </author>
+</feed>
+EOA
+
+      assert_equal("ja", feed.lang)
+      assert_equal("ja", feed.id.lang)
+      assert_equal("en", feed.title.lang)
+      assert_equal("ja", feed.updated.lang)
+      assert_equal("en", feed.author.lang)
+      assert_equal("en", feed.author.name.lang)
+    end
+
+    def test_base
+      feed = RSS::Parser.parse(<<-EOA)
+<feed xmlns="#{Atom::URI}" xml:base="http://example.com/">
+  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
+  <title xml:lang="en">Example Feed</title>
+  <updated>2003-12-13T18:30:02Z</updated>
+  <generator uri="generator">Generator</generator>
+  <link hreflang="ja" href="http://example.org/link1"/>
+  <link hreflang="en" href="link2"/>
+  <link hreflang="fr" xml:base="http://example.net/" href="link3"/>
+  <author>
+    <name>A person</name>
+    <uri>person</uri>
+  </author>
+</feed>
+EOA
+
+      assert_equal("http://example.com/", feed.base)
+      assert_equal("http://example.com/", feed.id.base)
+      assert_equal("http://example.com/", feed.title.base)
+      assert_equal("http://example.com/", feed.updated.base)
+      assert_equal("http://example.com/", feed.generator.base)
+      assert_equal("http://example.com/generator", feed.generator.uri)
+
+      assert_equal("http://example.com/", feed.links[0].base)
+      assert_equal("http://example.org/link1", feed.links[0].href)
+      assert_equal("http://example.com/", feed.links[1].base)
+      assert_equal("http://example.com/link2", feed.links[1].href)
+      assert_equal("http://example.net/", feed.links[2].base)
+      assert_equal("http://example.net/link3", feed.links[2].href)
+      assert_equal("http://example.com/person", feed.author.uri.content)
+    end
+
+    def test_feed_author
+      assert_atom_person("author", method(:make_feed)) do |feed|
+        assert_equal(2, feed.authors.size)
+        feed.authors[1]
+      end
+    end
+
+    def test_entry_author
+      generator = method(:make_feed_with_open_entry)
+      assert_atom_person("author", generator) do |feed|
+        assert_equal(1, feed.entries.size)
+        assert_equal(1, feed.entry.authors.size)
+        feed.entry.author
+      end
+    end
+
+    def test_feed_category
+      assert_atom_category(method(:make_feed)) do |feed|
+        assert_equal(1, feed.categories.size)
+        feed.category
+      end
+    end
+
+    def test_entry_category
+      assert_atom_category(method(:make_feed_with_open_entry)) do |feed|
+        assert_equal(1, feed.entries.size)
+        assert_equal(1, feed.entry.categories.size)
+        feed.entry.category
+      end
+    end
+
+    def test_entry_content
+      assert_atom_content(method(:make_feed_with_open_entry)) do |feed|
+        assert_equal(1, feed.entries.size)
+        feed.entry.content
+      end
+    end
+
+    def test_feed_contributor
+      assert_atom_person("contributor", method(:make_feed)) do |feed|
+        assert_equal(1, feed.contributors.size)
+        feed.contributor
+      end
+    end
+
+    def test_entry_contributor
+      generator = method(:make_feed_with_open_entry)
+      assert_atom_person("contributor", generator) do |feed|
+        assert_equal(1, feed.entries.size)
+        assert_equal(1, feed.entry.contributors.size)
+        feed.entry.contributor
+      end
+    end
+
+    def test_feed_generator
+      assert_atom_generator(method(:make_feed)) do |feed|
+        feed.generator
+      end
+    end
+
+    def test_feed_icon
+      assert_atom_icon(method(:make_feed)) do |feed|
+        feed.icon
+      end
+    end
+
+    def test_feed_id
+      feed = RSS::Parser.parse(make_feed(''))
+      assert_equal(FEED_ID, feed.id.content)
+    end
+
+    def test_entry_id
+      feed = RSS::Parser.parse(make_feed(''))
+      assert_equal(ENTRY_ID, feed.entry.id.content)
+    end
+
+    def test_feed_link
+      assert_atom_link(method(:make_feed)) do |feed|
+        assert_equal(1, feed.links.size)
+        feed.link
+      end
+    end
+
+    def test_entry_link
+      assert_atom_link(method(:make_feed_with_open_entry)) do |feed|
+        assert_equal(1, feed.entries.size)
+        assert_equal(1, feed.entry.links.size)
+        feed.entry.link
+      end
+    end
+
+    def test_feed_logo
+      assert_atom_logo(method(:make_feed)) do |feed|
+        feed.logo
+      end
+    end
+
+    def test_feed_rights
+      assert_atom_text_construct("rights", method(:make_feed)) do |feed|
+        feed.rights
+      end
+    end
+
+    def test_entry_rights
+      generator = method(:make_feed_with_open_entry)
+      assert_atom_text_construct("rights", generator) do |feed|
+        assert_equal(1, feed.entries.size)
+        feed.entry.rights
+      end
+    end
+
+    def test_entry_source
+      assert_atom_source(method(:make_feed_with_open_entry_source)) do |feed|
+        assert_equal(1, feed.entries.size)
+        assert_not_nil(feed.entry.source)
+        feed.entry.source
+      end
+    end
+
+    def test_feed_subtitle
+      assert_atom_text_construct("subtitle", method(:make_feed)) do |feed|
+        feed.subtitle
+      end
+    end
+
+    def test_feed_title
+      feed = RSS::Parser.parse(make_feed(''))
+      assert_equal(FEED_TITLE, feed.title.content)
+    end
+
+    def test_entry_title
+      feed = RSS::Parser.parse(make_feed(''))
+      assert_equal(ENTRY_TITLE, feed.entry.title.content)
+    end
+
+    def test_feed_updated
+      feed = RSS::Parser.parse(make_feed(''))
+      assert_equal(Time.parse(FEED_UPDATED), feed.updated.content)
+    end
+
+    def test_entry_updated
+      feed = RSS::Parser.parse(make_feed(''))
+      assert_equal(Time.parse(ENTRY_UPDATED), feed.entry.updated.content)
+    end
+
+    def test_entry_published
+      generator = method(:make_feed_with_open_entry)
+      assert_atom_date_construct("published", generator) do |feed|
+        assert_equal(1, feed.entries.size)
+        feed.entry.published
+      end
+    end
+
+    def test_entry_summary
+      generator = method(:make_feed_with_open_entry)
+      assert_atom_text_construct("summary", generator) do |feed|
+        assert_equal(1, feed.entries.size)
+        feed.entry.summary
+      end
+    end
+  end
+end