roxml 1.2 → 2.3.2

data/test/unit/xml_hash_test.rb

@@ -0,0 +1,65 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class TestXMLHash < Test::Unit::TestCase
+  def setup
+    @contents = {'quaquaversally' => 'adjective: (of a geological formation) sloping downward from the center in all directions.',
+                 'tergiversate' => 'To use evasions or ambiguities; equivocate.'}
+  end
+
+  def test_attrs_hash
+    dict = DictionaryOfAttrs.from_xml(fixture(:dictionary_of_attrs))
+    assert_equal Hash, dict.definitions.class
+    assert_equal @contents, dict.definitions
+  end
+
+  def test_text_hash
+    dict = DictionaryOfTexts.from_xml(fixture(:dictionary_of_texts))
+    assert_equal Hash, dict.definitions.class
+    assert_equal @contents, dict.definitions
+  end
+
+  def test_mixed_content_hash
+    dict = DictionaryOfMixeds.from_xml(fixture(:dictionary_of_mixeds))
+    assert_equal Hash, dict.definitions.class
+    assert_equal @contents, dict.definitions
+  end
+
+  def test_name_hash
+    dict = DictionaryOfNames.from_xml(fixture(:dictionary_of_names))
+    assert_equal Hash, dict.definitions.class
+    assert_equal @contents, dict.definitions
+  end
+
+  def test_guarded_name_hash
+    dict = DictionaryOfGuardedNames.from_xml(fixture(:dictionary_of_guarded_names))
+    assert_equal Hash, dict.definitions.class
+    assert_equal @contents, dict.definitions
+  end
+
+  def test_text_name_clashes
+    dict = DictionaryOfNameClashes.from_xml(fixture(:dictionary_of_name_clashes))
+    assert_equal Hash, dict.definitions.class
+    assert_equal @contents, dict.definitions
+  end
+
+  def test_attr_name_clashes
+    dict = DictionaryOfAttrNameClashes.from_xml(fixture(:dictionary_of_attr_name_clashes))
+    assert_equal Hash, dict.definitions.class
+    assert_equal @contents, dict.definitions
+  end
+
+  def test_it_should_gracefully_handle_empty_hash
+    dict = Class.new do
+      include ROXML
+
+      xml_reader :missing_hash, {:key => :name, :value => :content}, :in => 'EmptyDictionary'
+    end
+
+    assert_equal({}, dict.from_xml(%{
+      <dict>
+        <EmptyDictionary>
+        </EmptyDictionary>
+      </dict>
+    }).missing_hash)
+  end
+end

data/test/unit/xml_initialize_test.rb

@@ -0,0 +1,50 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class BookWithXmlInitialize < BookWithDepth
+  attr_reader :created_at, :creator
+
+  def initialize(created_at, creator = "Unknown")
+    @created_at = created_at
+    @creator = creator
+  end
+  alias_method :xml_initialize, :initialize
+end
+
+class TestXMLInitialize < Test::Unit::TestCase
+  def test_xml_construct_not_in_use
+    assert Measurement.xml_construction_args_without_deprecation.empty?
+  end
+
+  def test_initialize_is_run
+    m = Measurement.from_xml('<measurement units="hundredths-meters">1130</measurement>')
+    assert_equal 11.3, m.value
+    assert_equal 'meters', m.units
+  end
+
+  def test_initialize_is_run_for_nested_type
+    b = BookWithDepth.from_xml(fixture(:book_with_depth))
+    assert_equal Measurement.new(11.3, 'meters'), b.depth
+  end
+
+  def test_initialize_is_run_for_nested_type_with_inheritance
+    b = InheritedBookWithDepth.from_xml(fixture(:book_with_depth))
+    assert_equal Measurement.new(11.3, 'meters'), b.depth
+  end
+
+  def test_initialize_fails_on_missing_required_arg
+    assert_raises(ArgumentError) do
+      b = BookWithXmlInitialize.from_xml(fixture(:book_with_depth))
+    end
+  end
+
+  def test_initialize_with_extra_args
+    now = Time.now
+    b = BookWithXmlInitialize.from_xml(fixture(:book_with_depth), now)
+    assert_equal now, b.created_at
+    assert_equal "Unknown", b.creator
+
+    b = BookWithXmlInitialize.from_xml(fixture(:book_with_depth), Time.now, "Joe Librarian")
+    assert now < b.created_at
+    assert_equal "Joe Librarian", b.creator
+  end
+end

data/test/unit/xml_name_test.rb

@@ -0,0 +1,108 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+#      Parent        |    Child
+#  :from  | no :from |
+# -------------------|--------------
+#  :from  | xml_name | xml_name-d
+#  value  |  value   |
+# -------------------|--------------
+#  :from  | parent's |
+#  value  | accessor | un-xml_name-d
+#         |  name    |
+
+class Child
+  include ROXML
+end
+
+class NamedChild
+  include ROXML
+
+  xml_name :xml_name_of_child
+end
+
+class ParentOfNamedChild
+  include ROXML
+
+  xml_name :parent
+  xml_accessor :child_accessor_name, NamedChild
+end
+
+class ParentOfNamedChildWithFrom
+  include ROXML
+
+  xml_name :parent
+  xml_accessor :child_accessor_name, NamedChild, :from => 'child_from_name'
+end
+
+class ParentOfUnnamedChild
+  include ROXML
+
+  xml_name :parent
+  xml_accessor :child_accessor_name, Child
+end
+
+class ParentOfUnnamedChildWithFrom
+  include ROXML
+
+  xml_name :parent
+  xml_accessor :child_accessor_name, Child, :from => 'child_from_name'
+end
+
+class TestXMLName < Test::Unit::TestCase
+  def test_from_always_dominates_attribute_name_xml_name_or_not
+    parent = ParentOfNamedChildWithFrom.new
+    parent.child_accessor_name = Child.new
+
+    assert_equal "<parent><child_from_name/></parent>", parent.to_xml.to_s.gsub(/[\n ]/, '')
+
+    parent = ParentOfUnnamedChildWithFrom.new
+    parent.child_accessor_name = Child.new
+
+    assert_equal "<parent><child_from_name/></parent>", parent.to_xml.to_s.gsub(/[\n ]/, '')
+  end
+
+  def test_attribute_name_comes_from_the_xml_name_value_if_present
+    parent = ParentOfNamedChild.new
+    parent.child_accessor_name = Child.new
+
+    assert_equal "<parent><xml_name_of_child/></parent>", parent.to_xml.to_s.gsub(/[\n ]/, '')
+  end
+
+  def test_attribute_name_comes_from_parent_accessor_by_default
+    parent = ParentOfUnnamedChild.new
+    parent.child_accessor_name = Child.new
+
+    assert_equal "<parent><child_accessor_name/></parent>", parent.to_xml.to_s.gsub(/[\n ]/, '')
+  end
+
+  def test_named_books_picked_up
+    named = Library.from_xml(fixture(:library))
+    assert named.books
+    assert_equal :book, named.books.first.tag_name
+  end
+
+  def test_nameless_books_missing
+    nameless = LibraryWithBooksOfUnderivableName.from_xml(fixture(:library))
+    assert nameless.novels.empty?
+  end
+
+  def test_tag_name
+    assert_equal :dictionary, DictionaryOfTexts.tag_name
+
+    dict = DictionaryOfTexts.from_xml(fixture(:dictionary_of_texts))
+
+    assert_equal :dictionary, dict.tag_name
+  end
+
+  def test_tag_refs
+    assert_equal 'definition', DictionaryOfTexts.tag_refs.only.name
+    assert_equal 'word', DictionaryOfTexts.tag_refs.only.hash.key.name
+    assert_equal 'meaning', DictionaryOfTexts.tag_refs.only.hash.value.name
+
+    dict = DictionaryOfTexts.from_xml(fixture(:dictionary_of_texts))
+
+    assert_equal 'definition', dict.tag_refs.only.name
+    assert_equal 'word', dict.tag_refs.only.hash.key.name
+    assert_equal 'meaning', dict.tag_refs.only.hash.value.name
+  end
+end

data/test/unit/xml_namespace_test.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class TestXMLNamespaces < Test::Unit::TestCase
+  def setup
+    @book = BookWithContributions.from_xml(fixture(:book_with_default_namespace))
+  end
+
+  def test_default_namespace_doesnt_interfere_with_normal_operation
+    assert_equal("Programming Ruby - 2nd Edition", @book.title)
+  end
+
+  def test_default_namespace_is_applied_to_in_element
+    expected_authors = ["David Thomas","Andrew Hunt","Chad Fowler"]
+    assert !@book.contributions.empty?
+    @book.contributions.each do |contributor|
+      assert expected_authors.include?(contributor.name)
+    end
+  end
+
+  def test_that_rexml_follows_nameless_default_namespace
+    require 'rexml/document'
+    xml = REXML::Document.new(
+      '<container xmlns="http://fakenamespace.org"><node>Yeah, content</node></container>')
+
+    assert_equal "Yeah, content", xml.root.get_elements('node').first.text
+  end
+
+  def test_default_namespace_on_root_node_should_be_found
+    require 'libxml'
+    xml = LibXML::XML::Parser.string(
+      '<container xmlns="http://defaultnamespace.org"><node>Yeah, content</node><node><subnode>Another</subnode></node></container>').parse
+
+    assert_equal nil, xml.find_first('node')
+    assert_equal "Yeah, content", xml.find_first('ns:node', 'ns:http://defaultnamespace.org').content
+    assert_equal nil, xml.find_first('ns:node/subnode', 'ns:http://defaultnamespace.org')
+    assert_equal "Another", xml.find_first('ns:node/ns:subnode', 'ns:http://defaultnamespace.org').content
+  end
+end

data/test/unit/xml_object_test.rb

@@ -0,0 +1,116 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class TestXMLObject < Test::Unit::TestCase
+  # Test book with text and attribute
+  def test_book_author_text_attribute
+    book = BookWithAuthorTextAttribute.from_xml(fixture(:book_text_with_attribute))
+    assert_equal("primary",book.author.role)
+    assert_equal("David Thomas",book.author.text)
+  end
+
+  # Test XML object containing list of other XML objects (one-to-many)
+  # In this case, book with contibutions
+  def test_one_to_many_with_container
+    expected_authors = ["David Thomas","Andrew Hunt","Chad Fowler"]
+    book = BookWithContributions.from_xml(fixture(:book_with_contributions))
+    assert_equal("Programming Ruby - 2nd Edition", book.title)
+    book.contributions.each do |contributor|
+      assert expected_authors.include?(contributor.name)
+    end
+  end
+
+  # Test XML object containing 1-n other XML objects without container (one-to-many)
+  # In this case, book with contibutions
+  def test_one_to_many_without_container
+    expected_contributors = ["David Thomas","Andrew Hunt","Chad Fowler"]
+    book = BookWithContributors.from_xml(fixture(:book_with_contributors))
+    assert_equal("Programming Ruby - 2nd Edition", book.title)
+    book.contributors.each do |contributor|
+      assert(expected_contributors.include?(contributor.name))
+    end
+  end
+
+  # when building objects that contain arrays, the second object seems to
+  # inherit data from the first
+  #
+  def test_one_to_many_without_container_sequence
+    contrib = WriteableContributor.new
+    contrib.name = "David Thomas"
+
+    book_one = WriteableBookWithContributors.new
+    book_one.isbn = "9781843549161"
+    book_one.title = "Anathem"
+    book_one.description = "A new title from Neal Stephenson"
+    book_one.contributors << contrib
+
+    # this book should be completely empty
+    book_two = WriteableBookWithContributors.new
+
+    assert_equal(nil, book_two.isbn)
+    assert_equal(nil, book_two.title)
+    assert_equal(nil, book_two.description)
+    assert_equal(0, book_two.contributors.size)
+  end
+
+  # Test XML object containing one other XML object (one-to-one)
+  # In this case, book with publisher
+  def test_one_to_one
+    book = BookWithPublisher.from_xml(fixture(:book_with_publisher))
+    assert_equal("Programming Ruby - 2nd Edition", book.title)
+    assert_equal("Pragmatic Bookshelf", book.publisher.name)
+  end
+
+  # Test XML object containing type of self (self-reference)
+  def test_self_reference
+    book = BookPair.from_xml(fixture(:book_pair))
+    assert_equal("Programming Ruby - 2nd Edition", book.title)
+    assert_equal("Agile Web Development with Rails", book.book.title)
+  end
+
+  # Test three-level composition (one-to-many-to-many)
+  def test_one_to_many_to_many
+    expected_contributors = ["David Thomas","Andrew Hunt","Chad Fowler", "David Heinemeier Hansson"]
+    expected_books = ["Programming Ruby - 2nd Edition", "Agile Web Development with Rails"]
+    library = Library.from_xml(fixture(:library))
+    assert_equal("Ruby library", library.name)
+    assert !library.books.empty?
+    library.books.each do |book|
+      assert expected_books.include?(book.title)
+      book.contributions.each do |contributor|
+        assert(expected_contributors.include?(contributor.name))
+      end
+    end
+  end
+
+  def test_without_needed_from
+    assert_equal [], UppercaseLibrary.from_xml(fixture(:library)).books
+    assert_equal [], Library.from_xml(fixture(:library_uppercase)).books
+  end
+
+  def test_with_needed_from
+    assert Library.from_xml(fixture(:library)).books
+    assert UppercaseLibrary.from_xml(fixture(:library_uppercase)).books
+  end
+
+  def test_with_recursion
+    p = PersonWithMother.from_xml(fixture(:person_with_mothers))
+    assert_equal 'Ben Franklin', p.name
+    assert_equal 'Abiah Folger', p.mother.name
+    assert_equal 'Madeup Mother', p.mother.mother.name
+    assert_equal nil, p.mother.mother.mother
+  end
+
+  def test_with_guarded_recursion
+    p = PersonWithGuardedMother.from_xml(fixture(:person_with_guarded_mothers))
+    assert_equal 'Ben Franklin', p.name
+    assert_equal 'Abiah Folger', p.mother.name
+    assert_equal 'Madeup Mother', p.mother.mother.name
+    assert_equal nil, p.mother.mother.mother
+  end
+
+  def test_recursive_with_default_initialization
+    p = PersonWithMotherOrMissing.from_xml(fixture(:person_with_mothers))
+    assert_equal 'Unknown', p.mother.mother.mother.name
+    assert_equal Person, p.mother.mother.mother.class
+  end
+end

data/test/unit/xml_required_test.rb

@@ -0,0 +1,93 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class TestXMLRequired < Test::Unit::TestCase
+  def setup
+    @full_book = <<BOOK
+  <book ISBN="1234">
+    <title>This &amp; that</title>
+    <contributor_array>
+      <contributor role="Author">
+        <name>Johnny</name>
+      </contributor>
+    </contributor_array>
+    <contributor_hash>
+      <contributor role="Author" name="Johnny" />
+    </contributor_hash>
+  </book>
+BOOK
+
+    @book_missing_attr = <<BOOK
+  <book>
+    <title>This &amp; that</title>
+    <contributor_array>
+      <contributor role="Author">
+        <name>Johnny</name>
+      </contributor>
+    </contributor_array>
+    <contributor_hash>
+      <contributor role="Author" name="Johnny" />
+    </contributor_hash>
+  </book>
+BOOK
+
+    @book_missing_text = <<BOOK
+  <book ISBN="1234">
+    <contributor_array>
+      <contributor role="Author">
+        <name>Johnny</name>
+      </contributor>
+    </contributor_array>
+    <contributor_hash>
+      <contributor role="Author" name="Johnny" />
+    </contributor_hash>
+  </book>
+BOOK
+
+    @book_missing_array = <<BOOK
+  <book ISBN="1234">
+    <title>This &amp; that</title>
+    <contributor_hash>
+      <contributor role="Author" name="Johnny" />
+    </contributor_hash>
+  </book>
+BOOK
+
+    @book_missing_hash = <<BOOK
+  <book ISBN="1234">
+    <title>This &amp; that</title>
+    <contributor_array>
+      <contributor role="Author">
+        <name>Johnny</name>
+      </contributor>
+    </contributor_array>
+  </book>
+BOOK
+  end
+
+  def test_required_passes_on_prescence
+    BookWithRequired.from_xml(@full_book)
+  end
+
+  def test_required_throws_on_attr_absence
+    assert_raise ROXML::RequiredElementMissing do
+      BookWithRequired.from_xml(@book_missing_attr)
    end
+  end
+
+  def test_required_throws_on_text_absence
+    assert_raise ROXML::RequiredElementMissing do
+      BookWithRequired.from_xml(@book_missing_text)
+    end
+  end
+
+  def test_required_throws_on_array_absence
+    assert_raise ROXML::RequiredElementMissing do
+      BookWithRequired.from_xml(@book_missing_array)
+    end
+  end
+
+  def test_required_throws_on_hash_absence
+    assert_raise ROXML::RequiredElementMissing do
+      BookWithRequired.from_xml(@book_missing_hash)
+    end
+  end
+end