rss-nokogiri 0.0.1

data/test/regression/test_1.0.rb

@@ -0,0 +1,295 @@
+require "rexml/document"
+
+require "rss-testcase"
+
+require "rss/1.0"
+
+module RSS
+  class TestRSS10Core < TestCase
+
+    def setup
+      @rdf_prefix = "rdf"
+      @rdf_uri = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+      @uri = "http://purl.org/rss/1.0/"
+    end
+
+    def test_RDF
+      version = "1.0"
+      encoding = "UTF-8"
+      standalone = false
+
+      rdf = RDF.new(version, encoding, standalone)
+      setup_rss10(rdf)
+      doc = REXML::Document.new(rdf.to_s)
+
+      xmldecl = doc.xml_decl
+
+      assert_equal(version, xmldecl.version)
+      assert_equal(encoding, xmldecl.encoding.to_s)
+      assert_equal(standalone, !xmldecl.standalone.nil?)
+
+      assert_equal(@rdf_uri, doc.root.namespace)
+    end
+
+    def test_not_displayed_xml_stylesheets
+      rdf = RDF.new()
+      plain_rdf = rdf.to_s
+      3.times do
+        rdf.xml_stylesheets.push(XMLStyleSheet.new)
+        assert_equal(plain_rdf, rdf.to_s)
+      end
+    end
+
+    def test_xml_stylesheets
+      [
+        [{:href => "a.xsl", :type => "text/xsl"}],
+        [
+          {:href => "a.xsl", :type => "text/xsl"},
+          {:href => "a.css", :type => "text/css"},
+        ],
+      ].each do |attrs_ary|
+        assert_xml_stylesheet_pis(attrs_ary)
+      end
+    end
+
+    def test_channel
+      about = "http://hoge.com"
+      title = "fugafuga"
+      link = "http://hoge.com"
+      description = "fugafugafugafuga"
+      resource = "http://hoge.com/hoge.png"
+
+      item_title = "item title"
+      item_link = "http://hoge.com/item"
+
+      image = RDF::Channel::Image.new(resource)
+      items = RDF::Channel::Items.new
+      items.Seq.lis << items.class::Seq::Li.new(item_link)
+      textinput = RDF::Channel::Textinput.new(resource)
+
+      rss_item = RDF::Item.new
+      rss_item.title = item_title
+      rss_item.link = item_link
+      rss_item.about = item_link
+
+      channel = RDF::Channel.new(about)
+      %w(title link description image items textinput).each do |x|
+        channel.__send__("#{x}=", instance_eval(x))
+      end
+
+      doc = REXML::Document.new(make_RDF(<<-EOR))
+#{channel}
+<items>
+#{rss_item}
+</items>
+EOR
+      c = doc.root.elements[1]
+
+      assert_equal(about, c.attributes["about"])
+      %w(title link description image textinput).each do |x|
+        elem = c.elements[x]
+        assert_equal(x, elem.name)
+        assert_equal(@uri, elem.namespace)
+        if x == "image" or x == "textinput"
+          excepted = resource
+          res = elem.attributes.get_attribute("resource")
+          assert_equal(@rdf_uri, res.namespace)
+          value = res.value
+        else
+          excepted = instance_eval(x)
+          value = elem.text
+        end
+        assert_equal(excepted, value)
+      end
+      assert_equal(@uri, c.elements["items"].namespace)
+      assert_equal("items", c.elements["items"].name)
+    end
+
+    def test_channel_image
+      resource = "http://hoge.com/hoge.png"
+      image = RDF::Channel::Image.new(resource)
+
+      doc = REXML::Document.new(make_RDF(image.to_s))
+      i = doc.root.elements[1]
+
+      assert_equal("image", i.name)
+      assert_equal(@uri, i.namespace)
+
+      res = i.attributes.get_attribute("resource")
+
+      assert_equal(@rdf_uri, res.namespace)
+      assert_equal(resource, res.value)
+    end
+
+    def test_channel_textinput
+      resource = "http://hoge.com/hoge.png"
+      textinput = RDF::Channel::Textinput.new(resource)
+
+      doc = REXML::Document.new(make_RDF(textinput.to_s))
+      t = doc.root.elements[1]
+
+      assert_equal("textinput", t.name)
+      assert_equal(@uri, t.namespace)
+
+      res = t.attributes.get_attribute("resource")
+
+      assert_equal(@rdf_uri, res.namespace)
+      assert_equal(resource, res.value)
+    end
+
+    def test_channel_items
+      item_link = "http://example.com/item"
+
+      items = RDF::Channel::Items.new
+      li = items.Seq.class::Li.new(item_link)
+      items.Seq.lis << li
+
+      doc = REXML::Document.new(make_RDF(items.to_s))
+      i = doc.root.elements[1]
+
+      assert_equal("items", i.name)
+      assert_equal(@uri, i.namespace)
+
+      assert_equal(1, i.elements.size)
+      seq = i.elements[1]
+      assert_equal("Seq", seq.name)
+      assert_equal(@rdf_uri, seq.namespace)
+
+      assert_equal(1, seq.elements.size)
+      l = seq.elements[1]
+      assert_equal("li", l.name)
+      assert_equal(@rdf_uri, l.namespace)
+      assert_equal(item_link, l.attributes["resource"])
+    end
+
+    def test_seq
+      item_link = "http://example.com/item"
+      seq = RDF::Seq.new
+      li = seq.class::Li.new(item_link)
+      seq.lis << li
+
+      doc = REXML::Document.new(make_RDF(seq.to_s))
+      s = doc.root.elements[1]
+
+      assert_equal("Seq", s.name)
+      assert_equal(@rdf_uri, s.namespace)
+
+      assert_equal(1, s.elements.size)
+      l = s.elements[1]
+      assert_equal("li", l.name)
+      assert_equal(@rdf_uri, l.namespace)
+      assert_equal(item_link, l.attributes["resource"])
+    end
+
+    def test_li
+      resource = "http://hoge.com/"
+      li = RDF::Li.new(resource)
+
+      doc = REXML::Document.new(make_RDF(li.to_s))
+      l = doc.root.elements[1]
+
+      assert_equal("li", l.name)
+      assert_equal(@rdf_uri, l.namespace(l.prefix))
+
+      res = l.attributes.get_attribute("resource")
+
+      assert_equal('', res.instance_eval("@prefix"))
+      assert_equal(resource, res.value)
+    end
+
+    def test_image
+      about = "http://hoge.com"
+      title = "fugafuga"
+      url = "http://hoge.com/hoge"
+      link = "http://hoge.com/fuga"
+
+      image = RDF::Image.new(about)
+      %w(title url link).each do |x|
+        image.__send__("#{x}=", instance_eval(x))
+      end
+
+      doc = REXML::Document.new(make_RDF(image.to_s))
+      i = doc.root.elements[1]
+
+      assert_equal(about, i.attributes["about"])
+      %w(title url link).each do |x|
+        elem = i.elements[x]
+        assert_equal(x, elem.name)
+        assert_equal(@uri, elem.namespace)
+        assert_equal(instance_eval(x), elem.text)
+      end
+    end
+
+    def test_item
+      about = "http://hoge.com"
+      title = "fugafuga"
+      link = "http://hoge.com/fuga"
+      description = "hogehogehoge"
+
+      item = RDF::Item.new(about)
+      %w(title link description).each do |x|
+        item.__send__("#{x}=", instance_eval(x))
+      end
+
+      doc = REXML::Document.new(make_RDF(item.to_s))
+      i = doc.root.elements[1]
+
+      assert_equal(about, i.attributes["about"])
+      %w(title link description).each do |x|
+        elem = i.elements[x]
+        assert_equal(x, elem.name)
+        assert_equal(@uri, elem.namespace)
+        assert_equal(instance_eval(x), elem.text)
+      end
+    end
+
+    def test_textinput
+      about = "http://hoge.com"
+      title = "fugafuga"
+      link = "http://hoge.com/fuga"
+      name = "foo"
+      description = "hogehogehoge"
+
+      textinput = RDF::Textinput.new(about)
+      %w(title link name description).each do |x|
+        textinput.__send__("#{x}=", instance_eval(x))
+      end
+
+      doc = REXML::Document.new(make_RDF(textinput.to_s))
+      t = doc.root.elements[1]
+
+      assert_equal(about, t.attributes["about"])
+      %w(title link name description).each do |x|
+        elem = t.elements[x]
+        assert_equal(x, elem.name)
+        assert_equal(@uri, elem.namespace)
+        assert_equal(instance_eval(x), elem.text)
+      end
+    end
+
+    def test_to_xml
+      rss = RSS::Parser.parse(make_sample_RDF)
+      assert_equal(rss.to_s, rss.to_xml)
+      assert_equal(rss.to_s, rss.to_xml("1.0"))
+      rss09 = rss.to_xml("0.91") do |maker|
+        maker.channel.language = "en-us"
+      end
+      rss09 = RSS::Parser.parse(rss09)
+      assert_equal("0.91", rss09.rss_version)
+      assert_equal(["rss", "0.91", nil], rss09.feed_info)
+      rss20 = RSS::Parser.parse(rss.to_xml("2.0"))
+      assert_equal("2.0", rss20.rss_version)
+      assert_equal(["rss", "2.0", nil], rss20.feed_info)
+
+      atom_xml = rss.to_xml("atom") do |maker|
+        maker.channel.author = "Alice"
+        maker.channel.updated ||= Time.now
+        maker.items.each do |item|
+          item.updated ||= Time.now
+        end
+      end
+      atom = RSS::Parser.parse(atom_xml)
+      assert_equal(["atom", "1.0", "feed"], atom.feed_info)
+    end
+  end
+end

data/test/regression/test_2.0.rb

@@ -0,0 +1,409 @@
+require "rexml/document"
+
+require "rss-testcase"
+
+module RSS
+  class TestRSS20Core < TestCase
+
+    def setup
+      @rss_version = "2.0"
+    end
+
+    def test_Rss
+      version = "1.0"
+      encoding = "UTF-8"
+      standalone = false
+
+      rss = Rss.new(@rss_version, version, encoding, standalone)
+      setup_rss20(rss)
+
+      doc = REXML::Document.new(rss.to_s(false))
+
+      xmldecl = doc.xml_decl
+
+      assert_equal(version, xmldecl.version)
+      assert_equal(encoding, xmldecl.encoding.to_s)
+      assert_equal(standalone, !xmldecl.standalone.nil?)
+
+      assert_equal("", doc.root.namespace)
+      assert_equal(@rss_version, doc.root.attributes["version"])
+    end
+
+    def test_not_displayed_xml_stylesheets
+      rss = Rss.new(@rss_version)
+      plain_rss = rss.to_s
+      3.times do
+        rss.xml_stylesheets.push(XMLStyleSheet.new)
+        assert_equal(plain_rss, rss.to_s)
+      end
+    end
+
+    def test_xml_stylesheets
+      [
+        [{:href => "a.xsl", :type => "text/xsl"}],
+        [
+          {:href => "a.xsl", :type => "text/xsl"},
+          {:href => "a.css", :type => "text/css"},
+        ],
+      ].each do |attrs_ary|
+        rss = Rss.new(@rss_version)
+        setup_rss20(rss)
+        assert_xml_stylesheet_pis(attrs_ary, rss)
+      end
+    end
+
+    def test_channel
+      title = "fugafuga"
+      link = "http://hoge.com"
+      description = "fugafugafugafuga"
+
+      language = "en-us"
+      copyright = "Copyright 2002, Spartanburg Herald-Journal"
+      managingEditor = "geo@herald.com (George Matesky)"
+      webMaster = "betty@herald.com (Betty Guernsey)"
+      pubDate = Time.parse("Sat, 07 Sep 2002 00:00:01 GMT")
+      lastBuildDate = Time.parse("Sat, 07 Sep 2002 09:42:31 GMT")
+      categories = [
+        {
+          :content => "Newspapers",
+        },
+        {
+          :domain => "Syndic8",
+          :content => "1765",
+        }
+      ]
+      generator = "MightyInHouse Content System v2.3"
+      docs = "http://blogs.law.harvard.edu/tech/rss"
+
+      ttl = "60"
+
+      rating = '(PICS-1.1 "http://www.rsac.org/ratingsv01.html" l gen true comment "RSACi North America Server" for "http://www.rsac.org" on "1996.04.16T08:15-0500" r (n 0 s 0 v 0 l 0))'
+
+      channel = Rss::Channel.new
+
+      elems = %w(title link description language copyright
+                 managingEditor webMaster pubDate lastBuildDate
+                 generator docs ttl rating)
+      elems.each do |x|
+        value = instance_eval(x)
+        value = value.rfc822 if %w(pubDate lastBuildDate).include?(x)
+        channel.__send__("#{x}=", value)
+      end
+      categories.each do |cat|
+        channel.categories << Rss::Channel::Category.new(cat[:domain],
+                                                         cat[:content])
+      end
+
+      doc = REXML::Document.new(make_rss20(channel.to_s))
+      c = doc.root.elements[1]
+
+      elems.each do |x|
+        elem = c.elements[x]
+        assert_equal(x, elem.name)
+        assert_equal("", elem.namespace)
+        expected = instance_eval(x)
+        case x
+        when "pubDate", "lastBuildDate"
+          assert_equal(expected, Time.parse(elem.text))
+        when "ttl"
+          expected = channel.__send__(x)
+          assert_equal(expected, elem.text.to_i)
+        else
+          assert_equal(expected, elem.text)
+        end
+      end
+      categories.each_with_index do |cat, i|
+        cat = cat.dup
+        cat[:domain] ||= nil
+        category = c.elements["category[#{i+1}]"]
+        actual = {
+          :domain => category.attributes["domain"],
+          :content => category.text,
+        }
+        assert_equal(cat, actual)
+      end
+    end
+
+    def test_channel_cloud
+      cloud_params = {
+        :domain => "rpc.sys.com",
+        :port => "80",
+        :path => "/RPC2",
+        :registerProcedure => "myCloud.rssPleaseNotify",
+        :protocol => "xml-rpc",
+      }
+      cloud = Rss::Channel::Cloud.new(cloud_params[:domain],
+                                      cloud_params[:port],
+                                      cloud_params[:path],
+                                      cloud_params[:registerProcedure],
+                                      cloud_params[:protocol])
+      cloud_params[:port] = cloud.port
+
+      doc = REXML::Document.new(cloud.to_s)
+      cloud_elem = doc.root
+
+      actual = {}
+      cloud_elem.attributes.each do |name, value|
+        value = value.to_i if name == "port"
+        actual[name.intern] = value
+      end
+      assert_equal(cloud_params, actual)
+    end
+
+    def test_channel_image
+      image_params = {
+        :url => "http://hoge.com/hoge.png",
+        :title => "fugafuga",
+        :link => "http://hoge.com",
+        :width => "144",
+        :height => "400",
+        :description => "an image",
+      }
+      image = Rss::Channel::Image.new(image_params[:url],
+                                      image_params[:title],
+                                      image_params[:link],
+                                      image_params[:width],
+                                      image_params[:height],
+                                      image_params[:description])
+
+      doc = REXML::Document.new(image.to_s)
+      image_elem = doc.root
+
+      image_params.each do |name, value|
+        value = image.__send__(name)
+        actual = image_elem.elements[name.to_s].text
+        actual = actual.to_i if [:width, :height].include?(name)
+        assert_equal(value, actual)
+      end
+    end
+
+    def test_channel_textInput
+      textInput_params = {
+        :title => "fugafuga",
+        :description => "text hoge fuga",
+        :name => "hoge",
+        :link => "http://hoge.com",
+      }
+      textInput = Rss::Channel::TextInput.new(textInput_params[:title],
+                                              textInput_params[:description],
+                                              textInput_params[:name],
+                                              textInput_params[:link])
+
+      doc = REXML::Document.new(textInput.to_s)
+      input_elem = doc.root
+
+      textInput_params.each do |name, value|
+        actual = input_elem.elements[name.to_s].text
+        assert_equal(value, actual)
+      end
+    end
+
+    def test_channel_skip_days
+      skipDays_values = [
+        "Sunday",
+        "Monday",
+      ]
+      skipDays = Rss::Channel::SkipDays.new
+      skipDays_values.each do |value|
+        skipDays.days << Rss::Channel::SkipDays::Day.new(value)
+      end
+
+      doc = REXML::Document.new(skipDays.to_s)
+      days_elem = doc.root
+
+      skipDays_values.each_with_index do |value, i|
+        assert_equal(value, days_elem.elements[i + 1].text)
+      end
+    end
+
+    def test_channel_skip_hours
+      skipHours_values = [
+        "0",
+        "13",
+      ]
+      skipHours = Rss::Channel::SkipHours.new
+      skipHours_values.each do |value|
+        skipHours.hours << Rss::Channel::SkipHours::Hour.new(value)
+      end
+
+      doc = REXML::Document.new(skipHours.to_s)
+      hours_elem = doc.root
+
+      skipHours_values.each_with_index do |value, i|
+        expected = skipHours.hours[i].content
+        assert_equal(expected, hours_elem.elements[i + 1].text.to_i)
+      end
+    end
+
+    def test_item
+      title = "fugafuga"
+      link = "http://hoge.com/"
+      description = "text hoge fuga"
+      author = "oprah@oxygen.net"
+      categories = [
+        {
+          :content => "Newspapers",
+        },
+        {
+          :domain => "Syndic8",
+          :content => "1765",
+        }
+      ]
+      comments = "http://www.myblog.org/cgi-local/mt/mt-comments.cgi?entry_id=290"
+      pubDate = Time.parse("Sat, 07 Sep 2002 00:00:01 GMT")
+
+      channel = Rss::Channel.new
+      channel.title = "title"
+      channel.link = "http://example.com/"
+      channel.description = "description"
+
+      item = Rss::Channel::Item.new
+      channel.items << item
+
+      elems = %w(title link description author comments pubDate)
+      elems.each do |x|
+        value = instance_eval(x)
+        value = value.rfc822 if x == "pubDate"
+        item.__send__("#{x}=", value)
+      end
+      categories.each do |cat|
+        item.categories << Rss::Channel::Category.new(cat[:domain],
+                                                      cat[:content])
+      end
+
+      doc = REXML::Document.new(channel.to_s)
+      channel_elem = doc.root
+
+      item_elem = channel_elem.elements["item[1]"]
+      elems.each do |x|
+        elem = item_elem.elements[x]
+        assert_equal(x, elem.name)
+        assert_equal("", elem.namespace)
+        expected = instance_eval(x)
+        case x
+        when "pubDate"
+          assert_equal(expected, Time.parse(elem.text))
+        else
+          assert_equal(expected, elem.text)
+        end
+      end
+      categories.each_with_index do |cat, i|
+        cat = cat.dup
+        cat[:domain] ||= nil
+        category = item_elem.elements["category[#{i+1}]"]
+        actual = {
+          :domain => category.attributes["domain"],
+          :content => category.text,
+        }
+        assert_equal(cat, actual)
+      end
+    end
+
+    def test_item_enclosure
+      enclosure_params = {
+        :url => "http://www.scripting.com/mp3s/weatherReportSuite.mp3",
+        :length => "12216320",
+        :type => "audio/mpeg",
+      }
+
+      enclosure = Rss::Channel::Item::Enclosure.new(enclosure_params[:url],
+                                                    enclosure_params[:length],
+                                                    enclosure_params[:type])
+      enclosure_params[:length] = enclosure.length
+
+      doc = REXML::Document.new(enclosure.to_s)
+      enclosure_elem = doc.root
+
+      actual = {}
+      enclosure_elem.attributes.each do |name, value|
+        value = value.to_i if name == "length"
+        actual[name.intern] = value
+      end
+      assert_equal(enclosure_params, actual)
+    end
+
+    def test_item_guid
+      test_params = [
+        {
+          :content => "http://some.server.com/weblogItem3207",
+        },
+        {
+          :isPermaLink => "true",
+          :content => "http://inessential.com/2002/09/01.php#a2",
+        },
+      ]
+
+      test_params.each do |guid_params|
+        guid = Rss::Channel::Item::Guid.new(guid_params[:isPermaLink],
+                                            guid_params[:content])
+        if guid_params.has_key?(:isPermaLink)
+          guid_params[:isPermaLink] = guid.isPermaLink
+        end
+        if guid.isPermaLink.nil?
+          assert_equal(true, guid.PermaLink?)
+        else
+          assert_equal(guid.isPermaLink, guid.PermaLink?)
+        end
+
+        doc = REXML::Document.new(guid.to_s)
+        guid_elem = doc.root
+
+        actual = {}
+        actual[:content] = guid_elem.text if guid_elem.text
+        guid_elem.attributes.each do |name, value|
+          value = value == "true" if name == "isPermaLink"
+          actual[name.intern] = value
+        end
+        assert_equal(guid_params, actual)
+      end
+    end
+
+    def test_item_source
+      source_params = {
+        :url => "http://www.tomalak.org/links2.xml",
+        :content => "Tomalak's Realm",
+      }
+
+      source = Rss::Channel::Item::Source.new(source_params[:url],
+                                              source_params[:content])
+
+      doc = REXML::Document.new(source.to_s)
+      source_elem = doc.root
+
+      actual = {}
+      actual[:content] = source_elem.text
+      source_elem.attributes.each do |name, value|
+        actual[name.intern] = value
+      end
+      assert_equal(source_params, actual)
+    end
+
+    def test_to_xml
+      rss = RSS::Parser.parse(make_sample_rss20)
+      assert_equal(rss.to_s, rss.to_xml)
+      assert_equal(rss.to_s, rss.to_xml("2.0"))
+      rss09_xml = rss.to_xml("0.91") do |maker|
+        setup_dummy_image(maker)
+      end
+      rss09 = RSS::Parser.parse(rss09_xml)
+      assert_equal("0.91", rss09.rss_version)
+      rss10 = rss.to_xml("1.0") do |maker|
+        maker.channel.about = "http://www.example.com/index.rdf"
+      end
+      rss10 = RSS::Parser.parse(rss10)
+      assert_equal("1.0", rss10.rss_version)
+
+      atom_xml = rss.to_xml("atom1.0") do |maker|
+        maker.channel.id = "http://www.example.com/atom.xml"
+        maker.channel.author = "Alice"
+        maker.channel.updated = Time.now
+        maker.items.each do |item|
+          item.author = "Bob"
+          item.updated = Time.now
+        end
+      end
+      atom = RSS::Parser.parse(atom_xml)
+      assert_equal(["atom", "1.0", "feed"], atom.feed_info)
+    end
+  end
+end