yob-roxml 3.1.6

data/test/unit/deprecations_test.rb

@@ -0,0 +1,24 @@
+require 'test/test_helper'
+
+class TestDeprecation < ActiveSupport::TestCase
+  def test_as_array_not_deprecated
+    assert_not_deprecated do
+      opts = ROXML::Definition.new(:name, :as => [])
+      assert_equal :text, opts.sought_type
+      assert opts.array?
+    end
+  end
+
+  def test_as_hash_not_deprecated
+    assert_not_deprecated do
+      opts = ROXML::Definition.new(:name, :as => {:key => '@dt', :value => '@dd'})
+      assert opts.hash?
+    end
+  end
+
+  def test_as_object_with_from_xml_not_deprecated
+    assert_not_deprecated do
+      ROXML::Definition.new(:name, :as => OctalInteger)
+    end
+  end
+end

data/test/unit/to_xml_test.rb

@@ -0,0 +1,81 @@
+require 'test/test_helper'
+
+class TestHashToXml < ActiveSupport::TestCase
+  to_xml_test :dictionary_of_attrs,
+              :dictionary_of_mixeds,
+              :dictionary_of_texts,
+              :dictionary_of_names,
+              :dictionary_of_guarded_names,
+              :dictionary_of_name_clashes,
+              :dictionary_of_attr_name_clashes
+end
+
+class TestOtherToXml < ActiveSupport::TestCase
+  to_xml_test :book => :book_valid,
+              :book_with_author_text_attribute => :book_text_with_attribute,
+              :uppercase_library => :library_uppercase
+
+  to_xml_test :book_with_authors,
+              :book_with_contributors,
+              :book_with_contributions,
+              :library,
+              :node_with_name_conflicts,
+              :node_with_attr_name_conflicts
+
+  to_xml_test :person_with_mother => :person_with_mothers,
+              :person_with_guarded_mother => :person_with_guarded_mothers
+
+  to_xml_test :book_with_wrapped_attr
+end
+
+class TestToXmlWithDefaults < ActiveSupport::TestCase
+  def test_content_and_attr_defaults_are_represented_in_output
+    dict = Person.from_xml(fixture(:nameless_ageless_youth))
+
+    xml = '<person age="21">Unknown</person>'
+    assert_equal ROXML::XML.parse_string(xml).root.to_s, dict.to_xml.to_s
+  end
+end
+
+class TestToXmlWithBlocks < ActiveSupport::TestCase
+  def test_pagecount_serialized_properly_after_modification
+    b = Book.from_xml(fixture(:book_valid))
+    xml = xml_fixture(:book_valid)
+    assert_equal '357', xml.roxml_search('pagecount').first.content
+    assert_equal 357, b.pages
+
+    b.pages = 500
+    doc = ROXML::XML::Document.new()
+    doc.root = b.to_xml
+    assert_equal '500', doc.roxml_search('pagecount').first.content
+  end
+end
+
+class OctalInteger
+  def self.from_xml(val)
+    new(Integer(val.content))
+  end
+
+  def initialize(value)
+    @val = value
+  end
+
+  def ==(other)
+    @val == other
+  end
+
+  def to_xml
+    sprintf("%#o", @val)
+  end
+end
+
+class BookWithOctalPages
+  include ROXML
+
+  xml_accessor :pages_with_to_xml_proc, :as => Integer, :to_xml => proc {|val| sprintf("%#o", val) }, :required => true
+  xml_accessor :pages_with_type, :as => OctalInteger, :required => true
+end
+
+class TestToXmlWithOverriddenOutput < ActiveSupport::TestCase
+  to_xml_test :book_with_octal_pages
+end

data/test/unit/xml_attribute_test.rb

@@ -0,0 +1,39 @@
+require 'test/test_helper'
+
+class TestXMLAttribute < ActiveSupport::TestCase
+  def test_attr_from
+    # :attr => *
+    book = Book.from_xml(fixture(:book_text_with_attribute))
+    assert_equal '0201710897', book.isbn
+
+    # :attr, :from => *
+    book = BookWithAttrFrom.from_xml(fixture(:book_text_with_attribute))
+    assert_equal '0201710897', book.isbn
+  end
+
+  def test_mutable_attr
+    book = Book.from_xml(fixture(:book_text_with_attribute))
+    assert book.respond_to?(:'isbn=')
+  end
+
+  def test_default_initialization
+    person = PersonWithMotherOrMissing.from_xml(fixture(:nameless_ageless_youth))
+    assert_equal 21, person.age
+  end
+
+  def test_recursive_with_default_initialization
+    p = PersonWithMotherOrMissing.from_xml(fixture(:person_with_mothers))
+    assert_equal 21, p.mother.mother.mother.age
+  end
+
+  def test_no_name_clashes
+    n = NodeWithAttrNameConflicts.from_xml(fixture(:node_with_attr_name_conflicts))
+    assert_equal "Just junk... really", n.content
+    assert_equal "Cartwheel", n.name
+  end
+
+  def test_wrapped_attr_accessible
+    b = BookWithWrappedAttr.from_xml(fixture(:book_with_wrapped_attr))
+    assert_equal "0974514055", b.isbn
+  end
+end

data/test/unit/xml_block_test.rb

@@ -0,0 +1,81 @@
+require 'test/test_helper'
+
+class ArrayWithBlockShorthand
+  include ROXML
+
+  xml_reader :array, :as => [Integer], :from => 'number'
+end
+
+class ArrayWithBlock
+  include ROXML
+
+  xml_reader :array, :as => [], :from => 'number' do |arr|
+    arr.map(&:to_i).reverse
+  end
+end
+
+class TestXMLBlocks < ActiveSupport::TestCase
+  def test_block_is_applied
+    muffins = Muffins.from_xml(fixture(:muffins))
+
+    assert muffins.count > 0
+    assert_equal 0, muffins.count % 13
+  end
+
+  def test_block_is_applied_to_hash
+    numerology = Numerology.from_xml(fixture(:numerology))
+
+    assert !numerology.predictions.keys.empty?
+    assert numerology.predictions.keys.all? {|k| k.is_a? Integer }
+    assert numerology.predictions.values.all? {|k| k.is_a? String }
+  end
+
+  def test_stacked_blocks_are_applied
+    muffins = MuffinsWithStackedBlocks.from_xml(fixture(:muffins))
+
+    assert muffins.count > 0
+    assert_equal 0, muffins.count % 13
+  end
+
+  def test_block_shorthand_applied_properly_to_array
+    obj = ArrayWithBlockShorthand.from_xml(%{
+      <array_with_block_shorthand>
+        <number>1</number>
+        <number>2</number>
+        <number>3</number>
+      </array_with_block_shorthand>
+    })
+
+    assert_equal [1, 2, 3], obj.array
+  end
+
+  def test_block_applied_properly_to_array
+    obj = ArrayWithBlock.from_xml(%{
+      <array_with_block>
+        <number>1</number>
+        <number>2</number>
+        <number>3</number>
+      </array_with_block>
+    })
+
+    assert_equal [3, 2, 1], obj.array
+  end
+
+  def test_block_shorthand_applied_properly_to_empty_array
+    obj = ArrayWithBlockShorthand.from_xml(%{
+      <array_with_block_shorthand>
+      </array_with_block_shorthand>
+    })
+
+    assert_equal [], obj.array
+  end
+
+  def test_block_applied_properly_to_empty_array
+    obj = ArrayWithBlock.from_xml(%{
+      <array_with_block>
+      </array_with_block>
+    })
+
+    assert_equal [], obj.array
+  end
+end

data/test/unit/xml_bool_test.rb

@@ -0,0 +1,122 @@
+require 'test/test_helper'
+
+PROC_TRUE = proc {|val| val ? 'TRUE' : 'FALSE'}
+PROC_True = proc {|val| val ? 'True' : 'False'}
+PROC_true = proc {|val| val.to_s}
+PROC_1    = proc {|val| val ? 1 : 0}
+
+class XmlBool
+  include ROXML
+
+  xml_name 'xml_bool'
+  xml_reader :true_from_TRUE?, :to_xml => PROC_TRUE
+  xml_reader :false_from_FALSE?, :from => 'text_for_FALSE', :to_xml => PROC_TRUE
+  xml_reader :true_from_one?, :from => '@attr_for_one', :to_xml => PROC_1
+  xml_reader :false_from_zero?, :from => 'text_for_zero', :in => 'container', :to_xml => PROC_1
+  xml_reader :true_from_True?, :from => '@attr_for_True', :in => 'container', :to_xml => PROC_True
+  xml_reader :false_from_False?, :from => 'false_from_cdata_False', :cdata => true, :to_xml => PROC_True
+  xml_reader :true_from_true?, :to_xml => PROC_true
+  xml_reader :false_from_false?, :to_xml => PROC_true
+  xml_reader :missing?
+end
+
+class XmlBoolRequired
+  include ROXML
+
+  xml_reader :required?, :required => true
+end
+
+class XmlBoolUnexpected
+  include ROXML
+
+  xml_reader :unexpected?
+end
+
+class XmlBoolUnexpectedWithBlock
+  include ROXML
+
+  xml_reader :unexpected? do |val|
+    val
+  end
+end
+
+BOOL_XML = %{
+  <xml_bool attr_for_one="1">
+    <true_from_TRUE>TRUE</true_from_TRUE>
+    <text_for_FALSE>FALSE</text_for_FALSE>
+    <container attr_for_True="True">
+      <text_for_zero>0</text_for_zero>
+    </container>
+    <false_from_cdata_False><![CDATA[False]]></false_from_cdata_False>
+    <true_from_true>true</true_from_true>
+    <false_from_false>false</false_from_false>
+  </xml_bool>
+}
+PRESENT = %{
+  <xml_bool_required>
+    <required>true</required>
+  </xml_bool_required>
+}
+ABSENT = %{
+  <xml_bool_required>
+  </xml_bool_required>
+}
+UNEXPECTED_VALUE_XML = %{
+  <xml_bool_unexpected>
+    <unexpected>Unexpected Value</unexpected>
+  </xml_bool_unexpected>
+}
+
+
+class TestXMLBool < ActiveSupport::TestCase
+  def test_bool_results_for_various_inputs
+    x = XmlBool.from_xml(BOOL_XML)
+    assert_equal true, x.true_from_TRUE?
+    assert_equal false, x.false_from_FALSE?
+    assert_equal true, x.true_from_one?
+    assert_equal false, x.false_from_zero?
+    assert_equal true, x.true_from_True?
+    assert_equal false, x.false_from_False?
+    assert_equal true, x.true_from_true?
+    assert_equal false, x.false_from_false?
+  end
+
+  def test_missing_results_in_nil
+    x = XmlBool.from_xml(BOOL_XML)
+    assert_equal nil, x.missing?
+  end
+
+  def test_unexpected_value_results_in_nil
+    x = XmlBoolUnexpected.from_xml(UNEXPECTED_VALUE_XML)
+    assert_equal nil, x.unexpected?
+  end
+
+  def test_block_recieves_unexpected_value_rather_than_nil
+    x = XmlBoolUnexpectedWithBlock.from_xml(UNEXPECTED_VALUE_XML)
+    assert_equal "Unexpected Value", x.unexpected?
+  end
+
+  def test_required_raises_on_missing
+    assert_nothing_raised do
+      XmlBoolRequired.from_xml(PRESENT)
+    end
+
+    assert_raise ROXML::RequiredElementMissing do
+      XmlBoolRequired.from_xml(ABSENT)
+    end
+  end
+
+  def test_writable_references_properly_handle_punctuation
+    klass = Class.new do
+      include ROXML
+      xml_accessor :punctuation?
+    end
+
+    instance = klass.from_xml("<xml><punctuation>True</punctuation></xml>")
+    assert_equal true, instance.punctuation?
+    instance.punctuation = false
+    assert_equal false, instance.punctuation?
+  end
+
+  to_xml_test XmlBool => BOOL_XML
+end

data/test/unit/xml_convention_test.rb

@@ -0,0 +1,150 @@
+require 'test/test_helper'
+
+XML_CAMELLOWER = %{
+  <bookCase name="Jonas' Books">
+    <bookCount>12</bookCount>
+    <bigBooks>
+      <bigBook>GED</bigBook>
+      <bigBook>House of Leaves</bigBook>
+    </bigBooks>
+  </bookCase>
+}
+
+XML_CAMELCASE = %{
+  <BookCase Name="Jonas' Books">
+    <BookCount>12</BookCount>
+    <BigBooks>
+      <BigBook>GED</BigBook>
+      <BigBook>House of Leaves</BigBook>
+    </BigBooks>
+  </BookCase>
+}
+
+XML_UNDERSCORE = %{
+  <book_case name="Jonas' Books">
+    <book_count>12</book_count>
+    <big_books>
+      <big_book>GED</big_book>
+      <big_book>House of Leaves</big_book>
+    </big_books>
+  </book_case>
+}
+
+XML_DASHES = %{
+  <book-case name="Jonas' Books">
+    <book-count>12</book-count>
+    <big-books>
+      <big-book>GED</big-book>
+      <big-book>House of Leaves</big-book>
+    </big-books>
+  </book-case>
+}
+
+XML_UPCASE = %{
+  <BOOKCASE NAME="Jonas' Books">
+    <BOOKCOUNT>12</BOOKCOUNT>
+    <BIGBOOKS>
+      <BIGBOOK>GED</BIGBOOK>
+      <BIGBOOK>House of Leaves</BIGBOOK>
+    </BIGBOOKS>
+  </BOOKCASE>
+}
+
+class BookCase
+  include ROXML
+
+  xml_reader :book_count, :as => Integer, :required => true
+  xml_reader :big_books, :as => [], :required => true
+end
+
+class BookCaseCamelCase < BookCase
+  xml_convention :camelcase
+end
+
+class BookCaseUnderScore < BookCase
+  xml_convention :underscore
+end
+
+class BookCaseDashes < BookCase
+  xml_convention &:dasherize
+end
+
+class BookCaseCamelLower < BookCase
+  xml_convention {|val| val.camelcase(:lower) }
+end
+
+class BookCaseUpCase < BookCase
+  xml_convention {|val| val.gsub('_', '').upcase }
+end
+
+class InheritedBookCaseCamelCase < BookCaseCamelCase
+end
+
+class InheritedBookCaseUpCase < BookCaseUpCase
+end
+
+# Same as BookCase.  Needed to keep BookCase clean for other tests
+class ParentBookCaseDefault
+  include ROXML
+
+  xml_reader :book_count, :as => Integer, :required => true
+  xml_reader :big_books, :as => [], :required => true
+end
+
+class InheritedBookCaseDefault < ParentBookCaseDefault
+end
+
+class TestXMLConvention < ActiveSupport::TestCase
+  # TODO: Test convention applies to xml_name as well...
+
+  def test_default_convention_is_underscore
+    bc = BookCase.from_xml(XML_UNDERSCORE)
+    assert_has_book_case_info(bc)
+  end
+
+  [BookCaseUpCase, BookCaseCamelLower, BookCaseDashes, BookCaseUnderScore, BookCaseCamelCase].each do |klass|
+    define_method(:"test_xml_convention_#{klass.to_s.underscore}") do
+      data = :"XML_#{klass.to_s.sub('BookCase', '').upcase}"
+      assert_equal Proc, klass.roxml_naming_convention.class
+
+      bc = klass.from_xml(Object.const_get(data))
+      assert_has_book_case_info(bc)
+    end
+  end
+
+  def test_child_should_inherit_convention_if_it_doesnt_declare_one
+    [InheritedBookCaseUpCase, InheritedBookCaseCamelCase].each do |klass|
+      data = :"XML_#{klass.to_s.sub('InheritedBookCase', '').upcase}"
+      assert_equal Proc, klass.roxml_naming_convention.class
+
+      bc = klass.from_xml(Object.const_get(data))
+      assert_has_book_case_info(bc)
+    end
+  end
+
+  def test_child_should_inherit_convention_even_if_it_is_added_after_child_declaration
+    bc = InheritedBookCaseDefault.from_xml(XML_UNDERSCORE)
+    assert_has_book_case_info(bc)
+
+    ParentBookCaseDefault.class_eval do
+      xml_convention :dasherize
+    end
+
+    bc = InheritedBookCaseDefault.from_xml(XML_DASHES)
+    assert_has_book_case_info(bc)
+    assert_raise ROXML::RequiredElementMissing do
+      InheritedBookCaseDefault.from_xml(XML_UNDERSCORE)
+    end
+  end
+
+  def test_tag_name_should_get_convention_treatment_as_well
+    assert_equal "book-case-dashes", BookCaseDashes.tag_name
+    assert_equal "INHERITEDBOOKCASEUPCASE", InheritedBookCaseUpCase.tag_name
+    assert_equal "InheritedBookCaseCamelCase", InheritedBookCaseCamelCase.tag_name
+  end
+
+  def assert_has_book_case_info(bc)
+    assert_equal 12, bc.book_count
+    assert_equal ['GED', 'House of Leaves'], bc.big_books
+  end
+end