roxml 1.2 → 2.3.2

data/test/unit/inheritance_test.rb

@@ -0,0 +1,19 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class TestInheritance < Test::Unit::TestCase
+  def setup
+    @b = InheritedBookWithDepth.from_xml(fixture(:book_with_depth))
+  end
+
+  def test_inherited_object_should_include_parents_attributes
+    assert_equal '0201710897', @b.isbn
+    assert_equal 'The PickAxe', @b.title
+    assert_equal 'Probably the best Ruby book out there', @b.description
+    assert_equal 'David Thomas, Andrew Hunt, Dave Thomas', @b.author
+    assert_equal 0, @b.pages
+  end
+
+  def test_inherited_object_should_include_its_own_attributes
+    assert_equal '11.3 meters', @b.depth.to_s
+  end
+end

data/test/unit/options_test.rb

@@ -0,0 +1,102 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class TestOptions < Test::Unit::TestCase
+  def test_text_in_array_means_as_array_for_text
+    opts = ROXML::Opts.new(:authors, [:text])
+    assert opts.array?
+    assert_equal :text, opts.type
+  end
+
+  def test_attr_in_array_means_as_array_for_attr
+    opts = ROXML::Opts.new(:authors, [:attr])
+    assert opts.array?
+    assert_equal :attr, opts.type
+  end
+
+  def test_object_in_array_means_as_array_for_object
+    opts = ROXML::Opts.new(:authors, [Hash])
+    assert opts.array?
+    assert_equal Hash, opts.type
+  end
+
+  def test_content_is_a_recognized_type
+    assert ROXML::Opts.new(:author, :content).content?
+  end
+
+  def test_required
+    assert !ROXML::Opts.new(:author, :content).required?
+    assert ROXML::Opts.new(:author, :content, :required => true).required?
+    assert !ROXML::Opts.new(:author, :content, :required => false).required?
+  end
+
+  def test_required_conflicts_with_else
+    assert_raise ArgumentError do
+      ROXML::Opts.new(:author, :content, :required => true, :else => 'Johnny')
+    end
+    ROXML::Opts.new(:author, :content, :required => false, :else => 'Johnny')
+  end
+
+  def test_hash_of_attrs
+    opts = ROXML::Opts.new(:attributes, {:attrs => [:name, :value]})
+    assert opts.hash?
+    assert !opts.array?
+    assert_equal [ROXML::XMLAttributeRef, ROXML::XMLAttributeRef], opts.hash.types
+    assert_equal ['name', 'value'], opts.hash.names
+  end
+
+  def test_hash_with_attr_key_and_text_val
+    opts = ROXML::Opts.new(:attributes, {:key => {:attr => :name},
+                                         :value => :value})
+    assert opts.hash?
+    assert !opts.array?
+    assert_equal [ROXML::XMLAttributeRef, ROXML::XMLTextRef], opts.hash.types
+    assert_equal ['name', 'value'], opts.hash.names
+  end
+
+  def test_hash_with_attr_key_and_content_val
+    opts = ROXML::Opts.new(:attributes, {:key => {:attr => :name},
+                                         :value => :content})
+    assert opts.hash?
+    assert !opts.array?
+    assert opts.hash.value.content?
+    assert_equal [ROXML::XMLAttributeRef, ROXML::XMLTextRef], opts.hash.types
+    assert_equal ['name', ''], opts.hash.names
+  end
+
+  def test_hash_with_options
+    opts = ROXML::Opts.new(:definitions, {:attrs => [:dt, :dd]},
+                           :in => :definitions)
+
+    assert opts.hash?
+    assert !opts.array?
+    assert_equal [ROXML::XMLAttributeRef, ROXML::XMLAttributeRef], opts.hash.types
+    assert_equal ['dt', 'dd'], opts.hash.names
+  end
+
+  def test_no_block_shorthand_means_no_block
+    assert ROXML::Opts.new(:count).blocks.empty?
+    assert ROXML::Opts.new(:count, :as => :intager).blocks.empty?
+    assert ROXML::Opts.new(:count, :as => :foat).blocks.empty?
+  end
+
+  def test_block_integer_shorthand
+    assert_equal 3, ROXML::Opts.new(:count, :as => :integer).blocks.only['3']
+    assert_equal 3, ROXML::Opts.new(:count, :as => Integer).blocks.only['3']
+  end
+
+  def test_block_float_shorthand
+    assert_equal 3.1, ROXML::Opts.new(:count, :as => :float).blocks.only['3.1']
+    assert_equal 3.1, ROXML::Opts.new(:count, :as => Float).blocks.only['3.1']
+  end
+
+  def test_multiple_shorthands_raises
+    assert_raises ArgumentError do
+      ROXML::Opts.new(:count, :as => [Float, Integer])
+    end
+  end
+
+  def test_stacked_blocks
+    assert_equal 2, ROXML::Opts.new(:count, :as => Integer) {|val| val.to_i }.blocks.size
+    assert_equal 2, ROXML::Opts.new(:count, :as => Float) {|val| val.object_id }.blocks.size
+  end
+end

data/test/unit/roxml_test.rb

@@ -0,0 +1,24 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class TestROXML < Test::Unit::TestCase
+  # Malformed XML parsing should throw REXML::ParseException
+  def test_malformed
+    ROXML::XML::Parser.register_error_handler {|err| }
+    assert_raise ROXML::XML::Parser::ParseError do
+      book = Book.from_xml(fixture(:book_malformed))
+    end
+  end
+
+  # Verify that an exception is thrown when two accessors have the same
+  # name in a ROXML class.
+  def test_duplicate_accessor
+    assert_raise RuntimeError do
+      Class.new do
+        include ROXML
+
+        xml_reader :id
+        xml_accessor :id
+      end
+    end
+  end
+end

data/test/unit/string_test.rb

@@ -0,0 +1,11 @@
+require 'lib/roxml/extensions/string'
+
+class TestROXML < Test::Unit::TestCase
+  def test_to_latin_is_accessible
+    assert String.instance_methods.include?('to_latin')
+  end
+
+  def test_to_utf_is_accessible
+    assert String.instance_methods.include?('to_utf')
+  end
+end

data/test/unit/to_xml_test.rb

@@ -0,0 +1,52 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class TestHashToXml < Test::Unit::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 < Test::Unit::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 < Test::Unit::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::Parser.parse(xml).root, dict.to_xml
+  end
+end
+
+class TestToXmlWithBlocks < Test::Unit::TestCase
+  def test_pagecount_serialized_properly_after_modification
+    b = Book.from_xml(fixture(:book_valid))
+    xml = xml_fixture(:book_valid)
+    assert_equal '357', xml.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.search('pagecount').first.content
+  end
+end

data/test/unit/xml_attribute_test.rb

@@ -0,0 +1,39 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class TestXMLAttribute < Test::Unit::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 File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class ArrayWithBlockShorthand
+  include ROXML
+
+  xml_reader :array, [:text], :from => 'number', :as => Integer
+end
+
+class ArrayWithBlock
+  include ROXML
+
+  xml_reader :array, [:text], :from => 'number' do |arr|
+    arr.map(&:to_i).reverse
+  end
+end
+
+class TestXMLBlocks < Test::Unit::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,105 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class XmlBool
+  include ROXML
+
+  xml_reader :true_from_TRUE?
+  xml_reader :false_from_FALSE?, :text => 'text_for_FALSE'
+  xml_reader :true_from_one?, :attr => 'attr_for_one'
+  xml_reader :false_from_zero?, :text => 'text_for_zero', :in => 'container'
+  xml_reader :true_from_True?, :attr => 'attr_for_True', :in => 'container'
+  xml_reader :false_from_False?, :text => 'false_from_cdata_False', :as => :cdata
+  xml_reader :true_from_true?
+  xml_reader :false_from_false?
+  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>
+    <present_and_required>true</present_and_required>
+  </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 < Test::Unit::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_raises(ROXML::RequiredElementMissing) do
+      XmlBoolRequired.from_xml(ABSENT)
+    end
+  end
+
+#  to_xml_test XmlBool => BOOL_XML
+end

data/test/unit/xml_construct_test.rb

@@ -0,0 +1,77 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class MeasurementWithXmlConstruct
+  include ROXML
+
+  xml_reader :units, :attr
+  xml_reader :value, :content
+
+  xml_construct_without_deprecation :value, :units
+
+  def initialize(value, units = 'pixels')
+    @value = Float(value)
+    @units = units.to_s
+    if @units.starts_with? 'hundredths-'
+      @value /= 100
+      @units = @units.split('hundredths-')[1]
+    end
+  end
+
+  def ==(other)
+    other.units == @units && other.value == @value
+  end
+end
+
+class BookWithDepthWithXmlConstruct
+  include ROXML
+
+  xml_reader :isbn, :attr => 'ISBN'
+  xml_reader :title
+  xml_reader :description, :as => :cdata
+  xml_reader :author
+  xml_reader :depth, MeasurementWithXmlConstruct
+end
+
+class InheritedBookWithDepthWithXmlConstruct < Book
+  xml_reader :depth, MeasurementWithXmlConstruct
+end
+
+class TestXMLConstruct < Test::Unit::TestCase
+  def test_is_deprecated
+    assert_deprecated do
+      MeasurementWithXmlConstruct.xml_construction_args
+    end
+  end
+
+  def test_initialize_is_run
+    m = MeasurementWithXmlConstruct.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 = BookWithDepthWithXmlConstruct.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 = InheritedBookWithDepthWithXmlConstruct.from_xml(fixture(:book_with_depth))
+    assert_equal Measurement.new(11.3, 'meters'), b.depth
+  end
+
+  def test_xml_name_uses_accessor_not_name
+    assert_nothing_raised do
+      Class.new do
+        include ROXML
+
+        xml_reader :bar, :attr => 'Foo'
+        xml_reader :foo, :text => 'Foo'
+        xml_reader :baz, :attr => 'Bar'
+
+        xml_construct_without_deprecation :baz, :bar, :foo
+        def initialize(baz, bar, foo)
+        end
+      end
+    end
+  end
+end