poly_belongs_to 0.1.8 → 0.1.9

data/test/dup_test.rb

@@ -4,41 +4,74 @@ require 'minitest/autorun'
 class DupTest < ActiveSupport::TestCase
   fixtures :all
 
-  it "has method pbt_dup_build" do
-    User.instance_methods.include?(:pbt_dup_build).must_be_same_as true
-    User.methods.include?(:pbt_dup_build).must_be_same_as true
-  end
+  describe PolyBelongsTo::Dup do
+    it "has method :pbt_dup_build" do
+      User.instance_methods.must_include(:pbt_dup_build)
+      User.methods.must_include(:pbt_dup_build)
+    end
 
-  it "has method pbt_deep_dup_build" do
-    User.instance_methods.include?(:pbt_deep_dup_build).must_be_same_as true
-    User.methods.include?(:pbt_deep_dup_build).must_be_same_as true
-  end
+    it "has method :pbt_deep_dup_build" do
+      User.instance_methods.must_include(:pbt_deep_dup_build)
+      User.methods.must_include(:pbt_deep_dup_build)
+    end
 
-  it "builds copy from dup'd attributes" do
-    user = users(:bob)
-    susan_prof = profiles(:susan_prof)
-    contact = user.contacts.new
-    contact.pbt_dup_build( susan_prof )
-    CleanAttrs[contact.profile].must_equal CleanAttrs[susan_prof]
+    it "#pbt_dup_build builds copy from dup'd attributes" do
+      user = users(:bob)
+      susan_prof = profiles(:susan_prof)
+      contact = user.contacts.new
+      contact.pbt_dup_build( susan_prof )
+      CleanAttrs[contact.profile].must_equal CleanAttrs[susan_prof]
+    end
+    
+    it "#pbt_deep_dup_build builds deep copy of dup'd attributes" do
+      user1 = users(:steve)
+      bob_prof = profiles(:bob_prof)
+      contact = user1.contacts.new
+      contact.pbt_deep_dup_build(bob_prof)
+      CleanAttrs[contact.profile                                                        ].
+        must_equal CleanAttrs[bob_prof]
+      CleanAttrs[contact.profile.addresses.first                                        ].
+        must_equal CleanAttrs[bob_prof.addresses.first]
+      CleanAttrs[contact.profile.addresses.first.squishies.first                        ].
+        must_equal CleanAttrs[bob_prof.addresses.first.squishies.first]
+      CleanAttrs[contact.profile.addresses.first.geo_location                           ].
+        must_equal CleanAttrs[bob_prof.addresses.first.geo_location]
+      CleanAttrs[contact.profile.addresses.first.geo_location.squishies.first           ].
+        must_equal CleanAttrs[bob_prof.addresses.first.geo_location.squishies.first]
+      CleanAttrs[contact.profile.addresses.last                                         ].
+        must_equal CleanAttrs[bob_prof.addresses.last]
+      CleanAttrs[contact.profile.phones.first                                           ].
+        must_equal CleanAttrs[bob_prof.phones.first]
+      CleanAttrs[contact.profile.phones.first.squishy                                   ].
+        must_equal CleanAttrs[bob_prof.phones.first.squishy]
+      CleanAttrs[contact.profile.phones.last                                            ].
+        must_equal CleanAttrs[bob_prof.phones.last]
+      CleanAttrs[contact.profile.photo                                                  ].
+        must_equal CleanAttrs[bob_prof.photo]
+    end
   end
-  
-  it "builds deep copy of dup'd attributes" do
-    user1 = users(:steve)
-    bob_prof = profiles(:bob_prof)
-    contact = user1.contacts.new
-    contact.pbt_deep_dup_build(bob_prof)
-    cp = contact.profile
-    cpa = cp.addresses
-    cpaf = cpa.first
-    CleanAttrs[cp                               ].must_equal CleanAttrs[bob_prof]
-    CleanAttrs[cpaf                             ].must_equal CleanAttrs[bob_prof.addresses.first]
-    CleanAttrs[cpaf.squishies.first             ].must_equal CleanAttrs[bob_prof.addresses.first.squishies.first]
-    CleanAttrs[cpaf.geo_location                ].must_equal CleanAttrs[bob_prof.addresses.first.geo_location]
-    CleanAttrs[cpaf.geo_location.squishies.first].must_equal CleanAttrs[bob_prof.addresses.first.geo_location.squishies.first]
-    CleanAttrs[cp.addresses.last                ].must_equal CleanAttrs[bob_prof.addresses.last]
-    CleanAttrs[cp.phones.first                  ].must_equal CleanAttrs[bob_prof.phones.first]
-    CleanAttrs[cp.phones.first.squishy          ].must_equal CleanAttrs[bob_prof.phones.first.squishy]
-    CleanAttrs[cp.phones.last                   ].must_equal CleanAttrs[bob_prof.phones.last]
-    CleanAttrs[cp.photo                         ].must_equal CleanAttrs[bob_prof.photo]
+
+  describe "PolyBelongsTo::Dup #pbt_deep_dup_build handles circular references like a champ!" do
+    alpha = Alpha.new; alpha.save
+    beta = alpha.betas.build; beta.save
+    capa = beta.capas.build; capa.save
+    delta = capa.deltas.build; delta.save
+    alpha.update(delta_id: delta.id)
+    it "is a circle" do
+      alpha.pbt_parent.must_equal delta
+      beta.pbt_parent.must_equal alpha
+      capa.pbt_parent.must_equal beta
+      delta.pbt_parent.must_equal capa
+    end
+    it "clones without duplicating cirular reference" do
+      alpha2 = Alpha.new( CleanAttrs[alpha] )
+      CleanAttrs[alpha2].must_equal CleanAttrs[alpha]
+      alpha2.pbt_deep_dup_build(beta)
+      CleanAttrs[alpha2.betas.first].must_equal CleanAttrs[beta]
+      CleanAttrs[alpha2.betas.first.capas.first].must_equal CleanAttrs[capa]
+      CleanAttrs[alpha2.betas.first.capas.first.deltas.first].must_equal CleanAttrs[delta]
+      CleanAttrs[alpha2.betas.first.capas.first.deltas.first.alphas.first].must_equal CleanAttrs[alpha]
+      alpha2.betas.first.capas.first.deltas.first.alphas.first.betas.first.must_be_nil
+    end
   end
 end

data/test/faked_collection_test.rb

@@ -4,88 +4,103 @@ require 'minitest/autorun'
 class FakedCollectionTest < ActiveSupport::TestCase
   fixtures :all
 
-  let(:photos){
+  let(:steve_photos){
     steve_prof = users(:steve).profiles.first
     PolyBelongsTo::FakedCollection.new(steve_prof, Photo)
   }
 
-  it "is named correctly" do
-    photos.class.name.must_equal "PolyBelongsTo::FakedCollection" 
-  end
+  describe PolyBelongsTo::FakedCollection do
 
-  it "knows its superclass" do
-    PolyBelongsTo::FakedCollection.superclass.must_equal Object
-  end
+    it "#class.name is named correctly" do
+      steve_photos.class.name.must_equal "PolyBelongsTo::FakedCollection" 
+    end
 
-  it ".all is an Array" do
-    photos.all.is_a?(Array).must_be_same_as true
-    photos.all.kind_of?(Array).must_be_same_as true
-  end
+    it "#superclass knows its superclass" do
+      PolyBelongsTo::FakedCollection.superclass.must_equal Object
+    end
 
-  it "first is the item" do
-    photos.first.class.name.must_equal "Photo"
-  end
+    it "IDs the inner ited on :id" do
+      [nil, photos(:steve_photo).id].must_include steve_photos.id
+    end
 
-  it "last is the item" do
-    photos.last.class.name.must_equal "Photo"
-  end
+    it "#all is an Array" do
+      steve_photos.all.is_a?(Array).must_be_same_as true
+      steve_photos.all.must_be_kind_of(Array)
+      steve_photos.all.must_be_instance_of(Array)
+    end
 
-  it "counts as 1 or 0" do
-    photos.count.between?(0,1).must_be_same_as true
-    photos.size.between?(0,1).must_be_same_as true
-  end
+    it "#first is the item" do
+      steve_photos.first.class.name.must_equal "Photo"
+    end
 
-  it "FakedCollection has ancestors" do
-    photos.ancestors.include?(Object).must_be_same_as true
-  end
+    it "#last is the item" do
+      steve_photos.last.class.name.must_equal "Photo"
+    end
 
-  it "build kind of FakedCollection object" do
-    photos.kind_of?(PolyBelongsTo::FakedCollection).must_be_same_as true
-  end
+    it "#count and #size counts as 1 or 0" do
+      steve_photos.count.between?(0,1).must_be_same_as true
+      [0,1].must_include steve_photos.count
+      steve_photos.size.between?(0,1).must_be_same_as true
+      [0,1].must_include steve_photos.size
+    end
 
-  it "build is a FakedCollection object" do
-    photos.is_a?(PolyBelongsTo::FakedCollection).must_be_same_as true
-  end
+    it "#ancestors has ActiveRecord::Base ancestor" do
+      steve_photos.ancestors.must_include(ActiveRecord::Base)
+    end
 
-  it "build instance of FakedCollection object" do
-    photos.instance_of?(PolyBelongsTo::FakedCollection).must_be_same_as true
-  end
-  
-  it "builds appropriately" do
-    photos.build({content: "cheese"})
-    photos.first.content.must_equal "cheese"
-  end
+    it "build #kind_of? FakedCollection object" do
+      steve_photos.must_be_kind_of(PolyBelongsTo::FakedCollection)
+    end
 
-  it "build returns self and not nil" do
-    res = photos.build({content: "cheese"})
-    res.wont_be_nil
-    res.class.name.must_equal photos.class.name
-    res.first.content.must_equal "cheese"
-    photos.first.content.must_equal "cheese"
-  end
+    it "build #is_a? FakedCollection object" do
+      steve_photos.is_a?(PolyBelongsTo::FakedCollection).must_be_same_as true
+    end
 
-  it "loops appropriately" do
-    photos.each do |photo|
-      photo.class.name.must_equal "Photo"
+    it "build #instance_of? FakedCollection object" do
+      steve_photos.must_be_instance_of(PolyBelongsTo::FakedCollection)
+    end
+    
+    it "#build builds appropriately" do
+      steve_photos.build({content: "cheese"})
+      steve_photos.first.content.must_equal "cheese"
     end
-  end
 
-  it "defines klass to inner items class" do
-    photos.klass.name.must_equal "Photo"
-  end
+    it "#build returns self and not nil" do
+      res = steve_photos.build({content: "cheese"})
+      res.wont_be_nil
+      res.class.name.must_equal steve_photos.class.name
+      res.first.content.must_equal "cheese"
+      steve_photos.first.content.must_equal "cheese"
+    end
 
-  it "respond_to? :first and :last" do
-    photos.respond_to?(:first).must_be_same_as true
-    photos.respond_to?(:last).must_be_same_as true
-  end
+    it "#each loops appropriately" do
+      steve_photos.each do |photo|
+        photo.class.name.must_equal "Photo"
+      end
+    end
 
-  it "knows sneeze is a missing method" do
-    ->{photos.sneeze}.must_raise NoMethodError
-  end
+    it "defines #klass to point to inner items class" do
+      steve_photos.klass.name.must_equal "Photo"
+    end
+
+    it "#respond_to? :first and :last" do
+      steve_photos.must_respond_to(:first)
+      steve_photos.must_respond_to(:last)
+    end
+
+    it "knows sneeze is a missing method" do
+      ->{steve_photos.sneeze}.must_raise NoMethodError
+    end
+
+    it "has method_missing forward appropriate calls" do
+      steve_photos.method_missing(:nil?).must_equal false
+    end
+
+    it "will not initialize on has_many" do
+      steve = users(:steve)
+      ->{ PolyBelongsTo::FakedCollection.new(steve, Profile) }.must_raise RuntimeError 
+    end
 
-  it "will not initialize on has_many" do
-    steve = users(:steve)
-    ->{ PolyBelongsTo::FakedCollection.new(steve, Profile) }.must_raise RuntimeError 
   end
 
 end

data/test/pbt_test.rb

@@ -4,106 +4,110 @@ require 'minitest/autorun'
 class PbtTest < ActiveSupport::TestCase
   fixtures :all
 
-  it "AttrSanitizer removes conflicting attributes" do
-    user = users(:bob)
-    PolyBelongsTo::Pbt::AttrSanitizer[user].must_equal Hash[id: nil, content: user.content].stringify_keys
-    PolyBelongsTo::Pbt::AttrSanitizer[nil ].must_equal Hash[] 
-  end
+  describe PolyBelongsTo::Pbt do
+    it "AttrSanitizer removes conflicting attributes" do
+      user = users(:bob)
+      PolyBelongsTo::Pbt::AttrSanitizer[user].must_equal Hash[id: nil, content: user.content].stringify_keys
+      PolyBelongsTo::Pbt::AttrSanitizer[nil ].must_equal Hash[] 
+    end
 
-  it "BuildCmd returns build command" do
-    profile = profiles(:bob_prof)
-    "#{PolyBelongsTo::Pbt::BuildCmd[profile,Phone]}".must_equal "phones.build"
-    "#{PolyBelongsTo::Pbt::BuildCmd[profile,Photo]}".must_equal "build_photo"
-    PolyBelongsTo::Pbt::BuildCmd[nil,       Photo].must_be_nil
-    PolyBelongsTo::Pbt::BuildCmd[profile,     nil].must_be_nil
-  end
+    it "BuildCmd returns build command" do
+      profile = profiles(:bob_prof)
+      "#{PolyBelongsTo::Pbt::BuildCmd[profile,Phone]}".must_equal "phones.build"
+      "#{PolyBelongsTo::Pbt::BuildCmd[profile,Photo]}".must_equal "build_photo"
+      PolyBelongsTo::Pbt::BuildCmd[nil,       Photo].must_be_nil
+      PolyBelongsTo::Pbt::BuildCmd[profile,     nil].must_be_nil
+    end
 
-  it "Reflects retruns has_one and has_many relationships" do
-    profile = profiles(:bob_prof)
-    PolyBelongsTo::Pbt::Reflects[profile].sort.must_equal [:phones, :addresses, :photo].sort
-    PolyBelongsTo::Pbt::Reflects[nil    ].must_equal Array[]
-  end
+    it "Reflects retruns has_one and has_many relationships" do
+      profile = profiles(:bob_prof)
+      PolyBelongsTo::Pbt::Reflects[profile].sort.must_equal [:phones, :addresses, :photo].sort
+      PolyBelongsTo::Pbt::Reflects[nil    ].must_equal Array[]
+    end
 
-  it "ReflectsAsClasses one and many relations as classes" do
-    profile = profiles(:bob_prof)
-    PolyBelongsTo::Pbt::ReflectsAsClasses[profile].map(&:hash).sort.must_equal [Phone, Address, Photo].map(&:hash).sort
-    PolyBelongsTo::Pbt::ReflectsAsClasses[nil    ].must_equal Array[]
-  end
+    it "ReflectsAsClasses one and many relations as classes" do
+      profile = profiles(:bob_prof)
+      PolyBelongsTo::Pbt::ReflectsAsClasses[profile].map(&:hash).sort.must_equal [Phone, Address, Photo].map(&:hash).sort
+      PolyBelongsTo::Pbt::ReflectsAsClasses[nil    ].must_equal Array[]
+    end
 
-  it "IsReflected gives boolean of child" do
-    profile = profiles(:bob_prof)
-    PolyBelongsTo::Pbt::IsReflected[profile,  Phone].must_equal true
-    PolyBelongsTo::Pbt::IsReflected[profile,Address].must_equal true
-    PolyBelongsTo::Pbt::IsReflected[profile,  Photo].must_equal true
-    PolyBelongsTo::Pbt::IsReflected[profile,   User].must_equal false
-    PolyBelongsTo::Pbt::IsReflected[nil,       User].must_equal false
-    PolyBelongsTo::Pbt::IsReflected[profile,    nil].must_equal false
-  end
+    it "IsReflected gives boolean of child" do
+      profile = profiles(:bob_prof)
+      PolyBelongsTo::Pbt::IsReflected[profile,  Phone].must_equal true
+      PolyBelongsTo::Pbt::IsReflected[profile,Address].must_equal true
+      PolyBelongsTo::Pbt::IsReflected[profile,  Photo].must_equal true
+      PolyBelongsTo::Pbt::IsReflected[profile,   User].must_equal false
+      PolyBelongsTo::Pbt::IsReflected[nil,       User].must_equal false
+      PolyBelongsTo::Pbt::IsReflected[profile,    nil].must_equal false
+    end
 
-  it "SingularOrPlural responds for child relations" do
-    profile = profiles(:susan_prof)
-    PolyBelongsTo::Pbt::SingularOrPlural[profile,Phone].must_equal :plural
-    PolyBelongsTo::Pbt::SingularOrPlural[profile,Photo].must_equal :singular
-    PolyBelongsTo::Pbt::SingularOrPlural[profile, User].must_be_nil
-    PolyBelongsTo::Pbt::SingularOrPlural[nil,     User].must_be_nil
-    PolyBelongsTo::Pbt::SingularOrPlural[profile,  nil].must_be_nil
-  end
+    it "SingularOrPlural responds for child relations" do
+      profile = profiles(:susan_prof)
+      PolyBelongsTo::Pbt::SingularOrPlural[profile,Phone].must_equal :plural
+      PolyBelongsTo::Pbt::SingularOrPlural[profile,Photo].must_equal :singular
+      PolyBelongsTo::Pbt::SingularOrPlural[profile, User].must_be_nil
+      PolyBelongsTo::Pbt::SingularOrPlural[nil,     User].must_be_nil
+      PolyBelongsTo::Pbt::SingularOrPlural[profile,  nil].must_be_nil
+    end
 
-  it "IsSingular tells child singleness" do
-    profile = profiles(:steve_prof)
-    PolyBelongsTo::Pbt::IsSingular[profile,Phone].must_be_same_as false
-    PolyBelongsTo::Pbt::IsSingular[nil,    Phone].must_be_same_as false
-    PolyBelongsTo::Pbt::IsSingular[profile,  nil].must_be_same_as false
-    PolyBelongsTo::Pbt::IsSingular[profile,Photo].must_be_same_as true
-  end
+    it "IsSingular tells child singleness" do
+      profile = profiles(:steve_prof)
+      PolyBelongsTo::Pbt::IsSingular[profile,Phone].must_be_same_as false
+      PolyBelongsTo::Pbt::IsSingular[nil,    Phone].must_be_same_as false
+      PolyBelongsTo::Pbt::IsSingular[profile,  nil].must_be_same_as false
+      PolyBelongsTo::Pbt::IsSingular[profile,Photo].must_be_same_as true
+    end
 
-  it "IsPlural tells child pluralness" do
-    profile = profiles(:bob_prof)
-    PolyBelongsTo::Pbt::IsPlural[profile,Phone].must_be_same_as true
-    PolyBelongsTo::Pbt::IsPlural[profile,Photo].must_be_same_as false
-    PolyBelongsTo::Pbt::IsPlural[nil,    Photo].must_be_same_as false
-    PolyBelongsTo::Pbt::IsPlural[profile,  nil].must_be_same_as false
-  end
+    it "IsPlural tells child pluralness" do
+      profile = profiles(:bob_prof)
+      PolyBelongsTo::Pbt::IsPlural[profile,Phone].must_be_same_as true
+      PolyBelongsTo::Pbt::IsPlural[profile,Photo].must_be_same_as false
+      PolyBelongsTo::Pbt::IsPlural[nil,    Photo].must_be_same_as false
+      PolyBelongsTo::Pbt::IsPlural[profile,  nil].must_be_same_as false
+    end
 
-  it "CollectionProxy: singular or plural proxy name" do
-    profile = profiles(:steve_prof)
-    PolyBelongsTo::Pbt::CollectionProxy[profile,Phone].must_equal :phones
-    PolyBelongsTo::Pbt::CollectionProxy[profile,Photo].must_equal :photo
-    PolyBelongsTo::Pbt::CollectionProxy[profile, User].must_be_nil
-    PolyBelongsTo::Pbt::CollectionProxy[nil,     User].must_be_nil
-    PolyBelongsTo::Pbt::CollectionProxy[profile,  nil].must_be_nil
-  end
+    it "CollectionProxy singular or plural proxy name" do
+      profile = profiles(:steve_prof)
+      PolyBelongsTo::Pbt::CollectionProxy[profile,Phone].must_equal :phones
+      PolyBelongsTo::Pbt::CollectionProxy[profile,Photo].must_equal :photo
+      PolyBelongsTo::Pbt::CollectionProxy[profile, User].must_be_nil
+      PolyBelongsTo::Pbt::CollectionProxy[nil,     User].must_be_nil
+      PolyBelongsTo::Pbt::CollectionProxy[profile,  nil].must_be_nil
+    end
 
-  it "AsCollectionProxy: has_one emulated collectionproxy" do
-    address = profiles(:bob_prof).addresses.first
-    address_to_geo = PolyBelongsTo::Pbt::AsCollectionProxy[address, GeoLocation]
-    address_to_geo.respond_to?(:klass).must_be_same_as true
-    address_to_geo.respond_to?(:build).must_be_same_as true
-    address_to_geo.respond_to?(:each ).must_be_same_as true
-    address_to_geo.respond_to?(:all  ).must_be_same_as true
-    address_to_geo.respond_to?(:first).must_be_same_as true
-    address_to_geo.respond_to?(:last ).must_be_same_as true
-    address_to_geo.kind_of?(PolyBelongsTo::FakedCollection).must_be_same_as true
-  end
+    it "AsCollectionProxy has_one emulated collectionproxy" do
+      address = profiles(:bob_prof).addresses.first
+      address_to_geo = PolyBelongsTo::Pbt::AsCollectionProxy[address, GeoLocation]
+      address_to_geo.must_respond_to(:klass)
+      address_to_geo.must_respond_to(:build)
+      address_to_geo.must_respond_to(:each )
+      address_to_geo.must_respond_to(:all  )
+      address_to_geo.must_respond_to(:first)
+      address_to_geo.must_respond_to(:last )
+      address_to_geo.must_be_kind_of(PolyBelongsTo::FakedCollection)
+    end
 
-  it "AsCollectionProxy: has one or zero items" do
-    address = profiles(:bob_prof).addresses.first
-    address_to_geo = PolyBelongsTo::Pbt::AsCollectionProxy[address, GeoLocation]
-    address_to_geo.count.between?(0,1).must_be_same_as true
-    address_to_geo.size.between?(0,1).must_be_same_as true
-  end
+    it "AsCollectionProxy has one or zero items" do
+      address = profiles(:bob_prof).addresses.first
+      address_to_geo = PolyBelongsTo::Pbt::AsCollectionProxy[address, GeoLocation]
+      address_to_geo.count.between?(0,1).must_be_same_as true
+      [0,1].must_include address_to_geo.count
+      address_to_geo.size.between?(0,1).must_be_same_as true
+      [0,1].must_include address_to_geo.size
+    end
 
-  
-  it "AsCollectionProxy: has_many uses AR CollectionProxy" do
-    bob = users(:bob)
-    bob_to_prof = PolyBelongsTo::Pbt::AsCollectionProxy[bob, Profile]
-    bob_to_prof.respond_to?(:klass).must_be_same_as true
-    bob_to_prof.respond_to?(:build).must_be_same_as true 
-    bob_to_prof.respond_to?(:each ).must_be_same_as true 
-    bob_to_prof.respond_to?(:all  ).must_be_same_as true 
-    bob_to_prof.respond_to?(:first).must_be_same_as true 
-    bob_to_prof.respond_to?(:last ).must_be_same_as true 
-    bob_to_prof.kind_of?(ActiveRecord::Associations::CollectionProxy).must_be_same_as true
+    
+    it "AsCollectionProxy has_many uses ActiveRecord::Associations::CollectionProxy" do
+      bob = users(:bob)
+      bob_to_prof = PolyBelongsTo::Pbt::AsCollectionProxy[bob, Profile]
+      bob_to_prof.must_respond_to(:klass)
+      bob_to_prof.must_respond_to(:build)
+      bob_to_prof.must_respond_to(:each )
+      bob_to_prof.must_respond_to(:all  )
+      bob_to_prof.must_respond_to(:first)
+      bob_to_prof.must_respond_to(:last )
+      bob_to_prof.must_be_kind_of(ActiveRecord::Associations::CollectionProxy)
+    end
   end
 
 end