representable 3.2.0 → 3.3.0

data/test/xml_test.rb

@@ -1,5 +1,4 @@
-require 'test_helper'
-
+require "test_helper"
 
 class XmlPublicMethodsTest < Minitest::Spec
   #---
@@ -10,32 +9,30 @@ class XmlPublicMethodsTest < Minitest::Spec
     property :name
   end
 
-  let(:data) { %{<data><id>1</id><name>Rancid</name></data>} }
+  let(:data) { %{<band><id>1</id><name>Rancid</name></band>} }
 
-  it { _(BandRepresenter.new(Band.new).from_xml(data)[:id, :name]).must_equal ["1", "Rancid"] }
-  it { _(BandRepresenter.new(Band.new).parse(data)[:id, :name]).must_equal ["1", "Rancid"] }
+  it { _(BandRepresenter.new(Band.new).from_xml(data)[:id, :name]).must_equal %w[1 Rancid] }
+  it { _(BandRepresenter.new(Band.new).parse(data)[:id, :name]).must_equal %w[1 Rancid] }
 
   #---
   # to_hash
   let(:band) { Band.new("1", "Rancid") }
 
-  it { BandRepresenter.new(band).to_xml.must_equal_xml data }
-  it { BandRepresenter.new(band).render.must_equal_xml data }
+  it { assert_xml_equal(BandRepresenter.new(band).to_xml, data) }
+  it { assert_xml_equal(BandRepresenter.new(band).render, data) }
 end
 
-class XmlTest < MiniTest::Spec
-
+class XmlTest < Minitest::Spec
   class Band
     include Representable::XML
     property :name
     attr_accessor :name
 
-    def initialize(name=nil)
+    def initialize(name = nil)
       name and self.name = name
     end
   end
 
-
   XML = Representable::XML
   Def = Representable::Definition
 
@@ -52,7 +49,6 @@ class XmlTest < MiniTest::Spec
       @band = @Band.new
     end
 
-
     describe "#from_xml" do
       before do
         @band = @Band.new
@@ -61,7 +57,7 @@ class XmlTest < MiniTest::Spec
 
       it "parses XML and assigns properties" do
         @band.from_xml(@xml)
-        assert_equal ["Nofx", "NOFX"], [@band.name, @band.label]
+        assert_equal %w[Nofx NOFX], [@band.name, @band.label]
       end
     end
 
@@ -74,7 +70,7 @@ class XmlTest < MiniTest::Spec
 
       it "parses with xmlns present" do
         @band.from_xml(@xml)
-        assert_equal ["Nofx", "NOFX"], [@band.name, @band.label]
+        assert_equal %w[Nofx NOFX], [@band.name, @band.label]
       end
     end
 
@@ -86,18 +82,16 @@ class XmlTest < MiniTest::Spec
 
       it "receives Nokogiri node and assigns properties" do
         @band.from_node(@xml)
-        assert_equal ["Nofx", "NOFX"], [@band.name, @band.label]
+        assert_equal %w[Nofx NOFX], [@band.name, @band.label]
       end
     end
 
-
     describe "#to_xml" do
       it "delegates to #to_node and returns string" do
-        assert_xml_equal "<band><name>Rise Against</name></band>", Band.new("Rise Against").to_xml
+        assert_xml_equal(Band.new("Rise Against").to_xml, "<band><name>Rise Against</name></band>")
       end
     end
 
-
     describe "#to_node" do
       it "returns Nokogiri node" do
         node = Band.new("Rise Against").to_node
@@ -106,7 +100,7 @@ class XmlTest < MiniTest::Spec
 
       it "wraps with infered class name per default" do
         node = Band.new("Rise Against").to_node
-        assert_xml_equal "<band><name>Rise Against</name></band>", node.to_s
+        assert_xml_equal(node.to_s, "<band><name>Rise Against</name></band>")
       end
 
       it "respects #representation_wrap=" do
@@ -116,11 +110,10 @@ class XmlTest < MiniTest::Spec
         end
 
         klass.representation_wrap = :group
-        assert_xml_equal "<group><name>Rise Against</name></group>", klass.new("Rise Against").to_node.to_s
+        assert_xml_equal(klass.new("Rise Against").to_node.to_s, "<group><name>Rise Against</name></group>")
       end
     end
 
-
     describe "XML::Binding#build_for" do
       it "returns AttributeBinding" do
         assert_kind_of XML::Binding::Attribute, XML::Binding.build_for(Def.new(:band, :as => "band", :attribute => true))
@@ -132,15 +125,14 @@ class XmlTest < MiniTest::Spec
       end
 
       it "returns CollectionBinding" do
-        assert_kind_of XML::Binding::Collection, XML::Binding.build_for(Def.new(:band, :collection => :true))
+        assert_kind_of XML::Binding::Collection, XML::Binding.build_for(Def.new(:band, :collection => true))
       end
 
       it "returns HashBinding" do
-        assert_kind_of XML::Binding::Hash, XML::Binding.build_for(Def.new(:band, :hash => :true))
+        assert_kind_of XML::Binding::Hash, XML::Binding.build_for(Def.new(:band, :hash => true))
       end
     end
 
-
     describe "DCI" do
       module SongRepresenter
         include Representable::XML
@@ -153,7 +145,6 @@ class XmlTest < MiniTest::Spec
         collection :songs, :class => Song, :as => :song, :extend => SongRepresenter
       end
 
-
       it "allows adding the representer by using #extend" do
         module BandRepresenter
           include Representable::XML
@@ -163,25 +154,27 @@ class XmlTest < MiniTest::Spec
         civ = Object.new
         civ.instance_eval do
           def name; "CIV"; end
+
           def name=(v)
             @name = v
           end
         end
 
         civ.extend(BandRepresenter)
-        assert_xml_equal "<object><name>CIV</name></object>", civ.to_xml
+        assert_xml_equal(civ.to_xml, "<object><name>CIV</name></object>")
       end
 
       it "extends contained models when serializing" do
         @album = Album.new(
-          [Song.new("I Hate My Brain"), mr=Song.new("Mr. Charisma")], mr)
+          [Song.new("I Hate My Brain"), mr = Song.new("Mr. Charisma")], mr
+        )
         @album.extend(AlbumRepresenter)
 
-        @album.to_xml.must_equal_xml "<album>
+        assert_xml_equal(@album.to_xml, "<album>
   <song><name>Mr. Charisma</name></song>
   <song><name>I Hate My Brain</name></song>
   <song><name>Mr. Charisma</name></song>
-</album>"
+</album>")
       end
 
       it "extends contained models when deserializing" do
@@ -195,8 +188,7 @@ class XmlTest < MiniTest::Spec
   end
 end
 
-
-class AttributesTest < MiniTest::Spec
+class AttributesTest < Minitest::Spec
   describe ":as => rel, :attribute => true" do
     class Link
       include Representable::XML
@@ -206,9 +198,11 @@ class AttributesTest < MiniTest::Spec
     end
 
     it "#from_xml creates correct accessors" do
-      link = Link.new.from_xml(%{
+      link = Link.new.from_xml(
+        %{
         <a href="http://apotomo.de" title="Home, sweet home" />
-      })
+      }
+      )
       assert_equal "http://apotomo.de", link.href
       assert_equal "Home, sweet home",  link.title
     end
@@ -217,35 +211,36 @@ class AttributesTest < MiniTest::Spec
       link = Link.new
       link.href = "http://apotomo.de/"
 
-      assert_xml_equal %{<link href="http://apotomo.de/">}, link.to_xml
+      assert_xml_equal(link.to_xml, %{<link href="http://apotomo.de/">})
     end
   end
 end
 
-
 class CDataBand
   class CData < Representable::XML::Binding
-    def serialize_node(parent, value)
+    def serialize_node(parent, _value)
       parent << Nokogiri::XML::CDATA.new(parent, represented.name)
     end
   end
 
   include Representable::XML
-  property :name, :binding => lambda { |*args| CData.new(*args) }#getter: lambda { |opt| Nokogiri::XML::CDATA.new(opt[:doc], name) }
+  property :name, :binding => ->(*args) {
+                                CData.new(*args)
+                              } # getter: lambda { |opt| Nokogiri::XML::CDATA.new(opt[:doc], name) }
   attr_accessor :name
 
-  def initialize(name=nil)
+  def initialize(name = nil)
     name and self.name = name
   end
 end
 
-class TypedPropertyTest < MiniTest::Spec
+class TypedPropertyTest < Minitest::Spec
   class Band
     include Representable::XML
     property :name
     attr_accessor :name
 
-    def initialize(name=nil)
+    def initialize(name = nil)
       name and self.name = name
     end
   end
@@ -257,21 +252,24 @@ class TypedPropertyTest < MiniTest::Spec
 
   class Album
     attr_accessor :band
-    def initialize(band=nil)
+
+    def initialize(band = nil)
       @band = band
     end
   end
 
-  # TODO:property :group, :class => Band
+  # TODO: property :group, :class => Band
   # :class
   # where to mixin DCI?
   describe ":class => Item" do
     it "#from_xml creates one Item instance" do
-      album = Album.new.extend(AlbumRepresenter).from_xml(%{
+      album = Album.new.extend(AlbumRepresenter).from_xml(
+        %{
         <album>
           <band><name>Bad Religion</name></band>
         </album>
-      })
+      }
+      )
       assert_equal "Bad Religion", album.band.name
     end
 
@@ -280,11 +278,11 @@ class TypedPropertyTest < MiniTest::Spec
         band = Band.new("Bad Religion")
         album = Album.new(band).extend(AlbumRepresenter)
 
-        assert_xml_equal %{<album>
+        assert_xml_equal(album.to_xml, %{<album>
          <band>
            <name>Bad Religion</name>
          </band>
-       </album>}, album.to_xml
+       </album>})
       end
 
       it "doesn't escape and wrap string from Band#to_node" do
@@ -295,7 +293,7 @@ class TypedPropertyTest < MiniTest::Spec
           end
         end
 
-        assert_xml_equal %{<album><band>Baaaad Religion</band></album>}, Album.new(band).extend(AlbumRepresenter).to_xml
+        assert_xml_equal(Album.new(band).extend(AlbumRepresenter).to_xml, %{<album><band>Baaaad Religion</band></album>})
       end
     end
 
@@ -304,11 +302,11 @@ class TypedPropertyTest < MiniTest::Spec
         band = CDataBand.new("Bad Religion")
         album = Album.new(band).extend(AlbumRepresenter)
 
-        assert_xml_equal %{<album>
+        assert_xml_equal(album.to_xml, %{<album>
          <c_data_band>
            <name><![CDATA[Bad Religion]]></name>
          </c_data_band>
-       </album>}, album.to_xml
+       </album>})
       end
     end
   end
@@ -327,7 +325,7 @@ class XMLPropertyTest < Minitest::Spec
     property :genre, attribute: true
   end
 
-  it { BandRepresenter.new(Band.new("Mute")).to_xml.must_equal_xml %{<band><theyCallUs>Mute</theyCallUs></band>} }
+  it { assert_xml_equal(BandRepresenter.new(Band.new("Mute")).to_xml, %{<band><theyCallUs>Mute</theyCallUs></band>}) }
 
   class ManagerRepresenter < Representable::Decorator
     include Representable::XML
@@ -335,11 +333,19 @@ class XMLPropertyTest < Minitest::Spec
   end
 
   #- :as with nested property
-  it { ManagerRepresenter.new(Manager.new(Band.new("Mute", "Punkrock"))).to_xml.must_equal_xml %{<manager><band genre="Punkrock"><theyCallUs>Mute</theyCallUs></band></manager>} }
+  it {
+    assert_xml_equal(ManagerRepresenter.new(
+      Manager.new(
+        Band.new(
+          "Mute",
+          "Punkrock"
+        )
+      )
+    ).to_xml, %{<manager><band genre="Punkrock"><theyCallUs>Mute</theyCallUs></band></manager>})
+  }
 end
 
-
-class XMLCollectionTest < MiniTest::Spec
+class XMLCollectionTest < Minitest::Spec
   Band        = Struct.new(:name)
   Compilation = Struct.new(:bands)
 
@@ -358,12 +364,14 @@ class XMLCollectionTest < MiniTest::Spec
 
     describe "#from_xml" do
       it "pushes collection items to array" do
-        cd = CompilationRepresenter.new(Compilation.new).from_xml(%{
+        cd = CompilationRepresenter.new(Compilation.new).from_xml(
+          %{
           <compilation>
             <group><name>Diesel Boy</name></group>
             <group><name>Cobra Skulls</name></group>
           </compilation>
-        })
+        }
+        )
         assert_equal ["Cobra Skulls", "Diesel Boy"], cd.bands.map(&:name).sort
       end
     end
@@ -371,45 +379,48 @@ class XMLCollectionTest < MiniTest::Spec
     it "responds to #to_xml" do
       cd = Compilation.new([Band.new("Diesel Boy"), Band.new("Bad Religion")])
 
-      CompilationRepresenter.new(cd).to_xml.must_equal_xml %{<compilation>
+      assert_xml_equal(CompilationRepresenter.new(cd).to_xml, %{<compilation>
         <group><name>Diesel Boy</name></group>
         <group><name>Bad Religion</name></group>
-      </compilation>}
+      </compilation>})
     end
   end
 
-
   describe ":as" do
-    let(:xml_doc) {
+    let(:xml_doc) do
       Module.new do
         include Representable::XML
         collection :songs, :as => :song
-      end }
+      end
+    end
 
     it "collects untyped items" do
-      album = Album.new.extend(xml_doc).from_xml(%{
+      album = Album.new.extend(xml_doc).from_xml(
+        %{
         <album>
           <song>Two Kevins</song>
           <song>Wright and Rong</song>
           <song>Laundry Basket</song>
         </album>
-      })
+      }
+      )
       assert_equal ["Laundry Basket", "Two Kevins", "Wright and Rong"].sort, album.songs.sort
     end
   end
 
-
   describe ":wrap" do
     let(:album) { Album.new.extend(xml_doc) }
-    let(:xml_doc) {
+    let(:xml_doc) do
       Module.new do
         include Representable::XML
         collection :songs, :as => :song, :wrap => :songs
-      end }
+      end
+    end
 
     describe "#from_xml" do
       it "finds items in wrapped collection" do
-        album.from_xml(%{
+        album.from_xml(
+          %{
           <album>
             <songs>
               <song>Two Kevins</song>
@@ -417,7 +428,8 @@ class XMLCollectionTest < MiniTest::Spec
               <song>Laundry Basket</song>
             </songs>
           </album>
-        })
+        }
+        )
         assert_equal ["Laundry Basket", "Two Kevins", "Wright and Rong"].sort, album.songs.sort
       end
     end
@@ -425,7 +437,7 @@ class XMLCollectionTest < MiniTest::Spec
     describe "#to_xml" do
       it "wraps items" do
         album.songs = ["Laundry Basket", "Two Kevins", "Wright and Rong"]
-        assert_xml_equal %{
+        assert_xml_equal(album.to_xml, %{
           <album>
             <songs>
               <song>Laundry Basket</song>
@@ -433,13 +445,13 @@ class XMLCollectionTest < MiniTest::Spec
               <song>Wright and Rong</song>
             </songs>
           </album>
-        }, album.to_xml
+        })
       end
     end
   end
 
-  require 'representable/xml/hash'
-  class LonelyRepresenterTest < MiniTest::Spec
+  require "representable/xml/hash"
+  class LonelyRepresenterTest < Minitest::Spec
     # TODO: where is the XML::Hash test?
     module SongRepresenter
       include Representable::XML
@@ -451,20 +463,20 @@ class XMLCollectionTest < MiniTest::Spec
 
     describe "XML::Collection" do
       describe "with contained objects" do
-        representer!(:module => Representable::XML::Collection)  do
+        representer!(:module => Representable::XML::Collection) do
           items :class => Song, :extend => SongRepresenter
-          self.representation_wrap= :songs
+          self.representation_wrap = :songs
         end
 
         let(:songs) { [Song.new("Days Go By"), Song.new("Can't Take Them All")] }
-        let(:xml_doc)   { "<songs><song><name>Days Go By</name></song><song><name>Can't Take Them All</name></song></songs>" }
+        let(:xml_doc) { "<songs><song><name>Days Go By</name></song><song><name>Can't Take Them All</name></song></songs>" }
 
         it "renders array" do
-          songs.extend(representer).to_xml.must_equal_xml xml_doc
+          assert_xml_equal(songs.extend(representer).to_xml, xml_doc)
         end
 
         it "renders array with decorator" do
-          decorator.new(songs).to_xml.must_equal_xml xml_doc
+          assert_xml_equal(decorator.new(songs).to_xml, xml_doc)
         end
 
         it "parses array" do
@@ -477,29 +489,29 @@ class XMLCollectionTest < MiniTest::Spec
       end
     end
 
-    describe "XML::AttributeHash" do  # TODO: move to HashTest.
+    describe "XML::AttributeHash" do # TODO: move to HashTest.
       representer!(:module => Representable::XML::AttributeHash) do
-        self.representation_wrap= :songs
+        self.representation_wrap = :songs
       end
 
       let(:songs) { {"one" => "Graveyards", "two" => "Can't Take Them All"} }
-      let(:xml_doc)   { "<favs one=\"Graveyards\" two=\"Can't Take Them All\" />" }
+      let(:xml_doc) { "<songs one=\"Graveyards\" two=\"Can't Take Them All\" />" }
 
       describe "#to_xml" do
         it "renders hash" do
-          songs.extend(representer).to_xml.must_equal_xml xml_doc
+          assert_xml_equal(songs.extend(representer).to_xml, xml_doc)
         end
 
         it "respects :exclude" do
-          assert_xml_equal "<favs two=\"Can't Take Them All\" />", songs.extend(representer).to_xml(:exclude => [:one])
+          assert_xml_equal(songs.extend(representer).to_xml(:exclude => [:one]), "<songs two=\"Can't Take Them All\" />")
         end
 
         it "respects :include" do
-          assert_xml_equal "<favs two=\"Can't Take Them All\" />", songs.extend(representer).to_xml(:include => [:two])
+          assert_xml_equal(songs.extend(representer).to_xml(:include => [:two]), "<songs two=\"Can't Take Them All\" />")
         end
 
         it "renders hash with decorator" do
-          decorator.new(songs).to_xml.must_equal_xml xml_doc
+          assert_xml_equal(decorator.new(songs).to_xml, xml_doc)
         end
       end
 
@@ -524,7 +536,7 @@ class XMLCollectionTest < MiniTest::Spec
   end
 end
 
-class XmlHashTest < MiniTest::Spec
+class XmlHashTest < Minitest::Spec
   # scalar, no object
   describe "plain text" do
     representer!(module: Representable::XML) do
@@ -534,7 +546,7 @@ class XmlHashTest < MiniTest::Spec
     let(:doc) { "<open_struct><first>The Gargoyle</first><second>Bronx</second></open_struct>" }
 
     # to_xml
-    it { OpenStruct.new(songs: {"first" => "The Gargoyle", "second" => "Bronx"}).extend(representer).to_xml.must_equal_xml(doc) }
+    it { assert_xml_equal(OpenStruct.new(songs: {"first" => "The Gargoyle", "second" => "Bronx"}).extend(representer).to_xml, doc) }
     # FIXME: this NEVER worked!
     # it { OpenStruct.new.extend(representer).from_xml(doc).songs.must_equal({"first" => "The Gargoyle", "second" => "Bronx"}) }
   end
@@ -546,17 +558,26 @@ class XmlHashTest < MiniTest::Spec
       end
     end
 
-    let(:doc) { "<open_struct>
+    let(:doc) do
+      "<open_struct>
   <open_struct>
     <title>The Gargoyle</title>
   </open_struct>
   <open_struct>
     <title>Bronx</title>
   </open_struct>
-</open_struct>" }
+</open_struct>"
+    end
 
     # to_xml
-    it { OpenStruct.new(songs: {"first" => OpenStruct.new(title: "The Gargoyle"), "second" => OpenStruct.new(title: "Bronx")}).extend(representer).to_xml.must_equal_xml(doc) }
+    it {
+      assert_xml_equal(OpenStruct.new(
+        songs: {
+          "first"  => OpenStruct.new(title: "The Gargoyle"),
+          "second" => OpenStruct.new(title: "Bronx")
+        }
+      ).extend(representer).to_xml, doc)
+    }
     # FIXME: this NEVER worked!
     # it { OpenStruct.new.extend(representer).from_xml(doc).songs.must_equal({"first" => "The Gargoyle", "second" => "Bronx"}) }
   end