rss 0.2.9 → 0.3.0

data/test/test_1.0.rb

@@ -1,308 +0,0 @@
-# frozen_string_literal: false
-require "rexml/document"
-
-require_relative "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"
-      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
-
-      h = {
-        'title' => "fugafuga",
-        'link' => "http://hoge.com",
-        'description' => "fugafugafugafuga",
-        'image' => image,
-        'items' => items,
-        'textinput' => textinput,
-      }
-
-      channel = RDF::Channel.new(about)
-      %w(title link description image items textinput).each do |x|
-        channel.__send__("#{x}=", h[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 = h[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"
-      h = {
-        '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}=", h[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(h[x], elem.text)
-      end
-    end
-
-    def test_item
-      about = "http://hoge.com"
-      h = {
-        'title' => "fugafuga",
-        'link' => "http://hoge.com/fuga",
-        'description' => "hogehogehoge",
-      }
-
-      item = RDF::Item.new(about)
-      %w(title link description).each do |x|
-        item.__send__("#{x}=", h[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(h[x], elem.text)
-      end
-    end
-
-    def test_textinput
-      about = "http://hoge.com"
-      h = {
-        '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}=", h[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(h[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/test_2.0.rb

@@ -1,412 +0,0 @@
-# frozen_string_literal: false
-require "rexml/document"
-
-require_relative "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
-      h = {
-        '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"),
-        '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))',
-      }
-      categories = [
-        {
-          :content => "Newspapers",
-        },
-        {
-          :domain => "Syndic8",
-          :content => "1765",
-        }
-      ]
-
-      channel = Rss::Channel.new
-
-      elems = %w(title link description language copyright
-                 managingEditor webMaster pubDate lastBuildDate
-                 generator docs ttl rating)
-      elems.each do |x|
-        value = h[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 = h[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
-      h = {
-        'title' => "fugafuga",
-        'link' => "http://hoge.com/",
-        'description' => "text hoge fuga",
-        'author' => "oprah@oxygen.net",
-        '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"),
-      }
-      categories = [
-        {
-          :content => "Newspapers",
-        },
-        {
-          :domain => "Syndic8",
-          :content => "1765",
-        }
-      ]
-
-      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 = h[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 = h[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