From 966a25465aab5c2972e6c453f631a15fc2223256 Mon Sep 17 00:00:00 2001 From: kou Date: Sat, 17 Mar 2007 10:13:25 +0000 Subject: * lib/rss, test/rss: - supported Atom. - bumped version 0.1.6 to 0.1.7. * sample/rss/convert.rb: added new sample. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12087 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- test/rss/rss-assertions.rb | 2207 ++++++++++++++++++++++++++++++- test/rss/rss-testcase.rb | 201 ++- test/rss/test_1.0.rb | 81 +- test/rss/test_2.0.rb | 54 +- test/rss/test_atom.rb | 281 ++++ test/rss/test_content.rb | 2 +- test/rss/test_dublincore.rb | 316 +++-- test/rss/test_image.rb | 18 +- test/rss/test_maker_0.9.rb | 140 +- test/rss/test_maker_1.0.rb | 171 ++- test/rss/test_maker_2.0.rb | 74 +- test/rss/test_maker_atom_entry.rb | 367 +++++ test/rss/test_maker_atom_feed.rb | 380 ++++++ test/rss/test_maker_dc.rb | 15 +- test/rss/test_maker_sy.rb | 1 + test/rss/test_maker_taxo.rb | 10 +- test/rss/test_maker_trackback.rb | 5 +- test/rss/test_maker_xml-stylesheet.rb | 46 +- test/rss/test_parser.rb | 586 -------- test/rss/test_parser_1.0.rb | 503 +++++++ test/rss/test_parser_2.0.rb | 122 ++ test/rss/test_parser_atom_entry.rb | 163 +++ test/rss/test_parser_atom_feed.rb | 276 ++++ test/rss/test_setup_maker_0.9.rb | 61 +- test/rss/test_setup_maker_1.0.rb | 124 +- test/rss/test_setup_maker_2.0.rb | 75 +- test/rss/test_setup_maker_atom_entry.rb | 409 ++++++ test/rss/test_setup_maker_atom_feed.rb | 443 +++++++ test/rss/test_syndication.rb | 6 +- test/rss/test_taxonomy.rb | 2 +- test/rss/test_trackback.rb | 2 +- test/rss/test_version.rb | 2 +- test/rss/test_xml-stylesheet.rb | 6 +- 33 files changed, 6100 insertions(+), 1049 deletions(-) create mode 100644 test/rss/test_atom.rb create mode 100644 test/rss/test_maker_atom_entry.rb create mode 100644 test/rss/test_maker_atom_feed.rb create mode 100644 test/rss/test_parser_1.0.rb create mode 100644 test/rss/test_parser_2.0.rb create mode 100644 test/rss/test_parser_atom_entry.rb create mode 100644 test/rss/test_parser_atom_feed.rb create mode 100644 test/rss/test_setup_maker_atom_entry.rb create mode 100644 test/rss/test_setup_maker_atom_feed.rb (limited to 'test') diff --git a/test/rss/rss-assertions.rb b/test/rss/rss-assertions.rb index c61f74b136..01f68678f0 100644 --- a/test/rss/rss-assertions.rb +++ b/test/rss/rss-assertions.rb @@ -1,6 +1,5 @@ module RSS module Assertions - def assert_parse(rss, assert_method, *args) __send__("assert_#{assert_method}", *args) do ::RSS::Parser.parse(rss) @@ -58,13 +57,14 @@ module RSS end end - def assert_not_excepted_tag(tag, parent) + def assert_not_expected_tag(tag, uri, parent) _wrap_assertion do begin yield - flunk("Not raise NotExceptedTagError") - rescue ::RSS::NotExceptedTagError => e + flunk("Not raise NotExpectedTagError") + rescue ::RSS::NotExpectedTagError => e assert_equal(tag, e.tag) + assert_equal(uri, e.uri) assert_equal(parent, e.parent) end end @@ -129,10 +129,13 @@ module RSS def assert_xml_stylesheet_pis(attrs_ary, rss=nil) _wrap_assertion do - rss ||= ::RSS::RDF.new() + if rss.nil? + rss = ::RSS::RDF.new + setup_rss10(rss) + end xss_strs = [] attrs_ary.each do |attrs| - xss = ::RSS::XMLStyleSheet.new(*attrs) + xss = ::RSS::XMLStyleSheet.new(attrs) xss_strs.push(xss.to_s) rss.xml_stylesheets.push(xss) end @@ -381,6 +384,648 @@ module RSS end end + def assert_atom_person(tag_name, generator) + _wrap_assertion do + name = "Mark Pilgrim" + uri = "http://example.org/" + email = "f8dy@example.com" + + assert_parse(generator.call(<<-EOA), :missing_tag, "name", tag_name) + <#{tag_name}/> +EOA + + assert_parse(generator.call(<<-EOA), :missing_tag, "name", tag_name) + <#{tag_name}> + #{uri} + #{email} + +EOA + + assert_parse(generator.call(<<-EOA), :nothing_raised) + <#{tag_name}> + #{name} + +EOA + + feed = RSS::Parser.parse(generator.call(<<-EOA)) + <#{tag_name}> + #{name} + #{uri} + #{email} + +EOA + + person = yield(feed) + assert_not_nil(person) + assert_equal(name, person.name.content) + assert_equal(uri, person.uri.content) + assert_equal(email, person.email.content) + end + end + + def assert_atom_category(generator) + _wrap_assertion do + term = "Music" + scheme = "http://xmlns.com/wordnet/1.6/" + label = "music" + + missing_args = [:missing_attribute, "category", "term"] + assert_parse(generator.call(<<-EOA), *missing_args) + +EOA + + assert_parse(generator.call(<<-EOA), *missing_args) + +EOA + + assert_parse(generator.call(<<-EOA), :nothing_raised) + +EOA + + feed = RSS::Parser.parse(generator.call(<<-EOA)) + +EOA + + category = yield(feed) + assert_not_nil(category) + assert_equal(term, category.term) + assert_equal(scheme, category.scheme) + assert_equal(label, category.label) + end + end + + def assert_atom_link(generator) + _wrap_assertion do + href = "http://example.org/feed.atom" + rel = "self" + type = "application/atom+xml" + hreflang = "en" + title = "Atom" + length = "1024" + + assert_parse(generator.call(<<-EOA), :missing_attribute, "link", "href") + +EOA + + assert_parse(generator.call(<<-EOA), :missing_attribute, "link", "href") + +EOA + + assert_parse(generator.call(<<-EOA), :nothing_raised) + +EOA + + feed = RSS::Parser.parse(generator.call(<<-EOA)) + +EOA + + link = yield(feed) + assert_not_nil(link) + assert_equal(href, link.href) + assert_equal(rel, link.rel) + assert_equal(type, link.type) + assert_equal(hreflang, link.hreflang) + assert_equal(title, link.title) + assert_equal(length, link.length) + + + href = "http://example.org/index.html.ja" + parent = link.parent.tag_name + return if parent == "source" + + optional_attributes = %w(hreflang="ja" type="text/html") + 0.upto(optional_attributes.size) do |i| + combination(optional_attributes, i).each do |attributes| + attrs = attributes.join(" ") + assert_parse(generator.call(<<-EOA), :too_much_tag, "link", parent) + + +EOA + end + end + end + end + + def assert_atom_generator(generator) + _wrap_assertion do + uri = "http://www.example.com/" + version = "1.0" + content = "Example Toolkit" + + assert_parse(generator.call(<<-EOA), :nothing_raised) + +EOA + + assert_parse(generator.call(<<-EOA), :nothing_raised) + +EOA + + feed = RSS::Parser.parse(generator.call(<<-EOA)) + #{content} +EOA + + gen = yield(feed) + assert_not_nil(gen) + assert_equal(uri, gen.uri) + assert_equal(version, gen.version) + assert_equal(content, gen.content) + end + end + + def assert_atom_icon(generator) + _wrap_assertion do + content = "http://www.example.com/example.png" + + assert_parse(generator.call(<<-EOA), :nothing_raised) + +EOA + + feed = RSS::Parser.parse(generator.call(<<-EOA)) + #{content} +EOA + + icon = yield(feed) + assert_not_nil(icon) + assert_equal(content, icon.content) + end + end + + def assert_atom_text_construct(tag_name, generator) + _wrap_assertion do + [nil, "text", "html"].each do |type| + attr = "" + attr = " type=\"#{type}\""if type + assert_parse(generator.call(<<-EOA), :nothing_raised) + <#{tag_name}#{attr}/> +EOA + end + + assert_parse(generator.call(<<-EOA), :missing_tag, "div", tag_name) + <#{tag_name} type="xhtml"/> +EOA + + args = ["x", Atom::URI, tag_name] + assert_parse(generator.call(<<-EOA), :not_expected_tag, *args) + <#{tag_name} type="xhtml"> +EOA + + invalid_value = "invalid" + args = ["type", invalid_value] + assert_parse(generator.call(<<-EOA), :not_available_value, *args) + <#{tag_name} type="#{invalid_value}"/> +EOA + + [ + [nil, "A lot of effort went into making this effortless"], + ["text", "A lot of effort went into making this effortless"], + ["html", "A lot of effort went into making this effortless"], + ].each do |type, content| + attr = "" + attr = " type=\"#{type}\"" if type + feed = RSS::Parser.parse(generator.call(<<-EOA)) + <#{tag_name}#{attr}>#{h content} +EOA + + element = yield(feed) + assert_not_nil(element) + assert_equal(type, element.type) + assert_equal(content, element.content) + end + + [false, true].each do |with_space| + xhtml_uri = "http://www.w3.org/1999/xhtml" + xhtml_content = "
abc
" + xhtml_element = RSS::XML::Element.new("div", nil, xhtml_uri, + {"xmlns" => xhtml_uri}, + ["abc"]) + content = xhtml_content + content = " #{content} " if with_space + feed = RSS::Parser.parse(generator.call(<<-EOA)) + <#{tag_name} type="xhtml">#{content} +EOA + + element = yield(feed) + assert_not_nil(element) + assert_equal("xhtml", element.type) + assert_equal(xhtml_content, element.content) + assert_equal(xhtml_element, element.xhtml) + end + end + end + + def assert_atom_date_construct(tag_name, generator) + _wrap_assertion do + args = [tag_name, ""] + assert_parse(generator.call(<<-EOR), :not_available_value, *args) + <#{tag_name}/> +EOR + + [ + ["xxx", false], + ["2007", false], + ["2007/02/09", true], + ].each do |invalid_value, can_parse| + assert_not_available_value(tag_name, invalid_value) do + RSS::Parser.parse(generator.call(<<-EOR)) + <#{tag_name}>#{invalid_value} +EOR + end + + feed = RSS::Parser.parse(generator.call(<<-EOR), false) + <#{tag_name}>#{invalid_value} +EOR + value = yield(feed).content + if can_parse + assert_equal(Time.parse(invalid_value), value) + else + assert_nil(value) + end + end + + [ + "2003-12-13T18:30:02Z", + "2003-12-13T18:30:02.25Z", + "2003-12-13T18:30:02+01:00", + "2003-12-13T18:30:02.25+01:00", + ].each do |valid_value| + assert_parse(generator.call(<<-EOR), :nothing_raised) + <#{tag_name}>#{valid_value} +EOR + + feed = RSS::Parser.parse(generator.call(<<-EOR)) + <#{tag_name}>#{valid_value} +EOR + assert_equal(Time.parse(valid_value), yield(feed).content) + end + end + end + + def assert_atom_logo(generator) + _wrap_assertion do + content = "http://www.example.com/example.png" + + assert_parse(generator.call(<<-EOA), :nothing_raised) + +EOA + + feed = RSS::Parser.parse(generator.call(<<-EOA)) + #{content} +EOA + + logo = yield(feed) + assert_not_nil(logo) + assert_equal(content, logo.content) + end + end + + def assert_atom_content(generator, &getter) + _wrap_assertion do + assert_atom_content_inline_text(generator, &getter) + assert_atom_content_inline_xhtml(generator, &getter) + assert_atom_content_inline_other(generator, &getter) + assert_atom_content_out_of_line(generator, &getter) + end + end + + def assert_atom_content_inline_text(generator) + _wrap_assertion do + [nil, "text", "html"].each do |type| + content = "sample content"] + ].each do |type, content_content| + feed = RSS::Parser.parse(generator.call(<<-EOA)) + #{h content_content} +EOA + content = yield(feed) + assert_equal(type, content.type) + if %w(text html).include?(type) + assert(content.inline_text?) + else + assert(!content.inline_text?) + end + if type == "html" + assert(content.inline_html?) + else + assert(!content.inline_html?) + end + assert(!content.inline_xhtml?) + if type == "text/plain" + assert(content.inline_other?) + assert(content.inline_other_text?) + else + assert(!content.inline_other?) + assert(!content.inline_other_text?) + end + assert(!content.inline_other_xml?) + assert(!content.inline_other_base64?) + assert(!content.out_of_line?) + assert(!content.have_xml_content?) + assert_equal(content_content, content.content) + end + end + end + + def assert_atom_content_inline_xhtml(generator) + _wrap_assertion do + args = ["div", "content"] + assert_parse(generator.call(<<-EOA), :missing_tag, *args) + +EOA + + args = ["x", Atom::URI, "content"] + assert_parse(generator.call(<<-EOA), :not_expected_tag, *args) + +EOA + + xhtml_uri = "http://www.w3.org/1999/xhtml" + xhtml_content = "
abc
" + xhtml_element = RSS::XML::Element.new("div", nil, xhtml_uri, + {"xmlns" => xhtml_uri}, + ["abc"]) + feed = RSS::Parser.parse(generator.call(<<-EOA)) + #{xhtml_content} +EOA + + content = yield(feed) + assert_not_nil(content) + assert_equal("xhtml", content.type) + assert(!content.inline_text?) + assert(!content.inline_html?) + assert(content.inline_xhtml?) + assert(!content.inline_other?) + assert(!content.inline_other_text?) + assert(!content.inline_other_xml?) + assert(!content.inline_other_base64?) + assert(!content.out_of_line?) + assert(content.have_xml_content?) + assert_equal(xhtml_content, content.content) + assert_equal(xhtml_element, content.xhtml) + end + end + + def assert_atom_content_inline_other(generator, &getter) + _wrap_assertion do + assert_atom_content_inline_other_text(generator, &getter) + assert_atom_content_inline_other_xml(generator, &getter) + end + end + + def assert_atom_content_inline_other_text(generator) + _wrap_assertion do + require "zlib" + + type = "application/zip" + assert_parse(generator.call(<<-EOA), :nothing_raised) + +EOA + + text = "" + char = "a" + 100.times do |i| + text << char + char.succ! + end + base64_content = Base64.encode64(Zlib::Deflate.deflate(text)) + + [false, true].each do |with_space| + xml_content = base64_content + xml_content = " #{base64_content}" if with_space + feed = RSS::Parser.parse(generator.call(<<-EOA)) + #{xml_content} +EOA + + content = yield(feed) + assert_not_nil(content) + assert_equal(type, content.type) + assert(!content.inline_text?) + assert(!content.inline_html?) + assert(!content.inline_xhtml?) + assert(content.inline_other?) + assert(!content.inline_other_text?) + assert(!content.inline_other_xml?) + assert(content.inline_other_base64?) + assert(!content.out_of_line?) + assert(!content.have_xml_content?) + assert_equal(text, Zlib::Inflate.inflate(content.content)) + + xml = REXML::Document.new(content.to_s).root + assert_rexml_element([], {"type" => type}, base64_content, xml) + end + end + end + + def assert_atom_content_inline_other_xml(generator) + _wrap_assertion do + type = "image/svg+xml" + + assert_parse(generator.call(<<-EOA), :nothing_raised) + +EOA + + svg_uri = "http://www.w3.org/2000/svg" + svg_width = "50pt" + svg_height = "20pt" + svg_version = "1.0" + text_x = "15" + text_y = "15" + text = "text" + svg_content = <<-EOS +#{text} +EOS + + text_element = RSS::XML::Element.new("text", nil, svg_uri, + { + "x" => text_x, + "y" => text_y, + }, + [text]) + svg_element = RSS::XML::Element.new("svg", nil, svg_uri, + { + "xmlns" => svg_uri, + "width" => svg_width, + "height" => svg_height, + "version" => svg_version, + }, + [text_element]) + feed = RSS::Parser.parse(generator.call(<<-EOA)) + #{svg_content} +EOA + + content = yield(feed) + assert_not_nil(content) + assert_equal(type, content.type) + assert(!content.inline_text?) + assert(!content.inline_html?) + assert(!content.inline_xhtml?) + assert(content.inline_other?) + assert(!content.inline_other_text?) + assert(content.inline_other_xml?) + assert(!content.inline_other_base64?) + assert(!content.out_of_line?) + assert(content.have_xml_content?) + assert_equal(REXML::Document.new(svg_content).to_s.chomp, + REXML::Document.new(content.content).to_s.chomp) + assert_equal(svg_element, content.xml) + assert_nil(content.xhtml) + end + end + + def assert_atom_content_out_of_line(generator) + _wrap_assertion do + text_type = "text/plain" + text_src = "http://example.com/README.txt" + + missing_args = [:missing_attribute, "content", "type"] + # RSS Parser raises error even if this is "should" not "must". + assert_parse(generator.call(<<-EOA), *missing_args) + +EOA + + content_content = "xxx" + not_available_value_args = [:not_available_value, + "content", content_content] + assert_parse(generator.call(<<-EOA), *not_available_value_args) + #{content_content} +EOA + + feed = RSS::Parser.parse(generator.call(<<-EOA)) + +EOA + content = yield(feed) + assert_not_nil(content) + assert_equal(text_type, content.type) + assert_equal(text_src, content.src) + assert(!content.inline_text?) + assert(!content.inline_html?) + assert(!content.inline_xhtml?) + assert(!content.inline_other?) + assert(!content.inline_other_text?) + assert(!content.inline_other_xml?) + assert(!content.inline_other_base64?) + assert(content.out_of_line?) + assert(!content.have_xml_content?) + assert_nil(content.xml) + assert_nil(content.xhtml) + assert_equal("", content.content) + end + end + + def assert_atom_source(generator, &getter) + _wrap_assertion do + assert_atom_source_author(generator, &getter) + assert_atom_source_category(generator, &getter) + assert_atom_source_contributor(generator, &getter) + assert_atom_source_generator(generator, &getter) + assert_atom_source_icon(generator, &getter) + assert_atom_source_id(generator, &getter) + assert_atom_source_link(generator, &getter) + assert_atom_source_logo(generator, &getter) + assert_atom_source_rights(generator, &getter) + assert_atom_source_subtitle(generator, &getter) + assert_atom_source_title(generator, &getter) + assert_atom_source_updated(generator, &getter) + end + end + + def assert_atom_source_author(generator) + assert_atom_person("author", generator) do |feed| + source = yield(feed) + assert_equal(1, source.authors.size) + source.author + end + end + + def assert_atom_source_category(generator) + assert_atom_category(generator) do |feed| + source = yield(feed) + assert_equal(1, source.categories.size) + source.category + end + end + + def assert_atom_source_contributor(generator) + assert_atom_person("contributor", generator) do |feed| + source = yield(feed) + assert_equal(1, source.contributors.size) + source.contributor + end + end + + def assert_atom_source_generator(generator) + assert_atom_generator(generator) do |feed| + yield(feed).generator + end + end + + def assert_atom_source_icon(generator) + assert_atom_icon(generator) do |feed| + yield(feed).icon + end + end + + def assert_atom_source_id(generator) + id_content = "urn:uuid:a2fb588b-5674-4898-b420-265a734fea69" + id = "#{id_content}" + feed = RSS::Parser.parse(generator.call(id)) + assert_equal(id_content, yield(feed).id.content) + end + + def assert_atom_source_link(generator) + assert_atom_link(generator) do |feed| + source = yield(feed) + assert_equal(1, source.links.size) + source.link + end + end + + def assert_atom_source_logo(generator) + assert_atom_logo(generator) do |feed| + yield(feed).logo + end + end + + def assert_atom_source_rights(generator) + assert_atom_text_construct("rights", generator) do |feed| + yield(feed).rights + end + end + + def assert_atom_source_subtitle(generator) + assert_atom_text_construct("subtitle", generator) do |feed| + yield(feed).subtitle + end + end + + def assert_atom_source_title(generator) + assert_atom_text_construct("title", generator) do |feed| + yield(feed).title + end + end + + def assert_atom_source_updated(generator) + assert_atom_date_construct("updated", generator) do |feed| + yield(feed).updated + end + end def assert_dublin_core(elems, target) _wrap_assertion do @@ -479,14 +1124,1550 @@ module RSS end end end - - def normalized_attrs(attrs) - n_attrs = {} - attrs.each do |name, value| - n_attrs[name.to_s] = value + + def assert_rexml_element(children, attrs, text, element, text_type=nil) + _wrap_assertion do + if children + children_info = element.elements.collect {|e| [e.namespace, e.name]} + assert_equal(children.collect {|uri, name| [uri, name]}.sort, + children_info.sort) + end + if attrs + assert_equal(attrs.collect {|k, v| [k, v]}.sort, + element.attributes.collect {|k, v| [k, v]}.sort) + end + case text_type + when :time + assert_not_nil(element.text) + assert_equal(Time.parse(text).to_s, Time.parse(element.text).to_s) + else + assert_equal(text, element.text) + end + end + end + + + def assert_atom_person_to_s(target_class) + _wrap_assertion do + name = "A person" + uri = "http://example.com/person/" + email = "person@example.com" + + target = target_class.new + assert_equal("", target.to_s) + + target = target_class.new + person_name = target_class::Name.new + person_name.content = name + target.name = person_name + xml_target = REXML::Document.new(target.to_s).root + assert_equal(["name"], xml_target.elements.collect {|e| e.name}) + assert_equal([name], xml_target.elements.collect {|e| e.text}) + + person_uri = target_class::Uri.new + person_uri.content = uri + target.uri = person_uri + xml_target = REXML::Document.new(target.to_s).root + assert_equal(["name", "uri"], xml_target.elements.collect {|e| e.name}) + assert_equal([name, uri], xml_target.elements.collect {|e| e.text}) + + person_email = target_class::Email.new + person_email.content = email + target.email = person_email + xml_target = REXML::Document.new(target.to_s).root + assert_equal(["name", "uri", "email"], + xml_target.elements.collect {|e| e.name}) + assert_equal([name, uri, email], + xml_target.elements.collect {|e| e.text}) + end + end + + def assert_atom_category_to_s(target_class) + _wrap_assertion do + term = "music" + scheme = "http://example.com/music" + label = "Music" + + category = target_class.new + assert_equal("", category.to_s) + + category = target_class.new + category.scheme = scheme + assert_equal("", category.to_s) + + category = target_class.new + category.label = label + assert_equal("", category.to_s) + + category = target_class.new + category.scheme = scheme + category.label = label + assert_equal("", category.to_s) + + category = target_class.new + category.term = term + xml = REXML::Document.new(category.to_s).root + assert_rexml_element([], {"term" => term}, nil, xml) + + category = target_class.new + category.term = term + category.scheme = scheme + xml = REXML::Document.new(category.to_s).root + assert_rexml_element([], {"term" => term, "scheme" => scheme}, nil, xml) + + category = target_class.new + category.term = term + category.label = label + xml = REXML::Document.new(category.to_s).root + assert_rexml_element([], {"term" => term, "label" => label}, nil, xml) + + category = target_class.new + category.term = term + category.scheme = scheme + category.label = label + xml = REXML::Document.new(category.to_s).root + attrs = {"term" => term, "scheme" => scheme, "label" => label} + assert_rexml_element([], attrs, nil, xml) + end + end + + def assert_atom_generator_to_s(target_class) + _wrap_assertion do + content = "Feed generator" + uri = "http://example.com/generator" + version = "0.0.1" + + generator = target_class.new + assert_equal("", generator.to_s) + + generator = target_class.new + generator.uri = uri + assert_equal("", generator.to_s) + + generator = target_class.new + generator.version = version + assert_equal("", generator.to_s) + + generator = target_class.new + generator.uri = uri + generator.version = version + assert_equal("", generator.to_s) + + generator = target_class.new + generator.content = content + xml = REXML::Document.new(generator.to_s).root + assert_rexml_element([], {}, content, xml) + + generator = target_class.new + generator.content = content + generator.uri = uri + xml = REXML::Document.new(generator.to_s).root + assert_rexml_element([], {"uri" => uri}, content, xml) + + generator = target_class.new + generator.content = content + generator.version = version + xml = REXML::Document.new(generator.to_s).root + assert_rexml_element([], {"version" => version}, content, xml) + + generator = target_class.new + generator.content = content + generator.uri = uri + generator.version = version + xml = REXML::Document.new(generator.to_s).root + assert_rexml_element([], {"uri" => uri, "version" => version}, + content, xml) + end + end + + def assert_atom_icon_to_s(target_class) + _wrap_assertion do + content = "http://example.com/icon.png" + + icon = target_class.new + assert_equal("", icon.to_s) + + icon = target_class.new + icon.content = content + xml = REXML::Document.new(icon.to_s).root + assert_rexml_element([], {}, content, xml) + end + end + + def assert_atom_id_to_s(target_class) + _wrap_assertion do + content = "http://example.com/1" + + id = target_class.new + assert_equal("", id.to_s) + + id = target_class.new + id.content = content + xml = REXML::Document.new(id.to_s).root + assert_rexml_element([], {}, content, xml) + end + end + + def assert_atom_link_to_s(target_class) + _wrap_assertion do + href = "http://example.com/atom.xml" + rel = "self" + type = "application/atom+xml" + hreflang = "ja" + title = "Atom Feed" + length = "801" + + link = target_class.new + assert_equal("", link.to_s) + + link = target_class.new + link.href = href + xml = REXML::Document.new(link.to_s).root + assert_rexml_element([], {"href" => href}, nil, xml) + + optional_arguments = %w(rel type hreflang title length) + optional_arguments.each do |name| + rest = optional_arguments.reject {|x| x == name} + + link = target_class.new + link.__send__("#{name}=", eval(name)) + assert_equal("", link.to_s) + + rest.each do |n| + link.__send__("#{n}=", eval(n)) + assert_equal("", link.to_s) + end + + link = target_class.new + link.href = href + link.__send__("#{name}=", eval(name)) + attrs = [["href", href], [name, eval(name)]] + xml = REXML::Document.new(link.to_s).root + assert_rexml_element([], attrs, nil, xml) + + rest.each do |n| + link.__send__("#{n}=", eval(n)) + attrs << [n, eval(n)] + xml = REXML::Document.new(link.to_s).root + assert_rexml_element([], attrs, nil, xml) + end + end + end + end + + def assert_atom_logo_to_s(target_class) + _wrap_assertion do + content = "http://example.com/logo.png" + + logo = target_class.new + assert_equal("", logo.to_s) + + logo = target_class.new + logo.content = content + xml = REXML::Document.new(logo.to_s).root + assert_rexml_element([], {}, content, xml) + end + end + + def assert_atom_text_construct_to_s(target_class) + _wrap_assertion do + text_content = "plain text" + html_content = "#{text_content}" + xhtml_uri = "http://www.w3.org/1999/xhtml" + xhtml_em = RSS::XML::Element.new("em", nil, xhtml_uri, {}, text_content) + xhtml_content = RSS::XML::Element.new("div", nil, xhtml_uri, + {"xmlns" => xhtml_uri}, + [xhtml_em]) + + text = target_class.new + assert_equal("", text.to_s) + + text = target_class.new + text.type = "text" + assert_equal("", text.to_s) + + text = target_class.new + text.content = text_content + xml = REXML::Document.new(text.to_s).root + assert_rexml_element([], {}, text_content, xml) + + text = target_class.new + text.type = "text" + text.content = text_content + xml = REXML::Document.new(text.to_s).root + assert_rexml_element([], {"type" => "text"}, text_content, xml) + + text = target_class.new + text.type = "html" + text.content = html_content + xml = REXML::Document.new(text.to_s).root + assert_rexml_element([], {"type" => "html"}, html_content, xml) + + text = target_class.new + text.type = "xhtml" + text.content = xhtml_content + assert_equal("", text.to_s) + + text = target_class.new + text.type = "xhtml" + text.__send__(target_class.xml_setter, xhtml_content) + xml = REXML::Document.new(text.to_s).root + assert_rexml_element([[xhtml_uri, "div"]], {"type" => "xhtml"}, + nil, xml) + assert_rexml_element([[xhtml_uri, "em"]], nil, nil, xml.elements[1]) + assert_rexml_element([], {}, text_content, xml.elements[1].elements[1]) + + text = target_class.new + text.type = "xhtml" + text.__send__(target_class.xml_setter, xhtml_em) + xml = REXML::Document.new(text.to_s).root + assert_rexml_element([[xhtml_uri, "div"]], {"type" => "xhtml"}, + nil, xml) + assert_rexml_element([[xhtml_uri, "em"]], nil, nil, xml.elements[1]) + assert_rexml_element([], {}, text_content, xml.elements[1].elements[1]) + end + end + + def assert_atom_date_construct_to_s(target_class) + _wrap_assertion do + date = target_class.new + assert_equal("", date.to_s) + + [ + "2003-12-13T18:30:02Z", + "2003-12-13T18:30:02.25Z", + "2003-12-13T18:30:02+01:00", + "2003-12-13T18:30:02.25+01:00", + ].each do |content| + date = target_class.new + date.content = content + xml = REXML::Document.new(date.to_s).root + assert_rexml_element([], {}, content, xml, :time) + + date = target_class.new + date.content = Time.parse(content) + xml = REXML::Document.new(date.to_s).root + assert_rexml_element([], {}, content, xml, :time) + end + end + end + + def assert_atom_content_to_s(target_class) + _wrap_assertion do + assert_atom_text_construct_to_s(target_class) + assert_atom_content_inline_other_xml_to_s(target_class) + assert_atom_content_inline_other_text_to_s(target_class) + assert_atom_content_inline_other_base64_to_s(target_class) + assert_atom_content_out_of_line_to_s(target_class) + end + end + + def assert_atom_content_inline_other_xml_to_s(target_class) + _wrap_assertion do + content = target_class.new + content.type = "text/xml" + assert_equal("", content.to_s) + + content = target_class.new + content.type = "text/xml" + content.xml = RSS::XML::Element.new("em") + xml = REXML::Document.new(content.to_s).root + assert_rexml_element([["", "em"]], {"type" => "text/xml"}, nil, xml) + end + end + + def assert_atom_content_inline_other_text_to_s(target_class) + _wrap_assertion do + content = target_class.new + content.type = "text/plain" + assert_equal("", content.to_s) + + content = target_class.new + content.type = "text/plain" + content.xml = RSS::XML::Element.new("em") + assert_equal("", content.to_s) + + content = target_class.new + content.type = "text/plain" + content.content = "content" + xml = REXML::Document.new(content.to_s).root + assert_rexml_element([], {"type" => "text/plain"}, "content", xml) + end + end + + def assert_atom_content_inline_other_base64_to_s(target_class) + _wrap_assertion do + require "zlib" + + text = "" + char = "a" + 100.times do |i| + text << char + char.succ! + end + + type = "application/zip" + original_content = Zlib::Deflate.deflate(text) + + content = target_class.new + content.type = type + content.content = original_content + xml = REXML::Document.new(content.to_s).root + assert_rexml_element([], {"type" => type}, + Base64.encode64(original_content), xml) + end + end + + def assert_atom_content_out_of_line_to_s(target_class) + _wrap_assertion do + type = "application/zip" + src = "http://example.com/xxx.zip" + + content = target_class.new + assert(!content.out_of_line?) + content.src = src + assert(content.out_of_line?) + xml = REXML::Document.new(content.to_s).root + assert_rexml_element([], {"src" => src}, nil, xml) + + content = target_class.new + assert(!content.out_of_line?) + content.type = type + assert(!content.out_of_line?) + content.src = src + assert(content.out_of_line?) + xml = REXML::Document.new(content.to_s).root + assert_rexml_element([], {"type" => type, "src" => src}, nil, xml) + end + end + + def _assert_maker_atom_persons(feed_type, maker_readers, feed_readers) + _wrap_assertion do + persons = [] + feed = RSS::Maker.make("atom:#{feed_type}") do |maker| + yield maker + targets = chain_reader(maker, maker_readers) + targets.each do |target| + person = { + :name => target.name, + :uri => target.uri, + :email => target.email, + } + persons << person if person[:name] + end + end + + actual_persons = chain_reader(feed, feed_readers) || [] + actual_persons = actual_persons.collect do |person| + { + :name => person.name ? person.name.content : nil, + :uri => person.uri ? person.uri.content : nil, + :email => person.email ? person.email.content : nil, + } + end + p [feed_readers, feed.source.authors] unless persons == actual_persons + assert_equal(persons, actual_persons) + end + end + + def assert_maker_atom_persons(feed_type, maker_readers, feed_readers, + not_set_error_name=nil, + parent_not_set_error_name=nil, + parent_not_set_variable=nil) + _wrap_assertion do + not_set_error_name ||= "maker.#{maker_readers.join('.')}" + + args = [feed_type, maker_readers, feed_readers] + if parent_not_set_error_name or parent_not_set_variable + assert_not_set_error(parent_not_set_error_name, + parent_not_set_variable) do + _assert_maker_atom_persons(*args) do |maker| + yield maker + end + end + else + _assert_maker_atom_persons(*args) do |maker| + yield maker + end + end + + assert_not_set_error(not_set_error_name, %w(name)) do + _assert_maker_atom_persons(feed_type, maker_readers, + feed_readers) do |maker| + yield maker + targets = chain_reader(maker, maker_readers) + target = targets.new_child + end + end + + assert_not_set_error(not_set_error_name, %w(name)) do + _assert_maker_atom_persons(feed_type, maker_readers, + feed_readers) do |maker| + yield maker + targets = chain_reader(maker, maker_readers) + target = targets.new_child + target.uri = "http://example.com/~me/" + end + end + + assert_not_set_error(not_set_error_name, %w(name)) do + _assert_maker_atom_persons(feed_type, maker_readers, + feed_readers) do |maker| + yield maker + targets = chain_reader(maker, maker_readers) + target = targets.new_child + target.email = "me@example.com" + end + end + + assert_not_set_error(not_set_error_name, %w(name)) do + _assert_maker_atom_persons(feed_type, maker_readers, + feed_readers) do |maker| + yield maker + targets = chain_reader(maker, maker_readers) + target = targets.new_child + target.uri = "http://example.com/~me/" + target.email = "me@example.com" + end + end + + _assert_maker_atom_persons(feed_type, maker_readers, + feed_readers) do |maker| + yield maker + targets = chain_reader(maker, maker_readers) + target = targets.new_child + target.name = "me" + end + + _assert_maker_atom_persons(feed_type, maker_readers, + feed_readers) do |maker| + yield maker + targets = chain_reader(maker, maker_readers) + target = targets.new_child + target.name = "me" + target.uri = "http://example.com/~me/" + end + + _assert_maker_atom_persons(feed_type, maker_readers, + feed_readers) do |maker| + yield maker + targets = chain_reader(maker, maker_readers) + target = targets.new_child + target.name = "me" + target.email = "me@example.com" + end + + _assert_maker_atom_persons(feed_type, maker_readers, + feed_readers) do |maker| + yield maker + targets = chain_reader(maker, maker_readers) + target = targets.new_child + target.name = "me" + target.uri = "http://example.com/~me/" + target.email = "me@example.com" + end + + _assert_maker_atom_persons(feed_type, maker_readers, + feed_readers) do |maker| + yield maker + targets = chain_reader(maker, maker_readers) + + target = targets.new_child + target.name = "me" + target.uri = "http://example.com/~me/" + target.email = "me@example.com" + + target = targets.new_child + target.name = "you" + target.uri = "http://example.com/~you/" + target.email = "you@example.com" + end + + assert_not_set_error(not_set_error_name, %w(name)) do + _assert_maker_atom_persons(feed_type, maker_readers, + feed_readers) do |maker| + yield maker + targets = chain_reader(maker, maker_readers) + + target = targets.new_child + target.name = "me" + target.uri = "http://example.com/~me/" + target.email = "me@example.com" + + target = targets.new_child + end + end + end + end + + def _assert_maker_atom_text_construct(feed_type, maker_readers, + feed_readers, &block) + maker_extractor = Proc.new do |target| + text = { + :type => target.type, + :content => target.content, + :xml_content => target.xml_content, + } + if text[:type] == "xhtml" + if text[:xml_content] + xml_content = text[:xml_content] + xhtml_uri = "http://www.w3.org/1999/xhtml" + unless xml_content.is_a?(RSS::XML::Element) and + ["div", xhtml_uri] == [xml_content.name, xml_content.uri] + children = xml_content + children = [children] unless children.is_a?(Array) + xml_content = RSS::XML::Element.new("div", nil, xhtml_uri, + {"xmlns" => xhtml_uri}, + children) + text[:xml_content] = xml_content + end + text + else + nil + end + else + text[:content] ? text : nil + end + end + feed_extractor = Proc.new do |target| + { + :type => target.type, + :content => target.content, + :xml_content => target.xhtml, + } + end + _assert_maker_atom_element(feed_type, maker_readers, feed_readers, + maker_extractor, feed_extractor, + &block) + end + + def assert_maker_atom_text_construct(feed_type, maker_readers, feed_readers, + parent_not_set_error_name=nil, + parent_not_set_variable=nil, + not_set_error_name=nil) + _wrap_assertion do + not_set_error_name ||= "maker.#{maker_readers.join('.')}" + + args = [feed_type, maker_readers, feed_readers] + if parent_not_set_error_name or parent_not_set_variable + assert_not_set_error(parent_not_set_error_name, + parent_not_set_variable) do + _assert_maker_atom_text_construct(*args) do |maker| + yield maker + end + end + else + _assert_maker_atom_text_construct(*args) do |maker| + yield maker + end + end + + assert_not_set_error(not_set_error_name, %w(content)) do + _assert_maker_atom_text_construct(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "text" + end + end + + assert_not_set_error(not_set_error_name, %w(content)) do + _assert_maker_atom_text_construct(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "html" + end + end + + assert_not_set_error(not_set_error_name, %w(xml_content)) do + _assert_maker_atom_text_construct(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "xhtml" + end + end + + assert_not_set_error(not_set_error_name, %w(xml_content)) do + _assert_maker_atom_text_construct(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "xhtml" + target.content = "Content" + end + end + + _assert_maker_atom_text_construct(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "text" + target.content = "Content" + end + + _assert_maker_atom_text_construct(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "html" + target.content = "Content" + end + + _assert_maker_atom_text_construct(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "xhtml" + target.xml_content = "text only" + end + + _assert_maker_atom_text_construct(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "xhtml" + target.xml_content = RSS::XML::Element.new("unknown") + end + end + end + + def _assert_maker_atom_date_construct(feed_type, maker_readers, + feed_readers, &block) + maker_extractor = Proc.new do |target| + date = { + :content => target, + } + date[:content] ? date : nil + end + feed_extractor = Proc.new do |target| + { + :content => target.content, + } + end + _assert_maker_atom_element(feed_type, maker_readers, feed_readers, + maker_extractor, feed_extractor, + &block) + end + + def assert_maker_atom_date_construct(feed_type, maker_readers, feed_readers, + parent_not_set_error_name=nil, + parent_not_set_variable=nil) + _wrap_assertion do + args = [feed_type, maker_readers, feed_readers] + if parent_not_set_error_name or parent_not_set_variable + assert_not_set_error(parent_not_set_error_name, + parent_not_set_variable) do + _assert_maker_atom_date_construct(*args) do |maker| + yield maker + end + end + else + _assert_maker_atom_date_construct(*args) do |maker| + yield maker + end + end + + maker_readers = maker_readers.dup + writer = "#{maker_readers.pop}=" + _assert_maker_atom_date_construct(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.__send__(writer, Time.now) + end + end + end + + def _assert_maker_atom_element(feed_type, maker_readers, feed_readers, + maker_extractor, feed_extractor) + _wrap_assertion do + element = nil + feed = RSS::Maker.make("atom:#{feed_type}") do |maker| + yield maker + target = chain_reader(maker, maker_readers) + element = maker_extractor.call(target) + end + + target = chain_reader(feed, feed_readers) + if target + actual_element = feed_extractor.call(target) + else + actual_element = nil + end + assert_equal(element, actual_element) + end + end + + def _assert_maker_atom_elements(feed_type, maker_readers, feed_readers, + maker_extractor, feed_extractor, + invalid_feed_checker=nil) + _wrap_assertion do + elements = [] + invalid_feed = false + feed = RSS::Maker.make("atom:#{feed_type}") do |maker| + yield maker + targets = chain_reader(maker, maker_readers) + targets.each do |target| + element = maker_extractor.call(target) + elements << element if element + end + if invalid_feed_checker + invalid_feed = invalid_feed_checker.call(targets) + end + end + + if invalid_feed + assert_nil(feed) + else + actual_elements = chain_reader(feed, feed_readers) || [] + actual_elements = actual_elements.collect do |target| + feed_extractor.call(target) + end + assert_equal(elements, actual_elements) + end + end + end + + def assert_maker_atom_element(feed_type, maker_readers, feed_readers, + setup_target, optional_variables, + required_variable, assert_method_name, + not_set_error_name=nil, + *additional_args) + _wrap_assertion do + not_set_error_name ||= "maker.#{maker_readers.join('.')}" + + 0.upto(optional_variables.size) do |i| + combination(optional_variables, i).each do |names| + have = {} + names.each do |name| + have[name.intern] = true + end + have_required_variable_too = + have.merge({required_variable.intern => true}) + + assert_not_set_error(not_set_error_name, [required_variable]) do + __send__(assert_method_name, feed_type, maker_readers, + feed_readers, *additional_args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + setup_target.call(target, have) + end + end + + __send__(assert_method_name, feed_type, maker_readers, feed_readers, + *additional_args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + setup_target.call(target, have_required_variable_too) + end + end + end + end + end + + def assert_maker_atom_elements(feed_type, maker_readers, feed_readers, + setup_target, optional_variables, + required_variable, assert_method_name, + not_set_error_name=nil, + *additional_args) + _wrap_assertion do + not_set_error_name ||= "maker.#{maker_readers.join('.')}" + + 0.upto(optional_variables.size) do |i| + combination(optional_variables, i).each do |names| + have = {} + names.each do |name| + have[name.intern] = true + end + have_required_variable_too = + have.merge({required_variable.intern => true}) + + assert_not_set_error(not_set_error_name, [required_variable]) do + __send__(assert_method_name, feed_type, maker_readers, + feed_readers, *additional_args) do |maker| + yield maker + targets = chain_reader(maker, maker_readers) + setup_target.call(targets, have) + end + end + + __send__(assert_method_name, feed_type, maker_readers, feed_readers, + *additional_args) do |maker| + yield maker + targets = chain_reader(maker, maker_readers) + setup_target.call(targets, have_required_variable_too) + end + + __send__(assert_method_name, feed_type, maker_readers, feed_readers, + *additional_args) do |maker| + yield maker + targets = chain_reader(maker, maker_readers) + setup_target.call(targets, have_required_variable_too) + setup_target.call(targets, have_required_variable_too) + end + + assert_not_set_error(not_set_error_name, [required_variable]) do + __send__(assert_method_name, feed_type, maker_readers, feed_readers, + *additional_args) do |maker| + yield maker + targets = chain_reader(maker, maker_readers) + setup_target.call(targets, have_required_variable_too) + setup_target.call(targets, have) + end + end + end + end + end + end + + def _assert_maker_atom_categories(feed_type, maker_readers, + feed_readers, &block) + maker_extractor = Proc.new do |target| + category = { + :term => target.term, + :scheme => target.scheme, + :label => target.label, + } + category[:term] ? category : nil + end + feed_extractor = Proc.new do |target| + { + :term => target.term, + :scheme => target.scheme, + :label => target.label, + } + end + _assert_maker_atom_elements(feed_type, maker_readers, feed_readers, + maker_extractor, feed_extractor, &block) + end + + def assert_maker_atom_categories(feed_type, maker_readers, feed_readers, + not_set_error_name=nil, &block) + _wrap_assertion do + _assert_maker_atom_categories(feed_type, maker_readers, + feed_readers) do |maker| + yield maker + end + + setup_target = Proc.new do |targets, have| + target = targets.new_child + target.term = "music" if have[:term] + target.scheme = "http://example.com/category/music" if have[:scheme] + target.label = "Music" if have[:label] + end + + optional_variables = %w(scheme label) + + assert_maker_atom_elements(feed_type, maker_readers, feed_readers, + setup_target, optional_variables, + "term", :_assert_maker_atom_categories, + not_set_error_name, &block) + end + end + + def _assert_maker_atom_generator(feed_type, maker_readers, + feed_readers, &block) + maker_extractor = Proc.new do |target| + generator = { + :uri => target.uri, + :version => target.version, + :content => target.content, + } + generator[:content] ? generator : nil + end + feed_extractor = Proc.new do |target| + { + :uri => target.uri, + :version => target.version, + :content => target.content, + } + end + _assert_maker_atom_element(feed_type, maker_readers, feed_readers, + maker_extractor, feed_extractor, + &block) + end + + def assert_maker_atom_generator(feed_type, maker_readers, feed_readers, + not_set_error_name=nil, &block) + _wrap_assertion do + not_set_error_name ||= "maker.#{maker_readers.join('.')}" + + _assert_maker_atom_generator(feed_type, maker_readers, + feed_readers) do |maker| + yield maker + end + + setup_target = Proc.new do |target, have| + target.content = "RSS Maker" if have[:content] + target.uri = "http://example.com/rss/maker" if have[:uri] + target.version = "0.0.1" if have[:version] + end + + optional_variables = %w(uri version) + + assert_maker_atom_element(feed_type, maker_readers, feed_readers, + setup_target, optional_variables, + "content", :_assert_maker_atom_generator, + not_set_error_name, &block) + end + end + + def _assert_maker_atom_icon(feed_type, maker_readers, feed_readers, + accessor_base, &block) + maker_extractor = Proc.new do |target| + icon = { + :content => target.__send__(accessor_base), + } + icon[:content] ? icon : nil + end + feed_extractor = Proc.new do |target| + { + :content => target.content, + } + end + _assert_maker_atom_element(feed_type, maker_readers, feed_readers, + maker_extractor, feed_extractor, + &block) + end + + def assert_maker_atom_icon(feed_type, maker_readers, feed_readers, + accessor_base=nil, not_set_error_name=nil) + _wrap_assertion do + accessor_base ||= "url" + not_set_error_name ||= "maker.#{maker_readers.join('.')}" + + _assert_maker_atom_icon(feed_type, maker_readers, feed_readers, + accessor_base) do |maker| + yield maker + end + + _assert_maker_atom_icon(feed_type, maker_readers, feed_readers, + accessor_base) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.__send__("#{accessor_base}=", "http://example.com/icon.png") + end + end + end + + def _assert_maker_atom_links(feed_type, maker_readers, feed_readers, + allow_duplication=false, &block) + maker_extractor = Proc.new do |target| + link = { + :href => target.href, + :rel => target.rel, + :type => target.type, + :hreflang => target.hreflang, + :title => target.title, + :length => target.length, + } + link[:href] ? link : nil + end + feed_extractor = Proc.new do |target| + { + :href => target.href, + :rel => target.rel, + :type => target.type, + :hreflang => target.hreflang, + :title => target.title, + :length => target.length, + } + end + invalid_feed_checker = Proc.new do |targets| + infos = {} + invalid = false + targets.each do |target| + key = [target.hreflang, target.type] + if infos.has_key?(key) + invalid = true + break + end + infos[key] = true if target.rel.nil? or target.rel == "alternate" + end + invalid + end + invalid_feed_checker = nil if allow_duplication + _assert_maker_atom_elements(feed_type, maker_readers, feed_readers, + maker_extractor, feed_extractor, + invalid_feed_checker, + &block) + end + + def assert_maker_atom_links(feed_type, maker_readers, feed_readers, + not_set_error_name=nil, allow_duplication=false, + &block) + _wrap_assertion do + _assert_maker_atom_links(feed_type, maker_readers, + feed_readers) do |maker| + yield maker + end + + langs = %(ja en fr zh po) + setup_target = Proc.new do |targets, have| + target = targets.new_child + lang = langs[targets.size % langs.size] + target.href = "http://example.com/index.html.#{lang}" if have[:href] + target.rel = "alternate" if have[:rel] + target.type = "text/xhtml" if have[:type] + target.hreflang = lang if have[:hreflang] + target.title = "FrontPage(#{lang})" if have[:title] + target.length = 1024 if have[:length] + end + + optional_variables = %w(rel type hreflang title length) + + assert_maker_atom_elements(feed_type, maker_readers, feed_readers, + setup_target, optional_variables, + "href", :_assert_maker_atom_links, + not_set_error_name, allow_duplication, + &block) + end + end + + def _assert_maker_atom_logo(feed_type, maker_readers, feed_readers, + accessor_base, &block) + maker_extractor = Proc.new do |target| + logo = { + :uri => target.__send__(accessor_base), + } + logo[:uri] ? logo : nil + end + feed_extractor = Proc.new do |target| + { + :uri => target.content, + } + end + _assert_maker_atom_element(feed_type, maker_readers, feed_readers, + maker_extractor, feed_extractor, + &block) + end + + def assert_maker_atom_logo(feed_type, maker_readers, feed_readers, + accessor_base=nil, not_set_error_name=nil) + _wrap_assertion do + accessor_base ||= "uri" + not_set_error_name ||= "maker.#{maker_readers.join('.')}" + + _assert_maker_atom_logo(feed_type, maker_readers, feed_readers, + accessor_base) do |maker| + yield maker + end + + _assert_maker_atom_logo(feed_type, maker_readers, feed_readers, + accessor_base) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.__send__("#{accessor_base}=", "http://example.com/logo.png") + end + end + end + + def _assert_maker_atom_id(feed_type, maker_readers, feed_readers, &block) + maker_extractor = Proc.new do |target| + id = { + :uri => target.id, + } + id[:uri] ? id : nil + end + feed_extractor = Proc.new do |target| + if target.id + { + :uri => target.id.content, + } + else + nil + end + end + _assert_maker_atom_element(feed_type, maker_readers, feed_readers, + maker_extractor, feed_extractor, + &block) + end + + def assert_maker_atom_id(feed_type, maker_readers, feed_readers, + not_set_error_name=nil) + _wrap_assertion do + not_set_error_name ||= "maker.#{maker_readers.join('.')}" + + args = [feed_type, maker_readers, feed_readers] + _assert_maker_atom_id(*args) do |maker| + yield maker + end + + _assert_maker_atom_id(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.id = "http://example.com/id/1" + end + end + end + + def _assert_maker_atom_content(feed_type, maker_readers, + feed_readers, &block) + maker_extractor = Proc.new do |target| + content = { + :type => target.type, + :src => target.src, + :content => target.content, + :xml => target.xml, + :inline_text => target.__send!(:inline_text?), + :inline_html => target.__send!(:inline_html?), + :inline_xhtml => target.__send!(:inline_xhtml?), + :inline_other => target.__send!(:inline_other?), + :inline_other_text => target.__send!(:inline_other_text?), + :inline_other_xml => target.__send!(:inline_other_xml?), + :inline_other_base64 => target.__send!(:inline_other_base64?), + :out_of_line => target.__send!(:out_of_line?), + } + content[:src] = nil if content[:src] and content[:content] + if content[:type] or content[:content] + content + else + nil + end + end + feed_extractor = Proc.new do |target| + { + :type => target.type, + :src => target.src, + :content => target.content, + :xml => target.xml, + :inline_text => target.inline_text?, + :inline_html => target.inline_html?, + :inline_xhtml => target.inline_xhtml?, + :inline_other => target.inline_other?, + :inline_other_text => target.inline_other_text?, + :inline_other_xml => target.inline_other_xml?, + :inline_other_base64 => target.inline_other_base64?, + :out_of_line => target.out_of_line?, + } + end + _assert_maker_atom_element(feed_type, maker_readers, feed_readers, + maker_extractor, feed_extractor, + &block) + end + + def assert_maker_atom_content(feed_type, maker_readers, feed_readers, + not_set_error_name=nil, &block) + _wrap_assertion do + not_set_error_name ||= "maker.#{maker_readers.join('.')}" + args = [feed_type, maker_readers, feed_readers, not_set_error_name] + assert_maker_atom_content_inline_text(*args, &block) + assert_maker_atom_content_inline_xhtml(*args, &block) + assert_maker_atom_content_inline_other(*args, &block) + assert_maker_atom_content_out_of_line(*args, &block) + end + end + + def assert_maker_atom_content_inline_text(feed_type, maker_readers, + feed_readers, not_set_error_name) + _wrap_assertion do + args = [feed_type, maker_readers, feed_readers] + _assert_maker_atom_content(*args) do |maker| + yield maker + end + + assert_not_set_error(not_set_error_name, %w(content)) do + RSS::Maker.make("atom:#{feed_type}") do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "text" + end + end + + assert_not_set_error(not_set_error_name, %w(content)) do + RSS::Maker.make("atom:#{feed_type}") do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "html" + end + end + + _assert_maker_atom_content(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.content = "" + end + + _assert_maker_atom_content(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "text" + target.content = "example content" + end + + _assert_maker_atom_content(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "html" + target.content = "text" + end + end + end + + def assert_maker_atom_content_inline_xhtml(feed_type, maker_readers, + feed_readers, not_set_error_name) + _wrap_assertion do + args = [feed_type, maker_readers, feed_readers] + assert_not_set_error(not_set_error_name, %w(xml_content)) do + RSS::Maker.make("atom:#{feed_type}") do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "xhtml" + end + end + + assert_not_set_error(not_set_error_name, %w(xml_content)) do + RSS::Maker.make("atom:#{feed_type}") do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "xhtml" + target.content = "dummy" + end + end + + _assert_maker_atom_content(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "xhtml" + target.xml_content = "text" + end + + _assert_maker_atom_content(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "xhtml" + target.xml = "text" + end + + _assert_maker_atom_content(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "xhtml" + target.xml_content = + RSS::XML::Element.new("em", nil, nil, {}, ["text"]) + end + + _assert_maker_atom_content(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "xhtml" + target.xml = RSS::XML::Element.new("em", nil, nil, {}, ["text"]) + end + + + xhtml_uri = "http://www.w3.org/1999/xhtml" + em = RSS::XML::Element.new("em", nil, nil, {}, ["text"]) + em_with_xhtml_uri = + RSS::XML::Element.new("em", nil, xhtml_uri, {}, ["text"]) + feed = RSS::Maker.make("atom:#{feed_type}") do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "xhtml" + target.xml = em + end + assert_equal(RSS::XML::Element.new("div", nil, xhtml_uri, + {"xmlns" => xhtml_uri}, + [em_with_xhtml_uri]), + chain_reader(feed, feed_readers).xml) + + div = RSS::XML::Element.new("div", nil, xhtml_uri, + {"xmlns" => xhtml_uri, + "class" => "sample"}, + ["text"]) + feed = RSS::Maker.make("atom:#{feed_type}") do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "xhtml" + target.xml = div + end + assert_equal(div, chain_reader(feed, feed_readers).xml) + end + end + + def assert_maker_atom_content_inline_other(*args, &block) + _wrap_assertion do + assert_maker_atom_content_inline_other_xml(*args, &block) + assert_maker_atom_content_inline_other_text(*args, &block) + assert_maker_atom_content_inline_other_base64(*args, &block) + end + end + + def assert_maker_atom_content_inline_other_xml(feed_type, maker_readers, + feed_readers, + not_set_error_name) + _wrap_assertion do + args = [feed_type, maker_readers, feed_readers] + assert_not_set_error(not_set_error_name, %w(xml_content)) do + RSS::Maker.make("atom:#{feed_type}") do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "application/xml" + end + end + + assert_not_set_error(not_set_error_name, %w(xml_content)) do + RSS::Maker.make("atom:#{feed_type}") do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "svg/image+xml" + end + end + + svg_uri = "http://www.w3.org/2000/svg" + rect = RSS::XML::Element.new("rect", nil, svg_uri, + {"x" => "0.5cm", + "y" => "0.5cm", + "width" => "2cm", + "height" => "1cm"}) + svg = RSS::XML::Element.new("svg", nil, svg_uri, + {"xmlns" => svg_uri, + "version" => "1.1", + "width" => "5cm", + "height" => "4cm"}, + [rect]) + _assert_maker_atom_content(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "image/svg+xml" + target.xml = svg + end + + feed = RSS::Maker.make("atom:#{feed_type}") do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "image/svg+xml" + target.xml = svg + end + assert_equal(svg, chain_reader(feed, feed_readers).xml) + end + end + + def assert_maker_atom_content_inline_other_text(feed_type, maker_readers, + feed_readers, + not_set_error_name) + _wrap_assertion do + args = [feed_type, maker_readers, feed_readers] + assert_not_set_error(not_set_error_name, %w(content)) do + RSS::Maker.make("atom:#{feed_type}") do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "text/plain" + end + end + + _assert_maker_atom_content(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "text/plain" + target.content = "text" + end + end + end + + def assert_maker_atom_content_inline_other_base64(feed_type, maker_readers, + feed_readers, + not_set_error_name) + _wrap_assertion do + args = [feed_type, maker_readers, feed_readers] + content = "\211PNG\r\n\032\n" + _assert_maker_atom_content(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "image/png" + target.content = content + end + + _assert_maker_atom_content(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "image/png" + target.src = "http://example.com/logo.png" + target.content = content + end + + feed = RSS::Maker.make("atom:#{feed_type}") do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "image/png" + target.src = "http://example.com/logo.png" + target.content = content + end + target = chain_reader(feed, feed_readers) + assert_nil(target.src) + assert_equal(content, target.content) + end + end + + def assert_maker_atom_content_out_of_line(feed_type, maker_readers, + feed_readers, not_set_error_name) + _wrap_assertion do + args = [feed_type, maker_readers, feed_readers] + assert_not_set_error(not_set_error_name, %w(content)) do + RSS::Maker.make("atom:#{feed_type}") do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "image/png" + end + end + + assert_not_set_error(not_set_error_name, %w(type)) do + RSS::Maker.make("atom:#{feed_type}") do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.src = "http://example.com/logo.png" + end + end + + _assert_maker_atom_content(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "image/png" + target.src = "http://example.com/logo.png" + end + + _assert_maker_atom_content(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "image/png" + target.content = "\211PNG\r\n\032\n" + end + + _assert_maker_atom_content(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "application/xml" + target.src = "http://example.com/sample.xml" + end + + + _assert_maker_atom_content(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) + target.type = "text/plain" + target.src = "http://example.com/README.txt" + end + end + end + + def chain_reader(target, readers) + readers.inject(target) do |result, reader| + return nil if result.nil? + result.__send__(reader) + end + end + + def normalized_attrs(attrs) + n_attrs = {} + attrs.each do |name, value| + n_attrs[name.to_s] = value + end + n_attrs + end + + def combination(elements, n) + if n <= 0 or elements.size < n + [] + elsif n == 1 + elements.collect {|element| [element]} + else + first, *rest = elements + combination(rest, n - 1).collect do |sub_elements| + [first, *sub_elements] + end + combination(rest, n) end - n_attrs end - end end diff --git a/test/rss/rss-testcase.rb b/test/rss/rss-testcase.rb index 0612abcccd..baac597c00 100644 --- a/test/rss/rss-testcase.rb +++ b/test/rss/rss-testcase.rb @@ -3,6 +3,8 @@ require "erb" require "test/unit" require 'rss-assertions' +require "rss" + module RSS class TestCase < Test::Unit::TestCase include ERB::Util @@ -22,7 +24,7 @@ module RSS NAME_VALUE = "hogehoge" LANGUAGE_VALUE = "ja" DESCRIPTION_VALUE = " - XML.com features a rich mix of information and services + XML.com features a rich mix of information and services for the XML community. " RESOURCES = [ @@ -42,6 +44,45 @@ module RSS CATEGORY_DOMAIN = "http://www.superopendirectory.com/" + FEED_TITLE = "dive into mark" + FEED_UPDATED = "2003-12-13T18:30:02Z" + FEED_AUTHOR_NAME = "John Doe" + FEED_ID = "urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6" + + ENTRY_TITLE = "Atom-Powered Robots Run Amok" + ENTRY_LINK = "http://example.org/2003/12/13/atom03" + ENTRY_ID = "urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a" + ENTRY_UPDATED = "2003-12-13T18:30:02Z" + ENTRY_SUMMARY = "Some text." + + t = Time.iso8601("2000-01-01T12:00:05+00:00") + class << t + alias_method(:to_s, :iso8601) + end + + DC_ELEMENTS = { + :title => "hoge", + :description => + " XML is placing increasingly heavy loads on + the existing technical infrastructure of the Internet.", + :creator => "Rael Dornfest (mailto:rael@oreilly.com)", + :subject => "XML", + :publisher => "The O'Reilly Network", + :contributor => "hogehoge", + :type => "fugafuga", + :format => "hohoho", + :identifier => "fufufu", + :source => "barbar", + :language => "ja", + :relation => "cococo", + :rights => "Copyright (c) 2000 O'Reilly & Associates, Inc.", + :date => t, + } + + DC_NODES = DC_ELEMENTS.collect do |name, value| + "<#{DC_PREFIX}:#{name}>#{value}" + end.join("\n") + def default_test # This class isn't tested end @@ -140,6 +181,15 @@ EOR EORSS end + def make_sample_items20 + RESOURCES.collect do |res| + elems = ["#{res}"] + elems << "title of #{res}" + elems = elems.join("\n") + item = "\n#{elems}\n" + end.join("\n") + end + def make_channel20(content=nil) <<-EOC @@ -154,7 +204,7 @@ EORSS #{LINK_VALUE} -#{RESOURCES.collect do |res| '' + res + '' end.join("\n")} +#{make_sample_items20} #{TITLE_VALUE} @@ -190,6 +240,88 @@ EOI EOC end + def make_sample_rss20 + make_rss20(<<-EOR) +#{make_channel20} +EOR + end + + def make_feed_without_entry(content=nil, xmlns=[]) + <<-EOA + + #{FEED_ID} + #{FEED_TITLE} + #{FEED_UPDATED} + + #{FEED_AUTHOR_NAME} + +#{block_given? ? yield : content} + +EOA + end + + def make_entry(content=nil) + <<-EOA + + #{ENTRY_TITLE} + #{ENTRY_ID} + #{ENTRY_UPDATED} +#{block_given? ? yield : content} + +EOA + end + + def make_feed_with_open_entry(content=nil, xmlns=[], &block) + make_feed_without_entry(<<-EOA, xmlns) +#{make_entry(content, &block)} +EOA + end + + def make_feed_with_open_entry_source(content=nil, xmlns=[]) + make_feed_with_open_entry(<<-EOA, xmlns) + +#{block_given? ? yield : content} + +EOA + end + + def make_feed(content=nil, xmlns=[]) + make_feed_without_entry(<<-EOA, xmlns) + + #{ENTRY_TITLE} + + #{ENTRY_ID} + #{ENTRY_UPDATED} + #{ENTRY_SUMMARY} + +#{block_given? ? yield : content} +EOA + end + + def make_entry_document(content=nil, xmlns=[]) + <<-EOA + + #{ENTRY_ID} + #{ENTRY_TITLE} + #{ENTRY_UPDATED} + + #{FEED_AUTHOR_NAME} + +#{block_given? ? yield : content} + +EOA + end + + def make_entry_document_with_open_source(content=nil, xmlns=[]) + make_entry_document(<<-EOA, xmlns) + +#{block_given? ? yield : content} + +EOA + end + def make_element(elem_name, attrs, contents) attrs_str = attrs.collect do |name, value| "#{h name}='#{h value}'" @@ -202,10 +334,52 @@ EOC end private + def setup_rss10(rdf) + assert_equal("", rdf.to_s) + + channel = RDF::Channel.new + assert_equal("", channel.to_s) + channel.about = "http://example.com/index.rdf" + channel.title = "title" + channel.link = "http://example.com/" + channel.description = "description" + assert_equal("", channel.to_s) + + item_title = "item title" + item_link = "http://example.com/item" + channel.items = RDF::Channel::Items.new + channel.items.Seq.lis << RDF::Channel::Items::Seq::Li.new(item_link) + assert_not_equal("", channel.to_s) + + rdf.channel = channel + assert_equal("", rdf.to_s) + + item = RDF::Item.new + item.title = item_title + item.link = item_link + item.about = item_link + rdf.items << item + assert_not_equal("", rdf.to_s) + end + + def setup_rss20(rss) + assert_equal("", rss.to_s) + + channel = Rss::Channel.new + assert_equal("", channel.to_s) + channel.title = "title" + channel.link = "http://example.com/" + channel.description = "description" + assert_not_equal("", channel.to_s) + + rss.channel = channel + assert_not_equal("", rss.to_s) + end + def setup_dummy_channel(maker) about = "http://hoge.com" title = "fugafuga" - link = "http://hoge.com" + link = "http://hoge.com/feed.xml" description = "fugafugafugafuga" language = "ja" @@ -216,6 +390,17 @@ EOC maker.channel.language = language end + def setup_dummy_channel_atom(maker) + updated = Time.now + author = "Foo" + + setup_dummy_channel(maker) + maker.channel.links.first.rel = "self" + maker.channel.links.first.type = "application/atom+xml" + maker.channel.updated = updated + maker.channel.author = author + end + def setup_dummy_image(maker) title = "fugafuga" link = "http://hoge.com" @@ -247,7 +432,15 @@ EOC item.title = title item.link = link end - + + def setup_dummy_item_atom(maker) + setup_dummy_item(maker) + + item = maker.items.first + item.id = "http://example.net/xxx" + item.updated = Time.now + end + def setup_taxo_topic(target, topics) topics.each do |topic| taxo_topic = target.taxo_topics.new_taxo_topic diff --git a/test/rss/test_1.0.rb b/test/rss/test_1.0.rb index b905ba6e94..9cb7607590 100644 --- a/test/rss/test_1.0.rb +++ b/test/rss/test_1.0.rb @@ -19,8 +19,8 @@ module RSS standalone = false rdf = RDF.new(version, encoding, standalone) - - doc = REXML::Document.new(rdf.to_s(false)) + setup_rss10(rdf) + doc = REXML::Document.new(rdf.to_s) xmldecl = doc.xml_decl @@ -59,16 +59,31 @@ module RSS 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(channel.to_s)) + doc = REXML::Document.new(make_RDF(<<-EOR)) +#{channel} + +#{rss_item} + +EOR c = doc.root.elements[1] assert_equal(about, c.attributes["about"]) @@ -123,8 +138,12 @@ module RSS assert_equal(resource, res.value) end - def test_items + 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] @@ -133,18 +152,34 @@ module RSS assert_equal(@uri, i.namespace) assert_equal(1, i.elements.size) - assert_equal("Seq", i.elements[1].name) - assert_equal(@rdf_uri, i.elements[1].namespace) + 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 @@ -233,15 +268,29 @@ module RSS end end - def test_indent_size - assert_equal(0, RDF.indent_size) - assert_equal(1, RDF::Channel.indent_size) - assert_equal(2, RDF::Channel::Image.indent_size) - assert_equal(2, RDF::Channel::Textinput.indent_size) - assert_equal(2, RDF::Channel::Items.indent_size) - assert_equal(1, RDF::Image.indent_size) - assert_equal(1, RDF::Item.indent_size) - assert_equal(1, RDF::Textinput.indent_size) + 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 diff --git a/test/rss/test_2.0.rb b/test/rss/test_2.0.rb index 2027e5344a..5a63efbcb9 100644 --- a/test/rss/test_2.0.rb +++ b/test/rss/test_2.0.rb @@ -2,8 +2,6 @@ require "rexml/document" require "rss-testcase" -require "rss/2.0" - module RSS class TestRSS20Core < TestCase @@ -17,6 +15,7 @@ module RSS standalone = false rss = Rss.new(@rss_version, version, encoding, standalone) + setup_rss20(rss) doc = REXML::Document.new(rss.to_s(false)) @@ -48,7 +47,9 @@ module RSS {:href => "a.css", :type => "text/css"}, ], ].each do |attrs_ary| - assert_xml_stylesheet_pis(attrs_ary, Rss.new(@rss_version)) + rss = Rss.new(@rss_version) + setup_rss20(rss) + assert_xml_stylesheet_pis(attrs_ary, rss) end end @@ -253,6 +254,10 @@ module RSS 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 @@ -373,22 +378,33 @@ module RSS end assert_equal(source_params, actual) end - - def test_indent_size - assert_equal(0, Rss.indent_size) - assert_equal(1, Rss::Channel.indent_size) - assert_equal(2, Rss::Channel::SkipDays.indent_size) - assert_equal(3, Rss::Channel::SkipDays::Day.indent_size) - assert_equal(2, Rss::Channel::SkipHours.indent_size) - assert_equal(3, Rss::Channel::SkipHours::Hour.indent_size) - assert_equal(2, Rss::Channel::Image.indent_size) - assert_equal(2, Rss::Channel::Cloud.indent_size) - assert_equal(2, Rss::Channel::Item.indent_size) - assert_equal(3, Rss::Channel::Item::Source.indent_size) - assert_equal(3, Rss::Channel::Item::Enclosure.indent_size) - assert_equal(3, Rss::Channel::Item::Category.indent_size) - assert_equal(3, Rss::Channel::Item::Guid.indent_size) - assert_equal(2, Rss::Channel::TextInput.indent_size) + + 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 diff --git a/test/rss/test_atom.rb b/test/rss/test_atom.rb new file mode 100644 index 0000000000..aea05bebbe --- /dev/null +++ b/test/rss/test_atom.rb @@ -0,0 +1,281 @@ +require "rexml/document" + +require "rss-testcase" + +require "rss/atom" + +module RSS + class TestAtomCore < TestCase + def setup + @uri = "http://www.w3.org/2005/Atom" + @xhtml_uri = "http://www.w3.org/1999/xhtml" + end + + def test_feed + version = "1.0" + encoding = "UTF-8" + standalone = false + + feed = Atom::Feed.new(version, encoding, standalone) + assert_equal("", feed.to_s) + + author = feed.class::Author.new + name = feed.class::Author::Name.new + name.content = "an author" + author.name = name + assert_not_equal("", author.to_s) + feed.authors << author + assert_equal("", feed.to_s) + + id = feed.class::Id.new + id.content = "http://example.com/atom.xml" + assert_not_equal("", id.to_s) + feed.id = id + assert_equal("", feed.to_s) + + title = feed.class::Title.new + title.content = "a title" + assert_not_equal("", title.to_s) + feed.title = title + assert_equal("", feed.to_s) + + updated = feed.class::Updated.new + updated.content = Time.now + assert_not_equal("", updated.to_s) + feed.updated = updated + assert_not_equal("", feed.to_s) + + + feed.authors.clear + assert_equal("", feed.to_s) + entry = Atom::Feed::Entry.new + setup_entry(entry) + assert_not_equal("", entry.to_s) + + author = entry.authors.first + entry.authors.clear + assert_equal("", entry.to_s) + entry.parent = feed + assert_equal("", entry.to_s) + feed.authors << author + assert_not_equal("", entry.to_s) + feed.authors.clear + feed.entries << entry + assert_equal("", feed.to_s) + entry.authors << author + assert_not_equal("", entry.to_s) + assert_not_equal("", feed.to_s) + + doc = REXML::Document.new(feed.to_s) + xmldecl = doc.xml_decl + + %w(version encoding).each do |x| + assert_equal(instance_eval(x), xmldecl.__send__(x)) + end + assert_equal(standalone, !xmldecl.standalone.nil?) + + assert_equal(@uri, doc.root.namespace) + end + + def test_entry + version = "1.0" + encoding = "UTF-8" + standalone = false + + entry = Atom::Entry.new(version, encoding, standalone) + setup_entry(entry) + + author = entry.authors.first + entry.authors.clear + assert_equal("", entry.to_s) + source = Atom::Entry::Source.new + source.authors << author + entry.source = source + assert_not_equal("", entry.to_s) + + doc = REXML::Document.new(entry.to_s) + xmldecl = doc.xml_decl + + %w(version encoding).each do |x| + assert_equal(instance_eval(x), xmldecl.__send__(x)) + end + assert_equal(standalone, !xmldecl.standalone.nil?) + + assert_equal(@uri, doc.root.namespace) + end + + def test_not_displayed_xml_stylesheets + feed = Atom::Feed.new + plain_feed = feed.to_s + 3.times do + feed.xml_stylesheets.push(XMLStyleSheet.new) + assert_equal(plain_feed, feed.to_s) + end + end + + def test_atom_author + assert_atom_person_to_s(Atom::Feed::Author) + assert_atom_person_to_s(Atom::Feed::Entry::Author) + assert_atom_person_to_s(Atom::Entry::Author) + assert_atom_person_to_s(Atom::Feed::Entry::Source::Author) + assert_atom_person_to_s(Atom::Entry::Source::Author) + end + + def test_atom_category + assert_atom_category_to_s(Atom::Feed::Category) + assert_atom_category_to_s(Atom::Feed::Entry::Category) + assert_atom_category_to_s(Atom::Entry::Category) + assert_atom_category_to_s(Atom::Feed::Entry::Source::Category) + assert_atom_category_to_s(Atom::Entry::Source::Category) + end + + def test_atom_contributor + assert_atom_person_to_s(Atom::Feed::Contributor) + assert_atom_person_to_s(Atom::Feed::Entry::Contributor) + assert_atom_person_to_s(Atom::Entry::Contributor) + assert_atom_person_to_s(Atom::Feed::Entry::Source::Contributor) + assert_atom_person_to_s(Atom::Entry::Source::Contributor) + end + + def test_atom_generator + assert_atom_generator_to_s(Atom::Feed::Generator) + assert_atom_generator_to_s(Atom::Feed::Entry::Source::Generator) + assert_atom_generator_to_s(Atom::Entry::Source::Generator) + end + + def test_atom_icon + assert_atom_icon_to_s(Atom::Feed::Icon) + assert_atom_icon_to_s(Atom::Feed::Entry::Source::Icon) + assert_atom_icon_to_s(Atom::Entry::Source::Icon) + end + + def test_atom_id + assert_atom_id_to_s(Atom::Feed::Id) + assert_atom_id_to_s(Atom::Feed::Entry::Id) + assert_atom_id_to_s(Atom::Entry::Id) + assert_atom_id_to_s(Atom::Feed::Entry::Source::Id) + assert_atom_id_to_s(Atom::Entry::Source::Id) + end + + def test_atom_link + assert_atom_link_to_s(Atom::Feed::Link) + assert_atom_link_to_s(Atom::Feed::Entry::Link) + assert_atom_link_to_s(Atom::Entry::Link) + assert_atom_link_to_s(Atom::Feed::Entry::Source::Link) + assert_atom_link_to_s(Atom::Entry::Source::Link) + end + + def test_atom_logo + assert_atom_logo_to_s(Atom::Feed::Logo) + assert_atom_logo_to_s(Atom::Feed::Entry::Source::Logo) + assert_atom_logo_to_s(Atom::Entry::Source::Logo) + end + + def test_atom_rights + assert_atom_text_construct_to_s(Atom::Feed::Rights) + assert_atom_text_construct_to_s(Atom::Feed::Entry::Rights) + assert_atom_text_construct_to_s(Atom::Entry::Rights) + assert_atom_text_construct_to_s(Atom::Feed::Entry::Source::Rights) + assert_atom_text_construct_to_s(Atom::Entry::Source::Rights) + end + + def test_atom_subtitle + assert_atom_text_construct_to_s(Atom::Feed::Subtitle) + assert_atom_text_construct_to_s(Atom::Feed::Entry::Source::Subtitle) + assert_atom_text_construct_to_s(Atom::Entry::Source::Subtitle) + end + + def test_atom_title + assert_atom_text_construct_to_s(Atom::Feed::Title) + assert_atom_text_construct_to_s(Atom::Feed::Entry::Title) + assert_atom_text_construct_to_s(Atom::Entry::Title) + assert_atom_text_construct_to_s(Atom::Feed::Entry::Source::Title) + assert_atom_text_construct_to_s(Atom::Entry::Source::Title) + end + + def test_atom_updated + assert_atom_date_construct_to_s(Atom::Feed::Updated) + assert_atom_date_construct_to_s(Atom::Feed::Entry::Updated) + assert_atom_date_construct_to_s(Atom::Entry::Updated) + assert_atom_date_construct_to_s(Atom::Feed::Entry::Source::Updated) + assert_atom_date_construct_to_s(Atom::Entry::Source::Updated) + end + + def test_atom_content + assert_atom_content_to_s(Atom::Feed::Entry::Content) + assert_atom_content_to_s(Atom::Entry::Content) + end + + def test_atom_published + assert_atom_date_construct_to_s(Atom::Feed::Entry::Published) + assert_atom_date_construct_to_s(Atom::Entry::Published) + end + + def test_atom_summary + assert_atom_text_construct_to_s(Atom::Feed::Entry::Summary) + assert_atom_text_construct_to_s(Atom::Entry::Summary) + end + + + def test_to_xml + atom = RSS::Parser.parse(make_feed) + assert_equal(atom.to_s, atom.to_xml) + assert_equal(atom.to_s, atom.to_xml("atom")) + assert_equal(atom.to_s, atom.to_xml("atom1.0")) + assert_equal(atom.to_s, atom.to_xml("atom1.0:feed")) + assert_equal(atom.to_s, atom.to_xml("atom:feed")) + + rss09_xml = atom.to_xml("0.91") do |maker| + maker.channel.language = "en-us" + maker.channel.link = "http://example.com/" + maker.channel.description.content = atom.title.content + + maker.image.url = "http://example.com/logo.png" + maker.image.title = "Logo" + end + rss09 = RSS::Parser.parse(rss09_xml) + assert_equal(["rss", "0.91", nil], rss09.feed_info) + + rss20_xml = atom.to_xml("2.0") do |maker| + maker.channel.link = "http://example.com/" + maker.channel.description.content = atom.title.content + end + rss20 = RSS::Parser.parse(rss20_xml) + assert_equal("2.0", rss20.rss_version) + assert_equal(["rss", "2.0", nil], rss20.feed_info) + end + + private + def setup_entry(entry) + _wrap_assertion do + assert_equal("", entry.to_s) + + author = entry.class::Author.new + name = entry.class::Author::Name.new + name.content = "an author" + author.name = name + assert_not_equal("", author.to_s) + entry.authors << author + assert_equal("", entry.to_s) + + id = entry.class::Id.new + id.content = "http://example.com/atom.xml" + assert_not_equal("", id.to_s) + entry.id = id + assert_equal("", entry.to_s) + + title = entry.class::Title.new + title.content = "a title" + assert_not_equal("", title.to_s) + entry.title = title + assert_equal("", entry.to_s) + + updated = entry.class::Updated.new + updated.content = Time.now + assert_not_equal("", updated.to_s) + entry.updated = updated + assert_not_equal("", entry.to_s) + end + end + end +end diff --git a/test/rss/test_content.rb b/test/rss/test_content.rb index 0622625e26..aef930caa1 100644 --- a/test/rss/test_content.rb +++ b/test/rss/test_content.rb @@ -74,7 +74,7 @@ EOR excepted = "<#{@prefix}:#{name}>#{CGI.escapeHTML(value)}" @parents.each do |parent| meth = "#{RSS::CONTENT_PREFIX}_#{name}_element" - assert_equal(excepted, @rss.__send__(parent).funcall(meth)) + assert_equal(excepted, @rss.__send__(parent).__send!(meth)) end end diff --git a/test/rss/test_dublincore.rb b/test/rss/test_dublincore.rb index 36c7f14ec9..0e049e7910 100644 --- a/test/rss/test_dublincore.rb +++ b/test/rss/test_dublincore.rb @@ -8,86 +8,168 @@ require "rss/dublincore" module RSS class TestDublinCore < TestCase - def setup - @prefix = "dc" - @uri = "http://purl.org/dc/elements/1.1/" - - @parents = %w(channel image item textinput) - - t = Time.iso8601("2000-01-01T12:00:05+00:00") - class << t - alias_method(:to_s, :iso8601) - end - - @elems = { - :title => "hoge", - :description => - " XML is placing increasingly heavy loads on - the existing technical infrastructure of the Internet.", - :creator => "Rael Dornfest (mailto:rael@oreilly.com)", - :subject => "XML", - :publisher => "The O'Reilly Network", - :contributor => "hogehoge", - :type => "fugafuga", - :format => "hohoho", - :identifier => "fufufu", - :source => "barbar", - :language => "ja", - :relation => "cococo", - :rights => "Copyright (c) 2000 O'Reilly & Associates, Inc.", - :date => t, - } - - @dc_nodes = @elems.collect do |name, value| - "<#{@prefix}:#{name}>#{value}" - end.join("\n") - - @rss_source = make_RDF(<<-EOR, {@prefix => @uri}) -#{make_channel(@dc_nodes)} -#{make_image(@dc_nodes)} -#{make_item(@dc_nodes)} -#{make_textinput(@dc_nodes)} + @rss10_parents = [%w(channel), %w(image), %w(item), %w(textinput)] + + @rss10_source = make_RDF(<<-EOR, {DC_PREFIX => DC_URI}) +#{make_channel(DC_NODES)} +#{make_image(DC_NODES)} +#{make_item(DC_NODES)} +#{make_textinput(DC_NODES)} +EOR + + @rss20_parents = [%w(channel), %w(items last)] + + @rss20_source = make_rss20(<<-EOR, {DC_PREFIX => DC_URI}) +#{make_channel20(DC_NODES + make_item20(DC_NODES))} +EOR + + @atom_feed_parents = [[], %w(entries last)] + + @atom_feed_source = make_feed(<<-EOR, {DC_PREFIX => DC_URI}) +#{DC_NODES} +#{make_entry(DC_NODES)} EOR - @rss = Parser.parse(@rss_source) + @atom_entry_parents = [[]] + + @atom_entry_source = make_entry_document(<<-EOR, {DC_PREFIX => DC_URI}) +#{DC_NODES} +EOR end - + def test_parser - assert_nothing_raised do - Parser.parse(@rss_source) + rss10_maker = Proc.new do |content, xmlns| + make_RDF(<<-EOR, xmlns) +#{make_channel(content)} +#{make_image(content)} +#{make_item(content)} +#{make_textinput(content)} +EOR + end + assert_dc_parse(@rss10_source, @rss10_parents, false, &rss10_maker) + assert_dc_parse(@rss10_source, @rss10_parents, true, &rss10_maker) + + rss20_maker = Proc.new do |content, xmlns| + make_rss20(<<-EOR, xmlns) +#{make_channel20(content + make_item20(content))} +EOR + end + assert_dc_parse(@rss20_source, @rss20_parents, false, &rss20_maker) + assert_dc_parse(@rss20_source, @rss20_parents, true, &rss20_maker) + + atom_feed_maker = Proc.new do |content, xmlns| + make_feed(<<-EOR, xmlns) +#{content} +#{make_entry(content)} +EOR end - - @elems.each do |tag, value| - rss = nil - assert_nothing_raised do - rss = Parser.parse(make_RDF(<<-EOR, {@prefix => @uri})) -#{make_channel(("<" + @prefix + ":" + tag.to_s + ">" + - value.to_s + - "") * 2)} -#{make_item} + assert_dc_parse(@atom_feed_source, @atom_feed_parents, false, + &atom_feed_maker) + assert_dc_parse(@atom_feed_source, @atom_feed_parents, true, + &atom_feed_maker) + + atom_entry_maker = Proc.new do |content, xmlns| + make_entry_document(<<-EOR, xmlns) +#{content} EOR + end + assert_dc_parse(@atom_entry_source, @atom_entry_parents, false, + &atom_entry_maker) + assert_dc_parse(@atom_entry_source, @atom_entry_parents, true, + &atom_entry_maker) + end + + def test_singular_accessor + assert_dc_singular_accessor(@rss10_source, @rss10_parents) + assert_dc_singular_accessor(@rss20_source, @rss20_parents) + assert_dc_singular_accessor(@atom_feed_source, @atom_feed_parents) + assert_dc_singular_accessor(@atom_entry_source, @atom_entry_parents) + end + + def test_plural_accessor + assert_dc_plural_accessor(@rss10_source, @rss10_parents, false) + assert_dc_plural_accessor(@rss10_source, @rss10_parents, true) + + assert_dc_plural_accessor(@rss20_source, @rss20_parents, false) + assert_dc_plural_accessor(@rss20_source, @rss20_parents, true) + + assert_dc_plural_accessor(@atom_feed_source, @atom_feed_parents, false) + assert_dc_plural_accessor(@atom_feed_source, @atom_feed_parents, true) + + assert_dc_plural_accessor(@atom_entry_source, @atom_entry_parents, false) + assert_dc_plural_accessor(@atom_entry_source, @atom_entry_parents, true) + end + + def test_to_s + assert_dc_to_s(@rss10_source, @rss10_parents, false) + assert_dc_to_s(@rss10_source, @rss10_parents, true) + + targets = ["channel", "channel/item[3]"] + assert_dc_to_s(@rss20_source, @rss20_parents, false, targets) + assert_dc_to_s(@rss20_source, @rss20_parents, true, targets) + + targets = [".", "entry"] + assert_dc_to_s(@atom_feed_source, @atom_feed_parents, false, targets) + assert_dc_to_s(@atom_feed_source, @atom_feed_parents, true, targets) + + targets = ["."] + assert_dc_to_s(@atom_entry_source, @atom_entry_parents, false, targets) + assert_dc_to_s(@atom_entry_source, @atom_entry_parents, true, targets) + end + + private + def dc_plural_suffix(name, check_backward_compatibility) + if name == :rights + if check_backward_compatibility + "es" + else + "_list" end - plural_reader = "dc_#{tag}" + (tag == :rights ? "es" : "s") - values = rss.channel.__send__(plural_reader).collect do |x| - val = x.value - if val.kind_of?(String) - CGI.escapeHTML(val) - else - val + else + "s" + end + end + + def assert_dc_parse(source, parents, check_backward_compatibility, &maker) + assert_nothing_raised do + Parser.parse(source) + end + + DC_ELEMENTS.each do |name, value| + parents.each do |parent_readers| + feed = nil + assert_nothing_raised do + tag = "#{DC_PREFIX}:#{name}" + dc_content = "<#{tag}>#{value}\n" + dc_content *= 2 + feed = Parser.parse(maker.call(dc_content, {DC_PREFIX => DC_URI})) end + parent = chain_reader(feed, parent_readers) + + plural_suffix = dc_plural_suffix(name, check_backward_compatibility) + plural_reader = "dc_#{name}#{plural_suffix}" + values = parent.__send__(plural_reader).collect do |x| + val = x.value + if val.kind_of?(String) + CGI.escapeHTML(val) + else + val + end + end + assert_equal([value, value], values) end - assert_equal([value, value], values) end - end - def test_singular_accessor + def assert_dc_singular_accessor(source, parents) + feed = Parser.parse(source) new_value = "hoge" - @elems.each do |name, value| - @parents.each do |parent| - parsed_value = @rss.__send__(parent).__send__("dc_#{name}") + parents.each do |parent_readers| + parent = chain_reader(feed, parent_readers) + DC_ELEMENTS.each do |name, value| + parsed_value = parent.__send__("dc_#{name}") if parsed_value.kind_of?(String) parsed_value = CGI.escapeHTML(parsed_value) end @@ -97,34 +179,40 @@ EOR class << t alias_method(:to_s, :iso8601) end - @rss.__send__(parent).__send__("dc_#{name}=", t.iso8601) - assert_equal(t, @rss.__send__(parent).__send__("dc_#{name}")) - assert_equal(t, @rss.__send__(parent).date) - - @rss.__send__(parent).date = value - assert_equal(value, @rss.__send__(parent).date) - assert_equal(value, @rss.__send__(parent).__send__("dc_#{name}")) + parent.__send__("dc_#{name}=", t.iso8601) + assert_equal(t, parent.__send__("dc_#{name}")) + if parent.class.method_defined?(:date_without_dc_date=) + assert_nil(parent.date) + else + assert_equal(t, parent.date) + end + + parent.date = value + assert_equal(value, parent.date) + assert_equal(value, parent.__send__("dc_#{name}")) else - @rss.__send__(parent).__send__("dc_#{name}=", new_value) - assert_equal(new_value, - @rss.__send__(parent).__send__("dc_#{name}")) + parent.__send__("dc_#{name}=", new_value) + assert_equal(new_value, parent.__send__("dc_#{name}")) end end end end - def test_plural_accessor + def assert_dc_plural_accessor(source, parents, check_backward_compatibility) + feed = Parser.parse(source) new_value = "hoge" - - @elems.each do |name, value| - @parents.each do |parent| - parsed_value = @rss.__send__(parent).__send__("dc_#{name}") + + DC_ELEMENTS.each do |name, value| + parents.each do |parent_readers| + parent = chain_reader(feed, parent_readers) + parsed_value = parent.__send__("dc_#{name}") if parsed_value.kind_of?(String) parsed_value = CGI.escapeHTML(parsed_value) end assert_equal(value, parsed_value) - plural_reader = "dc_#{name}" + (name == :rights ? "es" : "s") + plural_suffix = dc_plural_suffix(name, check_backward_compatibility) + plural_reader = "dc_#{name}#{plural_suffix}" klass_name = "DublinCore#{Utils.to_class_name(name.to_s)}" klass = DublinCoreModel.const_get(klass_name) if name == :date @@ -132,58 +220,60 @@ EOR class << t alias_method(:to_s, :iso8601) end - elems = @rss.__send__(parent).__send__(plural_reader) + elems = parent.__send__(plural_reader) elems << klass.new(t.iso8601) - new_elems = @rss.__send__(parent).__send__(plural_reader) + new_elems = parent.__send__(plural_reader) values = new_elems.collect{|x| x.value} - assert_equal([@rss.__send__(parent).__send__("dc_#{name}"), t], - values) + assert_equal([parent.__send__("dc_#{name}"), t], values) else - elems = @rss.__send__(parent).__send__(plural_reader) + elems = parent.__send__(plural_reader) elems << klass.new(new_value) - new_elems = @rss.__send__(parent).__send__(plural_reader) + new_elems = parent.__send__(plural_reader) values = new_elems.collect{|x| x.value} - assert_equal([ - @rss.__send__(parent).__send__("dc_#{name}"), - new_value - ], + assert_equal([parent.__send__("dc_#{name}"), new_value], values) end end end end - def test_to_s - @elems.each do |name, value| - excepted = "<#{@prefix}:#{name}>#{value}" - @parents.each do |parent| - assert_equal(excepted, - @rss.__send__(parent).funcall("dc_#{name}_elements")) + def assert_dc_to_s(source, parents, check_backward_compatibility, + targets=nil) + feed = Parser.parse(source) + + DC_ELEMENTS.each do |name, value| + excepted = "<#{DC_PREFIX}:#{name}>#{value}" + parents.each do |parent_readers| + parent = chain_reader(feed, parent_readers) + assert_equal(excepted, parent.__send!("dc_#{name}_elements")) end - + + plural_suffix = dc_plural_suffix(name, check_backward_compatibility) + reader = "dc_#{name}#{plural_suffix}" excepted = Array.new(2, excepted).join("\n") - @parents.each do |parent| - reader = "dc_#{name}" + (name == :rights ? "es" : "s") - elems = @rss.__send__(parent).__send__(reader) + parents.each do |parent_readers| + parent = chain_reader(feed, parent_readers) + elems = parent.__send__(reader) klass_name = "DublinCore#{Utils.to_class_name(name.to_s)}" klass = DublinCoreModel.const_get(klass_name) - elems << klass.new(@rss.__send__(parent).__send__("dc_#{name}")) - assert_equal(excepted, - @rss.__send__(parent).funcall("dc_#{name}_elements")) + elems << klass.new(parent.__send__("dc_#{name}")) + assert_equal(excepted, parent.__send!("dc_#{name}_elements")) end end - - REXML::Document.new(@rss_source).root.each_element do |parent| - if @parents.include?(parent.name) - parent.each_element do |elem| - if elem.namespace == @uri - assert_equal(CGI.escapeHTML(elem.text), - @elems[elem.name.intern].to_s) - end + + targets ||= parents.collect do |parent_readers| + parent_readers.first + end + feed_root = REXML::Document.new(source).root + targets.each do |target_xpath| + parent = feed_root.elements[target_xpath] + parent.each_element do |elem| + if elem.namespace == DC_URI + assert_equal(CGI.escapeHTML(elem.text), + DC_ELEMENTS[elem.name.intern].to_s) end end end end - end end diff --git a/test/rss/test_image.rb b/test/rss/test_image.rb index 0fb9fce276..8bb7323206 100644 --- a/test/rss/test_image.rb +++ b/test/rss/test_image.rb @@ -52,11 +52,11 @@ module RSS items << make_item(image_item) end - ns = { + @ns = { @prefix => @uri, DC_PREFIX => DC_URI, } - @rss_source = make_RDF(<<-EOR, ns) + @rss_source = make_RDF(<<-EOR, @ns) #{make_channel(@channel_nodes)} #{make_image} #{items} @@ -70,11 +70,21 @@ EOR assert_nothing_raised do Parser.parse(@rss_source) end - + assert_too_much_tag("favicon", "channel") do - Parser.parse(make_RDF(<<-EOR, {@prefix => @uri})) + Parser.parse(make_RDF(<<-EOR, @ns)) #{make_channel(@channel_nodes * 2)} #{make_item} +EOR + end + + attrs = {"rdf:about" => "http://www.example.org/item.png"} + contents = [["#{@prefix}:width", "80"]] * 5 + image_item = make_element("#{@prefix}:item", attrs, contents) + assert_too_much_tag("width", "item") do + Parser.parse(make_RDF(<<-EOR, @ns)) +#{make_channel} +#{make_item(image_item)} EOR end end diff --git a/test/rss/test_maker_0.9.rb b/test/rss/test_maker_0.9.rb index d8556887e1..0551dc2800 100644 --- a/test/rss/test_maker_0.9.rb +++ b/test/rss/test_maker_0.9.rb @@ -11,18 +11,21 @@ module RSS rss = RSS::Maker.make("0.9") do |maker| setup_dummy_channel(maker) + setup_dummy_image(maker) end assert_equal("0.91", rss.rss_version) rss = RSS::Maker.make("0.91") do |maker| setup_dummy_channel(maker) + setup_dummy_image(maker) end assert_equal("0.91", rss.rss_version) rss = RSS::Maker.make("0.91") do |maker| setup_dummy_channel(maker) - + setup_dummy_image(maker) + maker.encoding = "EUC-JP" end assert_equal("0.91", rss.rss_version) @@ -30,7 +33,8 @@ module RSS rss = RSS::Maker.make("0.91") do |maker| setup_dummy_channel(maker) - + setup_dummy_image(maker) + maker.standalone = "yes" end assert_equal("0.91", rss.rss_version) @@ -38,7 +42,8 @@ module RSS rss = RSS::Maker.make("0.91") do |maker| setup_dummy_channel(maker) - + setup_dummy_image(maker) + maker.encoding = "EUC-JP" maker.standalone = "yes" end @@ -67,7 +72,10 @@ module RSS ] pubDate = Time.now lastBuildDate = Time.now - + + image_url = "http://example.com/logo.png" + image_title = "Logo" + rss = RSS::Maker.make("0.91") do |maker| maker.channel.title = title maker.channel.link = link @@ -82,13 +90,18 @@ module RSS maker.channel.lastBuildDate = lastBuildDate skipDays.each do |day| - new_day = maker.channel.skipDays.new_day - new_day.content = day + maker.channel.skipDays.new_day do |new_day| + new_day.content = day + end end skipHours.each do |hour| - new_hour = maker.channel.skipHours.new_hour - new_hour.content = hour + maker.channel.skipHours.new_hour do |new_hour| + new_hour.content = hour + end end + + maker.image.url = image_url + maker.image.title = image_title end channel = rss.channel @@ -113,7 +126,11 @@ module RSS end assert(channel.items.empty?) - assert_nil(channel.image) + + assert_equal(image_url, channel.image.url) + assert_equal(image_title, channel.image.title) + assert_equal(link, channel.image.link) + assert_nil(channel.textInput) end @@ -209,17 +226,18 @@ module RSS height = "400" description = "an image" - rss = RSS::Maker.make("0.91") do |maker| - setup_dummy_channel(maker) - maker.channel.link = link - - # maker.image.title = title - maker.image.url = url - maker.image.width = width - maker.image.height = height - maker.image.description = description + assert_not_set_error("maker.image", %w(title)) do + RSS::Maker.make("0.91") do |maker| + setup_dummy_channel(maker) + maker.channel.link = link + + # maker.image.title = title + maker.image.url = url + maker.image.width = width + maker.image.height = height + maker.image.description = description + end end - assert_nil(rss.channel.image) assert_not_set_error("maker.channel", %w(link)) do RSS::Maker.make("0.91") do |maker| @@ -235,17 +253,18 @@ module RSS end end - rss = RSS::Maker.make("0.91") do |maker| - setup_dummy_channel(maker) - maker.channel.link = link - - maker.image.title = title - # maker.image.url = url - maker.image.width = width - maker.image.height = height - maker.image.description = description + assert_not_set_error("maker.image", %w(url)) do + RSS::Maker.make("0.91") do |maker| + setup_dummy_channel(maker) + maker.channel.link = link + + maker.image.title = title + # maker.image.url = url + maker.image.width = width + maker.image.height = height + maker.image.description = description + end end - assert_nil(rss.channel.image) end def test_items @@ -255,16 +274,20 @@ module RSS rss = RSS::Maker.make("0.91") do |maker| setup_dummy_channel(maker) + setup_dummy_image(maker) end assert(rss.channel.items.empty?) rss = RSS::Maker.make("0.91") do |maker| setup_dummy_channel(maker) - item = maker.items.new_item - item.title = title - item.link = link - # item.description = description + maker.items.new_item do |item| + item.title = title + item.link = link + # item.description = description + end + + setup_dummy_image(maker) end assert_equal(1, rss.channel.items.size) item = rss.channel.items.first @@ -278,12 +301,15 @@ module RSS setup_dummy_channel(maker) item_size.times do |i| - item = maker.items.new_item - item.title = "#{title}#{i}" - item.link = "#{link}#{i}" - item.description = "#{description}#{i}" + maker.items.new_item do |item| + item.title = "#{title}#{i}" + item.link = "#{link}#{i}" + item.description = "#{description}#{i}" + end end maker.items.do_sort = true + + setup_dummy_image(maker) end assert_equal(item_size, rss.items.size) rss.channel.items.each_with_index do |item, i| @@ -296,14 +322,17 @@ module RSS setup_dummy_channel(maker) item_size.times do |i| - item = maker.items.new_item - item.title = "#{title}#{i}" - item.link = "#{link}#{i}" - item.description = "#{description}#{i}" + maker.items.new_item do |item| + item.title = "#{title}#{i}" + item.link = "#{link}#{i}" + item.description = "#{description}#{i}" + end end maker.items.do_sort = Proc.new do |x, y| - y.title[-1] <=> x.title[-1] + y.title.content[-1] <=> x.title.content[-1] end + + setup_dummy_image(maker) end assert_equal(item_size, rss.items.size) rss.channel.items.reverse.each_with_index do |item, i| @@ -321,6 +350,7 @@ module RSS rss = RSS::Maker.make("0.91") do |maker| setup_dummy_channel(maker) + setup_dummy_image(maker) maker.textinput.title = title maker.textinput.description = description @@ -333,15 +363,17 @@ module RSS assert_equal(name, textInput.name) assert_equal(link, textInput.link) - rss = RSS::Maker.make("0.91") do |maker| - # setup_dummy_channel(maker) + assert_not_set_error("maker.channel", + %w(link language description title)) do + RSS::Maker.make("0.91") do |maker| + # setup_dummy_channel(maker) - maker.textinput.title = title - maker.textinput.description = description - maker.textinput.name = name - maker.textinput.link = link + maker.textinput.title = title + maker.textinput.description = description + maker.textinput.name = name + maker.textinput.link = link + end end - assert_nil(rss) end def test_not_valid_textInput @@ -352,6 +384,7 @@ module RSS rss = RSS::Maker.make("0.91") do |maker| setup_dummy_channel(maker) + setup_dummy_image(maker) # maker.textinput.title = title maker.textinput.description = description @@ -362,7 +395,8 @@ module RSS rss = RSS::Maker.make("0.91") do |maker| setup_dummy_channel(maker) - + setup_dummy_image(maker) + maker.textinput.title = title # maker.textinput.description = description maker.textinput.name = name @@ -372,7 +406,8 @@ module RSS rss = RSS::Maker.make("0.91") do |maker| setup_dummy_channel(maker) - + setup_dummy_image(maker) + maker.textinput.title = title maker.textinput.description = description # maker.textinput.name = name @@ -382,7 +417,8 @@ module RSS rss = RSS::Maker.make("0.91") do |maker| setup_dummy_channel(maker) - + setup_dummy_image(maker) + maker.textinput.title = title maker.textinput.description = description maker.textinput.name = name diff --git a/test/rss/test_maker_1.0.rb b/test/rss/test_maker_1.0.rb index 9d90f3bedd..cc1e58c1a2 100644 --- a/test/rss/test_maker_1.0.rb +++ b/test/rss/test_maker_1.0.rb @@ -8,12 +8,15 @@ module RSS def test_rdf rss = RSS::Maker.make("1.0") do |maker| setup_dummy_channel(maker) + setup_dummy_item(maker) end assert_equal("1.0", rss.rss_version) rss = RSS::Maker.make("1.0") do |maker| setup_dummy_channel(maker) maker.encoding = "EUC-JP" + + setup_dummy_item(maker) end assert_equal("1.0", rss.rss_version) assert_equal("EUC-JP", rss.encoding) @@ -21,6 +24,8 @@ module RSS rss = RSS::Maker.make("1.0") do |maker| setup_dummy_channel(maker) maker.standalone = "yes" + + setup_dummy_item(maker) end assert_equal("1.0", rss.rss_version) assert_equal("yes", rss.standalone) @@ -29,6 +34,8 @@ module RSS setup_dummy_channel(maker) maker.encoding = "EUC-JP" maker.standalone = "yes" + + setup_dummy_item(maker) end assert_equal("1.0", rss.rss_version) assert_equal("EUC-JP", rss.encoding) @@ -49,13 +56,15 @@ module RSS maker.channel.title = title maker.channel.link = link maker.channel.description = description + + setup_dummy_item(maker) end channel = rss.channel assert_equal(about, channel.about) assert_equal(title, channel.title) assert_equal(link, channel.link) assert_equal(description, channel.description) - assert(channel.items.Seq.lis.empty?) + assert_equal(1, channel.items.Seq.lis.size) assert_nil(channel.image) assert_nil(channel.textinput) @@ -68,13 +77,15 @@ module RSS setup_dummy_image(maker) setup_dummy_textinput(maker) + + setup_dummy_item(maker) end channel = rss.channel assert_equal(about, channel.about) assert_equal(title, channel.title) assert_equal(link, channel.link) assert_equal(description, channel.description) - assert(channel.items.Seq.lis.empty?) + assert_equal(1, channel.items.Seq.lis.size) assert_equal(rss.image.about, channel.image.resource) assert_equal(rss.textinput.about, channel.textinput.resource) end @@ -134,6 +145,8 @@ module RSS maker.image.title = title maker.image.url = url + + setup_dummy_item(maker) end image = rss.image assert_equal(url, image.about) @@ -164,6 +177,8 @@ module RSS # maker.image.url = url maker.image.title = title + + setup_dummy_item(maker) end assert_nil(rss.channel.image) assert_nil(rss.image) @@ -174,6 +189,8 @@ module RSS maker.image.url = url # maker.image.title = title + + setup_dummy_item(maker) end assert_nil(rss.channel.image) assert_nil(rss.image) @@ -186,27 +203,31 @@ module RSS maker.image.url = url maker.image.title = title + + setup_dummy_item(maker) end end end - + def test_items title = "TITLE" link = "http://hoge.com/" description = "text hoge fuga" - rss = RSS::Maker.make("1.0") do |maker| - setup_dummy_channel(maker) + assert_not_set_error("maker", %w(items)) do + RSS::Maker.make("1.0") do |maker| + setup_dummy_channel(maker) + end end - assert(rss.items.empty?) rss = RSS::Maker.make("1.0") do |maker| setup_dummy_channel(maker) - item = maker.items.new_item - item.title = title - item.link = link - # item.description = description + maker.items.new_item do |item| + item.title = title + item.link = link + # item.description = description + end end assert_equal(1, rss.items.size) item = rss.items.first @@ -221,10 +242,11 @@ module RSS setup_dummy_channel(maker) item_size.times do |i| - item = maker.items.new_item - item.title = "#{title}#{i}" - item.link = "#{link}#{i}" - item.description = "#{description}#{i}" + maker.items.new_item do |item| + item.title = "#{title}#{i}" + item.link = "#{link}#{i}" + item.description = "#{description}#{i}" + end end maker.items.do_sort = true end @@ -240,13 +262,14 @@ module RSS setup_dummy_channel(maker) item_size.times do |i| - item = maker.items.new_item - item.title = "#{title}#{i}" - item.link = "#{link}#{i}" - item.description = "#{description}#{i}" + maker.items.new_item do |item| + item.title = "#{title}#{i}" + item.link = "#{link}#{i}" + item.description = "#{description}#{i}" + end end maker.items.do_sort = Proc.new do |x, y| - y.title[-1] <=> x.title[-1] + y.title.content[-1] <=> x.title.content[-1] end end assert_equal(item_size, rss.items.size) @@ -262,10 +285,11 @@ module RSS setup_dummy_channel(maker) item_size.times do |i| - item = maker.items.new_item - item.title = "#{title}#{i}" - item.link = "#{link}#{i}" - item.description = "#{description}#{i}" + maker.items.new_item do |item| + item.title = "#{title}#{i}" + item.link = "#{link}#{i}" + item.description = "#{description}#{i}" + end end maker.items.max_size = max_size end @@ -278,28 +302,31 @@ module RSS end max_size = 0 - rss = RSS::Maker.make("1.0") do |maker| - setup_dummy_channel(maker) - - item_size.times do |i| - item = maker.items.new_item - item.title = "#{title}#{i}" - item.link = "#{link}#{i}" - item.description = "#{description}#{i}" + assert_not_set_error("maker", %w(items)) do + RSS::Maker.make("1.0") do |maker| + setup_dummy_channel(maker) + + item_size.times do |i| + maker.items.new_item do |item| + item.title = "#{title}#{i}" + item.link = "#{link}#{i}" + item.description = "#{description}#{i}" + end + end + maker.items.max_size = max_size end - maker.items.max_size = max_size end - assert_equal(max_size, rss.items.size) max_size = -2 rss = RSS::Maker.make("1.0") do |maker| setup_dummy_channel(maker) item_size.times do |i| - item = maker.items.new_item - item.title = "#{title}#{i}" - item.link = "#{link}#{i}" - item.description = "#{description}#{i}" + maker.items.new_item do |item| + item.title = "#{title}#{i}" + item.link = "#{link}#{i}" + item.description = "#{description}#{i}" + end end maker.items.max_size = max_size end @@ -316,25 +343,40 @@ module RSS title = "TITLE" link = "http://hoge.com/" - rss = RSS::Maker.make("1.0") do |maker| - setup_dummy_channel(maker) - - item = maker.items.new_item - # item.title = title - item.link = link + assert_not_set_error("maker.item", %w(title)) do + RSS::Maker.make("1.0") do |maker| + setup_dummy_channel(maker) + + maker.items.new_item do |item| + # item.title = title + item.link = link + end + end end - assert(rss.items.empty?) - rss = RSS::Maker.make("1.0") do |maker| - setup_dummy_channel(maker) - - item = maker.items.new_item - item.title = title - # item.link = link + assert_not_set_error("maker.item", %w(link)) do + RSS::Maker.make("1.0") do |maker| + setup_dummy_channel(maker) + + maker.items.new_item do |item| + item.title = title + # item.link = link + end + end + end + + assert_not_set_error("maker.item", %w(title link)) do + RSS::Maker.make("1.0") do |maker| + setup_dummy_channel(maker) + + maker.items.new_item do |item| + # item.title = title + # item.link = link + end + end end - assert(rss.items.empty?) end - + def test_textinput title = "fugafuga" description = "text hoge fuga" @@ -348,6 +390,8 @@ module RSS maker.textinput.title = title maker.textinput.description = description maker.textinput.name = name + + setup_dummy_item(maker) end textinput = rss.textinput assert_equal(link, textinput.about) @@ -357,15 +401,16 @@ module RSS assert_equal(description, textinput.description) assert_equal(link, textinput.link) - rss = RSS::Maker.make("1.0") do |maker| - # setup_dummy_channel(maker) + assert_not_set_error("maker.channel", %w(about link description title)) do + RSS::Maker.make("1.0") do |maker| + # setup_dummy_channel(maker) - maker.textinput.link = link - maker.textinput.title = title - maker.textinput.description = description - maker.textinput.name = name + maker.textinput.link = link + maker.textinput.title = title + maker.textinput.description = description + maker.textinput.name = name + end end - assert_nil(rss) end def test_not_valid_textinput @@ -381,6 +426,8 @@ module RSS maker.textinput.title = title maker.textinput.description = description maker.textinput.name = name + + setup_dummy_item(maker) end assert_nil(rss.channel.textinput) assert_nil(rss.textinput) @@ -392,6 +439,8 @@ module RSS # maker.textinput.title = title maker.textinput.description = description maker.textinput.name = name + + setup_dummy_item(maker) end assert_nil(rss.channel.textinput) assert_nil(rss.textinput) @@ -403,6 +452,8 @@ module RSS maker.textinput.title = title # maker.textinput.description = description maker.textinput.name = name + + setup_dummy_item(maker) end assert_nil(rss.channel.textinput) assert_nil(rss.textinput) @@ -414,6 +465,8 @@ module RSS maker.textinput.title = title maker.textinput.description = description # maker.textinput.name = name + + setup_dummy_item(maker) end assert_nil(rss.channel.textinput) assert_nil(rss.textinput) diff --git a/test/rss/test_maker_2.0.rb b/test/rss/test_maker_2.0.rb index 2c581f75ea..605d439a68 100644 --- a/test/rss/test_maker_2.0.rb +++ b/test/rss/test_maker_2.0.rb @@ -82,17 +82,20 @@ module RSS maker.channel.lastBuildDate = lastBuildDate skipDays.each do |day| - new_day = maker.channel.skipDays.new_day - new_day.content = day + maker.channel.skipDays.new_day do |new_day| + new_day.content = day + end end skipHours.each do |hour| - new_hour = maker.channel.skipHours.new_hour - new_hour.content = hour + maker.channel.skipHours.new_hour do |new_hour| + new_hour.content = hour + end end categories.each do |category| - new_category = maker.channel.categories.new_category - new_category.content = category + maker.channel.categories.new_category do |new_category| + new_category.content = category + end end maker.channel.generator = generator @@ -368,13 +371,14 @@ module RSS setup_dummy_channel(maker) item_size.times do |i| - item = maker.items.new_item - item.title = "#{title}#{i}" - item.link = "#{link}#{i}" - item.description = "#{description}#{i}" - item.author = "#{author}#{i}" - item.comments = "#{comments}#{i}" - item.date = pubDate + maker.items.new_item do |item| + item.title = "#{title}#{i}" + item.link = "#{link}#{i}" + item.description = "#{description}#{i}" + item.author = "#{author}#{i}" + item.comments = "#{comments}#{i}" + item.date = pubDate + end end maker.items.do_sort = true end @@ -393,16 +397,17 @@ module RSS setup_dummy_channel(maker) item_size.times do |i| - item = maker.items.new_item - item.title = "#{title}#{i}" - item.link = "#{link}#{i}" - item.description = "#{description}#{i}" - item.author = "#{author}#{i}" - item.comments = "#{comments}#{i}" - item.date = pubDate + maker.items.new_item do |item| + item.title = "#{title}#{i}" + item.link = "#{link}#{i}" + item.description = "#{description}#{i}" + item.author = "#{author}#{i}" + item.comments = "#{comments}#{i}" + item.date = pubDate + end end maker.items.do_sort = Proc.new do |x, y| - y.title[-1] <=> x.title[-1] + y.title.content[-1] <=> x.title.content[-1] end end assert_equal(item_size, rss.items.size) @@ -557,9 +562,10 @@ module RSS setup_dummy_channel(maker) setup_dummy_item(maker) - category = maker.items.last.categories.new_category - category.domain = domain - category.content = content + maker.items.last.categories.new_category do |category| + category.domain = domain + category.content = content + end end category = rss.channel.items.last.categories.last assert_equal(domain, category.domain) @@ -573,8 +579,9 @@ module RSS setup_dummy_channel(maker) setup_dummy_item(maker) - category = maker.items.last.categories.new_category - # category.content = content + maker.items.last.categories.new_category do |category| + # category.content = content + end end assert(rss.channel.items.last.categories.empty?) end @@ -599,15 +606,16 @@ module RSS assert_equal(name, textInput.name) assert_equal(link, textInput.link) - rss = RSS::Maker.make("2.0") do |maker| - # setup_dummy_channel(maker) + assert_not_set_error("maker.channel", %w(link description title)) do + RSS::Maker.make("2.0") do |maker| + # setup_dummy_channel(maker) - maker.textinput.title = title - maker.textinput.description = description - maker.textinput.name = name - maker.textinput.link = link + maker.textinput.title = title + maker.textinput.description = description + maker.textinput.name = name + maker.textinput.link = link + end end - assert_nil(rss) end def test_not_valid_textInput diff --git a/test/rss/test_maker_atom_entry.rb b/test/rss/test_maker_atom_entry.rb new file mode 100644 index 0000000000..ae0ab2d09f --- /dev/null +++ b/test/rss/test_maker_atom_entry.rb @@ -0,0 +1,367 @@ +require "rss-testcase" + +require "rss/maker" + +module RSS + class TestMakerAtomEntry < TestCase + def test_root_element + entry = Maker.make("atom:entry") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + assert_equal(["atom", "1.0", "entry"], entry.feed_info) + + entry = Maker.make("atom:entry") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + maker.encoding = "EUC-JP" + end + assert_equal(["atom", "1.0", "entry"], entry.feed_info) + assert_equal("EUC-JP", entry.encoding) + + entry = Maker.make("atom:entry") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + maker.standalone = "yes" + end + assert_equal(["atom", "1.0", "entry"], entry.feed_info) + assert_equal("yes", entry.standalone) + + entry = Maker.make("atom:entry") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + maker.encoding = "EUC-JP" + maker.standalone = "yes" + end + assert_equal(["atom", "1.0", "entry"], entry.feed_info) + assert_equal("EUC-JP", entry.encoding) + assert_equal("yes", entry.standalone) + end + + def test_invalid_feed + assert_not_set_error("maker.item", %w(id title author updated)) do + Maker.make("atom:entry") do |maker| + end + end + + assert_not_set_error("maker.item", %w(id title updated)) do + Maker.make("atom:entry") do |maker| + maker.channel.author = "foo" + end + end + + assert_not_set_error("maker.item", %w(title updated)) do + Maker.make("atom:entry") do |maker| + maker.channel.author = "foo" + maker.channel.id = "http://example.com" + end + end + + assert_not_set_error("maker.item", %w(updated)) do + Maker.make("atom:entry") do |maker| + maker.channel.author = "foo" + maker.channel.id = "http://example.com" + maker.channel.title = "Atom Feed" + end + end + + assert_not_set_error("maker.item", %w(author)) do + Maker.make("atom:entry") do |maker| + maker.channel.id = "http://example.com" + maker.channel.title = "Atom Feed" + maker.channel.updated = Time.now + end + end + + entry = Maker.make("atom:entry") do |maker| + maker.channel.author = "Foo" + maker.channel.id = "http://example.com" + maker.channel.title = "Atom Feed" + maker.channel.updated = Time.now + end + assert_not_nil(entry) + end + + def test_author + assert_maker_atom_persons("entry", + ["channel", "authors"], + ["authors"], + "maker.channel.author") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + + assert_maker_atom_persons("entry", + ["items", "first", "authors"], + ["authors"], + "maker.item.author", + "maker.item", ["author"]) do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + maker.channel.authors.clear + maker.items.first.authors.clear + end + + assert_maker_atom_persons("entry", + ["items", "first", "source", "authors"], + ["source", "authors"], + "maker.item.source.author") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_category + assert_maker_atom_categories("entry", + ["channel", "categories"], + ["categories"], + "maker.channel.category") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + + assert_maker_atom_categories("entry", + ["items", "first", "categories"], + ["categories"], + "maker.item.category") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + + assert_maker_atom_categories("entry", + ["items", "first", "source", "categories"], + ["source", "categories"], + "maker.item.source.category") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_content + assert_maker_atom_content("entry", + ["items", "first", "content"], + ["content"], + "maker.item.content") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_contributor + assert_maker_atom_persons("entry", + ["channel", "contributors"], + ["contributors"], + "maker.channel.contributor") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + + assert_maker_atom_persons("entry", + ["items", "first", "contributors"], + ["contributors"], + "maker.item.contributor") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + + assert_maker_atom_persons("entry", + ["items", "first", "source", "contributors"], + ["source", "contributors"], + "maker.item.source.contributor") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_link + assert_maker_atom_links("entry", + ["channel", "links"], + ["links"], + "maker.channel.link") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + maker.channel.links.clear + maker.items.first.links.clear + end + + assert_maker_atom_links("entry", + ["items", "first", "links"], + ["links"], + "maker.item.link") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + maker.channel.links.clear + maker.items.first.links.clear + end + + assert_maker_atom_links("entry", + ["items", "first", "source", "links"], + ["source", "links"], + "maker.item.source.link", true) do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_published + assert_maker_atom_date_construct("entry", + ["items", "first", "published"], + ["published"] + ) do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_rights + assert_maker_atom_text_construct("entry", + ["channel", "copyright"], + ["rights"]) do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + + assert_maker_atom_text_construct("entry", + ["items", "first", "rights"], + ["rights"], + nil, nil, "maker.item.rights" + ) do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + + assert_maker_atom_text_construct("entry", + ["items", "first", "source", "rights"], + ["source", "rights"], + nil, nil, "maker.item.source.rights" + ) do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + + def test_source_generator + assert_maker_atom_generator("entry", + ["items", "first", "source", "generator"], + ["source", "generator"], + "maker.item.source.generator") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_source_icon + assert_maker_atom_icon("entry", + ["items", "first", "source", "icon"], + ["source", "icon"], + nil, "maker.item.source.icon") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_source_id + assert_maker_atom_id("entry", + ["items", "first", "source"], + ["source"], + "maker.item.source") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_source_logo + assert_maker_atom_logo("entry", + ["items", "first", "source", "logo"], + ["source", "logo"], + nil, + "maker.item.source.logo") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_source_subtitle + assert_maker_atom_text_construct("entry", + ["items", "first", "source", "subtitle"], + ["source", "subtitle"], + nil, nil, + "maker.item.source.subtitle") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_summary + assert_maker_atom_text_construct("entry", + ["items", "first", "description"], + ["summary"], + nil, nil, "maker.item.description" + ) do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_title + assert_maker_atom_text_construct("entry", + ["channel", "title"], ["title"], + "maker.item", ["title"], + "maker.channel.title") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + maker.channel.title = nil + maker.items.first.title = nil + end + + assert_maker_atom_text_construct("entry", + ["items", "first", "title"], + ["title"], + "maker.item", ["title"], + "maker.item.title") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + maker.channel.title = nil + maker.items.first.title = nil + end + + assert_maker_atom_text_construct("entry", + ["items", "first", "source", "title"], + ["source", "title"], + nil, nil, "maker.item.source.title" + ) do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_updated + assert_maker_atom_date_construct("entry", + ["channel", "updated"], ["updated"], + "maker.item", ["updated"]) do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + maker.channel.updated = nil + maker.items.first.updated = nil + end + + assert_maker_atom_date_construct("entry", + ["items", "first", "updated"], + ["updated"], + "maker.item", ["updated"]) do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + maker.channel.updated = nil + maker.items.first.updated = nil + end + + assert_maker_atom_date_construct("entry", + ["items", "first", "source", "updated"], + ["source", "updated"]) do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + end +end diff --git a/test/rss/test_maker_atom_feed.rb b/test/rss/test_maker_atom_feed.rb new file mode 100644 index 0000000000..f4c5cc2a3d --- /dev/null +++ b/test/rss/test_maker_atom_feed.rb @@ -0,0 +1,380 @@ +require "rss-testcase" + +require "rss/maker" + +module RSS + class TestMakerAtomFeed < TestCase + def test_root_element + feed = Maker.make("atom") do |maker| + setup_dummy_channel_atom(maker) + end + assert_equal(["atom", "1.0", "feed"], feed.feed_info) + + feed = Maker.make("atom") do |maker| + setup_dummy_channel_atom(maker) + maker.encoding = "EUC-JP" + end + assert_equal(["atom", "1.0", "feed"], feed.feed_info) + assert_equal("EUC-JP", feed.encoding) + + feed = Maker.make("atom") do |maker| + setup_dummy_channel_atom(maker) + maker.standalone = "yes" + end + assert_equal(["atom", "1.0", "feed"], feed.feed_info) + assert_equal("yes", feed.standalone) + + feed = Maker.make("atom") do |maker| + setup_dummy_channel_atom(maker) + maker.encoding = "EUC-JP" + maker.standalone = "yes" + end + assert_equal(["atom", "1.0", "feed"], feed.feed_info) + assert_equal("EUC-JP", feed.encoding) + assert_equal("yes", feed.standalone) + end + + def test_invalid_feed + assert_not_set_error("maker.channel", %w(id title author updated)) do + Maker.make("atom") do |maker| + end + end + + assert_not_set_error("maker.channel", %w(id title updated)) do + Maker.make("atom") do |maker| + maker.channel.author = "foo" + end + end + + assert_not_set_error("maker.channel", %w(title updated)) do + Maker.make("atom") do |maker| + maker.channel.author = "foo" + maker.channel.id = "http://example.com" + end + end + + assert_not_set_error("maker.channel", %w(updated)) do + Maker.make("atom") do |maker| + maker.channel.author = "foo" + maker.channel.id = "http://example.com" + maker.channel.title = "Atom Feed" + end + end + + assert_not_set_error("maker.channel", %w(author)) do + Maker.make("atom") do |maker| + maker.channel.id = "http://example.com" + maker.channel.title = "Atom Feed" + maker.channel.updated = Time.now + end + end + + feed = Maker.make("atom") do |maker| + maker.channel.author = "Foo" + maker.channel.id = "http://example.com" + maker.channel.title = "Atom Feed" + maker.channel.updated = Time.now + end + assert_not_nil(feed) + end + + def test_author + assert_maker_atom_persons("feed", + ["channel", "authors"], + ["authors"], + "maker.channel.author") do |maker| + setup_dummy_channel_atom(maker) + end + + assert_not_set_error("maker.channel", %w(author)) do + RSS::Maker.make("atom") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + maker.channel.authors.clear + end + end + + assert_maker_atom_persons("feed", + ["items", "first", "authors"], + ["entries", "first", "authors"], + "maker.item.author") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + + assert_maker_atom_persons("feed", + ["items", "first", "source", "authors"], + ["entries", "first", "source", "authors"], + "maker.item.source.author") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_category + assert_maker_atom_categories("feed", + ["channel", "categories"], + ["categories"], + "maker.channel.category") do |maker| + setup_dummy_channel_atom(maker) + end + + assert_maker_atom_categories("feed", + ["items", "first", "categories"], + ["entries", "first", "categories"], + "maker.item.category") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + + assert_maker_atom_categories("feed", + ["items", "first", "source", "categories"], + ["entries", "first", "source", "categories"], + "maker.item.source.category") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_contributor + assert_maker_atom_persons("feed", + ["channel", "contributors"], + ["contributors"], + "maker.channel.contributor") do |maker| + setup_dummy_channel_atom(maker) + end + + assert_maker_atom_persons("feed", + ["items", "first", "contributors"], + ["entries", "first", "contributors"], + "maker.item.contributor") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + + assert_maker_atom_persons("feed", + ["items", "first", "source", "contributors"], + ["entries", "first", "source", "contributors"], + "maker.item.source.contributor") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_generator + assert_maker_atom_generator("feed", + ["channel", "generator"], + ["generator"]) do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + + assert_maker_atom_generator("feed", + ["items", "first", "source", "generator"], + ["entries", "first", "source", "generator"], + "maker.item.source.generator") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_icon + assert_maker_atom_icon("feed", ["channel"], ["icon"], "icon") do |maker| + setup_dummy_channel_atom(maker) + end + + assert_maker_atom_icon("feed", + ["items", "first", "source", "icon"], + ["entries", "first", "source", "icon"], + nil, "maker.item.source.icon") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_link + assert_maker_atom_links("feed", + ["channel", "links"], + ["links"], + "maker.channel.link") do |maker| + setup_dummy_channel_atom(maker) + end + + assert_maker_atom_links("feed", + ["items", "first", "links"], + ["entries", "first", "links"], + "maker.item.link") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + + assert_maker_atom_links("feed", + ["items", "first", "source", "links"], + ["entries", "first", "source", "links"], + "maker.item.source.link", true) do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_logo + assert_maker_atom_logo("feed", ["channel"], ["logo"], "logo") do |maker| + setup_dummy_channel_atom(maker) + end + + assert_maker_atom_logo("feed", ["image"], ["logo"], "url") do |maker| + setup_dummy_channel_atom(maker) + end + + assert_maker_atom_logo("feed", + ["items", "first", "source", "logo"], + ["entries", "first", "source", "logo"], + nil, "maker.item.source.logo") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_rights + assert_maker_atom_text_construct("feed", + ["channel", "copyright"], + ["rights"]) do |maker| + setup_dummy_channel_atom(maker) + end + + assert_maker_atom_text_construct("feed", + ["items", "first", "rights"], + ["entries", "first", "rights"], + nil, nil, "maker.item.rights" + ) do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + + assert_maker_atom_text_construct("feed", + ["items", "first", "source", "rights"], + ["entries", "first", "source", "rights"], + nil, nil, "maker.item.source.rights" + ) do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_subtitle + assert_maker_atom_text_construct("feed", + ["channel", "subtitle"], + ["subtitle"], + nil, nil, + "maker.channel.description") do |maker| + setup_dummy_channel_atom(maker) + maker.channel.description.content = nil + end + + assert_maker_atom_text_construct("feed", + ["items", "first", "source", "subtitle"], + ["entries", "first", + "source", "subtitle"], + nil, nil, + "maker.item.source.subtitle") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_title + assert_maker_atom_text_construct("feed", + ["channel", "title"], ["title"], + "maker.channel", ["title"]) do |maker| + setup_dummy_channel_atom(maker) + maker.channel.title = nil + end + + assert_maker_atom_text_construct("feed", + ["items", "first", "title"], + ["entries", "first", "title"], + "maker.item", ["title"], + "maker.item.title") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + maker.items.first.title = nil + end + + assert_maker_atom_text_construct("feed", + ["items", "first", "source", "title"], + ["entries", "first", "source", "title"], + nil, nil, "maker.item.source.title" + ) do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_updated + assert_maker_atom_date_construct("feed", + ["channel", "updated"], ["updated"], + "maker.channel", ["updated"]) do |maker| + setup_dummy_channel_atom(maker) + maker.channel.updated = nil + end + + assert_maker_atom_date_construct("feed", + ["items", "first", "updated"], + ["entries", "first", "updated"], + "maker.item", ["updated"]) do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + maker.items.first.updated = nil + end + + assert_maker_atom_date_construct("feed", + ["items", "first", "source", "updated"], + ["entries", "first", "source", "updated"] + ) do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_published + assert_maker_atom_date_construct("feed", + ["items", "first", "published"], + ["entries", "first", "published"] + ) do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_summary + assert_maker_atom_text_construct("feed", + ["items", "first", "description"], + ["entries", "first", "summary"], + nil, nil, "maker.item.description" + ) do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_content + assert_maker_atom_content("feed", + ["items", "first", "content"], + ["entries", "first", "content"], + "maker.item.content") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + + def test_id + assert_maker_atom_id("feed", + ["items", "first", "source"], + ["entries", "first", "source"], + "maker.item.source") do |maker| + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + end + end +end diff --git a/test/rss/test_maker_dc.rb b/test/rss/test_maker_dc.rb index 37a7f2bb1d..72a967231a 100644 --- a/test/rss/test_maker_dc.rb +++ b/test/rss/test_maker_dc.rb @@ -107,14 +107,16 @@ module RSS rss = RSS::Maker.make("1.0") do |maker| setup_dummy_channel(maker) maker.channel.date = t1 - date = maker.channel.dc_dates.new_date - date.value = t2 + maker.channel.dc_dates.new_date do |date| + date.value = t2 + end setup_dummy_item(maker) item = maker.items.last item.date = t2 - date = item.dc_dates.new_date - date.value = t1 + item.dc_dates.new_date do |date| + date.value = t1 + end end assert_equal([t1, t2], rss.channel.dc_dates.collect{|x| x.value}) assert_equal([t2, t1], rss.items.last.dc_dates.collect{|x| x.value}) @@ -136,8 +138,9 @@ module RSS plural ||= "#{name}s" dc_elems = target.__send__("dc_#{plural}") values.each do |value| - new_dc_elem = dc_elems.__send__("new_#{name}") - new_dc_elem.value = value + dc_elems.__send__("new_#{name}") do |new_dc_elem| + new_dc_elem.value = value + end end end end diff --git a/test/rss/test_maker_sy.rb b/test/rss/test_maker_sy.rb index fd6df9a0eb..309a3b70fd 100644 --- a/test/rss/test_maker_sy.rb +++ b/test/rss/test_maker_sy.rb @@ -24,6 +24,7 @@ module RSS rss = RSS::Maker.make("1.0") do |maker| setup_dummy_channel(maker) set_elements(maker.channel) + setup_dummy_item(maker) end assert_syndication(@elements, rss.channel) end diff --git a/test/rss/test_maker_taxo.rb b/test/rss/test_maker_taxo.rb index 1c7d2844ce..8feb4e1d33 100644 --- a/test/rss/test_maker_taxo.rb +++ b/test/rss/test_maker_taxo.rb @@ -56,14 +56,16 @@ module RSS rss = RSS::Maker.make("1.0") do |maker| setup_dummy_channel(maker) maker.channel.date = t1 - date = maker.channel.dc_dates.new_date - date.value = t2 + maker.channel.dc_dates.new_date do |date| + date.value = t2 + end setup_dummy_item(maker) item = maker.items.last item.date = t2 - date = item.dc_dates.new_date - date.value = t1 + item.dc_dates.new_date do |date| + date.value = t1 + end end assert_equal([t1, t2], rss.channel.dc_dates.collect{|x| x.value}) assert_equal([t2, t1], rss.items.last.dc_dates.collect{|x| x.value}) diff --git a/test/rss/test_maker_trackback.rb b/test/rss/test_maker_trackback.rb index e90bb600a3..58705c6f80 100644 --- a/test/rss/test_maker_trackback.rb +++ b/test/rss/test_maker_trackback.rb @@ -25,8 +25,9 @@ module RSS item = maker.items.last item.trackback_ping = @elements[:ping] @elements[:abouts].each do |about| - new_about = item.trackback_abouts.new_about - new_about.value = about + item.trackback_abouts.new_about do |new_about| + new_about.value = about + end end end assert_trackback(@elements, rss.items.last) diff --git a/test/rss/test_maker_xml-stylesheet.rb b/test/rss/test_maker_xml-stylesheet.rb index bbdfdc682b..9d45e52038 100644 --- a/test/rss/test_maker_xml-stylesheet.rb +++ b/test/rss/test_maker_xml-stylesheet.rb @@ -14,15 +14,17 @@ module RSS alternate = 'yes' rss = RSS::Maker.make("1.0") do |maker| - xss = maker.xml_stylesheets.new_xml_stylesheet - xss.href = href - xss.type = type - xss.title = title - xss.media = media - xss.charset = charset - xss.alternate = alternate - + maker.xml_stylesheets.new_xml_stylesheet do |xss| + xss.href = href + xss.type = type + xss.title = title + xss.media = media + xss.charset = charset + xss.alternate = alternate + end + setup_dummy_channel(maker) + setup_dummy_item(maker) end xss = rss.xml_stylesheets.first @@ -37,10 +39,12 @@ module RSS href = 'http://example.com/index.xsl' type = 'text/xsl' rss = RSS::Maker.make("1.0") do |maker| - xss = maker.xml_stylesheets.new_xml_stylesheet - xss.href = href - + maker.xml_stylesheets.new_xml_stylesheet do |xss| + xss.href = href + end + setup_dummy_channel(maker) + setup_dummy_item(maker) end xss = rss.xml_stylesheets.first @@ -53,20 +57,24 @@ module RSS type = "text/xsl" rss = RSS::Maker.make("1.0") do |maker| - xss = maker.xml_stylesheets.new_xml_stylesheet - # xss.href = href - xss.type = type - + maker.xml_stylesheets.new_xml_stylesheet do |xss| + # xss.href = href + xss.type = type + end + setup_dummy_channel(maker) + setup_dummy_item(maker) end assert(rss.xml_stylesheets.empty?) rss = RSS::Maker.make("1.0") do |maker| - xss = maker.xml_stylesheets.new_xml_stylesheet - xss.href = href - # xss.type = type - + maker.xml_stylesheets.new_xml_stylesheet do |xss| + xss.href = href + # xss.type = type + end + setup_dummy_channel(maker) + setup_dummy_item(maker) end assert(rss.xml_stylesheets.empty?) end diff --git a/test/rss/test_parser.rb b/test/rss/test_parser.rb index f410b1b4f0..49b441bf96 100644 --- a/test/rss/test_parser.rb +++ b/test/rss/test_parser.rb @@ -13,12 +13,10 @@ end require "rss-testcase" require "rss/1.0" -require "rss/2.0" require "rss/dublincore" module RSS class TestParser < TestCase - def setup @_default_parser = Parser.default_parser @rss10 = make_RDF(<<-EOR) @@ -35,588 +33,6 @@ EOR Parser.default_parser = @_default_parser FileUtils.rm_f(@rss_file) end - - def test_RDF - assert_ns("", RDF::URI) do - Parser.parse(<<-EOR) -#{make_xmldecl} - -EOR - end - - assert_ns("", RDF::URI) do - Parser.parse(<<-EOR) -#{make_xmldecl} - -EOR - end - - assert_ns("rdf", RDF::URI) do - Parser.parse(<<-EOR) -#{make_xmldecl} - -EOR - end - - assert_parse(<<-EOR, :missing_tag, "channel", "RDF") -#{make_xmldecl} - -EOR - - assert_parse(<<-EOR, :missing_tag, "channel", "RDF") -#{make_xmldecl} - -EOR - - assert_parse(<<-EOR, :missing_tag, "channel", "RDF") -#{make_xmldecl} - -EOR - - assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF") -#{make_channel} -EOR - - assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF") -#{make_channel} -#{make_image} -EOR - - assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF") -#{make_channel} -#{make_textinput} -EOR - - assert_too_much_tag("image", "RDF") do - Parser.parse(make_RDF(<<-EOR)) -#{make_channel} -#{make_image} -#{make_image} -#{make_item} -#{make_textinput} -EOR - end - - assert_parse(make_RDF(<<-EOR), :nothing_raised) -#{make_channel} -#{make_item} -#{make_image} -#{make_textinput} -EOR - - assert_parse(make_RDF(<<-EOR), :nothing_raised) -#{make_channel} -#{make_item} -#{make_textinput} -#{make_image} -EOR - - assert_parse(make_RDF(<<-EOR), :nothing_raised) -#{make_channel} -#{make_image} -#{make_item} -EOR - - assert_parse(make_RDF(<<-EOR), :nothing_raised) -#{make_channel} -#{make_image} -#{make_item} -#{make_textinput} -EOR - - 1.step(15, 3) do |i| - rss = make_RDF() do - res = make_channel - i.times { res << make_item } - res - end - assert_parse(rss, :nothing_raised) - end - end - - def test_undefined_entity - return unless RSS::Parser.default_parser.raise_for_undefined_entity? - assert_parse(make_RDF(<<-EOR), :raises, RSS::NotWellFormedError) -#{make_channel} -#{make_image} - - #{TITLE_VALUE} &UNKNOWN_ENTITY; - #{LINK_VALUE} - #{DESCRIPTION_VALUE} - -#{make_textinput} -EOR - end - - def test_channel - - assert_parse(make_RDF(<<-EOR), :missing_attribute, "channel", "rdf:about") - -EOR - - assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "channel") - -EOR - - assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "channel") - - hoge - -EOR - - assert_parse(make_RDF(< - hoge - http://example.com/ - -EOR - - assert_parse(make_RDF(<<-EOR), :missing_tag, "items", "channel") - - hoge - http://example.com/ - hogehoge - -EOR - - assert_parse(make_RDF(<<-EOR), :missing_attribute, "image", "rdf:resource") - - hoge - http://example.com/ - hogehoge - - -EOR - - assert_parse(make_RDF(<<-EOR), :missing_tag, "items", "channel") - - hoge - http://example.com/ - hogehoge - - -EOR - - rss = make_RDF(<<-EOR) - - hoge - http://example.com/ - hogehoge - - - -EOR - - assert_missing_tag("Seq", "items") do - Parser.parse(rss) - end - - assert_missing_tag("item", "RDF") do - Parser.parse(rss, false).validate - end - - assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF") - - hoge - http://example.com/ - hogehoge - - - - - - -EOR - - assert_parse(make_RDF(<<-EOR), :missing_attribute, "textinput", "rdf:resource") - - hoge - http://example.com/ - hogehoge - - - - - - - -EOR - - assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF") - - hoge - http://example.com/ - hogehoge - - - - - - - -EOR - - end - - def test_rdf_li - - rss = make_RDF(<<-EOR) - - hoge - http://example.com/ - hogehoge - - - - - - - - -#{make_item} -EOR - - source = Proc.new do |rdf_li_attr| - eval(%Q[%Q[#{rss}]], binding) - end - - attr = %q[resource="http://example.com/hoge"] - assert_parse(source.call(attr), :nothing_raised) - - attr = %q[rdf:resource="http://example.com/hoge"] - assert_parse(source.call(attr), :nothing_raised) - - assert_parse(source.call(""), :missing_attribute, "li", "resource") - end - - def test_image - - assert_parse(make_RDF(<<-EOR), :missing_attribute, "image", "rdf:about") -#{make_channel} - - -EOR - - assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "image") -#{make_channel} - - -EOR - - assert_parse(make_RDF(<<-EOR), :missing_tag, "url", "image") -#{make_channel} - - hoge - -EOR - - assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "image") -#{make_channel} - - hoge - http://example.com/hoge.png - -EOR - - assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF") -#{make_channel} - - hoge - http://example.com/hoge.png - http://example.com/ - -EOR - - rss = make_RDF(<<-EOR) -#{make_channel} - - http://example.com/ - http://example.com/hoge.png - hoge - -EOR - - assert_missing_tag("item", "RDF") do - Parser.parse(rss) - end - - assert_missing_tag("item", "RDF") do - Parser.parse(rss, false).validate - end - - end - - def test_item - - assert_parse(make_RDF(<<-EOR), :missing_attribute, "item", "rdf:about") -#{make_channel} -#{make_image} - - -EOR - - assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "item") -#{make_channel} -#{make_image} - - -EOR - - assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "item") -#{make_channel} -#{make_image} - - hoge - -EOR - - assert_too_much_tag("title", "item") do - Parser.parse(make_RDF(<<-EOR)) -#{make_channel} -#{make_image} - - hoge - hoge - http://example.com/hoge.html - -EOR - end - - assert_parse(make_RDF(<<-EOR), :nothing_raised) -#{make_channel} -#{make_image} - - hoge - http://example.com/hoge.html - -EOR - - assert_parse(make_RDF(<<-EOR), :nothing_raised) -#{make_channel} -#{make_image} - - hoge - http://example.com/hoge.html - hogehoge - -EOR - - end - - def test_textinput - - assert_parse(make_RDF(<<-EOR), :missing_attribute, "textinput", "rdf:about") -#{make_channel} -#{make_image} -#{make_item} - - -EOR - - assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "textinput") -#{make_channel} -#{make_image} -#{make_item} - - -EOR - - assert_parse(make_RDF(<<-EOR), :missing_tag, "description", "textinput") -#{make_channel} -#{make_image} -#{make_item} - - hoge - -EOR - - assert_too_much_tag("title", "textinput") do - Parser.parse(make_RDF(<<-EOR)) -#{make_channel} -#{make_image} -#{make_item} - - hoge - hoge - hogehoge - -EOR - end - - assert_parse(make_RDF(<<-EOR), :missing_tag, "name", "textinput") -#{make_channel} -#{make_image} -#{make_item} - - hoge - hogehoge - -EOR - - assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "textinput") -#{make_channel} -#{make_image} -#{make_item} - - hoge - hogehoge - key - -EOR - - assert_parse(make_RDF(<<-EOR), :nothing_raised) -#{make_channel} -#{make_image} -#{make_item} - - hoge - hogehoge - key - http://example.com/search.html - -EOR - - end - - 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[])} -EOR - - end - - end - - def test_source20 - - assert_parse(make_rss20(<<-EOR), :missing_attribute, "source", "url") -#{make_channel20(make_item20(%Q[Example]))} -EOR - - assert_parse(make_rss20(<<-EOR), :nothing_raised) -#{make_channel20(make_item20(%Q[]))} -EOR - - assert_parse(make_rss20(<<-EOR), :nothing_raised) -#{make_channel20(make_item20(%Q[Example]))} -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[ - - ])} - ])} -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[ -#{text} - ])} - ])} -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 - - def test_ignore - - rss = make_RDF(<<-EOR) -#{make_channel} -#{make_item} - -EOR - - assert_parse(rss, :nothing_raised) - - assert_not_excepted_tag("a", "RDF") do - Parser.parse(rss, true, false) - end - - end def test_default_parser assert_nothing_raised do @@ -640,7 +56,5 @@ EOR assert_nil(RSS::Parser.parse(garbage_rss_file)) end end - end end - diff --git a/test/rss/test_parser_1.0.rb b/test/rss/test_parser_1.0.rb new file mode 100644 index 0000000000..472602b04a --- /dev/null +++ b/test/rss/test_parser_1.0.rb @@ -0,0 +1,503 @@ +require "rss-testcase" + +require "rss/1.0" +require "rss/dublincore" + +module RSS + class TestParser10 < TestCase + def test_RDF + assert_ns("", RDF::URI) do + Parser.parse(<<-EOR) +#{make_xmldecl} + +EOR + end + + assert_ns("", RDF::URI) do + Parser.parse(<<-EOR) +#{make_xmldecl} + +EOR + end + + assert_ns("rdf", RDF::URI) do + Parser.parse(<<-EOR) +#{make_xmldecl} + +EOR + end + + assert_parse(<<-EOR, :missing_tag, "channel", "RDF") +#{make_xmldecl} + +EOR + + assert_parse(<<-EOR, :missing_tag, "channel", "RDF") +#{make_xmldecl} + +EOR + + assert_parse(<<-EOR, :missing_tag, "channel", "RDF") +#{make_xmldecl} + +EOR + + assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF") +#{make_channel} +EOR + + assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF") +#{make_channel} +#{make_image} +EOR + + assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF") +#{make_channel} +#{make_textinput} +EOR + + assert_too_much_tag("image", "RDF") do + Parser.parse(make_RDF(<<-EOR)) +#{make_channel} +#{make_image} +#{make_image} +#{make_item} +#{make_textinput} +EOR + end + + assert_parse(make_RDF(<<-EOR), :nothing_raised) +#{make_channel} +#{make_item} +#{make_image} +#{make_textinput} +EOR + + assert_parse(make_RDF(<<-EOR), :nothing_raised) +#{make_channel} +#{make_item} +#{make_textinput} +#{make_image} +EOR + + assert_parse(make_RDF(<<-EOR), :nothing_raised) +#{make_channel} +#{make_image} +#{make_item} +EOR + + assert_parse(make_RDF(<<-EOR), :nothing_raised) +#{make_channel} +#{make_image} +#{make_item} +#{make_textinput} +EOR + + 1.step(15, 3) do |i| + rss = make_RDF() do + res = make_channel + i.times { res << make_item } + res + end + assert_parse(rss, :nothing_raised) + end + end + + def test_undefined_entity + return unless RSS::Parser.default_parser.raise_for_undefined_entity? + assert_parse(make_RDF(<<-EOR), :raises, RSS::NotWellFormedError) +#{make_channel} +#{make_image} + + #{TITLE_VALUE} &UNKNOWN_ENTITY; + #{LINK_VALUE} + #{DESCRIPTION_VALUE} + +#{make_textinput} +EOR + end + + def test_channel + assert_parse(make_RDF(<<-EOR), :missing_attribute, "channel", "rdf:about") + +EOR + + assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "channel") + +EOR + + assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "channel") + + hoge + +EOR + + assert_parse(make_RDF(< + hoge + http://example.com/ + +EOR + + assert_parse(make_RDF(<<-EOR), :missing_tag, "items", "channel") + + hoge + http://example.com/ + hogehoge + +EOR + + assert_parse(make_RDF(<<-EOR), :missing_attribute, "image", "rdf:resource") + + hoge + http://example.com/ + hogehoge + + +EOR + + assert_parse(make_RDF(<<-EOR), :missing_tag, "items", "channel") + + hoge + http://example.com/ + hogehoge + + +EOR + + rss = make_RDF(<<-EOR) + + hoge + http://example.com/ + hogehoge + + + +EOR + + assert_missing_tag("Seq", "items") do + Parser.parse(rss) + end + + assert_missing_tag("item", "RDF") do + Parser.parse(rss, false).validate + end + + assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF") + + hoge + http://example.com/ + hogehoge + + + + + + +EOR + + assert_parse(make_RDF(<<-EOR), :missing_attribute, "textinput", "rdf:resource") + + hoge + http://example.com/ + hogehoge + + + + + + + +EOR + + assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF") + + hoge + http://example.com/ + hogehoge + + + + + + + +EOR + end + + def test_rdf_li + rss = make_RDF(<<-EOR) + + hoge + http://example.com/ + hogehoge + + + + + + + + +#{make_item} +EOR + + source = Proc.new do |rdf_li_attr| + eval(%Q[%Q[#{rss}]], binding) + end + + attr = %q[resource="http://example.com/hoge"] + assert_parse(source.call(attr), :nothing_raised) + + attr = %q[rdf:resource="http://example.com/hoge"] + assert_parse(source.call(attr), :nothing_raised) + + assert_parse(source.call(""), :missing_attribute, "li", "resource") + end + + def test_image + assert_parse(make_RDF(<<-EOR), :missing_attribute, "image", "rdf:about") +#{make_channel} + + +EOR + + assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "image") +#{make_channel} + + +EOR + + assert_parse(make_RDF(<<-EOR), :missing_tag, "url", "image") +#{make_channel} + + hoge + +EOR + + assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "image") +#{make_channel} + + hoge + http://example.com/hoge.png + +EOR + + assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF") +#{make_channel} + + hoge + http://example.com/hoge.png + http://example.com/ + +EOR + + rss = make_RDF(<<-EOR) +#{make_channel} + + http://example.com/ + http://example.com/hoge.png + hoge + +EOR + + assert_missing_tag("item", "RDF") do + Parser.parse(rss) + end + + assert_missing_tag("item", "RDF") do + Parser.parse(rss, false).validate + end + end + + def test_item + assert_parse(make_RDF(<<-EOR), :missing_attribute, "item", "rdf:about") +#{make_channel} +#{make_image} + + +EOR + + assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "item") +#{make_channel} +#{make_image} + + +EOR + + assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "item") +#{make_channel} +#{make_image} + + hoge + +EOR + + assert_too_much_tag("title", "item") do + Parser.parse(make_RDF(<<-EOR)) +#{make_channel} +#{make_image} + + hoge + hoge + http://example.com/hoge.html + +EOR + end + + assert_parse(make_RDF(<<-EOR), :nothing_raised) +#{make_channel} +#{make_image} + + hoge + http://example.com/hoge.html + +EOR + + assert_parse(make_RDF(<<-EOR), :nothing_raised) +#{make_channel} +#{make_image} + + hoge + http://example.com/hoge.html + hogehoge + +EOR + end + + def test_textinput + assert_parse(make_RDF(<<-EOR), :missing_attribute, "textinput", "rdf:about") +#{make_channel} +#{make_image} +#{make_item} + + +EOR + + assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "textinput") +#{make_channel} +#{make_image} +#{make_item} + + +EOR + + assert_parse(make_RDF(<<-EOR), :missing_tag, "description", "textinput") +#{make_channel} +#{make_image} +#{make_item} + + hoge + +EOR + + assert_too_much_tag("title", "textinput") do + Parser.parse(make_RDF(<<-EOR)) +#{make_channel} +#{make_image} +#{make_item} + + hoge + hoge + hogehoge + +EOR + end + + assert_parse(make_RDF(<<-EOR), :missing_tag, "name", "textinput") +#{make_channel} +#{make_image} +#{make_item} + + hoge + hogehoge + +EOR + + assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "textinput") +#{make_channel} +#{make_image} +#{make_item} + + hoge + hogehoge + key + +EOR + + assert_parse(make_RDF(<<-EOR), :nothing_raised) +#{make_channel} +#{make_image} +#{make_item} + + hoge + hogehoge + key + http://example.com/search.html + +EOR + end + + def test_ignore + name = "a" + rss = make_RDF(<<-EOR) +#{make_channel} +#{make_item} +<#{name}/> +EOR + assert_not_expected_tag(name, ::RSS::URI, "RDF") do + Parser.parse(rss, true, false) + end + + uri = "" + name = "a" + rss = make_RDF(<<-EOR) +#{make_channel} +#{make_item} +<#{name} xmlns=""/> +EOR + assert_parse(rss, :nothing_raised) + assert_not_expected_tag(name, uri, "RDF") do + Parser.parse(rss, true, false) + end + + uri = "http://example.com/" + name = "a" + rss = make_RDF(<<-EOR) +#{make_channel} +#{make_item} + +EOR + assert_parse(rss, :nothing_raised) + assert_not_expected_tag(name, uri, "RDF") do + Parser.parse(rss, true, false) + end + + uri = ::RSS::URI + name = "a" + rss = make_RDF(<<-EOR) +#{make_channel} +#{make_item} +#{make_image("<#{name}/>")} +EOR + assert_parse(rss, :nothing_raised) + assert_not_expected_tag(name, uri, "image") do + Parser.parse(rss, true, false) + end + + uri = CONTENT_URI + name = "encoded" + elem = "<#{name} xmlns='#{uri}'/>" + rss = make_RDF(<<-EOR) +#{make_channel} +#{make_item} +#{make_image(elem)} +EOR + assert_parse(rss, :nothing_raised) + assert_not_expected_tag(name, uri, "image") do + Parser.parse(rss, true, false) + end + end + end +end + diff --git a/test/rss/test_parser_2.0.rb b/test/rss/test_parser_2.0.rb new file mode 100644 index 0000000000..249347d3dc --- /dev/null +++ b/test/rss/test_parser_2.0.rb @@ -0,0 +1,122 @@ +require "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[])} +EOR + end + end + + def test_source20 + assert_parse(make_rss20(<<-EOR), :missing_attribute, "source", "url") +#{make_channel20(make_item20(%Q[Example]))} +EOR + + assert_parse(make_rss20(<<-EOR), :nothing_raised) +#{make_channel20(make_item20(%Q[]))} +EOR + + assert_parse(make_rss20(<<-EOR), :nothing_raised) +#{make_channel20(make_item20(%Q[Example]))} +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[ + + ])} + ])} +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[ +#{text} + ])} + ])} +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 + diff --git a/test/rss/test_parser_atom_entry.rb b/test/rss/test_parser_atom_entry.rb new file mode 100644 index 0000000000..c2572d7a3b --- /dev/null +++ b/test/rss/test_parser_atom_entry.rb @@ -0,0 +1,163 @@ +require "rss-testcase" + +require "rss/atom" + +module RSS + class TestParserAtom < TestCase + def test_entry_validation + assert_ns("", Atom::URI) do + Parser.parse(<<-EOA) + +EOA + end + + assert_ns("", Atom::URI) do + Parser.parse(<<-EOA) + +EOA + end + + assert_parse(<<-EOA, :missing_tag, "id", "entry") do + +EOA + end + + assert_parse(<<-EOA, :missing_tag, "title", "entry") do + + urn:uuid:506e336c-a26e-4457-917b-b89dca7ae746 + +EOA + end + + assert_parse(<<-EOA, :missing_tag, "updated", "entry") do + + urn:uuid:506e336c-a26e-4457-917b-b89dca7ae746 + Example Entry + +EOA + end + + assert_parse(<<-EOA, :missing_tag, "author", "entry") do + + urn:uuid:506e336c-a26e-4457-917b-b89dca7ae746 + Example Entry + 2003-10-10T18:30:02Z + +EOA + end + + assert_parse(<<-EOA, :nothing_raised) do + + urn:uuid:506e336c-a26e-4457-917b-b89dca7ae746 + Example Entry + 2003-10-10T18:30:02Z + + A person + + +EOA + end + end + + def test_entry + entry = RSS::Parser.parse(<<-EOA) + + + + A person + + Atom-Powered Robots Run Amok + + urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a + 2003-12-13T18:30:02Z + Some text. + +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 diff --git a/test/rss/test_parser_atom_feed.rb b/test/rss/test_parser_atom_feed.rb new file mode 100644 index 0000000000..4358cc8898 --- /dev/null +++ b/test/rss/test_parser_atom_feed.rb @@ -0,0 +1,276 @@ +require "rss-testcase" + +require "rss/atom" + +module RSS + class TestParserAtomFeed < TestCase + def test_feed_validation + assert_ns("", Atom::URI) do + Parser.parse(<<-EOA) + +EOA + end + + assert_ns("", Atom::URI) do + Parser.parse(<<-EOA) + +EOA + end + + assert_parse(<<-EOA, :missing_tag, "id", "feed") do + +EOA + end + + assert_parse(<<-EOA, :missing_tag, "title", "feed") do + + urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6 + +EOA + end + + assert_parse(<<-EOA, :missing_tag, "updated", "feed") do + + urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6 + Example Feed + +EOA + end + + assert_parse(<<-EOA, :missing_tag, "author", "feed") do + + urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6 + Example Feed + 2003-12-13T18:30:02Z + +EOA + end + + assert_parse(<<-EOA, :nothing_raised) do + + urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6 + Example Feed + 2003-12-13T18:30:02Z + + A person + + +EOA + end + end + + def test_lang + feed = RSS::Parser.parse(<<-EOA) + + urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6 + Example Feed + 2003-12-13T18:30:02Z + + A person + + +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) + + urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6 + Example Feed + 2003-12-13T18:30:02Z + Generator + + + + + A person + person + + +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 diff --git a/test/rss/test_setup_maker_0.9.rb b/test/rss/test_setup_maker_0.9.rb index 086065c2bc..c20186cc8a 100644 --- a/test/rss/test_setup_maker_0.9.rb +++ b/test/rss/test_setup_maker_0.9.rb @@ -40,17 +40,28 @@ module RSS maker.channel.lastBuildDate = lastBuildDate skipDays.each do |day| - new_day = maker.channel.skipDays.new_day - new_day.content = day + maker.channel.skipDays.new_day do |new_day| + new_day.content = day + end end skipHours.each do |hour| - new_hour = maker.channel.skipHours.new_hour - new_hour.content = hour + maker.channel.skipHours.new_hour do |new_hour| + new_hour.content = hour + end + end + + setup_dummy_image(maker) + end + + assert_not_set_error("maker.image", %w(title url)) do + RSS::Maker.make("0.91") do |maker| + rss.channel.setup_maker(maker) end end new_rss = RSS::Maker.make("0.91") do |maker| rss.channel.setup_maker(maker) + setup_dummy_image(maker) end channel = new_rss.channel @@ -72,9 +83,8 @@ module RSS skipHours.each_with_index do |hour, i| assert_equal(hour.to_i, channel.skipHours.hours[i].content) end - + assert(channel.items.empty?) - assert_nil(channel.image) assert_nil(channel.textInput) end @@ -119,6 +129,7 @@ module RSS rss = RSS::Maker.make("0.91") do |maker| setup_dummy_channel(maker) + setup_dummy_image(maker) maker.textinput.title = title maker.textinput.description = description @@ -128,6 +139,7 @@ module RSS new_rss = RSS::Maker.make("0.91") do |maker| rss.channel.setup_maker(maker) + rss.image.setup_maker(maker) rss.textinput.setup_maker(maker) end @@ -149,11 +161,14 @@ module RSS setup_dummy_channel(maker) item_size.times do |i| - item = maker.items.new_item - item.title = "#{title}#{i}" - item.link = "#{link}#{i}" - item.description = "#{description}#{i}" + maker.items.new_item do |item| + item.title = "#{title}#{i}" + item.link = "#{link}#{i}" + item.description = "#{description}#{i}" + end end + + setup_dummy_image(maker) end new_rss = RSS::Maker.make("0.91") do |maker| @@ -166,15 +181,16 @@ module RSS item.setup_maker(maker.items) end end + + rss.image.setup_maker(maker) end - + assert_equal(item_size, new_rss.items.size) new_rss.items.each_with_index do |item, i| assert_equal("#{title}#{i}", item.title) assert_equal("#{link}#{i}", item.link) assert_equal("#{description}#{i}", item.description) end - end def test_setup_maker_items_backward_compatibility @@ -196,17 +212,19 @@ module RSS maker.encoding = encoding maker.standalone = standalone - xss = maker.xml_stylesheets.new_xml_stylesheet - xss.href = href - xss.type = type - xss.title = title - xss.media = media - xss.charset = charset - xss.alternate = alternate - + maker.xml_stylesheets.new_xml_stylesheet do |xss| + xss.href = href + xss.type = type + xss.title = title + xss.media = media + xss.charset = charset + xss.alternate = alternate + end + setup_dummy_channel(maker) + setup_dummy_image(maker) end - + new_rss = RSS::Maker.make("0.91") do |maker| rss.setup_maker(maker) end @@ -224,6 +242,5 @@ module RSS assert_equal(charset, xss.charset) assert_equal(alternate, xss.alternate) end - end end diff --git a/test/rss/test_setup_maker_1.0.rb b/test/rss/test_setup_maker_1.0.rb index 95d8b310ba..539749bf20 100644 --- a/test/rss/test_setup_maker_1.0.rb +++ b/test/rss/test_setup_maker_1.0.rb @@ -87,10 +87,15 @@ module RSS @sy_elems.each do |var, value| maker.channel.__send__("sy_#{var}=", value) end + + setup_dummy_item(maker) end new_rss = RSS::Maker.make("1.0") do |maker| rss.channel.setup_maker(maker) + rss.items.each do |item| + item.setup_maker(maker) + end end channel = new_rss.channel @@ -98,7 +103,7 @@ module RSS assert_equal(title, channel.title) assert_equal(link, channel.link) assert_equal(description, channel.description) - assert_equal(true, channel.items.Seq.lis.empty?) + assert_equal(1, channel.items.Seq.lis.size) assert_nil(channel.image) assert_nil(channel.textinput) @@ -128,11 +133,16 @@ module RSS @dc_elems.each do |var, value| maker.image.__send__("dc_#{var}=", value) end + + setup_dummy_item(maker) end new_rss = RSS::Maker.make("1.0") do |maker| rss.channel.setup_maker(maker) rss.image.setup_maker(maker) + rss.items.each do |item| + item.setup_maker(maker) + end end image = new_rss.image @@ -164,11 +174,16 @@ module RSS @dc_elems.each do |var, value| maker.textinput.__send__("dc_#{var}=", value) end + + setup_dummy_item(maker) end new_rss = RSS::Maker.make("1.0") do |maker| rss.channel.setup_maker(maker) rss.textinput.setup_maker(maker) + rss.items.each do |item| + item.setup_maker(maker) + end end textinput = new_rss.textinput @@ -195,23 +210,25 @@ module RSS setup_dummy_channel(maker) item_size.times do |i| - item = maker.items.new_item - item.title = "#{title}#{i}" - item.link = "#{link}#{i}" - item.description = "#{description}#{i}" - - @dc_elems.each do |var, value| - item.__send__("dc_#{var}=", value) - end - - @content_elems.each do |var, value| - item.__send__("content_#{var}=", value) - end - - item.trackback_ping = @trackback_elems[:ping] - @trackback_elems[:about].each do |value| - new_about = item.trackback_abouts.new_about - new_about.value = value + maker.items.new_item do |item| + item.title = "#{title}#{i}" + item.link = "#{link}#{i}" + item.description = "#{description}#{i}" + + @dc_elems.each do |var, value| + item.__send__("dc_#{var}=", value) + end + + @content_elems.each do |var, value| + item.__send__("content_#{var}=", value) + end + + item.trackback_ping = @trackback_elems[:ping] + @trackback_elems[:about].each do |value| + item.trackback_abouts.new_about do |new_about| + new_about.value = value + end + end end end end @@ -321,15 +338,17 @@ module RSS maker.encoding = encoding maker.standalone = standalone - xss = maker.xml_stylesheets.new_xml_stylesheet - xss.href = href - xss.type = type - xss.title = title - xss.media = media - xss.charset = charset - xss.alternate = alternate - + maker.xml_stylesheets.new_xml_stylesheet do |xss| + xss.href = href + xss.type = type + xss.title = title + xss.media = media + xss.charset = charset + xss.alternate = alternate + end + setup_dummy_channel(maker) + setup_dummy_item(maker) end new_rss = RSS::Maker.make("1.0") do |maker| @@ -384,14 +403,15 @@ module RSS maker.encoding = encoding maker.standalone = standalone - xss = maker.xml_stylesheets.new_xml_stylesheet - xss.href = href - xss.type = type - xss.title = title - xss.media = media - xss.charset = charset - xss.alternate = alternate - + maker.xml_stylesheets.new_xml_stylesheet do |xss| + xss.href = href + xss.type = type + xss.title = title + xss.media = media + xss.charset = charset + xss.alternate = alternate + end + maker.channel.about = channel_about maker.channel.title = channel_title maker.channel.link = channel_link @@ -418,23 +438,25 @@ module RSS end item_size.times do |i| - item = maker.items.new_item - item.title = "#{item_title}#{i}" - item.link = "#{item_link}#{i}" - item.description = "#{item_description}#{i}" - - @dc_elems.each do |var, value| - item.__send__("dc_#{var}=", value) - end - - @content_elems.each do |var, value| - item.__send__("content_#{var}=", value) - end - - item.trackback_ping = @trackback_elems[:ping] - @trackback_elems[:about].each do |value| - new_about = item.trackback_abouts.new_about - new_about.value = value + maker.items.new_item do |item| + item.title = "#{item_title}#{i}" + item.link = "#{item_link}#{i}" + item.description = "#{item_description}#{i}" + + @dc_elems.each do |var, value| + item.__send__("dc_#{var}=", value) + end + + @content_elems.each do |var, value| + item.__send__("content_#{var}=", value) + end + + item.trackback_ping = @trackback_elems[:ping] + @trackback_elems[:about].each do |value| + item.trackback_abouts.new_about do |new_about| + new_about.value = value + end + end end end diff --git a/test/rss/test_setup_maker_2.0.rb b/test/rss/test_setup_maker_2.0.rb index a35096cf16..8fb727de8d 100644 --- a/test/rss/test_setup_maker_2.0.rb +++ b/test/rss/test_setup_maker_2.0.rb @@ -46,18 +46,21 @@ module RSS maker.channel.lastBuildDate = lastBuildDate skipDays.each do |day| - new_day = maker.channel.skipDays.new_day - new_day.content = day + maker.channel.skipDays.new_day do |new_day| + new_day.content = day + end end skipHours.each do |hour| - new_hour = maker.channel.skipHours.new_hour - new_hour.content = hour + maker.channel.skipHours.new_hour do |new_hour| + new_hour.content = hour + end end categories.each do |category| - new_category = maker.channel.categories.new_category - new_category.content = category + maker.channel.categories.new_category do |new_category| + new_category.content = category + end end maker.channel.generator = generator @@ -189,27 +192,28 @@ module RSS setup_dummy_channel(maker) item_size.times do |i| - item = maker.items.new_item - item.title = "#{title}#{i}" - item.link = "#{link}#{i}" - item.description = "#{description}#{i}" - item.author = "#{author}#{i}" - item.comments = "#{comments}#{i}" - item.date = pubDate - - item.guid.isPermaLink = guid_isPermaLink - item.guid.content = guid_content - - item.enclosure.url = enclosure_url - item.enclosure.length = enclosure_length - item.enclosure.type = enclosure_type - - item.source.url = source_url - item.source.content = source_content - - category = item.categories.new_category - category.domain = category_domain - category.content = category_content + maker.items.new_item do |item| + item.title = "#{title}#{i}" + item.link = "#{link}#{i}" + item.description = "#{description}#{i}" + item.author = "#{author}#{i}" + item.comments = "#{comments}#{i}" + item.date = pubDate + + item.guid.isPermaLink = guid_isPermaLink + item.guid.content = guid_content + + item.enclosure.url = enclosure_url + item.enclosure.length = enclosure_length + item.enclosure.type = enclosure_type + + item.source.url = source_url + item.source.content = source_content + + category = item.categories.new_category + category.domain = category_domain + category.content = category_content + end end end @@ -270,14 +274,15 @@ module RSS maker.encoding = encoding maker.standalone = standalone - xss = maker.xml_stylesheets.new_xml_stylesheet - xss.href = href - xss.type = type - xss.title = title - xss.media = media - xss.charset = charset - xss.alternate = alternate - + maker.xml_stylesheets.new_xml_stylesheet do |xss| + xss.href = href + xss.type = type + xss.title = title + xss.media = media + xss.charset = charset + xss.alternate = alternate + end + setup_dummy_channel(maker) end diff --git a/test/rss/test_setup_maker_atom_entry.rb b/test/rss/test_setup_maker_atom_entry.rb new file mode 100644 index 0000000000..6f3df65f3f --- /dev/null +++ b/test/rss/test_setup_maker_atom_entry.rb @@ -0,0 +1,409 @@ +require "rss-testcase" + +require "rss/maker" + +module RSS + class TestSetupMakerAtomEntry < TestCase + def setup + t = Time.iso8601("2000-01-01T12:00:05+00:00") + class << t + alias_method(:to_s, :iso8601) + end + + @dc_elems = { + :title => "hoge", + :description => + " XML is placing increasingly heavy loads on + the existing technical infrastructure of the Internet.", + :creator => "Rael Dornfest (mailto:rael@oreilly.com)", + :subject => "XML", + :publisher => "The O'Reilly Network", + :contributor => "hogehoge", + :type => "fugafuga", + :format => "hohoho", + :identifier => "fufufu", + :source => "barbar", + :language => "ja", + :relation => "cococo", + :rights => "Copyright (c) 2000 O'Reilly & Associates, Inc.", + :date => t, + } + end + + def test_setup_maker_entry(with_dc=true) + authors = [ + { + :name => "Bob", + :uri => "http://example.com/~bob/", + :email => "bob@example.com", + }, + { + :name => "Alice", + :uri => "http://example.com/~alice/", + :email => "alice@example.com", + }, + ] + categories = [ + { + :term => "music", + :label => "Music", + }, + { + :term => "book", + :scheme => "http://example.com/category/book/", + :label => "Book", + }, + ] + contributors = [ + { + :name => "Chris", + :email => "chris@example.com", + }, + { + :name => "Eva", + :uri => "http://example.com/~eva/", + }, + ] + id = "urn:uuid:8b105336-7e20-45fc-bb78-37fb3e1db25a" + link = "http://hoge.com" + published = Time.now - 60 * 3600 + rights = "Copyrights (c) 2007 Alice and Bob" + description = "fugafugafugafuga" + title = "fugafuga" + updated = Time.now + + feed = RSS::Maker.make("atom:entry") do |maker| + maker.items.new_item do |item| + authors.each do |author_info| + item.authors.new_author do |author| + author_info.each do |key, value| + author.__send__("#{key}=", value) + end + end + end + + categories.each do |category_info| + item.categories.new_category do |category| + category_info.each do |key, value| + category.__send__("#{key}=", value) + end + end + end + + contributors.each do |contributor_info| + item.contributors.new_contributor do |contributor| + contributor_info.each do |key, value| + contributor.__send__("#{key}=", value) + end + end + end + + item.id = id + item.link = link + item.published = published + item.rights = rights + item.description = description + item.title = title + item.updated = updated + + if with_dc + @dc_elems.each do |var, value| + if var == :date + item.new_dc_date(value) + else + item.__send__("dc_#{var}=", value) + end + end + end + end + end + assert_not_nil(feed) + + new_feed = RSS::Maker.make("atom:entry") do |maker| + feed.setup_maker(maker) + end + assert_not_nil(new_feed) + + new_authors = new_feed.authors.collect do |author| + { + :name => author.name.content, + :uri => author.uri.content, + :email => author.email.content, + } + end + assert_equal(authors, new_authors) + + new_categories = new_feed.categories.collect do |category| + { + :term => category.term, + :scheme => category.scheme, + :label => category.label, + }.reject {|key, value| value.nil?} + end + assert_equal(categories, new_categories) + + new_contributors = new_feed.contributors.collect do |contributor| + info = {} + info[:name] = contributor.name.content + info[:uri] = contributor.uri.content if contributor.uri + info[:email] = contributor.email.content if contributor.email + info + end + assert_equal(contributors, new_contributors) + + assert_equal(id, new_feed.id.content) + assert_equal(link, new_feed.link.href) + assert_equal(published, new_feed.published.content) + assert_equal(rights, new_feed.rights.content) + assert_equal(description, new_feed.summary.content) + assert_equal(title, new_feed.title.content) + assert_equal(updated, new_feed.updated.content) + + if with_dc + @dc_elems.each do |var, value| + if var == :date + assert_equal([updated, value], + new_feed.dc_dates.collect {|date| date.value}) + else + assert_equal(value, new_feed.__send__("dc_#{var}")) + end + end + end + + assert_equal(1, new_feed.items.size) + end + + def test_setup_maker_entry_without_dc + test_setup_maker_entry(false) + end + + def test_setup_maker_items(for_backward_compatibility=false) + title = "TITLE" + link = "http://hoge.com/" + description = "text hoge fuga" + updated = Time.now + + item_size = 5 + feed = RSS::Maker.make("atom:entry") do |maker| + setup_dummy_channel_atom(maker) + + item_size.times do |i| + maker.items.new_item do |item| + item.title = "#{title}#{i}" + item.link = "#{link}#{i}" + item.description = "#{description}#{i}" + item.updated = updated + i * 60 + end + end + end + + new_feed = RSS::Maker.make("atom:entry") do |maker| + feed.items.each do |item| + if for_backward_compatibility + item.setup_maker(maker) + else + item.setup_maker(maker.items) + end + end + + feed.items.clear + feed.setup_maker(maker) + end + + assert_equal(1, new_feed.items.size) + new_feed.items[0..1].each_with_index do |item, i| + assert_equal("#{title}#{i}", item.title.content) + assert_equal("#{link}#{i}", item.link.href) + assert_equal("#{description}#{i}", item.summary.content) + assert_equal(updated + i * 60, item.updated.content) + end + end + + def test_setup_maker_items_sort + title = "TITLE" + link = "http://hoge.com/" + summary = "text hoge fuga" + updated = Time.now + + feed_size = 5 + feed = RSS::Maker.make("atom:entry") do |maker| + setup_dummy_channel_atom(maker) + + feed_size.times do |i| + entry_class = RSS::Atom::Entry + entry = entry_class.new + entry.title = entry_class::Title.new(:content => "#{title}#{i}") + entry.links << entry_class::Link.new(:href => "#{link}#{i}") + entry.summary = entry_class::Summary.new(:content => "#{summary}#{i}") + entry.updated = entry_class::Updated.new(:content => updated + i * 60) + entry.setup_maker(maker.items) + end + maker.items.do_sort = false + end + assert_equal(1, feed.items.size) + + assert_equal("#{title}0", feed.title.content) + assert_equal("#{link}0", feed.link.href) + assert_equal("#{summary}0", feed.summary.content) + + + feed = RSS::Maker.make("atom:entry") do |maker| + setup_dummy_channel_atom(maker) + + feed_size.times do |i| + entry_class = RSS::Atom::Entry + entry = entry_class.new + entry.title = entry_class::Title.new(:content => "#{title}#{i}") + entry.links << entry_class::Link.new(:href => "#{link}#{i}") + entry.summary = entry_class::Summary.new(:content => "#{summary}#{i}") + entry.updated = entry_class::Updated.new(:content => updated + i * 60) + entry.setup_maker(maker.items) + end + maker.items.do_sort = true + end + assert_equal(1, feed.items.size) + + assert_equal("#{title}#{feed_size - 1}", feed.title.content) + assert_equal("#{link}#{feed_size - 1}", feed.link.href) + assert_equal("#{summary}#{feed_size - 1}", feed.summary.content) + end + + def test_setup_maker_items_backward_compatibility + test_setup_maker_items(true) + end + + def test_setup_maker + encoding = "EUC-JP" + standalone = true + + href = 'a.xsl' + type = 'text/xsl' + title = 'sample' + media = 'printer' + charset = 'UTF-8' + alternate = 'yes' + + feed = RSS::Maker.make("atom:entry") do |maker| + maker.encoding = encoding + maker.standalone = standalone + + maker.xml_stylesheets.new_xml_stylesheet do |xss| + xss.href = href + xss.type = type + xss.title = title + xss.media = media + xss.charset = charset + xss.alternate = alternate + end + + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + assert_not_nil(feed) + + new_feed = RSS::Maker.make("atom:entry") do |maker| + feed.setup_maker(maker) + end + + assert_equal(["atom", "1.0", "entry"], new_feed.feed_info) + assert_equal(encoding, new_feed.encoding) + assert_equal(standalone, new_feed.standalone) + + xss = new_feed.xml_stylesheets.first + assert_equal(1, new_feed.xml_stylesheets.size) + assert_equal(href, xss.href) + assert_equal(type, xss.type) + assert_equal(title, xss.title) + assert_equal(media, xss.media) + assert_equal(charset, xss.charset) + assert_equal(alternate, xss.alternate) + end + + def test_setup_maker_full + encoding = "EUC-JP" + standalone = true + + href = 'a.xsl' + type = 'text/xsl' + title = 'sample' + media = 'printer' + charset = 'UTF-8' + alternate = 'yes' + + channel_about = "http://hoge.com" + channel_title = "fugafuga" + channel_link = "http://hoge.com" + channel_description = "fugafugafugafuga" + channel_author = "Bob" + + image_url = "http://hoge.com/hoge.png" + + item_title = "TITLE" + item_link = "http://hoge.com/" + item_description = "text hoge fuga" + + entry_size = 5 + feed = RSS::Maker.make("atom:entry") do |maker| + maker.encoding = encoding + maker.standalone = standalone + + maker.xml_stylesheets.new_xml_stylesheet do |xss| + xss.href = href + xss.type = type + xss.title = title + xss.media = media + xss.charset = charset + xss.alternate = alternate + end + + maker.channel.about = channel_about + maker.channel.title = channel_title + maker.channel.link = channel_link + maker.channel.description = channel_description + maker.channel.author = channel_author + @dc_elems.each do |var, value| + maker.channel.__send__("dc_#{var}=", value) + end + + maker.image.url = image_url + + entry_size.times do |i| + maker.items.new_item do |item| + item.title = "#{item_title}#{i}" + item.link = "#{item_link}#{i}" + item.description = "#{item_description}#{i}" + + @dc_elems.each do |var, value| + item.__send__("dc_#{var}=", value) + end + end + end + end + + new_feed = RSS::Maker.make("atom:entry") do |maker| + feed.setup_maker(maker) + end + + assert_equal(["atom", "1.0", "entry"], new_feed.feed_info) + assert_equal(encoding, new_feed.encoding) + assert_equal(standalone, new_feed.standalone) + + xss = new_feed.xml_stylesheets.first + assert_equal(1, new_feed.xml_stylesheets.size) + assert_equal(href, xss.href) + assert_equal(type, xss.type) + assert_equal(title, xss.title) + assert_equal(media, xss.media) + assert_equal(charset, xss.charset) + assert_equal(alternate, xss.alternate) + + assert_equal("#{item_title}0", new_feed.title.content) + assert_equal("#{item_link}0", new_feed.link.href) + assert_equal("#{item_description}0", new_feed.summary.content) + @dc_elems.each do |var, value| + assert_equal(value, new_feed.__send__("dc_#{var}")) + end + assert_equal(1, new_feed.items.size) + end + end +end diff --git a/test/rss/test_setup_maker_atom_feed.rb b/test/rss/test_setup_maker_atom_feed.rb new file mode 100644 index 0000000000..0caed6cec8 --- /dev/null +++ b/test/rss/test_setup_maker_atom_feed.rb @@ -0,0 +1,443 @@ +require "rss-testcase" + +require "rss/maker" + +module RSS + class TestSetupMakerAtomFeed < TestCase + def setup + t = Time.iso8601("2000-01-01T12:00:05+00:00") + class << t + alias_method(:to_s, :iso8601) + end + + @dc_elems = { + :title => "hoge", + :description => + " XML is placing increasingly heavy loads on + the existing technical infrastructure of the Internet.", + :creator => "Rael Dornfest (mailto:rael@oreilly.com)", + :subject => "XML", + :publisher => "The O'Reilly Network", + :contributor => "hogehoge", + :type => "fugafuga", + :format => "hohoho", + :identifier => "fufufu", + :source => "barbar", + :language => "ja", + :relation => "cococo", + :rights => "Copyright (c) 2000 O'Reilly & Associates, Inc.", + :date => t, + } + end + + def test_setup_maker_feed(with_dc=true) + authors = [ + { + :name => "Bob", + :uri => "http://example.com/~bob/", + :email => "bob@example.com", + }, + { + :name => "Alice", + :uri => "http://example.com/~alice/", + :email => "alice@example.com", + }, + ] + categories = [ + { + :term => "music", + :label => "Music", + }, + { + :term => "book", + :scheme => "http://example.com/category/book/", + :label => "Book", + }, + ] + contributors = [ + { + :name => "Chris", + :email => "chris@example.com", + }, + { + :name => "Eva", + :uri => "http://example.com/~eva/", + }, + ] + generator = { + :uri => "http://example.com/generator/", + :version => "0.0.1", + :content => "Feed Generator", + } + icon = "http://example.com/icon.png" + about = "http://hoge.com" + title = "fugafuga" + link = "http://hoge.com" + logo = "http://example.com/logo.png" + rights = "Copyrights (c) 2007 Alice and Bob" + description = "fugafugafugafuga" + updated = Time.now + + feed = RSS::Maker.make("atom") do |maker| + authors.each do |author_info| + maker.channel.authors.new_author do |author| + author_info.each do |key, value| + author.__send__("#{key}=", value) + end + end + end + + categories.each do |category_info| + maker.channel.categories.new_category do |category| + category_info.each do |key, value| + category.__send__("#{key}=", value) + end + end + end + + contributors.each do |contributor_info| + maker.channel.contributors.new_contributor do |contributor| + contributor_info.each do |key, value| + contributor.__send__("#{key}=", value) + end + end + end + + generator.each do |key, value| + maker.channel.generator.__send__("#{key}=", value) + end + + maker.channel.icon = icon + + maker.channel.about = about + maker.channel.link = link + maker.channel.logo = logo + maker.channel.rights = rights + maker.channel.title = title + maker.channel.description = description + maker.channel.updated = updated + + if with_dc + @dc_elems.each do |var, value| + if var == :date + maker.channel.new_dc_date(value) + else + maker.channel.__send__("dc_#{var}=", value) + end + end + end + + setup_dummy_item_atom(maker) + end + assert_not_nil(feed) + + new_feed = RSS::Maker.make("atom") do |maker| + feed.setup_maker(maker) + end + assert_not_nil(new_feed) + + new_authors = new_feed.authors.collect do |author| + { + :name => author.name.content, + :uri => author.uri.content, + :email => author.email.content, + } + end + assert_equal(authors, new_authors) + + new_categories = new_feed.categories.collect do |category| + { + :term => category.term, + :scheme => category.scheme, + :label => category.label, + }.reject {|key, value| value.nil?} + end + assert_equal(categories, new_categories) + + new_contributors = new_feed.contributors.collect do |contributor| + info = {} + info[:name] = contributor.name.content + info[:uri] = contributor.uri.content if contributor.uri + info[:email] = contributor.email.content if contributor.email + info + end + assert_equal(contributors, new_contributors) + + new_generator = { + :uri => new_feed.generator.uri, + :version => new_feed.generator.version, + :content => new_feed.generator.content, + } + assert_equal(generator, new_generator) + + assert_equal(icon, new_feed.icon.content) + assert_equal(about, new_feed.id.content) + assert_equal(link, new_feed.link.href) + assert_equal(logo, new_feed.logo.content) + assert_equal(rights, new_feed.rights.content) + assert_equal(description, new_feed.subtitle.content) + assert_equal(title, new_feed.title.content) + assert_equal(updated, new_feed.updated.content) + + if with_dc + @dc_elems.each do |var, value| + if var == :date + assert_equal([updated, value], + new_feed.dc_dates.collect {|date| date.value}) + else + assert_equal(value, new_feed.__send__("dc_#{var}")) + end + end + end + + assert_equal(1, new_feed.items.size) + end + + def test_setup_maker_feed_without_dc + test_setup_maker_feed(false) + end + + def test_setup_maker_items(for_backward_compatibility=false) + title = "TITLE" + link = "http://hoge.com/" + description = "text hoge fuga" + updated = Time.now + + item_size = 5 + feed = RSS::Maker.make("atom") do |maker| + setup_dummy_channel_atom(maker) + + item_size.times do |i| + maker.items.new_item do |item| + item.title = "#{title}#{i}" + item.link = "#{link}#{i}" + item.description = "#{description}#{i}" + item.updated = updated + i * 60 + end + end + end + + new_feed = RSS::Maker.make("atom") do |maker| + feed.items.each do |item| + if for_backward_compatibility + item.setup_maker(maker) + else + item.setup_maker(maker.items) + end + end + + feed.items.clear + feed.setup_maker(maker) + end + + assert_equal(item_size, new_feed.items.size) + new_feed.items.each_with_index do |item, i| + assert_equal("#{title}#{i}", item.title.content) + assert_equal("#{link}#{i}", item.link.href) + assert_equal("#{description}#{i}", item.summary.content) + assert_equal(updated + i * 60, item.updated.content) + end + end + + def test_setup_maker_items_sort + title = "TITLE" + link = "http://hoge.com/" + summary = "text hoge fuga" + updated = Time.now + + feed_size = 5 + feed = RSS::Maker.make("atom") do |maker| + setup_dummy_channel_atom(maker) + + feed_size.times do |i| + entry_class = RSS::Atom::Feed::Entry + entry = entry_class.new + entry.title = entry_class::Title.new(:content => "#{title}#{i}") + entry.links << entry_class::Link.new(:href => "#{link}#{i}") + entry.summary = entry_class::Summary.new(:content => "#{summary}#{i}") + entry.updated = entry_class::Updated.new(:content => updated + i * 60) + entry.setup_maker(maker.items) + end + maker.items.do_sort = false + end + assert_equal(feed_size, feed.entries.size) + feed.entries.each_with_index do |entry, i| + assert_equal("#{title}#{i}", entry.title.content) + assert_equal("#{link}#{i}", entry.link.href) + assert_equal("#{summary}#{i}", entry.summary.content) + end + + + feed = RSS::Maker.make("atom") do |maker| + setup_dummy_channel_atom(maker) + + feed_size.times do |i| + entry_class = RSS::Atom::Feed::Entry + entry = entry_class.new + entry.title = entry_class::Title.new(:content => "#{title}#{i}") + entry.links << entry_class::Link.new(:href => "#{link}#{i}") + entry.summary = entry_class::Summary.new(:content => "#{summary}#{i}") + entry.updated = entry_class::Updated.new(:content => updated + i * 60) + entry.setup_maker(maker.items) + end + maker.items.do_sort = true + end + assert_equal(feed_size, feed.entries.size) + feed.entries.reverse.each_with_index do |entry, i| + assert_equal("#{title}#{i}", entry.title.content) + assert_equal("#{link}#{i}", entry.link.href) + assert_equal("#{summary}#{i}", entry.summary.content) + end + end + + def test_setup_maker_items_backward_compatibility + test_setup_maker_items(true) + end + + def test_setup_maker + encoding = "EUC-JP" + standalone = true + + href = 'a.xsl' + type = 'text/xsl' + title = 'sample' + media = 'printer' + charset = 'UTF-8' + alternate = 'yes' + + feed = RSS::Maker.make("atom") do |maker| + maker.encoding = encoding + maker.standalone = standalone + + maker.xml_stylesheets.new_xml_stylesheet do |xss| + xss.href = href + xss.type = type + xss.title = title + xss.media = media + xss.charset = charset + xss.alternate = alternate + end + + setup_dummy_channel_atom(maker) + setup_dummy_item_atom(maker) + end + assert_not_nil(feed) + + new_feed = RSS::Maker.make("atom") do |maker| + feed.setup_maker(maker) + end + + assert_equal(["atom", "1.0", "feed"], new_feed.feed_info) + assert_equal(encoding, new_feed.encoding) + assert_equal(standalone, new_feed.standalone) + + xss = new_feed.xml_stylesheets.first + assert_equal(1, new_feed.xml_stylesheets.size) + assert_equal(href, xss.href) + assert_equal(type, xss.type) + assert_equal(title, xss.title) + assert_equal(media, xss.media) + assert_equal(charset, xss.charset) + assert_equal(alternate, xss.alternate) + end + + def test_setup_maker_full + encoding = "EUC-JP" + standalone = true + + href = 'a.xsl' + type = 'text/xsl' + title = 'sample' + media = 'printer' + charset = 'UTF-8' + alternate = 'yes' + + channel_about = "http://hoge.com" + channel_title = "fugafuga" + channel_link = "http://hoge.com" + channel_description = "fugafugafugafuga" + channel_author = "Bob" + + image_url = "http://hoge.com/hoge.png" + + item_title = "TITLE" + item_link = "http://hoge.com/" + item_description = "text hoge fuga" + + entry_size = 5 + feed = RSS::Maker.make("atom") do |maker| + maker.encoding = encoding + maker.standalone = standalone + + maker.xml_stylesheets.new_xml_stylesheet do |xss| + xss.href = href + xss.type = type + xss.title = title + xss.media = media + xss.charset = charset + xss.alternate = alternate + end + + maker.channel.about = channel_about + maker.channel.title = channel_title + maker.channel.link = channel_link + maker.channel.description = channel_description + maker.channel.author = channel_author + @dc_elems.each do |var, value| + maker.channel.__send__("dc_#{var}=", value) + end + + maker.image.url = image_url + + entry_size.times do |i| + maker.items.new_item do |item| + item.title = "#{item_title}#{i}" + item.link = "#{item_link}#{i}" + item.description = "#{item_description}#{i}" + + @dc_elems.each do |var, value| + item.__send__("dc_#{var}=", value) + end + end + end + end + + new_feed = RSS::Maker.make("atom") do |maker| + feed.setup_maker(maker) + end + + assert_equal(["atom", "1.0", "feed"], new_feed.feed_info) + assert_equal(encoding, new_feed.encoding) + assert_equal(standalone, new_feed.standalone) + + xss = new_feed.xml_stylesheets.first + assert_equal(1, new_feed.xml_stylesheets.size) + assert_equal(href, xss.href) + assert_equal(type, xss.type) + assert_equal(title, xss.title) + assert_equal(media, xss.media) + assert_equal(charset, xss.charset) + assert_equal(alternate, xss.alternate) + + assert_equal(channel_title, new_feed.title.content) + assert_equal(channel_link, new_feed.link.href) + assert_equal(channel_description, new_feed.subtitle.content) + assert_equal(channel_author, new_feed.author.name.content) + assert_equal(image_url, new_feed.logo.content) + @dc_elems.each do |var, value| + assert_equal(value, new_feed.__send__("dc_#{var}")) + end + + assert_equal(entry_size, new_feed.entries.size) + new_feed.entries.each_with_index do |entry, i| + assert_equal("#{item_title}#{i}", entry.title.content) + assert_equal("#{item_link}#{i}", entry.link.href) + assert_equal("#{item_description}#{i}", entry.summary.content) + + @dc_elems.each do |var, value| + assert_equal(value, entry.__send__("dc_#{var}")) + end + end + end + end +end diff --git a/test/rss/test_syndication.rb b/test/rss/test_syndication.rb index 894a7855ac..6aaaa43382 100644 --- a/test/rss/test_syndication.rb +++ b/test/rss/test_syndication.rb @@ -93,7 +93,7 @@ EOR %w(-2 0.3 -0.4).each do |x| @parents.each do |parent| - assert_not_available_value("updateBase", x) do + assert_not_available_value("sy:updateBase", x) do @rss.__send__(parent).sy_updateBase = x end end @@ -107,7 +107,7 @@ EOR excepted = "<#{@prefix}:#{name}>#{value}" @parents.each do |parent| assert_equal(excepted, - @rss.__send__(parent).funcall("sy_#{name}_element")) + @rss.__send__(parent).__send!("sy_#{name}_element")) end end @@ -120,8 +120,6 @@ EOR end end end - end - end end diff --git a/test/rss/test_taxonomy.rb b/test/rss/test_taxonomy.rb index b4950c0004..42746af490 100644 --- a/test/rss/test_taxonomy.rb +++ b/test/rss/test_taxonomy.rb @@ -140,7 +140,7 @@ EOR def test_to_s @topics_parents.each do |parent| meth = "taxo_topics_element" - assert_equal(@topics_node, @rss.__send__(parent).funcall(meth)) + assert_equal(@topics_node, @rss.__send__(parent).__send!(meth)) end @topic_nodes.each_with_index do |node, i| diff --git a/test/rss/test_trackback.rb b/test/rss/test_trackback.rb index 5209a8c06b..db4f291317 100644 --- a/test/rss/test_trackback.rb +++ b/test/rss/test_trackback.rb @@ -114,7 +114,7 @@ EOR @parents.each do |parent| meth = "#{RSS::TRACKBACK_PREFIX}_#{name}_element" meth << "s" if name == :about - assert_equal(excepted, @rss.__send__(parent).funcall(meth)) + assert_equal(excepted, @rss.__send__(parent).__send!(meth)) end end diff --git a/test/rss/test_version.rb b/test/rss/test_version.rb index 237f364b20..2c7d2e0f7a 100644 --- a/test/rss/test_version.rb +++ b/test/rss/test_version.rb @@ -3,7 +3,7 @@ require "rss-testcase" module RSS class TestVersion < TestCase def test_version - assert_equal("0.1.6", ::RSS::VERSION) + assert_equal("0.1.7", ::RSS::VERSION) end end end diff --git a/test/rss/test_xml-stylesheet.rb b/test/rss/test_xml-stylesheet.rb index c88a858f56..b946af1294 100644 --- a/test/rss/test_xml-stylesheet.rb +++ b/test/rss/test_xml-stylesheet.rb @@ -14,7 +14,7 @@ module RSS {:media => "print", :title => "FOO"}, {:charset => "UTF-8", :alternate => "yes"}, ].each do |attrs| - assert_xml_stylesheet_attrs(attrs, XMLStyleSheet.new(*attrs)) + assert_xml_stylesheet_attrs(attrs, XMLStyleSheet.new(attrs)) end end @@ -35,8 +35,8 @@ module RSS :media => "printer", :charset => "UTF-8", :alternate => "yes"}, ].each do |attrs| - target, contents = parse_pi(XMLStyleSheet.new(*attrs).to_s) - assert_xml_stylesheet(target, attrs, XMLStyleSheet.new(*contents)) + target, contents = parse_pi(XMLStyleSheet.new(attrs).to_s) + assert_xml_stylesheet(target, attrs, XMLStyleSheet.new(contents)) end end -- cgit v1.2.3