diff options
Diffstat (limited to 'trunk/test/rss/rss-assertions.rb')
| -rw-r--r-- | trunk/test/rss/rss-assertions.rb | 2086 |
1 files changed, 0 insertions, 2086 deletions
diff --git a/trunk/test/rss/rss-assertions.rb b/trunk/test/rss/rss-assertions.rb deleted file mode 100644 index 12e53f7cd5..0000000000 --- a/trunk/test/rss/rss-assertions.rb +++ /dev/null @@ -1,2086 +0,0 @@ -require 'erb' - -module RSS - module Assertions - def assert_parse(rss, assert_method, *args) - __send__("assert_#{assert_method}", *args) do - ::RSS::Parser.parse(rss) - end - __send__("assert_#{assert_method}", *args) do - ::RSS::Parser.parse(rss, false).validate - end - end - - def assert_ns(prefix, uri) - _wrap_assertion do - begin - yield - flunk("Not raise NSError") - rescue ::RSS::NSError => e - assert_equal(prefix, e.prefix) - assert_equal(uri, e.uri) - end - end - end - - def assert_missing_tag(tag, parent) - _wrap_assertion do - begin - yield - flunk("Not raise MissingTagError") - rescue ::RSS::MissingTagError => e - assert_equal(tag, e.tag) - assert_equal(parent, e.parent) - end - end - end - - def assert_too_much_tag(tag, parent) - _wrap_assertion do - begin - yield - flunk("Not raise TooMuchTagError") - rescue ::RSS::TooMuchTagError => e - assert_equal(tag, e.tag) - assert_equal(parent, e.parent) - end - end - end - - def assert_missing_attribute(tag, attrname) - _wrap_assertion do - begin - yield - flunk("Not raise MissingAttributeError") - rescue ::RSS::MissingAttributeError => e - assert_equal(tag, e.tag) - assert_equal(attrname, e.attribute) - end - end - end - - def assert_not_expected_tag(tag, uri, parent) - _wrap_assertion do - begin - yield - flunk("Not raise NotExpectedTagError") - rescue ::RSS::NotExpectedTagError => e - assert_equal(tag, e.tag) - assert_equal(uri, e.uri) - assert_equal(parent, e.parent) - end - end - end - - def assert_not_available_value(tag, value, attribute=nil) - _wrap_assertion do - begin - yield - flunk("Not raise NotAvailableValueError") - rescue ::RSS::NotAvailableValueError => e - assert_equal(tag, e.tag) - assert_equal(value, e.value) - assert_equal(attribute, e.attribute) - end - end - end - - def assert_not_set_error(name, variables) - _wrap_assertion do - begin - yield - 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 - end - - def assert_xml_declaration(version, encoding, standalone, rss) - _wrap_assertion do - assert_equal(version, rss.version) - assert_equal(encoding, rss.encoding) - assert_equal(standalone, rss.standalone) - end - end - - def assert_xml_stylesheet_attrs(attrs, xsl) - _wrap_assertion do - n_attrs = normalized_attrs(attrs) - ::RSS::XMLStyleSheet::ATTRIBUTES.each do |name| - assert_equal(n_attrs[name], xsl.__send__(name)) - end - end - end - - def assert_xml_stylesheet(target, attrs, xsl) - _wrap_assertion do - if attrs.has_key?(:href) - if !attrs.has_key?(:type) and attrs.has_key?(:guess_type) - attrs[:type] = attrs[:guess_type] - end - assert_equal("xml-stylesheet", target) - assert_xml_stylesheet_attrs(attrs, xsl) - else - assert_nil(target) - assert_equal("", xsl.to_s) - end - end - end - - def assert_xml_stylesheet_pis(attrs_ary, rss=nil) - _wrap_assertion do - if rss.nil? - rss = ::RSS::RDF.new - setup_rss10(rss) - end - xss_strs = [] - attrs_ary.each do |attrs| - xss = ::RSS::XMLStyleSheet.new(attrs) - xss_strs.push(xss.to_s) - rss.xml_stylesheets.push(xss) - end - pi_str = rss.to_s.gsub(/<\?xml .*\n/, "").gsub(/\s*<[^\?].*\z/m, "") - assert_equal(xss_strs.join("\n"), pi_str) - end - end - - def assert_xml_stylesheets(attrs, xss) - _wrap_assertion do - xss.each_with_index do |xs, i| - assert_xml_stylesheet_attrs(attrs[i], xs) - end - end - end - - - def assert_atom_person(tag_name, generator) - _wrap_assertion do - name = "Mark Pilgrim" - uri = "http://example.org/" - email = "f8dy@example.com" - - assert_parse(generator.call(<<-EOA), :missing_tag, "name", tag_name) - <#{tag_name}/> -EOA - - assert_parse(generator.call(<<-EOA), :missing_tag, "name", tag_name) - <#{tag_name}> - <uri>#{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_atom_generator(generator) - _wrap_assertion do - 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_atom_icon(generator) - _wrap_assertion do - 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_atom_text_construct(tag_name, generator) - _wrap_assertion do - [nil, "text", "html"].each do |type| - attr = "" - attr = " type=\"#{type}\""if type - assert_parse(generator.call(<<-EOA), :nothing_raised) - <#{tag_name}#{attr}/> -EOA - end - - assert_parse(generator.call(<<-EOA), :missing_tag, "div", tag_name) - <#{tag_name} type="xhtml"/> -EOA - - args = ["x", Atom::URI, tag_name] - assert_parse(generator.call(<<-EOA), :not_expected_tag, *args) - <#{tag_name} type="xhtml"><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_atom_date_construct(tag_name, generator) - _wrap_assertion do - args = [tag_name, ""] - assert_parse(generator.call(<<-EOR), :not_available_value, *args) - <#{tag_name}/> -EOR - - [ - ["xxx", false], - ["2007", false], - ["2007/02/09", true], - ].each do |invalid_value, can_parse| - assert_not_available_value(tag_name, invalid_value) do - RSS::Parser.parse(generator.call(<<-EOR)) - <#{tag_name}>#{invalid_value}</#{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_atom_logo(generator) - _wrap_assertion do - 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_atom_content(generator, &getter) - _wrap_assertion do - assert_atom_content_inline_text(generator, &getter) - assert_atom_content_inline_xhtml(generator, &getter) - assert_atom_content_inline_other(generator, &getter) - assert_atom_content_out_of_line(generator, &getter) - end - end - - def assert_atom_content_inline_text(generator) - _wrap_assertion do - [nil, "text", "html"].each do |type| - content = "<content" - content << " type='#{type}'" if type - - 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_atom_content_inline_xhtml(generator) - _wrap_assertion do - 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_atom_content_inline_other(generator, &getter) - _wrap_assertion do - assert_atom_content_inline_other_text(generator, &getter) - assert_atom_content_inline_other_xml(generator, &getter) - end - end - - def assert_atom_content_inline_other_text(generator) - _wrap_assertion do - type = "image/png" - assert_parse(generator.call(<<-EOA), :nothing_raised) - <content type="#{type}"/> -EOA - - png_file = File.join(File.dirname(__FILE__), "dot.png") - png = File.open(png_file, "rb") do |file| - file.read.force_encoding("binary") - end - base64_content = [png].pack("m").delete("\n") - - [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(png, content.content) - - xml = REXML::Document.new(content.to_s).root - assert_rexml_element([], {"type" => type}, base64_content, xml) - end - end - end - - def assert_atom_content_inline_other_xml(generator) - _wrap_assertion do - type = "image/svg+xml" - - assert_parse(generator.call(<<-EOA), :nothing_raised) - <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_atom_content_out_of_line(generator) - _wrap_assertion do - text_type = "text/plain" - text_src = "http://example.com/README.txt" - - missing_args = [:missing_attribute, "content", "type"] - # RSS Parser raises error even if this is "should" not "must". - assert_parse(generator.call(<<-EOA), *missing_args) - <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_atom_source(generator, &getter) - _wrap_assertion do - assert_atom_source_author(generator, &getter) - assert_atom_source_category(generator, &getter) - assert_atom_source_contributor(generator, &getter) - assert_atom_source_generator(generator, &getter) - assert_atom_source_icon(generator, &getter) - assert_atom_source_id(generator, &getter) - assert_atom_source_link(generator, &getter) - assert_atom_source_logo(generator, &getter) - assert_atom_source_rights(generator, &getter) - assert_atom_source_subtitle(generator, &getter) - assert_atom_source_title(generator, &getter) - assert_atom_source_updated(generator, &getter) - end - end - - def assert_atom_source_author(generator) - assert_atom_person("author", generator) do |feed| - source = yield(feed) - assert_equal(1, source.authors.size) - source.author - end - end - - def assert_atom_source_category(generator) - assert_atom_category(generator) do |feed| - source = yield(feed) - assert_equal(1, source.categories.size) - source.category - end - end - - def assert_atom_source_contributor(generator) - assert_atom_person("contributor", generator) do |feed| - source = yield(feed) - assert_equal(1, source.contributors.size) - source.contributor - end - end - - def assert_atom_source_generator(generator) - assert_atom_generator(generator) do |feed| - yield(feed).generator - end - end - - def assert_atom_source_icon(generator) - assert_atom_icon(generator) do |feed| - yield(feed).icon - end - end - - def assert_atom_source_id(generator) - id_content = "urn:uuid:a2fb588b-5674-4898-b420-265a734fea69" - id = "<id>#{id_content}</id>" - feed = RSS::Parser.parse(generator.call(id)) - assert_equal(id_content, yield(feed).id.content) - end - - def assert_atom_source_link(generator) - assert_atom_link(generator) do |feed| - source = yield(feed) - assert_equal(1, source.links.size) - source.link - end - end - - def assert_atom_source_logo(generator) - assert_atom_logo(generator) do |feed| - yield(feed).logo - end - end - - def assert_atom_source_rights(generator) - assert_atom_text_construct("rights", generator) do |feed| - yield(feed).rights - end - end - - def assert_atom_source_subtitle(generator) - assert_atom_text_construct("subtitle", generator) do |feed| - yield(feed).subtitle - end - end - - def assert_atom_source_title(generator) - assert_atom_text_construct("title", generator) do |feed| - yield(feed).title - end - end - - def assert_atom_source_updated(generator) - assert_atom_date_construct("updated", generator) do |feed| - yield(feed).updated - end - end - - def assert_dublin_core(elems, target) - _wrap_assertion do - elems.each do |name, value| - assert_equal(value, target.__send__("dc_#{name}")) - end - end - end - - def assert_multiple_dublin_core(elems, target) - _wrap_assertion do - elems.each do |name, values, plural| - plural ||= "#{name}s" - actual = target.__send__("dc_#{plural}").collect{|x| x.value} - assert_equal(values, actual) - end - end - end - - def assert_syndication(elems, target) - _wrap_assertion do - elems.each do |name, value| - meth = "sy_#{name}" - value = value.to_i if meth == "sy_updateFrequency" - assert_equal(value, target.__send__(meth )) - end - end - end - - def assert_content(elems, target) - _wrap_assertion do - elems.each do |name, value| - assert_equal(value, target.__send__("content_#{name}")) - end - end - end - - def assert_trackback(attrs, target) - _wrap_assertion do - n_attrs = normalized_attrs(attrs) - if n_attrs["ping"] - assert_equal(n_attrs["ping"], target.trackback_ping) - end - if n_attrs["abouts"] - n_attrs["abouts"].each_with_index do |about, i| - assert_equal(about, target.trackback_abouts[i].value) - end - end - end - end - - def assert_taxo_topic(topics, target) - _wrap_assertion do - topics.each_with_index do |topic, i| - taxo_topic = target.taxo_topics[i] - topic.each do |name, value| - case name - when :link - assert_equal(value, taxo_topic.about) - assert_equal(value, taxo_topic.taxo_link) - when :topics - assert_equal(value, taxo_topic.taxo_topics.resources) - else - assert_equal(value, taxo_topic.__send__("dc_#{name}")) - end - end - end - end - end - - - def assert_attributes(attrs, names, target) - _wrap_assertion do - n_attrs = normalized_attrs(attrs) - names.each do |info| - if info.is_a?(String) - name = info - type = nil - else - name, type = info - end - value = n_attrs[name] - if value.is_a?(Time) - actual = target.__send__(name) - assert_instance_of(Time, actual) - assert_equal(value.to_i, actual.to_i) - elsif value - case type - when :integer - value = value.to_i - when :boolean - value = value == "true" if value.is_a?(String) - end - assert_equal(value, target.__send__(name)) - end - 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_exception = nil - feed = nil - begin - 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_exception = invalid_feed_checker.call(targets) - end - end - rescue RSS::Error - if invalid_feed_exception.is_a?(RSS::TooMuchTagError) - assert_too_much_tag(invalid_feed_exception.tag, - invalid_feed_exception.parent) do - raise - end - else - raise - end - end - - if invalid_feed_exception.nil? - 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 - - if feed_readers.first == "entries" - parent = "entry" - else - parent = feed_type - end - invalid_feed_checker = Proc.new do |targets| - infos = {} - invalid_exception = nil - targets.each do |target| - key = [target.hreflang, target.type] - if infos.has_key?(key) - invalid_exception = RSS::TooMuchTagError.new("link", parent) - break - end - infos[key] = true if target.rel.nil? or target.rel == "alternate" - end - invalid_exception - 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| - n_attrs[name.to_s] = value - end - n_attrs - end - - def combination(elements, n) - if n <= 0 or elements.size < n - [] - elsif n == 1 - elements.collect {|element| [element]} - else - first, *rest = elements - combination(rest, n - 1).collect do |sub_elements| - [first, *sub_elements] - end + combination(rest, n) - end - 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 |