diff options
Diffstat (limited to 'test')
35 files changed, 6634 insertions, 486 deletions
diff --git a/test/rss/rss-assertions.rb b/test/rss/rss-assertions.rb index 1e926bb84d..41e6cd62c5 100644 --- a/test/rss/rss-assertions.rb +++ b/test/rss/rss-assertions.rb @@ -1,19 +1,7 @@ -module Test - module Unit - module Assertions - # For backward compatibility - unless instance_methods.include?("assert_raise") - def assert_raise(*args, &block) - assert_raises(*args, &block) - end - end - end - end -end +require 'erb' module RSS module Assertions - def assert_parse(rss, assert_method, *args) __send__("assert_#{assert_method}", *args) do ::RSS::Parser.parse(rss) @@ -104,6 +92,7 @@ module RSS flunk("Not raise NotSetError") rescue ::RSS::NotSetError => e assert_equal(name, e.name) + assert_kind_of(Array, variables) assert_equal(variables.sort, e.variables.sort) end end @@ -143,10 +132,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 @@ -163,239 +155,650 @@ module RSS end end - - def assert_channel10(attrs, channel) + + def assert_atom_person(tag_name, generator) _wrap_assertion do - n_attrs = normalized_attrs(attrs) - - names = %w(about title link description) - assert_attributes(attrs, names, channel) + name = "Mark Pilgrim" + uri = "http://example.org/" + email = "f8dy@example.com" - %w(image items textinput).each do |name| - value = n_attrs[name] - if value - target = channel.__send__(name) - __send__("assert_channel10_#{name}", value, target) + 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>#{uri}</uri> + <email>#{email}</email> + </#{tag_name}> +EOA + + assert_parse(generator.call(<<-EOA), :nothing_raised) + <#{tag_name}> + <name>#{name}</name> + </#{tag_name}> +EOA + + feed = RSS::Parser.parse(generator.call(<<-EOA)) + <#{tag_name}> + <name>#{name}</name> + <uri>#{uri}</uri> + <email>#{email}</email> + </#{tag_name}> +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) + <category/> +EOA + + assert_parse(generator.call(<<-EOA), *missing_args) + <category scheme="#{scheme}" label="#{label}"/> +EOA + + assert_parse(generator.call(<<-EOA), :nothing_raised) + <category term="#{term}"/> +EOA + + feed = RSS::Parser.parse(generator.call(<<-EOA)) + <category term="#{term}" scheme="#{scheme}" label="#{label}"/> +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") + <link/> +EOA + + assert_parse(generator.call(<<-EOA), :missing_attribute, "link", "href") + <link rel="#{rel}" type="#{type}" hreflang="#{hreflang}" + title="#{title}" length="#{length}"/> +EOA + + assert_parse(generator.call(<<-EOA), :nothing_raised) + <link href="#{href}"/> +EOA + + feed = RSS::Parser.parse(generator.call(<<-EOA)) + <link href="#{href}" rel="#{rel}" type="#{type}" hreflang="#{hreflang}" + title="#{title}" length="#{length}"/> +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) + <link rel="alternate" #{attrs} href="#{href}"/> + <link rel="alternate" #{attrs} href="#{href}"/> +EOA end end end end - def assert_channel10_image(attrs, image) + def assert_atom_generator(generator) _wrap_assertion do - assert_attributes(attrs, %w(resource), image) + uri = "http://www.example.com/" + version = "1.0" + content = "Example Toolkit" + + assert_parse(generator.call(<<-EOA), :nothing_raised) + <generator/> +EOA + + assert_parse(generator.call(<<-EOA), :nothing_raised) + <generator uri="#{uri}" version="#{version}"/> +EOA + + feed = RSS::Parser.parse(generator.call(<<-EOA)) + <generator uri="#{uri}" version="#{version}">#{content}</generator> +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_channel10_textinput(attrs, textinput) + + def assert_atom_icon(generator) _wrap_assertion do - assert_attributes(attrs, %w(resource), textinput) + content = "http://www.example.com/example.png" + + assert_parse(generator.call(<<-EOA), :nothing_raised) + <icon/> +EOA + + feed = RSS::Parser.parse(generator.call(<<-EOA)) + <icon>#{content}</icon> +EOA + + icon = yield(feed) + assert_not_nil(icon) + assert_equal(content, icon.content) end end - def assert_channel10_items(attrs, items) + def assert_atom_text_construct(tag_name, generator) _wrap_assertion do - assert_equal(items.resources, items.Seq.lis.collect {|x| x.resource}) - items.Seq.lis.each_with_index do |li, i| - assert_attributes(attrs[i], %w(resource), li) + [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"><x/></#{tag_name}> +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 <em>lot</em> 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}</#{tag_name}> +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 = "<div xmlns=\"#{xhtml_uri}\">abc</div>" + 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}</#{tag_name}> +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_image10(attrs, image) + def assert_atom_date_construct(tag_name, generator) _wrap_assertion do - names = %w(about title url link) - assert_attributes(attrs, names, image) + 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}</#{tag_name}> +EOR + end + + feed = RSS::Parser.parse(generator.call(<<-EOR), false) + <#{tag_name}>#{invalid_value}</#{tag_name}> +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}</#{tag_name}> +EOR + + feed = RSS::Parser.parse(generator.call(<<-EOR)) + <#{tag_name}>#{valid_value}</#{tag_name}> +EOR + assert_equal(Time.parse(valid_value), yield(feed).content) + end end end - def assert_items10(attrs, items) + def assert_atom_logo(generator) _wrap_assertion do - names = %w(about title link description) - items.each_with_index do |item, i| - assert_attributes(attrs[i], names, item) - end + content = "http://www.example.com/example.png" + + assert_parse(generator.call(<<-EOA), :nothing_raised) + <logo/> +EOA + + feed = RSS::Parser.parse(generator.call(<<-EOA)) + <logo>#{content}</logo> +EOA + + logo = yield(feed) + assert_not_nil(logo) + assert_equal(content, logo.content) end end - def assert_textinput10(attrs, textinput) + def assert_atom_content(generator, &getter) _wrap_assertion do - names = %w(about title description name link) - assert_attributes(attrs, names, textinput) + 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_channel09(attrs, channel) + def assert_atom_content_inline_text(generator) _wrap_assertion do - n_attrs = normalized_attrs(attrs) + [nil, "text", "html"].each do |type| + content = "<content" + content << " type='#{type}'" if type - names = %w(title description link language rating - copyright pubDate lastBuildDate docs - managingEditor webMaster) - assert_attributes(attrs, names, channel) - - %w(skipHours skipDays).each do |name| - value = n_attrs[name] - if value - target = channel.__send__(name) - __send__("assert_channel09_#{name}", value, target) + suffix = "/>" + assert_parse(generator.call(content + suffix), :nothing_raised) + suffix = ">xxx</content>" + assert_parse(generator.call(content + suffix), :nothing_raised) + end + + [ + ["text", "sample content"], + ["text/plain", "sample content"], + ["html", "<em>sample</em> content"] + ].each do |type, content_content| + feed = RSS::Parser.parse(generator.call(<<-EOA)) + <content type="#{type}">#{h content_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_channel09_skipDays(contents, skipDays) + def assert_atom_content_inline_xhtml(generator) _wrap_assertion do - days = skipDays.days - contents.each_with_index do |content, i| - assert_equal(content, days[i].content) - end + args = ["div", "content"] + assert_parse(generator.call(<<-EOA), :missing_tag, *args) + <content type="xhtml"/> +EOA + + args = ["x", Atom::URI, "content"] + assert_parse(generator.call(<<-EOA), :not_expected_tag, *args) + <content type="xhtml"><x/></content> +EOA + + xhtml_uri = "http://www.w3.org/1999/xhtml" + xhtml_content = "<div xmlns=\"#{xhtml_uri}\">abc</div>" + xhtml_element = RSS::XML::Element.new("div", nil, xhtml_uri, + {"xmlns" => xhtml_uri}, + ["abc"]) + feed = RSS::Parser.parse(generator.call(<<-EOA)) + <content type="xhtml">#{xhtml_content}</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_channel09_skipHours(contents, skipHours) + + def assert_atom_content_inline_other(generator, &getter) _wrap_assertion do - hours = skipHours.hours - contents.each_with_index do |content, i| - assert_equal(content.to_i, hours[i].content) - end + assert_atom_content_inline_other_text(generator, &getter) + assert_atom_content_inline_other_xml(generator, &getter) end end - - def assert_image09(attrs, image) + + def assert_atom_content_inline_other_text(generator) _wrap_assertion do - names = %w(url link title description) - names << ["width", :integer] - names << ["height", :integer] - assert_attributes(attrs, names, image) + require "zlib" + + type = "application/zip" + assert_parse(generator.call(<<-EOA), :nothing_raised) + <content type="#{type}"/> +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)) + <content type="#{type}">#{xml_content}</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_items09(attrs, items) + def assert_atom_content_inline_other_xml(generator) _wrap_assertion do - names = %w(title link description) - items.each_with_index do |item, i| - assert_attributes(attrs[i], names, item) - end + type = "image/svg+xml" + + assert_parse(generator.call(<<-EOA), :nothing_raised) + <content type="#{type}"/> +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 +<svg + xmlns="#{svg_uri}" + width="#{svg_width}" + height="#{svg_height}" + version="#{svg_version}" +><text x="#{text_x}" y="#{text_y}">#{text}</text +></svg> +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)) + <content type="#{type}">#{svg_content}</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_textinput09(attrs, textinput) + + def assert_atom_content_out_of_line(generator) _wrap_assertion do - names = %w(title description name link) - assert_attributes(attrs, names, textinput) + 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) + <content src="#{text_src}"/> +EOA + + content_content = "xxx" + not_available_value_args = [:not_available_value, + "content", content_content] + assert_parse(generator.call(<<-EOA), *not_available_value_args) + <content type="#{text_type}" src="#{text_src}">#{content_content}</content> +EOA + + feed = RSS::Parser.parse(generator.call(<<-EOA)) + <content type="#{text_type}" src="#{text_src}"/> +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_channel20(attrs, channel) + def assert_atom_source(generator, &getter) _wrap_assertion do - n_attrs = normalized_attrs(attrs) - - names = %w(title link description language copyright - managingEditor webMaster pubDate - lastBuildDate generator docs rating) - names << ["ttl", :integer] - assert_attributes(attrs, names, channel) - - %w(cloud categories skipHours skipDays).each do |name| - value = n_attrs[name] - if value - target = channel.__send__(name) - __send__("assert_channel20_#{name}", value, target) - end - end + 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_channel20_skipDays(contents, skipDays) - assert_channel09_skipDays(contents, skipDays) - end - - def assert_channel20_skipHours(contents, skipHours) - assert_channel09_skipHours(contents, skipHours) + 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_channel20_cloud(attrs, cloud) - _wrap_assertion do - names = %w(domain path registerProcedure protocol) - names << ["port", :integer] - assert_attributes(attrs, names, cloud) + + 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_channel20_categories(attrs, categories) - _wrap_assertion do - names = %w(domain content) - categories.each_with_index do |category, i| - assert_attributes(attrs[i], names, category) - 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_image20(attrs, image) - _wrap_assertion do - names = %w(url link title description) - names << ["width", :integer] - names << ["height", :integer] - assert_attributes(attrs, names, image) + + def assert_atom_source_generator(generator) + assert_atom_generator(generator) do |feed| + yield(feed).generator end end - def assert_items20(attrs, items) - _wrap_assertion do - names = %w(about title link description) - items.each_with_index do |item, i| - assert_attributes(attrs[i], names, item) + def assert_atom_source_icon(generator) + assert_atom_icon(generator) do |feed| + yield(feed).icon + end + end - n_attrs = normalized_attrs(attrs[i]) + def assert_atom_source_id(generator) + id_content = "urn:uuid:a2fb588b-5674-4898-b420-265a734fea69" + id = "<id>#{id_content}</id>" + feed = RSS::Parser.parse(generator.call(id)) + assert_equal(id_content, yield(feed).id.content) + end - %w(source enclosure categories guid).each do |name| - value = n_attrs[name] - if value - target = item.__send__(name) - __send__("assert_items20_#{name}", value, target) - end - end - 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_items20_source(attrs, source) - _wrap_assertion do - assert_attributes(attrs, %w(url content), source) + def assert_atom_source_logo(generator) + assert_atom_logo(generator) do |feed| + yield(feed).logo end end - - def assert_items20_enclosure(attrs, enclosure) - _wrap_assertion do - names = ["url", ["length", :integer], "type"] - assert_attributes(attrs, names, enclosure) + + def assert_atom_source_rights(generator) + assert_atom_text_construct("rights", generator) do |feed| + yield(feed).rights end end - - def assert_items20_categories(attrs, categories) - _wrap_assertion do - assert_channel20_categories(attrs, categories) + + def assert_atom_source_subtitle(generator) + assert_atom_text_construct("subtitle", generator) do |feed| + yield(feed).subtitle end end - - def assert_items20_guid(attrs, guid) - _wrap_assertion do - names = [["isPermaLink", :boolean], ["content"]] - assert_attributes(attrs, names, guid) + + def assert_atom_source_title(generator) + assert_atom_text_construct("title", generator) do |feed| + yield(feed).title end end - def assert_textinput20(attrs, textinput) - _wrap_assertion do - names = %w(title description name link) - assert_attributes(attrs, names, textinput) + 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 elems.each do |name, value| @@ -493,7 +896,1147 @@ module RSS end end end - + + 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_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 + 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) {|x| x} + 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) {|x| x} + 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) {|x| x} + 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) {|x| x} + target.type = "xhtml" + target.content = "Content" + end + end + + _assert_maker_atom_text_construct(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) {|x| x} + target.type = "text" + target.content = "Content" + end + + _assert_maker_atom_text_construct(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) {|x| x} + target.type = "html" + target.content = "<em>Content</em>" + end + + _assert_maker_atom_text_construct(*args) do |maker| + yield maker + target = chain_reader(maker, maker_readers) {|x| x} + 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) {|x| x} + 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) {|x| x} + 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) {|x| x} + 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) {|x| x} + 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.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?, + } + 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 = "<em>text</em>" + 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 assert_slash_elements(expected, target) + assert_equal(expected, + { + "section" => target.slash_section, + "department" => target.slash_department, + "comments" => target.slash_comments, + "hit_parades" => target.slash_hit_parades, + }) + assert_equal(expected["hit_parades"].join(","), + target.slash_hit_parade) + end + + def chain_reader(target, readers, &block) + readers.inject(target) do |result, reader| + return nil if result.nil? + result.__send__(reader, &block) + end + end + def normalized_attrs(attrs) n_attrs = {} attrs.each do |name, value| @@ -501,6 +2044,31 @@ module RSS 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 + end + + def tag(name, content=nil, attributes={}) + attributes = attributes.collect do |key, value| + "#{ERB::Util.h(key)}=\"#{ERB::Util.h(value)}\"" + end.join(" ") + begin_tag = "<#{name}" + begin_tag << " #{attributes}" unless attributes.empty? + if content + "#{begin_tag}>#{content}</#{name}>\n" + else + "#{begin_tag}/>\n" + end + end end end diff --git a/test/rss/rss-testcase.rb b/test/rss/rss-testcase.rb index 21670bc05c..0fd9b5263f 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}</#{DC_PREFIX}:#{name}>" + end.join("\n") + def default_test # This class isn't tested end @@ -205,6 +246,82 @@ EOC EOR end + def make_feed_without_entry(content=nil, xmlns=[]) + <<-EOA +<feed xmlns="#{Atom::URI}" +#{xmlns.collect {|pre, uri| "xmlns:#{pre}='#{uri}'"}.join(' ')}> + <id>#{FEED_ID}</id> + <title>#{FEED_TITLE}</title> + <updated>#{FEED_UPDATED}</updated> + <author> + <name>#{FEED_AUTHOR_NAME}</name> + </author> +#{block_given? ? yield : content} +</feed> +EOA + end + + def make_entry(content=nil) + <<-EOA + <entry> + <title>#{ENTRY_TITLE}</title> + <id>#{ENTRY_ID}</id> + <updated>#{ENTRY_UPDATED}</updated> +#{block_given? ? yield : content} + </entry> +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) + <source> +#{block_given? ? yield : content} + </source> +EOA + end + + def make_feed(content=nil, xmlns=[]) + make_feed_without_entry(<<-EOA, xmlns) + <entry> + <title>#{ENTRY_TITLE}</title> + <link href="#{ENTRY_LINK}"/> + <id>#{ENTRY_ID}</id> + <updated>#{ENTRY_UPDATED}</updated> + <summary>#{ENTRY_SUMMARY}</summary> + </entry> +#{block_given? ? yield : content} +EOA + end + + def make_entry_document(content=nil, xmlns=[]) + <<-EOA +<entry xmlns="#{Atom::URI}" +#{xmlns.collect {|pre, uri| "xmlns:#{pre}='#{uri}'"}.join(' ')}> + <id>#{ENTRY_ID}</id> + <title>#{ENTRY_TITLE}</title> + <updated>#{ENTRY_UPDATED}</updated> + <author> + <name>#{FEED_AUTHOR_NAME}</name> + </author> +#{block_given? ? yield : content} +</entry> +EOA + end + + def make_entry_document_with_open_source(content=nil, xmlns=[]) + make_entry_document(<<-EOA, xmlns) + <source> +#{block_given? ? yield : content} + </source> +EOA + end + def make_element(elem_name, attrs, contents) attrs_str = attrs.collect do |name, value| "#{h name}='#{h value}'" @@ -215,12 +332,61 @@ EOR "<#{h elem_name} #{attrs_str}>\n#{contents_str}\n</#{h elem_name}>" end - + + def xmlns_container(xmlns_decls, content) + attributes = xmlns_decls.collect do |prefix, uri| + "xmlns:#{h prefix}=\"#{h uri}\"" + end.join(" ") + "<dummy #{attributes}>#{content}</dummy>" + 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" @@ -231,6 +397,17 @@ EOR 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" @@ -262,7 +439,15 @@ EOR 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 ff3c8a402e..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} +<items> +#{rss_item} +</items> +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 @@ -242,8 +277,20 @@ module RSS 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 d39c297ab7..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 @@ -378,13 +383,28 @@ module RSS 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 = RSS::Parser.parse(rss.to_xml("0.91")) + 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..c442c753b2 --- /dev/null +++ b/test/rss/test_atom.rb @@ -0,0 +1,688 @@ +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(with_convenience_way=true) + 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/" + if with_convenience_way + maker.channel.description = atom.title.content + else + maker.channel.description {|d| d.content = atom.title.content} + end + + 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/" + if with_convenience_way + maker.channel.description = atom.title.content + else + maker.channel.description {|d| d.content = atom.title.content} + end + end + rss20 = RSS::Parser.parse(rss20_xml) + assert_equal("2.0", rss20.rss_version) + assert_equal(["rss", "2.0", nil], rss20.feed_info) + end + + def test_to_xml_with_new_api_since_018 + test_to_xml(false) + 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 + + + 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 = "<em>#{text_content}</em>" + 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 + end +end diff --git a/test/rss/test_dublincore.rb b/test/rss/test_dublincore.rb index e5a4919362..22b81483f4 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}</#{@prefix}:#{name}>" - 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 + - "</" + @prefix + ":" + tag.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}</#{tag}>\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}</#{@prefix}:#{name}>" - @parents.each do |parent| - assert_equal(excepted, - @rss.__send__(parent).__send__("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}</#{DC_PREFIX}:#{name}>" + 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).__send__("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 241fdafb7d..101b7ffda2 100644 --- a/test/rss/test_image.rb +++ b/test/rss/test_image.rb @@ -11,7 +11,7 @@ module RSS def setup @prefix = "image" - @uri = "http://web.resource.org/rss/1.0/modules/image/" + @uri = "http://purl.org/rss/1.0/modules/image/" @favicon_attrs = { "rdf:about" => "http://www.kuro5hin.org/favicon.ico", @@ -65,20 +65,30 @@ EOR @rss = Parser.parse(@rss_source) end - + def test_parser assert_nothing_raised do Parser.parse(@rss_source) end - + assert_too_much_tag("favicon", "channel") do 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 - + def test_favicon_accessor favicon = @rss.channel.image_favicon [ @@ -135,7 +145,7 @@ EOR image_item.__send__("#{name}=", attrs[full_name]) assert_equal(attrs[full_name], image_item.__send__(name)) end - + [ ["width", "image:width", "111"], ["image_width", "image:width", "44"], @@ -163,22 +173,26 @@ EOR def test_favicon_to_s favicon = @rss.channel.image_favicon - expected = REXML::Document.new(make_element("#{@prefix}:favicon", - @favicon_attrs, - @favicon_contents)) - actual = REXML::Document.new(favicon.to_s(false, "")) + expected_xml = image_xmlns_container(make_element("#{@prefix}:favicon", + @favicon_attrs, + @favicon_contents)) + expected = REXML::Document.new(expected_xml) + actual_xml = image_xmlns_container(favicon.to_s(false, "")) + actual = REXML::Document.new(actual_xml) assert_equal(expected.to_s, actual.to_s) end def test_item_to_s @rss.items.each_with_index do |item, i| attrs, contents = @items[i] - expected_s = make_element("#{@prefix}:item", attrs, contents) - expected = REXML::Document.new(expected_s) - actual = REXML::Document.new(item.image_item.to_s(false, "")) + expected_xml = make_element("#{@prefix}:item", attrs, contents) + expected_xml = image_xmlns_container(expected_xml) + expected = REXML::Document.new(expected_xml) + actual_xml = image_xmlns_container(item.image_item.to_s(false, "")) + actual = REXML::Document.new(actual_xml) assert_equal(expected[0].attributes, actual[0].attributes) - + %w(image:height image:width dc:title).each do |name| actual_target = actual.elements["//#{name}"] expected_target = expected.elements["//#{name}"] @@ -187,5 +201,14 @@ EOR end end + private + def image_xmlns_container(content) + xmlns_container({ + @prefix => @uri, + "dc" => "http://purl.org/dc/elements/1.1/", + "rdf" => "http://www.w3.org/1999/02/22-rdf-syntax-ns#", + }, + content) + end end end diff --git a/test/rss/test_inherit.rb b/test/rss/test_inherit.rb index fc4bbbe76a..f73096f478 100644 --- a/test/rss/test_inherit.rb +++ b/test/rss/test_inherit.rb @@ -9,7 +9,7 @@ module RSS def self.indent_size; 1; end def self.tag_name; 'image'; end end - + def setup @rss = make_RDF(<<-EOR) #{make_channel} @@ -18,7 +18,7 @@ module RSS #{make_textinput} EOR end - + def test_inherit rss = RSS::Parser.parse(@rss) orig_image = rss.image @@ -36,6 +36,5 @@ EOR assert_equal("#{prefix} #{orig_image.url}", new_image.url) assert_equal("#{prefix} #{orig_image.link}", new_image.link) end - end end diff --git a/test/rss/test_itunes.rb b/test/rss/test_itunes.rb new file mode 100644 index 0000000000..3663e2c77a --- /dev/null +++ b/test/rss/test_itunes.rb @@ -0,0 +1,347 @@ +require "cgi" +require "rexml/document" + +require "rss-testcase" + +require "rss/2.0" +require "rss/itunes" + +module RSS + class TestITunes < TestCase + def test_author + assert_itunes_author(%w(channel)) do |content, xmlns| + make_rss20(make_channel20(content), xmlns) + end + + assert_itunes_author(%w(items last)) do |content, xmlns| + make_rss20(make_channel20(make_item20(content)), xmlns) + end + end + + def test_block + assert_itunes_block(%w(items last)) do |content, xmlns| + make_rss20(make_channel20(make_item20(content)), xmlns) + end + end + + def test_category + assert_itunes_category(%w(channel)) do |content, xmlns| + make_rss20(make_channel20(content), xmlns) + end + end + + def test_image + assert_itunes_image(%w(channel)) do |content, xmlns| + make_rss20(make_channel20(content), xmlns) + end + end + + def test_duration + assert_itunes_duration(%w(items last)) do |content, xmlns| + make_rss20(make_channel20(make_item20(content)), xmlns) + end + end + + def test_explicit + assert_itunes_explicit(%w(channel)) do |content, xmlns| + make_rss20(make_channel20(content), xmlns) + end + + assert_itunes_explicit(%w(items last)) do |content, xmlns| + make_rss20(make_channel20(make_item20(content)), xmlns) + end + end + + def test_keywords + assert_itunes_keywords(%w(channel)) do |content, xmlns| + make_rss20(make_channel20(content), xmlns) + end + + assert_itunes_keywords(%w(items last)) do |content, xmlns| + make_rss20(make_channel20(make_item20(content)), xmlns) + end + end + + def test_new_feed_url + assert_itunes_new_feed_url(%w(channel)) do |content, xmlns| + make_rss20(make_channel20(content), xmlns) + end + end + + def test_owner + assert_itunes_owner(%w(channel)) do |content, xmlns| + make_rss20(make_channel20(content), xmlns) + end + end + + def test_subtitle + assert_itunes_subtitle(%w(channel)) do |content, xmlns| + make_rss20(make_channel20(content), xmlns) + end + + assert_itunes_subtitle(%w(items last)) do |content, xmlns| + make_rss20(make_channel20(make_item20(content)), xmlns) + end + end + + def test_summary + assert_itunes_summary(%w(channel)) do |content, xmlns| + make_rss20(make_channel20(content), xmlns) + end + + assert_itunes_summary(%w(items last)) do |content, xmlns| + make_rss20(make_channel20(make_item20(content)), xmlns) + end + end + + private + def itunes_rss20_parse(content, &maker) + xmlns = {"itunes" => "http://www.itunes.com/dtds/podcast-1.0.dtd"} + rss20_xml = maker.call(content, xmlns) + ::RSS::Parser.parse(rss20_xml) + end + + def assert_itunes_author(readers, &rss20_maker) + _wrap_assertion do + author = "John Lennon" + rss20 = itunes_rss20_parse(tag("itunes:author", author), &rss20_maker) + target = chain_reader(rss20, readers) + assert_equal(author, target.itunes_author) + end + end + + def _assert_itunes_block(value, boolean_value, readers, &rss20_maker) + rss20 = itunes_rss20_parse(tag("itunes:block", value), &rss20_maker) + target = chain_reader(rss20, readers) + assert_equal(value, target.itunes_block) + assert_equal(boolean_value, target.itunes_block?) + end + + def assert_itunes_block(readers, &rss20_maker) + _wrap_assertion do + _assert_itunes_block("yes", true, readers, &rss20_maker) + _assert_itunes_block("Yes", true, readers, &rss20_maker) + _assert_itunes_block("no", false, readers, &rss20_maker) + _assert_itunes_block("", false, readers, &rss20_maker) + end + end + + def _assert_itunes_category(categories, readers, &rss20_maker) + cats = categories.collect do |category| + if category.is_a?(Array) + category, sub_category = category + tag("itunes:category", + tag("itunes:category", nil, {"text" => sub_category}), + {"text" => category}) + else + tag("itunes:category", nil, {"text" => category}) + end + end.join + rss20 = itunes_rss20_parse(cats, &rss20_maker) + target = chain_reader(rss20, readers) + actual_categories = target.itunes_categories.collect do |category| + cat = category.text + if category.itunes_categories.empty? + cat + else + [cat, *category.itunes_categories.collect {|c| c.text}] + end + end + assert_equal(categories, actual_categories) + end + + def assert_itunes_category(readers, &rss20_maker) + _wrap_assertion do + _assert_itunes_category(["Audio Blogs"], readers, &rss20_maker) + _assert_itunes_category([["Arts & Entertainment", "Games"]], + readers, &rss20_maker) + _assert_itunes_category([["Arts & Entertainment", "Games"], + ["Technology", "Computers"], + "Audio Blogs"], + readers, &rss20_maker) + end + end + + def assert_itunes_image(readers, &rss20_maker) + _wrap_assertion do + url = "http://example.com/podcasts/everything/AllAboutEverything.jpg" + content = tag("itunes:image", nil, {"href" => url}) + rss20 = itunes_rss20_parse(content, &rss20_maker) + target = chain_reader(rss20, readers) + assert_not_nil(target.itunes_image) + assert_equal(url, target.itunes_image.href) + + assert_missing_attribute("image", "href") do + content = tag("itunes:image") + itunes_rss20_parse(content, &rss20_maker) + end + end + end + + def _assert_itunes_duration(hour, minute, second, value, + readers, &rss20_maker) + content = tag("itunes:duration", value) + rss20 = itunes_rss20_parse(content, &rss20_maker) + duration = chain_reader(rss20, readers).itunes_duration + assert_equal(value, duration.content) + assert_equal(hour, duration.hour) + assert_equal(minute, duration.minute) + assert_equal(second, duration.second) + end + + def _assert_itunes_duration_not_available_value(value, &rss20_maker) + assert_not_available_value("duration", value) do + content = tag("itunes:duration", value) + itunes_rss20_parse(content, &rss20_maker) + end + end + + def assert_itunes_duration(readers, &rss20_maker) + _wrap_assertion do + _assert_itunes_duration(7, 14, 5, "07:14:05", readers, &rss20_maker) + _assert_itunes_duration(7, 14, 5, "7:14:05", readers, &rss20_maker) + _assert_itunes_duration(0, 4, 55, "04:55", readers, &rss20_maker) + _assert_itunes_duration(0, 4, 5, "4:05", readers, &rss20_maker) + + _assert_itunes_duration_not_available_value("5", &rss20_maker) + _assert_itunes_duration_not_available_value("09:07:14:05", &rss20_maker) + _assert_itunes_duration_not_available_value("10:5", &rss20_maker) + _assert_itunes_duration_not_available_value("10:03:5", &rss20_maker) + _assert_itunes_duration_not_available_value("10:3:05", &rss20_maker) + + _assert_itunes_duration_not_available_value("xx:xx:xx", &rss20_maker) + end + end + + def _assert_itunes_explicit(explicit, value, readers, &rss20_maker) + content = tag("itunes:explicit", value) + rss20 = itunes_rss20_parse(content, &rss20_maker) + target = chain_reader(rss20, readers) + assert_equal(value, target.itunes_explicit) + assert_equal(explicit, target.itunes_explicit?) + end + + def assert_itunes_explicit(readers, &rss20_maker) + _wrap_assertion do + _assert_itunes_explicit(true, "yes", readers, &rss20_maker) + _assert_itunes_explicit(false, "clean", readers, &rss20_maker) + _assert_itunes_explicit(nil, "no", readers, &rss20_maker) + end + end + + def _assert_itunes_keywords(keywords, value, readers, &rss20_maker) + content = tag("itunes:keywords", value) + rss20 = itunes_rss20_parse(content, &rss20_maker) + target = chain_reader(rss20, readers) + assert_equal(keywords, target.itunes_keywords) + end + + def assert_itunes_keywords(readers, &rss20_maker) + _wrap_assertion do + _assert_itunes_keywords(["salt"], "salt", readers, &rss20_maker) + _assert_itunes_keywords(["salt"], " salt ", readers, &rss20_maker) + _assert_itunes_keywords(["salt", "pepper", "shaker", "exciting"], + "salt, pepper, shaker, exciting", + readers, &rss20_maker) + _assert_itunes_keywords(["metric", "socket", "wrenches", "toolsalt"], + "metric, socket, wrenches, toolsalt", + readers, &rss20_maker) + _assert_itunes_keywords(["olitics", "red", "blue", "state"], + "olitics, red, blue, state", + readers, &rss20_maker) + end + end + + def assert_itunes_new_feed_url(readers, &rss20_maker) + _wrap_assertion do + url = "http://newlocation.com/example.rss" + content = tag("itunes:new-feed-url", url) + rss20 = itunes_rss20_parse(content, &rss20_maker) + target = chain_reader(rss20, readers) + assert_equal(url, target.itunes_new_feed_url) + end + end + + def _assert_itunes_owner(name, email, readers, &rss20_maker) + content = tag("itunes:owner", + tag("itunes:name", name) + tag("itunes:email", email)) + rss20 = itunes_rss20_parse(content, &rss20_maker) + owner = chain_reader(rss20, readers).itunes_owner + assert_equal(name, owner.itunes_name) + assert_equal(email, owner.itunes_email) + end + + def assert_itunes_owner(readers, &rss20_maker) + _wrap_assertion do + _assert_itunes_owner("John Doe", "john.doe@example.com", + readers, &rss20_maker) + + assert_missing_tag("name", "owner") do + content = tag("itunes:owner") + itunes_rss20_parse(content, &rss20_maker) + end + + assert_missing_tag("name", "owner") do + content = tag("itunes:owner", + tag("itunes:email", "john.doe@example.com")) + itunes_rss20_parse(content, &rss20_maker) + end + + assert_missing_tag("email", "owner") do + content = tag("itunes:owner", tag("itunes:name", "John Doe")) + itunes_rss20_parse(content, &rss20_maker) + end + end + end + + def _assert_itunes_subtitle(value, readers, &rss20_maker) + content = tag("itunes:subtitle", value) + rss20 = itunes_rss20_parse(content, &rss20_maker) + target = chain_reader(rss20, readers) + assert_equal(value, target.itunes_subtitle) + end + + def assert_itunes_subtitle(readers, &rss20_maker) + _wrap_assertion do + _assert_itunes_subtitle("A show about everything", readers, &rss20_maker) + _assert_itunes_subtitle("A short primer on table spices", + readers, &rss20_maker) + _assert_itunes_subtitle("Comparing socket wrenches is fun!", + readers, &rss20_maker) + _assert_itunes_subtitle("Red + Blue != Purple", readers, &rss20_maker) + end + end + + def _assert_itunes_summary(value, readers, &rss20_maker) + content = tag("itunes:summary", value) + rss20 = itunes_rss20_parse(content, &rss20_maker) + target = chain_reader(rss20, readers) + assert_equal(value, target.itunes_summary) + end + + def assert_itunes_summary(readers, &rss20_maker) + _wrap_assertion do + _assert_itunes_summary("All About Everything is a show about " + + "everything. Each week we dive into any " + + "subject known to man and talk about it as " + + "much as we can. Look for our Podcast in " + + "the iTunes Music Store", + readers, &rss20_maker) + _assert_itunes_summary("This week we talk about salt and pepper " + + "shakers, comparing and contrasting pour " + + "rates, construction materials, and overall " + + "aesthetics. Come and join the party!", + readers, &rss20_maker) + _assert_itunes_summary("This week we talk about metric vs. old " + + "english socket wrenches. Which one is " + + "better? Do you really need both? Get all " + + "of your answers here.", + readers, &rss20_maker) + _assert_itunes_summary("This week we talk about surviving in a " + + "Red state if you’re a Blue person. Or " + + "vice versa.", + readers, &rss20_maker) + end + end + end +end diff --git a/test/rss/test_maker_0.9.rb b/test/rss/test_maker_0.9.rb index 820d567289..df92945a86 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 @@ -91,6 +99,9 @@ module RSS new_hour.content = hour end end + + maker.image.url = image_url + maker.image.title = image_title end channel = rss.channel @@ -115,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 @@ -211,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| @@ -237,26 +253,28 @@ 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 + def test_items(with_convenience_way=true) title = "TITLE" link = "http://hoge.com/" description = "text hoge fuga" rss = RSS::Maker.make("0.91") do |maker| setup_dummy_channel(maker) + setup_dummy_image(maker) end assert(rss.channel.items.empty?) @@ -268,6 +286,8 @@ module RSS item.link = link # item.description = description end + + setup_dummy_image(maker) end assert_equal(1, rss.channel.items.size) item = rss.channel.items.first @@ -281,43 +301,55 @@ module RSS 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}" + 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| - assert_equal("#{title}#{i}", item.title) - assert_equal("#{link}#{i}", item.link) - assert_equal("#{description}#{i}", item.description) + rss.channel.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 rss = RSS::Maker.make("0.91") 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}" + 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] + if with_convenience_way + y.title[-1] <=> x.title[-1] + else + y.title {|t| t.content[-1]} <=> x.title {|t| t.content[-1]} + end end + + setup_dummy_image(maker) end assert_equal(item_size, rss.items.size) - rss.channel.items.reverse.each_with_index do |item, i| - assert_equal("#{title}#{i}", item.title) - assert_equal("#{link}#{i}", item.link) - assert_equal("#{description}#{i}", item.description) + rss.channel.items.reverse.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_items_with_new_api_since_018 + test_items(false) + end + def test_textInput title = "fugafuga" description = "text hoge fuga" @@ -326,6 +358,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 @@ -338,15 +371,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 @@ -357,6 +392,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 @@ -367,7 +403,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 @@ -377,7 +414,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 @@ -387,7 +425,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 e15432146d..60cc3708a7 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,19 +203,22 @@ module RSS maker.image.url = url maker.image.title = title + + setup_dummy_item(maker) end end end - - def test_items + + def test_items(with_convenience_way=true) 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) @@ -222,42 +242,46 @@ module RSS 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}" + 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 assert_equal(item_size, rss.items.size) - rss.items.each_with_index do |item, i| - assert_equal("#{link}#{i}", item.about) - assert_equal("#{title}#{i}", item.title) - assert_equal("#{link}#{i}", item.link) - assert_equal("#{description}#{i}", item.description) + rss.items.each_with_index do |_item, i| + assert_equal("#{link}#{i}", _item.about) + assert_equal("#{title}#{i}", _item.title) + assert_equal("#{link}#{i}", _item.link) + assert_equal("#{description}#{i}", _item.description) end rss = 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}" + 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] + if with_convenience_way + y.title[-1] <=> x.title[-1] + else + y.title {|t| t.content[-1]} <=> x.title {|t| t.content[-1]} + end end end assert_equal(item_size, rss.items.size) - rss.items.reverse.each_with_index do |item, i| - assert_equal("#{link}#{i}", item.about) - assert_equal("#{title}#{i}", item.title) - assert_equal("#{link}#{i}", item.link) - assert_equal("#{description}#{i}", item.description) + rss.items.reverse.each_with_index do |_item, i| + assert_equal("#{link}#{i}", _item.about) + assert_equal("#{title}#{i}", _item.title) + assert_equal("#{link}#{i}", _item.link) + assert_equal("#{description}#{i}", _item.description) end max_size = item_size / 2 @@ -265,84 +289,102 @@ module RSS 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}" + 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 assert_equal(max_size, rss.items.size) - rss.items.each_with_index do |item, i| - assert_equal("#{link}#{i}", item.about) - assert_equal("#{title}#{i}", item.title) - assert_equal("#{link}#{i}", item.link) - assert_equal("#{description}#{i}", item.description) + rss.items.each_with_index do |_item, i| + assert_equal("#{link}#{i}", _item.about) + assert_equal("#{title}#{i}", _item.title) + assert_equal("#{link}#{i}", _item.link) + assert_equal("#{description}#{i}", _item.description) end max_size = 0 - rss = 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}" + 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| - maker.items.new_item do |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 assert_equal(item_size + max_size + 1, rss.items.size) - rss.items.each_with_index do |item, i| - assert_equal("#{link}#{i}", item.about) - assert_equal("#{title}#{i}", item.title) - assert_equal("#{link}#{i}", item.link) - assert_equal("#{description}#{i}", item.description) + rss.items.each_with_index do |_item, i| + assert_equal("#{link}#{i}", _item.about) + assert_equal("#{title}#{i}", _item.title) + assert_equal("#{link}#{i}", _item.link) + assert_equal("#{description}#{i}", _item.description) end end + def test_items_with_new_api_since_018 + test_items(false) + end + def test_not_valid_items title = "TITLE" link = "http://hoge.com/" - rss = RSS::Maker.make("1.0") do |maker| - setup_dummy_channel(maker) - - maker.items.new_item do |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) - - maker.items.new_item do |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" @@ -356,6 +398,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) @@ -365,15 +409,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 @@ -389,6 +434,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) @@ -400,6 +447,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) @@ -411,6 +460,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) @@ -422,6 +473,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 ec5f3abb8e..8fd9134f70 100644 --- a/test/rss/test_maker_2.0.rb +++ b/test/rss/test_maker_2.0.rb @@ -353,7 +353,7 @@ module RSS assert_nil(rss.image) end - def test_items + def test_items(with_convenience_way=true) title = "TITLE" link = "http://hoge.com/" description = "text hoge fuga" @@ -407,7 +407,11 @@ module RSS end end maker.items.do_sort = Proc.new do |x, y| - y.title[-1] <=> x.title[-1] + if with_convenience_way + y.title[-1] <=> x.title[-1] + else + y.title {|t| t.content[-1]} <=> x.title {|t| t.content[-1]} + end end end assert_equal(item_size, rss.items.size) @@ -422,6 +426,10 @@ module RSS end end + def test_items_with_new_api_since_018 + test_items(false) + end + def test_guid isPermaLink = "true" content = "http://inessential.com/2002/09/01.php#a2" @@ -606,15 +614,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..e5bf0e23b2 --- /dev/null +++ b/test/rss/test_maker_atom_feed.rb @@ -0,0 +1,389 @@ +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 = nil + end + + assert_maker_atom_text_construct("feed", + ["channel", "subtitle"], + ["subtitle"], + nil, nil, + "maker.channel.description") do |maker| + setup_dummy_channel_atom(maker) + maker.channel.description {|d| d.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 6266e953aa..c9df36a1ce 100644 --- a/test/rss/test_maker_dc.rb +++ b/test/rss/test_maker_dc.rb @@ -57,9 +57,14 @@ module RSS end def test_rss10_multiple + assert_multiple_dublin_core_rss10("_list") + assert_multiple_dublin_core_rss10("es") + end + + def assert_multiple_dublin_core_rss10(multiple_rights_suffix) elems = [] @elements.each do |name, value| - plural = name.to_s + (name == :rights ? "es" : "s") + plural = name.to_s + (name == :rights ? multiple_rights_suffix : "s") values = [value] if name == :date values << value + 60 @@ -68,7 +73,7 @@ module RSS end elems << [name, values, plural] end - + rss = RSS::Maker.make("1.0") do |maker| setup_dummy_channel(maker) set_multiple_elements(maker.channel, elems) diff --git a/test/rss/test_maker_itunes.rb b/test/rss/test_maker_itunes.rb new file mode 100644 index 0000000000..1d4e323057 --- /dev/null +++ b/test/rss/test_maker_itunes.rb @@ -0,0 +1,471 @@ +require "rss-testcase" + +require "rss/maker" + +module RSS + class TestMakerITunes < TestCase + def test_author + assert_maker_itunes_author(%w(channel)) + assert_maker_itunes_author(%w(items last)) + end + + def test_block + assert_maker_itunes_block(%w(channel)) + assert_maker_itunes_block(%w(items last)) + end + + def test_category + assert_maker_itunes_category(%w(channel)) + end + + def test_image + assert_maker_itunes_image(%w(channel)) + end + + def test_duration + assert_maker_itunes_duration(%w(items last)) + end + + def test_explicit + assert_maker_itunes_explicit(%w(channel)) + assert_maker_itunes_explicit(%w(items last)) + end + + def test_keywords + assert_maker_itunes_keywords(%w(channel)) + assert_maker_itunes_keywords(%w(items last)) + end + + def test_new_feed_url + assert_maker_itunes_new_feed_url(%w(channel)) + end + + def test_owner + assert_maker_itunes_owner(%w(channel)) + end + + def test_subtitle + assert_maker_itunes_subtitle(%w(channel)) + assert_maker_itunes_subtitle(%w(items last)) + end + + def test_summary + assert_maker_itunes_summary(%w(channel)) + assert_maker_itunes_summary(%w(items last)) + end + + private + + def assert_maker_itunes_author(maker_readers, feed_readers=nil) + _wrap_assertion do + feed_readers ||= maker_readers + author = "John Doe" + rss20 = ::RSS::Maker.make("rss2.0") do |maker| + setup_dummy_channel(maker) + setup_dummy_item(maker) + + target = chain_reader(maker, maker_readers) + target.itunes_author = author + end + target = chain_reader(rss20, feed_readers) + assert_equal(author, target.itunes_author) + end + end + + def _assert_maker_itunes_block(value, boolean_value, maker_readers, + feed_readers) + rss20 = ::RSS::Maker.make("rss2.0") do |maker| + setup_dummy_channel(maker) + setup_dummy_item(maker) + + target = chain_reader(maker, maker_readers) + target.itunes_block = value + assert_equal(value, target.itunes_block) + assert_equal(boolean_value, target.itunes_block?) + end + target = chain_reader(rss20, feed_readers) + if [true, false].include?(value) + feed_expected_value = value = value ? "yes" : "no" + else + feed_expected_value = value + end + assert_equal(value, target.itunes_block) + assert_equal(boolean_value, target.itunes_block?) + end + + def assert_maker_itunes_block(maker_readers, feed_readers=nil) + _wrap_assertion do + feed_readers ||= maker_readers + _assert_maker_itunes_block("yes", true, maker_readers, feed_readers) + _assert_maker_itunes_block("Yes", true, maker_readers, feed_readers) + _assert_maker_itunes_block("no", false, maker_readers, feed_readers) + _assert_maker_itunes_block("", false, maker_readers, feed_readers) + _assert_maker_itunes_block(true, true, maker_readers, feed_readers) + _assert_maker_itunes_block(false, false, maker_readers, feed_readers) + _assert_maker_itunes_block(nil, false, maker_readers, feed_readers) + end + end + + def _assert_maker_itunes_category(categories, maker_readers, feed_readers) + rss20 = ::RSS::Maker.make("rss2.0") do |maker| + setup_dummy_channel(maker) + setup_dummy_item(maker) + + target = chain_reader(maker, maker_readers) + categories.each do |category| + sub_target = target.itunes_categories + if category.is_a?(Array) + category.each do |sub_category| + sub_target = sub_target.new_category + sub_target.text = sub_category + end + else + sub_target.new_category.text = category + end + end + end + + target = chain_reader(rss20, feed_readers) + actual_categories = target.itunes_categories.collect do |category| + cat = category.text + if category.itunes_categories.empty? + cat + else + [cat, *category.itunes_categories.collect {|c| c.text}] + end + end + assert_equal(categories, actual_categories) + end + + def assert_maker_itunes_category(maker_readers, feed_readers=nil) + _wrap_assertion do + feed_readers ||= maker_readers + _assert_maker_itunes_category(["Audio Blogs"], + maker_readers, feed_readers) + _assert_maker_itunes_category([["Arts & Entertainment", "Games"]], + maker_readers, feed_readers) + _assert_maker_itunes_category([["Arts & Entertainment", "Games"], + ["Technology", "Computers"], + "Audio Blogs"], + maker_readers, feed_readers) + end + end + + def assert_maker_itunes_image(maker_readers, feed_readers=nil) + _wrap_assertion do + feed_readers ||= maker_readers + url = "http://example.com/podcasts/everything/AllAboutEverything.jpg" + + rss20 = ::RSS::Maker.make("rss2.0") do |maker| + setup_dummy_channel(maker) + setup_dummy_item(maker) + + target = chain_reader(maker, maker_readers) + target.itunes_image = url + end + + target = chain_reader(rss20, feed_readers) + assert_not_nil(target.itunes_image) + assert_equal(url, target.itunes_image.href) + end + end + + def _assert_maker_itunes_duration(hour, minute, second, value, + maker_readers, feed_readers) + _assert_maker_itunes_duration_by_value(hour, minute, second, value, + maker_readers, feed_readers) + _assert_maker_itunes_duration_by_hour_minute_second(hour, minute, second, + value, + maker_readers, + feed_readers) + end + + def _assert_maker_itunes_duration_by(hour, minute, second, value, + maker_readers, feed_readers) + expected_value = nil + rss20 = ::RSS::Maker.make("rss2.0") do |maker| + setup_dummy_channel(maker) + setup_dummy_item(maker) + + target = chain_reader(maker, maker_readers) + expected_value = yield(target) + assert_equal(expected_value, target.itunes_duration) + target.itunes_duration do |duration| + assert_equal([hour, minute, second, expected_value], + [duration.hour, duration.minute, + duration.second, duration.content]) + end + end + target = chain_reader(rss20, feed_readers) + duration = target.itunes_duration + assert_not_nil(duration) + assert_equal([hour, minute, second, expected_value], + [duration.hour, duration.minute, + duration.second, duration.content]) + end + + def _assert_maker_itunes_duration_by_value(hour, minute, second, value, + maker_readers, feed_readers) + _assert_maker_itunes_duration_by(hour, minute, second, value, + maker_readers, feed_readers) do |target| + target.itunes_duration = value + value + end + end + + def _assert_maker_itunes_duration_by_hour_minute_second(hour, minute, second, + value, + maker_readers, + feed_readers) + _assert_maker_itunes_duration_by(hour, minute, second, value, + maker_readers, feed_readers) do |target| + target.itunes_duration do |duration| + duration.hour = hour + duration.minute = minute + duration.second = second + end + value.split(":").collect {|v| "%02d" % v.to_i}.join(":") + end + end + + def _assert_maker_itunes_duration_invalid_value(value, maker_readers) + assert_raise(ArgumentError) do + ::RSS::Maker.make("rss2.0") do |maker| + setup_dummy_channel(maker) + setup_dummy_item(maker) + + target = chain_reader(maker, maker_readers) + target.itunes_duration = value + end + end + end + + def assert_maker_itunes_duration(maker_readers, feed_readers=nil) + _wrap_assertion do + feed_readers ||= maker_readers + _assert_maker_itunes_duration(7, 14, 5, "07:14:05", maker_readers, + feed_readers) + _assert_maker_itunes_duration(7, 14, 5, "7:14:05", maker_readers, + feed_readers) + _assert_maker_itunes_duration(0, 4, 55, "04:55", maker_readers, + feed_readers) + _assert_maker_itunes_duration(0, 4, 5, "4:05", maker_readers, + feed_readers) + + _assert_maker_itunes_duration_invalid_value("5", maker_readers) + _assert_maker_itunes_duration_invalid_value("09:07:14:05", maker_readers) + _assert_maker_itunes_duration_invalid_value("10:5", maker_readers) + _assert_maker_itunes_duration_invalid_value("10:03:5", maker_readers) + _assert_maker_itunes_duration_invalid_value("10:3:05", maker_readers) + + _assert_maker_itunes_duration_invalid_value("xx:xx:xx", maker_readers) + end + end + + def _assert_maker_itunes_explicit(explicit, value, + maker_readers, feed_readers) + rss20 = ::RSS::Maker.make("rss2.0") do |maker| + setup_dummy_channel(maker) + setup_dummy_item(maker) + + target = chain_reader(maker, maker_readers) + target.itunes_explicit = value + assert_equal(explicit, target.itunes_explicit?) + end + target = chain_reader(rss20, feed_readers) + assert_equal(value, target.itunes_explicit) + assert_equal(explicit, target.itunes_explicit?) + end + + def assert_maker_itunes_explicit(maker_readers, feed_readers=nil) + _wrap_assertion do + feed_readers ||= maker_readers + _assert_maker_itunes_explicit(true, "yes", maker_readers, feed_readers) + _assert_maker_itunes_explicit(false, "clean", + maker_readers, feed_readers) + _assert_maker_itunes_explicit(nil, "no", maker_readers, feed_readers) + end + end + + def _assert_maker_itunes_keywords(keywords, value, + maker_readers, feed_readers) + _assert_maker_itunes_keywords_by_value(keywords, value, + maker_readers, feed_readers) + _assert_maker_itunes_keywords_by_keywords(keywords, maker_readers, + feed_readers) + end + + def _assert_maker_itunes_keywords_by(keywords, maker_readers, feed_readers) + rss20 = ::RSS::Maker.make("rss2.0") do |maker| + setup_dummy_channel(maker) + setup_dummy_item(maker) + + target = chain_reader(maker, maker_readers) + yield(target) + end + assert_nothing_raised do + rss20 = ::RSS::Parser.parse(rss20.to_s) + end + target = chain_reader(rss20, feed_readers) + assert_equal(keywords, target.itunes_keywords) + end + + def _assert_maker_itunes_keywords_by_value(keywords, value, + maker_readers, feed_readers) + _assert_maker_itunes_keywords_by(keywords, maker_readers, + feed_readers) do |target| + target.itunes_keywords = value + end + end + + def _assert_maker_itunes_keywords_by_keywords(keywords, + maker_readers, feed_readers) + _assert_maker_itunes_keywords_by(keywords, maker_readers, + feed_readers) do |target| + target.itunes_keywords = keywords + end + end + + def assert_maker_itunes_keywords(maker_readers, feed_readers=nil) + _wrap_assertion do + feed_readers ||= maker_readers + _assert_maker_itunes_keywords(["salt"], "salt", + maker_readers, feed_readers) + _assert_maker_itunes_keywords(["salt"], " salt ", + maker_readers, feed_readers) + _assert_maker_itunes_keywords(["salt", "pepper", "shaker", "exciting"], + "salt, pepper, shaker, exciting", + maker_readers, feed_readers) + _assert_maker_itunes_keywords(["metric", "socket", "wrenches", + "toolsalt"], + "metric, socket, wrenches, toolsalt", + maker_readers, feed_readers) + _assert_maker_itunes_keywords(["olitics", "red", "blue", "state"], + "olitics, red, blue, state", + maker_readers, feed_readers) + end + end + + def assert_maker_itunes_new_feed_url(maker_readers, feed_readers=nil) + feed_readers ||= maker_readers + url = "http://newlocation.com/example.rss" + + rss20 = ::RSS::Maker.make("rss2.0") do |maker| + setup_dummy_channel(maker) + setup_dummy_item(maker) + + target = chain_reader(maker, maker_readers) + target.itunes_new_feed_url = url + end + target = chain_reader(rss20, feed_readers) + assert_equal(url, target.itunes_new_feed_url) + end + + def _assert_maker_itunes_owner(name, email, maker_readers, feed_readers) + rss20 = ::RSS::Maker.make("rss2.0") do |maker| + setup_dummy_channel(maker) + setup_dummy_item(maker) + + target = chain_reader(maker, maker_readers) + owner = target.itunes_owner + owner.itunes_name = name + owner.itunes_email = email + end + owner = chain_reader(rss20, feed_readers).itunes_owner + if name.nil? and email.nil? + assert_nil(owner) + else + assert_not_nil(owner) + assert_equal(name, owner.itunes_name) + assert_equal(email, owner.itunes_email) + end + end + + def assert_maker_itunes_owner(maker_readers, feed_readers=nil) + _wrap_assertion do + feed_readers ||= maker_readers + _assert_maker_itunes_owner("John Doe", "john.doe@example.com", + maker_readers, feed_readers) + + not_set_name = (["maker"] + maker_readers + ["itunes_owner"]).join(".") + assert_not_set_error(not_set_name, ["itunes_name"]) do + _assert_maker_itunes_owner(nil, "john.doe@example.com", + maker_readers, feed_readers) + end + assert_not_set_error(not_set_name, ["itunes_email"]) do + _assert_maker_itunes_owner("John Doe", nil, + maker_readers, feed_readers) + end + + _assert_maker_itunes_owner(nil, nil, maker_readers, feed_readers) + end + end + + def _assert_maker_itunes_subtitle(subtitle, maker_readers, feed_readers) + rss20 = ::RSS::Maker.make("rss2.0") do |maker| + setup_dummy_channel(maker) + setup_dummy_item(maker) + + target = chain_reader(maker, maker_readers) + target.itunes_subtitle = subtitle + end + + target = chain_reader(rss20, feed_readers) + assert_equal(subtitle, target.itunes_subtitle) + end + + def assert_maker_itunes_subtitle(maker_readers, feed_readers=nil) + _wrap_assertion do + feed_readers ||= maker_readers + _assert_maker_itunes_subtitle("A show about everything", + maker_readers, feed_readers) + _assert_maker_itunes_subtitle("A short primer on table spices", + maker_readers, feed_readers) + _assert_maker_itunes_subtitle("Comparing socket wrenches is fun!", + maker_readers, feed_readers) + _assert_maker_itunes_subtitle("Red + Blue != Purple", + maker_readers, feed_readers) + end + end + + def _assert_maker_itunes_summary(summary, maker_readers, feed_readers) + rss20 = ::RSS::Maker.make("rss2.0") do |maker| + setup_dummy_channel(maker) + setup_dummy_item(maker) + + target = chain_reader(maker, maker_readers) + target.itunes_summary = summary + end + + target = chain_reader(rss20, feed_readers) + assert_equal(summary, target.itunes_summary) + end + + def assert_maker_itunes_summary(maker_readers, feed_readers=nil) + _wrap_assertion do + feed_readers ||= maker_readers + _assert_maker_itunes_summary("All About Everything is a show about " + + "everything. Each week we dive into any " + + "subject known to man and talk about it " + + "as much as we can. Look for our Podcast " + + "in the iTunes Music Store", + maker_readers, feed_readers) + _assert_maker_itunes_summary("This week we talk about salt and pepper " + + "shakers, comparing and contrasting pour " + + "rates, construction materials, and " + + "overall aesthetics. Come and join the " + + "party!", + maker_readers, feed_readers) + _assert_maker_itunes_summary("This week we talk about metric vs. old " + + "english socket wrenches. Which one is " + + "better? Do you really need both? Get " + + "all of your answers here.", + maker_readers, feed_readers) + _assert_maker_itunes_summary("This week we talk about surviving in a " + + "Red state if you’re a Blue person. Or " + + "vice versa.", + maker_readers, feed_readers) + end + end + end +end diff --git a/test/rss/test_maker_slash.rb b/test/rss/test_maker_slash.rb new file mode 100644 index 0000000000..f2fbf9a231 --- /dev/null +++ b/test/rss/test_maker_slash.rb @@ -0,0 +1,37 @@ +require "rss-testcase" + +require "rss/maker" + +module RSS + class TestMakerSlash < TestCase + def setup + @elements = { + "section" => "articles", + "department" => "not-an-ocean-unless-there-are-lobsters", + "comments" => 177, + "hit_parades" => [177, 155, 105, 33, 6, 3, 0], + } + end + + def test_rss10 + rss = RSS::Maker.make("1.0") do |maker| + setup_dummy_channel(maker) + + setup_dummy_item(maker) + item = maker.items.last + @elements.each do |name, value| + item.send("slash_#{name}=", value) + end + end + + item = rss.items.last + assert_not_nil(item) + assert_slash_elements(item) + end + + private + def assert_slash_elements(target) + super(@elements, target) + 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_xml-stylesheet.rb b/test/rss/test_maker_xml-stylesheet.rb index c380f21dc3..81d97ddc0e 100644 --- a/test/rss/test_maker_xml-stylesheet.rb +++ b/test/rss/test_maker_xml-stylesheet.rb @@ -24,6 +24,7 @@ module RSS end setup_dummy_channel(maker) + setup_dummy_item(maker) end xss = rss.xml_stylesheets.first @@ -38,11 +39,12 @@ module RSS href = 'http://example.com/index.xsl' type = 'text/xsl' rss = RSS::Maker.make("1.0") do |maker| - maker.xml_stylesheets.new_xml_stylesheet do |xss| - 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 @@ -61,6 +63,7 @@ module RSS end setup_dummy_channel(maker) + setup_dummy_item(maker) end assert(rss.xml_stylesheets.empty?) @@ -71,6 +74,7 @@ module RSS 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 49b441bf96..59458ef51b 100644 --- a/test/rss/test_parser.rb +++ b/test/rss/test_parser.rb @@ -1,14 +1,4 @@ -begin - require "fileutils" -rescue LoadError - module FileUtils - module_function - def rm_f(target) - File.unlink(target) - rescue Errno::ENOENT - end - end -end +require "fileutils" require "rss-testcase" @@ -28,7 +18,7 @@ EOR @rss_file = "rss10.rdf" File.open(@rss_file, "w") {|f| f.print(@rss10)} end - + def teardown Parser.default_parser = @_default_parser FileUtils.rm_f(@rss_file) diff --git a/test/rss/test_parser_1.0.rb b/test/rss/test_parser_1.0.rb index 472602b04a..819ce286a5 100644 --- a/test/rss/test_parser_1.0.rb +++ b/test/rss/test_parser_1.0.rb @@ -498,6 +498,14 @@ EOR Parser.parse(rss, true, false) end end + + def test_unknown_duplicated_element + xmlns = {"test" => "http://localhost/test"} + assert_parse(make_RDF(<<-EOR, xmlns), :nothing_raised) + #{make_channel("<test:string/>")} + #{make_item} + #{make_image} + EOR + 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) +<entry/> +EOA + end + + assert_ns("", Atom::URI) do + Parser.parse(<<-EOA) +<entry xmlns="hoge"/> +EOA + end + + assert_parse(<<-EOA, :missing_tag, "id", "entry") do +<entry xmlns="#{Atom::URI}"/> +EOA + end + + assert_parse(<<-EOA, :missing_tag, "title", "entry") do +<entry xmlns="#{Atom::URI}"> + <id>urn:uuid:506e336c-a26e-4457-917b-b89dca7ae746</id> +</entry> +EOA + end + + assert_parse(<<-EOA, :missing_tag, "updated", "entry") do +<entry xmlns="#{Atom::URI}"> + <id>urn:uuid:506e336c-a26e-4457-917b-b89dca7ae746</id> + <title>Example Entry</title> +</entry> +EOA + end + + assert_parse(<<-EOA, :missing_tag, "author", "entry") do +<entry xmlns="#{Atom::URI}"> + <id>urn:uuid:506e336c-a26e-4457-917b-b89dca7ae746</id> + <title>Example Entry</title> + <updated>2003-10-10T18:30:02Z</updated> +</entry> +EOA + end + + assert_parse(<<-EOA, :nothing_raised) do +<entry xmlns="#{Atom::URI}"> + <id>urn:uuid:506e336c-a26e-4457-917b-b89dca7ae746</id> + <title>Example Entry</title> + <updated>2003-10-10T18:30:02Z</updated> + <author> + <name>A person</name> + </author> +</entry> +EOA + end + end + + def test_entry + entry = RSS::Parser.parse(<<-EOA) +<?xml version="1.0" encoding="utf-8"?> +<entry xmlns="http://www.w3.org/2005/Atom"> + <author> + <name>A person</name> + </author> + <title>Atom-Powered Robots Run Amok</title> + <link href="http://example.org/2003/12/13/atom03"/> + <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a</id> + <updated>2003-12-13T18:30:02Z</updated> + <summary>Some text.</summary> +</entry> +EOA + assert_not_nil(entry) + assert_equal("Atom-Powered Robots Run Amok", entry.title.content) + assert_equal("http://example.org/2003/12/13/atom03", entry.link.href) + assert_equal("urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a", + entry.id.content) + assert_equal(Time.parse("2003-12-13T18:30:02Z"), entry.updated.content) + assert_equal("Some text.", entry.summary.content) + end + + def test_entry_author + assert_atom_person("author", method(:make_entry_document)) do |entry| + assert_equal(2, entry.authors.size) + entry.authors.last + end + end + + def test_entry_category + assert_atom_category(method(:make_entry_document)) do |entry| + assert_equal(1, entry.categories.size) + entry.category + end + end + + def test_entry_content_text + assert_atom_content(method(:make_entry_document)) do |entry| + entry.content + end + end + + def test_entry_contributor + assert_atom_person("contributor", method(:make_entry_document)) do |entry| + assert_equal(1, entry.contributors.size) + entry.contributor + end + end + + def test_entry_id + entry = RSS::Parser.parse(make_entry_document) + assert_equal(ENTRY_ID, entry.id.content) + end + + def test_entry_link + assert_atom_link(method(:make_entry_document)) do |entry| + assert_equal(1, entry.links.size) + entry.link + end + end + + def test_published + generator = method(:make_entry_document) + assert_atom_date_construct("published", generator) do |entry| + entry.published + end + end + + def test_entry_rights + generator = method(:make_entry_document) + assert_atom_text_construct("rights", generator) do |entry| + entry.rights + end + end + + def test_entry_source + generator = method(:make_entry_document_with_open_source) + assert_atom_source(generator) do |entry| + assert_not_nil(entry.source) + entry.source + end + end + + def test_entry_summary + generator = method(:make_entry_document) + assert_atom_text_construct("summary", generator) do |entry| + entry.summary + end + end + + def test_entry_title + entry = RSS::Parser.parse(make_entry_document) + assert_equal(ENTRY_TITLE, entry.title.content) + end + + def test_entry_updated + entry = RSS::Parser.parse(make_entry_document) + assert_equal(Time.parse(ENTRY_UPDATED), entry.updated.content) + end + end +end 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) +<feed/> +EOA + end + + assert_ns("", Atom::URI) do + Parser.parse(<<-EOA) +<feed xmlns="hoge"/> +EOA + end + + assert_parse(<<-EOA, :missing_tag, "id", "feed") do +<feed xmlns="#{Atom::URI}"/> +EOA + end + + assert_parse(<<-EOA, :missing_tag, "title", "feed") do +<feed xmlns="#{Atom::URI}"> + <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id> +</feed> +EOA + end + + assert_parse(<<-EOA, :missing_tag, "updated", "feed") do +<feed xmlns="#{Atom::URI}"> + <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id> + <title>Example Feed</title> +</feed> +EOA + end + + assert_parse(<<-EOA, :missing_tag, "author", "feed") do +<feed xmlns="#{Atom::URI}"> + <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id> + <title>Example Feed</title> + <updated>2003-12-13T18:30:02Z</updated> +</feed> +EOA + end + + assert_parse(<<-EOA, :nothing_raised) do +<feed xmlns="#{Atom::URI}"> + <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id> + <title>Example Feed</title> + <updated>2003-12-13T18:30:02Z</updated> + <author> + <name>A person</name> + </author> +</feed> +EOA + end + end + + def test_lang + feed = RSS::Parser.parse(<<-EOA) +<feed xmlns="#{Atom::URI}" xml:lang="ja"> + <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id> + <title xml:lang="en">Example Feed</title> + <updated>2003-12-13T18:30:02Z</updated> + <author xml:lang="en"> + <name>A person</name> + </author> +</feed> +EOA + + assert_equal("ja", feed.lang) + assert_equal("ja", feed.id.lang) + assert_equal("en", feed.title.lang) + assert_equal("ja", feed.updated.lang) + assert_equal("en", feed.author.lang) + assert_equal("en", feed.author.name.lang) + end + + def test_base + feed = RSS::Parser.parse(<<-EOA) +<feed xmlns="#{Atom::URI}" xml:base="http://example.com/"> + <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id> + <title xml:lang="en">Example Feed</title> + <updated>2003-12-13T18:30:02Z</updated> + <generator uri="generator">Generator</generator> + <link hreflang="ja" href="http://example.org/link1"/> + <link hreflang="en" href="link2"/> + <link hreflang="fr" xml:base="http://example.net/" href="link3"/> + <author> + <name>A person</name> + <uri>person</uri> + </author> +</feed> +EOA + + assert_equal("http://example.com/", feed.base) + assert_equal("http://example.com/", feed.id.base) + assert_equal("http://example.com/", feed.title.base) + assert_equal("http://example.com/", feed.updated.base) + assert_equal("http://example.com/", feed.generator.base) + assert_equal("http://example.com/generator", feed.generator.uri) + + assert_equal("http://example.com/", feed.links[0].base) + assert_equal("http://example.org/link1", feed.links[0].href) + assert_equal("http://example.com/", feed.links[1].base) + assert_equal("http://example.com/link2", feed.links[1].href) + assert_equal("http://example.net/", feed.links[2].base) + assert_equal("http://example.net/link3", feed.links[2].href) + assert_equal("http://example.com/person", feed.author.uri.content) + end + + def test_feed_author + assert_atom_person("author", method(:make_feed)) do |feed| + assert_equal(2, feed.authors.size) + feed.authors[1] + end + end + + def test_entry_author + generator = method(:make_feed_with_open_entry) + assert_atom_person("author", generator) do |feed| + assert_equal(1, feed.entries.size) + assert_equal(1, feed.entry.authors.size) + feed.entry.author + end + end + + def test_feed_category + assert_atom_category(method(:make_feed)) do |feed| + assert_equal(1, feed.categories.size) + feed.category + end + end + + def test_entry_category + assert_atom_category(method(:make_feed_with_open_entry)) do |feed| + assert_equal(1, feed.entries.size) + assert_equal(1, feed.entry.categories.size) + feed.entry.category + end + end + + def test_entry_content + assert_atom_content(method(:make_feed_with_open_entry)) do |feed| + assert_equal(1, feed.entries.size) + feed.entry.content + end + end + + def test_feed_contributor + assert_atom_person("contributor", method(:make_feed)) do |feed| + assert_equal(1, feed.contributors.size) + feed.contributor + end + end + + def test_entry_contributor + generator = method(:make_feed_with_open_entry) + assert_atom_person("contributor", generator) do |feed| + assert_equal(1, feed.entries.size) + assert_equal(1, feed.entry.contributors.size) + feed.entry.contributor + end + end + + def test_feed_generator + assert_atom_generator(method(:make_feed)) do |feed| + feed.generator + end + end + + def test_feed_icon + assert_atom_icon(method(:make_feed)) do |feed| + feed.icon + end + end + + def test_feed_id + feed = RSS::Parser.parse(make_feed('')) + assert_equal(FEED_ID, feed.id.content) + end + + def test_entry_id + feed = RSS::Parser.parse(make_feed('')) + assert_equal(ENTRY_ID, feed.entry.id.content) + end + + def test_feed_link + assert_atom_link(method(:make_feed)) do |feed| + assert_equal(1, feed.links.size) + feed.link + end + end + + def test_entry_link + assert_atom_link(method(:make_feed_with_open_entry)) do |feed| + assert_equal(1, feed.entries.size) + assert_equal(1, feed.entry.links.size) + feed.entry.link + end + end + + def test_feed_logo + assert_atom_logo(method(:make_feed)) do |feed| + feed.logo + end + end + + def test_feed_rights + assert_atom_text_construct("rights", method(:make_feed)) do |feed| + feed.rights + end + end + + def test_entry_rights + generator = method(:make_feed_with_open_entry) + assert_atom_text_construct("rights", generator) do |feed| + assert_equal(1, feed.entries.size) + feed.entry.rights + end + end + + def test_entry_source + assert_atom_source(method(:make_feed_with_open_entry_source)) do |feed| + assert_equal(1, feed.entries.size) + assert_not_nil(feed.entry.source) + feed.entry.source + end + end + + def test_feed_subtitle + assert_atom_text_construct("subtitle", method(:make_feed)) do |feed| + feed.subtitle + end + end + + def test_feed_title + feed = RSS::Parser.parse(make_feed('')) + assert_equal(FEED_TITLE, feed.title.content) + end + + def test_entry_title + feed = RSS::Parser.parse(make_feed('')) + assert_equal(ENTRY_TITLE, feed.entry.title.content) + end + + def test_feed_updated + feed = RSS::Parser.parse(make_feed('')) + assert_equal(Time.parse(FEED_UPDATED), feed.updated.content) + end + + def test_entry_updated + feed = RSS::Parser.parse(make_feed('')) + assert_equal(Time.parse(ENTRY_UPDATED), feed.entry.updated.content) + end + + def test_entry_published + generator = method(:make_feed_with_open_entry) + assert_atom_date_construct("published", generator) do |feed| + assert_equal(1, feed.entries.size) + feed.entry.published + end + end + + def test_entry_summary + generator = method(:make_feed_with_open_entry) + assert_atom_text_construct("summary", generator) do |feed| + assert_equal(1, feed.entries.size) + feed.entry.summary + end + end + end +end diff --git a/test/rss/test_setup_maker_0.9.rb b/test/rss/test_setup_maker_0.9.rb index 9408728371..c20186cc8a 100644 --- a/test/rss/test_setup_maker_0.9.rb +++ b/test/rss/test_setup_maker_0.9.rb @@ -49,10 +49,19 @@ module RSS 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 @@ -74,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 @@ -121,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 @@ -130,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 @@ -157,6 +167,8 @@ module RSS item.description = "#{description}#{i}" end end + + setup_dummy_image(maker) end new_rss = RSS::Maker.make("0.91") do |maker| @@ -169,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 @@ -209,8 +222,9 @@ module RSS end setup_dummy_channel(maker) + setup_dummy_image(maker) end - + new_rss = RSS::Maker.make("0.91") do |maker| rss.setup_maker(maker) end @@ -228,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 51a4d146c7..0b960d91c8 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 @@ -247,8 +262,8 @@ module RSS assert_equal(@trackback_elems[:ping], item.trackback_ping) assert_equal(@trackback_elems[:about].size, item.trackback_abouts.size) - item.trackback_abouts.each_with_index do |about, i| - assert_equal(@trackback_elems[:about][i], about.value) + item.trackback_abouts.each_with_index do |about, j| + assert_equal(@trackback_elems[:about][j], about.value) end end end @@ -333,6 +348,7 @@ module RSS end setup_dummy_channel(maker) + setup_dummy_item(maker) end new_rss = RSS::Maker.make("1.0") do |maker| @@ -522,8 +538,8 @@ module RSS assert_equal(@trackback_elems[:ping], item.trackback_ping) assert_equal(@trackback_elems[:about].size, item.trackback_abouts.size) - item.trackback_abouts.each_with_index do |about, i| - assert_equal(@trackback_elems[:about][i], about.value) + item.trackback_abouts.each_with_index do |about, j| + assert_equal(@trackback_elems[:about][j], about.value) end 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..03d33dbb9c --- /dev/null +++ b/test/rss/test_setup_maker_atom_feed.rb @@ -0,0 +1,445 @@ +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 do |g| + g.__send__("#{key}=", value) + end + 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_setup_maker_itunes.rb b/test/rss/test_setup_maker_itunes.rb new file mode 100644 index 0000000000..1f0372d6e7 --- /dev/null +++ b/test/rss/test_setup_maker_itunes.rb @@ -0,0 +1,144 @@ +require "rss-testcase" + +require "rss/maker" + +module RSS + class TestSetupMakerITunes < TestCase + def test_setup_maker_simple + author = "John Doe" + block = true + categories = ["Audio Blogs"] + image = "http://example.com/podcasts/everything/AllAboutEverything.jpg" + duration = "4:05" + duration_components = [0, 4, 5] + explicit = true + keywords = ["salt", "pepper", "shaker", "exciting"] + new_feed_url = "http://newlocation.com/example.rss" + owner = {:name => "John Doe", :email => "john.doe@example.com"} + subtitle = "A show about everything" + summary = "All About Everything is a show about " + + "everything. Each week we dive into any " + + "subject known to man and talk about it " + + "as much as we can. Look for our Podcast " + + "in the iTunes Music Store" + + feed = RSS::Maker.make("rss2.0") do |maker| + setup_dummy_channel(maker) + setup_dummy_item(maker) + + channel = maker.channel + channel.itunes_author = author + channel.itunes_block = block + categories.each do |category| + channel.itunes_categories.new_category.text = category + end + channel.itunes_image = image + channel.itunes_explicit = explicit + channel.itunes_keywords = keywords + channel.itunes_owner.itunes_name = owner[:name] + channel.itunes_owner.itunes_email = owner[:email] + channel.itunes_subtitle = subtitle + channel.itunes_summary = summary + + item = maker.items.last + item.itunes_author = author + item.itunes_block = block + item.itunes_duration = duration + item.itunes_explicit = explicit + item.itunes_keywords = keywords + item.itunes_subtitle = subtitle + item.itunes_summary = summary + end + assert_not_nil(feed) + + new_feed = RSS::Maker.make("rss2.0") do |maker| + feed.setup_maker(maker) + end + assert_not_nil(new_feed) + + channel = new_feed.channel + item = new_feed.items.last + + assert_equal(author, channel.itunes_author) + assert_equal(author, item.itunes_author) + + assert_equal(block, channel.itunes_block?) + assert_equal(block, item.itunes_block?) + + assert_equal(categories, + collect_itunes_categories(channel.itunes_categories)) + + assert_equal(image, channel.itunes_image.href) + + assert_equal(duration_components, + [item.itunes_duration.hour, + item.itunes_duration.minute, + item.itunes_duration.second]) + + assert_equal(explicit, channel.itunes_explicit?) + assert_equal(explicit, item.itunes_explicit?) + + assert_equal(keywords, channel.itunes_keywords) + assert_equal(keywords, item.itunes_keywords) + + assert_equal(owner, + { + :name => channel.itunes_owner.itunes_name, + :email => channel.itunes_owner.itunes_email + }) + + assert_equal(subtitle, channel.itunes_subtitle) + assert_equal(subtitle, item.itunes_subtitle) + + assert_equal(summary, channel.itunes_summary) + assert_equal(summary, item.itunes_summary) + end + + def test_setup_maker_with_nested_categories + categories = [["Arts & Entertainment", "Games"], + ["Technology", "Computers"], + "Audio Blogs"] + + feed = RSS::Maker.make("rss2.0") do |maker| + setup_dummy_channel(maker) + setup_dummy_item(maker) + + channel = maker.channel + categories.each do |category| + target = channel.itunes_categories + if category.is_a?(Array) + category.each do |sub_category| + target = target.new_category + target.text = sub_category + end + else + target.new_category.text = category + end + end + end + assert_not_nil(feed) + + new_feed = RSS::Maker.make("rss2.0") do |maker| + feed.setup_maker(maker) + end + assert_not_nil(new_feed) + + channel = new_feed.channel + + assert_equal(categories, + collect_itunes_categories(channel.itunes_categories)) + end + + private + def collect_itunes_categories(categories) + categories.collect do |c| + rest = collect_itunes_categories(c.itunes_categories) + if rest.empty? + c.text + else + [c.text, *rest] + end + end + end + end +end diff --git a/test/rss/test_setup_maker_slash.rb b/test/rss/test_setup_maker_slash.rb new file mode 100644 index 0000000000..07fa5bb342 --- /dev/null +++ b/test/rss/test_setup_maker_slash.rb @@ -0,0 +1,38 @@ +require "rss-testcase" + +require "rss/maker" + +module RSS + class TestSetupMakerSlash < TestCase + def test_setup_maker + elements = { + "section" => "articles", + "department" => "not-an-ocean-unless-there-are-lobsters", + "comments" => 177, + "hit_parades" => [177, 155, 105, 33, 6, 3, 0], + } + + rss = RSS::Maker.make("rss1.0") do |maker| + setup_dummy_channel(maker) + setup_dummy_item(maker) + + item = maker.items.last + item.slash_section = elements["section"] + item.slash_department = elements["department"] + item.slash_comments = elements["comments"] + item.slash_hit_parade = elements["hit_parades"].join(",") + end + assert_not_nil(rss) + + new_rss = RSS::Maker.make("rss1.0") do |maker| + rss.setup_maker(maker) + end + assert_not_nil(new_rss) + + item = new_rss.items.last + assert_not_nil(item) + + assert_slash_elements(elements, item) + end + end +end diff --git a/test/rss/test_slash.rb b/test/rss/test_slash.rb new file mode 100644 index 0000000000..aec0a868f5 --- /dev/null +++ b/test/rss/test_slash.rb @@ -0,0 +1,64 @@ +require "cgi" +require "rexml/document" + +require "rss-testcase" + +require "rss/1.0" +require "rss/slash" + +module RSS + class TestSlash < TestCase + def setup + @elements = { + "section" => "articles", + "department" => "not-an-ocean-unless-there-are-lobsters", + "comments" => 177, + "hit_parades" => [177, 155, 105, 33, 6, 3, 0], + } + + slash_nodes = @elements.collect do |name, value| + if name == "hit_parades" + name = "hit_parade" + value = value.join(",") + end + "<slash:#{name}>#{value}</slash:#{name}>" + end.join("\n") + + slash_ns = {"slash" => "http://purl.org/rss/1.0/modules/slash/"} + @source = make_RDF(<<-EOR, slash_ns) +#{make_channel} +#{make_image} +#{make_item(slash_nodes)} +#{make_textinput} +EOR + end + + def test_parser + rss = RSS::Parser.parse(@source) + + assert_not_nil(rss) + + item = rss.items[0] + assert_not_nil(item) + + assert_slash_elements(item) + end + + def test_to_s + rss = RSS::Parser.parse(@source) + rss = RSS::Parser.parse(rss.to_s) + + assert_not_nil(rss) + + item = rss.items[0] + assert_not_nil(item) + + assert_slash_elements(item) + end + + private + def assert_slash_elements(target) + super(@elements, target) + end + end +end diff --git a/test/rss/test_syndication.rb b/test/rss/test_syndication.rb index 697ff439e4..abd75e905e 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 @@ -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 10ae55190a..5109f3d892 100644 --- a/test/rss/test_taxonomy.rb +++ b/test/rss/test_taxonomy.rb @@ -144,8 +144,10 @@ EOR end @topic_nodes.each_with_index do |node, i| - expected = REXML::Document.new(node).root - actual = REXML::Document.new(@rss.taxo_topics[i].to_s(true, "")).root + expected_xml = taxo_xmlns_container(node) + expected = REXML::Document.new(expected_xml).root.elements[1] + actual_xml = taxo_xmlns_container(@rss.taxo_topics[i].to_s(true, "")) + actual = REXML::Document.new(actual_xml).root.elements[1] expected_elems = expected.reject {|x| x.is_a?(REXML::Text)} actual_elems = actual.reject {|x| x.is_a?(REXML::Text)} expected_elems.sort! {|x, y| x.name <=> y.name} @@ -155,6 +157,16 @@ EOR assert_equal(expected.attributes.sort, actual.attributes.sort) end end + + private + def taxo_xmlns_container(content) + xmlns_container({ + @prefix => @uri, + "dc" => "http://purl.org/dc/elements/1.1/", + "rdf" => "http://www.w3.org/1999/02/22-rdf-syntax-ns#", + }, + content) + end end end diff --git a/test/rss/test_to_s.rb b/test/rss/test_to_s.rb index 1538534034..66739591ea 100644 --- a/test/rss/test_to_s.rb +++ b/test/rss/test_to_s.rb @@ -12,7 +12,6 @@ require "rss/trackback" module RSS class TestToS < TestCase - def setup @image_url = "http://example.com/foo.png" @textinput_link = "http://example.com/search.cgi" @@ -435,6 +434,237 @@ module RSS new_about.value = about end end + + + def assert_channel10(attrs, channel) + _wrap_assertion do + n_attrs = normalized_attrs(attrs) + + names = %w(about title link description) + assert_attributes(attrs, names, channel) + + %w(image items textinput).each do |name| + value = n_attrs[name] + if value + target = channel.__send__(name) + __send__("assert_channel10_#{name}", value, target) + end + end + end + end + + def assert_channel10_image(attrs, image) + _wrap_assertion do + assert_attributes(attrs, %w(resource), image) + end + end + + def assert_channel10_textinput(attrs, textinput) + _wrap_assertion do + assert_attributes(attrs, %w(resource), textinput) + end + end + + def assert_channel10_items(attrs, items) + _wrap_assertion do + assert_equal(items.resources, items.Seq.lis.collect {|x| x.resource}) + items.Seq.lis.each_with_index do |li, i| + assert_attributes(attrs[i], %w(resource), li) + end + end + end + + def assert_image10(attrs, image) + _wrap_assertion do + names = %w(about title url link) + assert_attributes(attrs, names, image) + end + end + + def assert_items10(attrs, items) + _wrap_assertion do + names = %w(about title link description) + items.each_with_index do |item, i| + assert_attributes(attrs[i], names, item) + end + end + end + + def assert_textinput10(attrs, textinput) + _wrap_assertion do + names = %w(about title description name link) + assert_attributes(attrs, names, textinput) + end + end + + + def assert_channel09(attrs, channel) + _wrap_assertion do + n_attrs = normalized_attrs(attrs) + + names = %w(title description link language rating + copyright pubDate lastBuildDate docs + managingEditor webMaster) + assert_attributes(attrs, names, channel) + + %w(skipHours skipDays).each do |name| + value = n_attrs[name] + if value + target = channel.__send__(name) + __send__("assert_channel09_#{name}", value, target) + end + end + end + end + + def assert_channel09_skipDays(contents, skipDays) + _wrap_assertion do + days = skipDays.days + contents.each_with_index do |content, i| + assert_equal(content, days[i].content) + end + end + end + + def assert_channel09_skipHours(contents, skipHours) + _wrap_assertion do + hours = skipHours.hours + contents.each_with_index do |content, i| + assert_equal(content.to_i, hours[i].content) + end + end + end + + def assert_image09(attrs, image) + _wrap_assertion do + names = %w(url link title description) + names << ["width", :integer] + names << ["height", :integer] + assert_attributes(attrs, names, image) + end + end + + def assert_items09(attrs, items) + _wrap_assertion do + names = %w(title link description) + items.each_with_index do |item, i| + assert_attributes(attrs[i], names, item) + end + end + end + def assert_textinput09(attrs, textinput) + _wrap_assertion do + names = %w(title description name link) + assert_attributes(attrs, names, textinput) + end + end + + + def assert_channel20(attrs, channel) + _wrap_assertion do + n_attrs = normalized_attrs(attrs) + + names = %w(title link description language copyright + managingEditor webMaster pubDate + lastBuildDate generator docs rating) + names << ["ttl", :integer] + assert_attributes(attrs, names, channel) + + %w(cloud categories skipHours skipDays).each do |name| + value = n_attrs[name] + if value + target = channel.__send__(name) + __send__("assert_channel20_#{name}", value, target) + end + end + end + end + + def assert_channel20_skipDays(contents, skipDays) + assert_channel09_skipDays(contents, skipDays) + end + + def assert_channel20_skipHours(contents, skipHours) + assert_channel09_skipHours(contents, skipHours) + end + + def assert_channel20_cloud(attrs, cloud) + _wrap_assertion do + names = %w(domain path registerProcedure protocol) + names << ["port", :integer] + assert_attributes(attrs, names, cloud) + end + end + + def assert_channel20_categories(attrs, categories) + _wrap_assertion do + names = %w(domain content) + categories.each_with_index do |category, i| + assert_attributes(attrs[i], names, category) + end + end + end + + def assert_image20(attrs, image) + _wrap_assertion do + names = %w(url link title description) + names << ["width", :integer] + names << ["height", :integer] + assert_attributes(attrs, names, image) + end + end + + def assert_items20(attrs, items) + _wrap_assertion do + names = %w(about title link description) + items.each_with_index do |item, i| + assert_attributes(attrs[i], names, item) + + n_attrs = normalized_attrs(attrs[i]) + + %w(source enclosure categories guid).each do |name| + value = n_attrs[name] + if value + target = item.__send__(name) + __send__("assert_items20_#{name}", value, target) + end + end + end + end + end + + def assert_items20_source(attrs, source) + _wrap_assertion do + assert_attributes(attrs, %w(url content), source) + end + end + + def assert_items20_enclosure(attrs, enclosure) + _wrap_assertion do + names = ["url", ["length", :integer], "type"] + assert_attributes(attrs, names, enclosure) + end + end + + def assert_items20_categories(attrs, categories) + _wrap_assertion do + assert_channel20_categories(attrs, categories) + end + end + + def assert_items20_guid(attrs, guid) + _wrap_assertion do + names = [["isPermaLink", :boolean], ["content"]] + assert_attributes(attrs, names, guid) + end + end + + def assert_textinput20(attrs, textinput) + _wrap_assertion do + names = %w(title description name link) + assert_attributes(attrs, names, textinput) + end + end end end diff --git a/test/rss/test_version.rb b/test/rss/test_version.rb index 237f364b20..9b64f0d4ed 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.2.0", ::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 |