vidibus-inheritance 0.3.6 → 0.3.9

data/spec/vidibus/inheritance/mongoid_spec.rb

@@ -1,66 +1,10 @@
 require "spec_helper"
 
-class Model
-  include Mongoid::Document
-  include Mongoid::Timestamps
-  include Vidibus::Uuid::Mongoid
-  include Vidibus::Inheritance::Mongoid
-  field :name
-  field :age, :type => Integer
-  embeds_many :children
-  embeds_many :puppets
-  embeds_one :location
-end
-
-class Child
-  include Mongoid::Document
-  field :name
-  field :mutated, :type => Boolean
-  validates :name, :presence => true
-  embedded_in :model, :inverse_of => :children
-  embeds_many :puppets
-  embeds_one :location
-end
-
-class Puppet
-  include Mongoid::Document
-  field :name
-  validates :name, :presence => true
-  embedded_in :child, :inverse_of => :puppets
-  embedded_in :model, :inverse_of => :puppets
-  embedded_in :location, :inverse_of => :puppets
-  embeds_one :location
-end
-
-class Location
-  include Mongoid::Document
-  field :name
-  field :mutated, :type => Boolean
-  validates :name, :presence => true
-  embedded_in :model, :inverse_of => :location
-  embedded_in :child, :inverse_of => :location
-  embedded_in :puppet, :inverse_of => :location
-  embeds_many :puppets
-end
-
-class Manager
-  include Mongoid::Document
-  include Vidibus::Uuid::Mongoid
-  include Vidibus::Inheritance::Mongoid
-  field :name
-  validates :name, :presence => true
-end
-
-class Clerk
-  include Mongoid::Document
-  field :name
-  validates :name, :presence => true
-end
-
 describe "Vidibus::Inheritance::Mongoid" do
   let(:ancestor) { Model.create }
-  let(:anna) { Model.create!(:name => "Anna", :age => 35) }
   let(:inheritor) { Model.new }
+  let(:anna) { Model.create!(:name => "Anna", :age => 35) }
+  let(:jeanny) { Model.create!(:name => "Jeanny", :age => 17) }
   
   describe "validation" do
     it "should fail if ancestor does not have an UUID" do
@@ -114,6 +58,12 @@ describe "Vidibus::Inheritance::Mongoid" do
       inheritor.update_attributes(:name => "Jenny")
       inheritor.mutated_attributes.should eql(["name"])
     end
+    
+    it "should be tracked if data gets modified in a before_validation callback" do
+      model = Trude.create
+      model.name.should eql("Trude")
+      model.mutated_attributes.should eql(["name"])
+    end
   end
   
   describe "#mutated?" do
@@ -136,13 +86,6 @@ describe "Vidibus::Inheritance::Mongoid" do
     end
   end
   
-  describe "#ancestor" do
-    it "should return an ancestor object by uuid" do
-      inheritor.ancestor_uuid = ancestor.uuid
-      inheritor.ancestor.should eql(ancestor)
-    end
-  end
-  
   describe "#ancestor=" do
     it "should set an ancestor object" do
       inheritor.ancestor = ancestor
@@ -168,6 +111,21 @@ describe "Vidibus::Inheritance::Mongoid" do
     end
   end
   
+  describe "#ancestor" do
+    it "should return an ancestor object by uuid" do
+      inheritor.ancestor_uuid = ancestor.uuid
+      inheritor.ancestor.should eql(ancestor)
+    end
+  end
+
+  describe "#ancestors" do
+    it "should return a list of all ancestors" do
+      inheritor = Model.create!(:ancestor => ancestor)
+      nextgen = Model.create!(:ancestor => inheritor)
+      nextgen.ancestors.should eql([inheritor, ancestor])
+    end
+  end
+  
   describe "#inherit!" do
     it "should call #inherit_attributes once" do
       stub(inheritor)._inherited { true }
@@ -233,368 +191,117 @@ describe "Vidibus::Inheritance::Mongoid" do
     it "should return all inheritors" do
       inheritor1 = Model.create(:ancestor => ancestor)
       inheritor2 = Model.create(:ancestor => ancestor)
-      ancestor.inheritors.should have(2).inheritors
-      ancestor.inheritors.should include(inheritor1)
-      ancestor.inheritors.should include(inheritor2)
+      list = ancestor.inheritors.to_a
+      list.should have(2).inheritors
+      list.should include(inheritor1)
+      list.should include(inheritor2)
     end
   end
   
-  describe "inheritance" do    
-    it "should happen when creating objects" do
-      ancestor # trigger object creation before mocking
-      mock.instance_of(Model).inherit_attributes
-      Model.create!(:ancestor => ancestor)
+  describe "#inheritable_documents" do
+    it "should perform .inheritable_documents with current object" do
+      mock(Model).inheritable_documents(anna, {})
+      anna.inheritable_documents
     end
     
-    it "should happen when ancestor did change" do
-      inheritor = Model.create!
-      inheritor.ancestor = ancestor
-      stub(inheritor).inherit_attributes
-      inheritor.save
-      inheritor.should have_received.inherit_attributes
+    it "should allow options" do
+      mock(Model).inheritable_documents(anna, :keys => true)
+      anna.inheritable_documents(:keys => true)
     end
-    
-    it "should not happen when ancestor did not change" do
-      inheritor = Model.create!(:ancestor => ancestor)
-      dont_allow(inheritor).inherit
-      inheritor.save
-      # Does not work with RR:
-      # inheritor.should_not have_received.inherit
+  end
+  
+  describe "#clone!" do
+    it "should create a sibling" do
+      twin = anna.clone!
+      twin.should_not eql(anna)
+      twin.name.should eql(anna.name)
+      twin.age.should eql(anna.age)
     end
     
-    it "should apply ancestor's attributes to inheritor" do
-      inheritor.update_attributes(:ancestor => anna)
-      inheritor.name.should eql("Anna")
-      inheritor.age.should eql(35)
+    it "should preserve ancestor relation" do
+      anna.inherit_from!(ancestor)
+      twin = anna.clone!
+      twin.ancestor.should eql(ancestor)
     end
     
-    it "should not inherit acquired attributes" do
-      inheritor.update_attributes(:ancestor => ancestor)
-      Model::ACQUIRED_ATTRIBUTES.should include("uuid")
-      inheritor.uuid.should_not eql(ancestor.uuid)
+    it "should not clone inheritors (should it?)" do
+      anna.inherit_from!(ancestor)
+      twin = ancestor.clone!
+      twin.inheritors.should be_empty
     end
     
-    it "should apply ancestor's attributes to inheritor but keep previously mutated attributes" do
-      inheritor.update_attributes(:name => "Jenny")
-      inheritor.update_attributes(:ancestor => anna)
-      inheritor.name.should eql("Jenny")
-      inheritor.age.should eql(35)
+    it "should clone embedded documents" do
+      anna.children.create(:name => "Lisa")
+      twin = anna.clone!
+      twin.children.should have(1).child
     end
     
-    it "should apply ancestor's attributes to inheritor but keep recently mutated attributes" do
-      inheritor.update_attributes(:ancestor => anna, :name => "Jenny")
-      inheritor.name.should eql("Jenny")
-      inheritor.age.should eql(35)
+    it "should clone a single embedded document" do
+      anna.create_location(:name => "Bathroom")
+      twin = anna.clone!
+      twin.location.name.should eql("Bathroom")
     end
     
-    it "should allow switching the ancestor" do
-      inheritor.inherit_from!(anna)
-      another_ancestor = Model.create!(:name => "Leah", :age => 30)
-      inheritor.inherit_from!(another_ancestor)
-      inheritor.ancestor.should eql(another_ancestor)
-      inheritor.name.should eql("Leah")
-      inheritor.age.should eql(30)
+    it "should clone children of embedded documents" do
+      lisa = anna.children.create(:name => "Lisa")
+      lisa.puppets.create(:name => "Gonzo")
+      twin = anna.clone!
+      lisa_twin = twin.children.first
+      lisa_twin.puppets.should have(1).puppet
+      # lisa_twin.puppets.first._id.should_not eql(lisa_twin.puppets.first._id)
     end
-    
-    it "should apply changes on ancestor to inheritor" do
-      inheritor.inherit_from!(anna)
-      inheritor.name.should eql("Anna")
-      anna.update_attributes(:name => "Leah")
-      inheritor.reload
-      inheritor.name.should eql("Leah")
+  end
+  
+  describe ".inheritable_documents" do
+    it "should return embedded relations of a given object" do
+      docs = Model.inheritable_documents(anna)
+      docs.length.should eql(3)
+      docs.should have_key("location")
+      docs.should have_key("children")
+      docs.should have_key("puppets")
     end
     
-    it "should preserve changes on inheritor" do
-      inheritor = Model.create(:ancestor => anna)
-      inheritor.update_attributes(:name => "Sara")
-      inheritor.mutated_attributes.should eql(["name"])
-      anna.update_attributes(:name => "Leah")
-      inheritor.reload
-      inheritor.name.should eql("Sara")
+    it "should return a collection of documents embedded by embeds_many" do
+      anna.children.create(:name => "Lisa")
+      docs = Model.inheritable_documents(anna)
+      docs["children"].should eql([anna.children.first])
     end
     
-    it "should not update inheritor if acquired attributes were changed on ancestor" do
-      inheritor.inherit_from!(ancestor)
-      Model::ACQUIRED_ATTRIBUTES.should include("updated_at")
-      dont_allow(ancestor.inheritors.first).inherit!
-      ancestor.update_attributes(:updated_at => Time.now)
+    it "should return a document embedded by embeds_one" do
+      anna.create_location(:name => "Beach")
+      docs = Model.inheritable_documents(anna)
+      docs["location"].should eql(anna.location)
     end
     
-    it "should not update inheritor if no inheritable attributes were changed on ancestor" do
-      inheritor.inherit_from!(anna)
-      dont_allow(anna.inheritors.first).inherit!
-      anna.update_attributes(:name => "Anna")
+    it "should return the keys of embedded relations if option :keys is given" do
+      keys = Model.inheritable_documents(anna, :keys => true)
+      keys.should eql(%w[location puppets children])
     end
-    
-    it "should be applied before validation" do
-      ancestor = Manager.create!(:name => "John")
-      invalid = Manager.new
-      invalid.should_not be_valid
-      valid = Manager.new(:ancestor => ancestor)
-      valid.should be_valid
+  end
+  
+  describe ".roots" do
+    before do
+      inheritor.inherit_from!(anna)
+      jeanny
     end
     
-    context "with embedded collections" do
-      before do
-        inheritor.inherit_from!(ancestor)
-        ancestor.children.create(:name => "Han")
-        ancestor.save
-        inheritor.reload
-      end
-      
-      it "should inherit subobjects on existing relationship" do
-        inheritor.children.should have(1).child
-      end
-      
-      it "should inherit subobjects when relationship gets established" do
-        inheritor = Model.new
-        inheritor.inherit_from!(ancestor)
-        inheritor.children.should have(1).child
-        inheritor.reload.children.should have(1).child
-      end
-      
-      it "should add subobjects" do
-        ancestor.children << Child.new(:name => "Leah")
-        ancestor.save
-        ancestor.children.should have(2).children
-        inheritor.reload
-        inheritor.children.should have(2).children
-      end
-      
-      it "should add subobjects with saving" do
-        ancestor.children << Child.new(:name => "Leah")
-        ancestor.save
-        ancestor.children.should have(2).children
-        inheritor.save
-        inheritor.reload
-        inheritor.children.should have(2).children
-      end
-      
-      it "should not add existing subobjects twice" do
-        inheritor.inherit_from!(ancestor)
-        inheritor.children.should have(1).child
-        inheritor.reload.children.should have(1).child
-      end
-      
-      it "should remove subobjects" do
-        inheritor.children.should have(1).child
-        ancestor.children.first.destroy
-        ancestor.save
-        inheritor.reload
-        ancestor.children.should have(0).children
-        inheritor.children.should have(0).children
-      end
-      
-      it "should update subobjects" do
-        ancestor.children.first.name = "Luke"
-        ancestor.save
-        inheritor.reload
-        inheritor.children.first.name.should eql("Luke")
-      end
-      
-      it "should call #update_inherited_attributes for updating subobjects, if available" do
-        Child.send(:define_method, :update_inherited_attributes) do
-          self.update_attributes(:name => "Callback")
-        end
-        Child.send(:protected, :update_inherited_attributes)
-        ancestor.children.first.name = "Luke"
-        ancestor.save
-        Child.send(:remove_method, :update_inherited_attributes)
-        inheritor.reload
-        inheritor.children.first.name.should eql("Callback")
-      end
-      
-      it "should exclude acquired attributes of subobjects" do
-        ancestor.children.first.mutated = true
-        ancestor.save
-        ancestor.children.first.mutated.should be_true
-        inheritor.reload
-        inheritor.children.first.mutated.should be_false
-      end
-      
-      it "should inherit embedded documents of subobjects" do
-        ancestor.children.first.puppets.create(:name => "Goofy")
-        ancestor.save
-        inheritor.reload
-        inheritor.children.first.puppets.should have(1).puppet
-      end
+    it "should return all model that have no ancestor" do
+      Model.all.to_a.should have(3).models
+      list = Model.roots.to_a
+      list.should have(2).models
     end
     
-    context "with embedded items" do
-      before do
-        inheritor.inherit_from!(ancestor)
-        ancestor.create_location(:name => "Home")
-        ancestor.save
-        inheritor.reload
-      end
-      
-      it "should inherit subobject on existing relationship" do
-        inheritor.location.should_not be_nil
-      end
-      
-      it "should inherit subobjects when relationship gets established" do
-        inheritor = Model.new
-        inheritor.inherit_from!(ancestor)
-        inheritor.location.should_not be_nil
-      end
-      
-      it "should update subobject" do
-        ancestor.location.name = "Studio"
-        ancestor.save
-        inheritor.reload
-        ancestor.location.name.should eql("Studio")
-        inheritor.location.name.should eql("Studio")
-      end
-      
-      it "should remove subobject" do
-        ancestor.location.destroy
-        ancestor.save
-        inheritor.reload
-        ancestor.location.should be_nil
-        inheritor.location.should be_nil
-      end
-      
-      it "should exclude acquired attributes of subobject" do
-        ancestor.location.mutated = true
-        ancestor.save
-        ancestor.location.mutated.should be_true
-        inheritor.reload
-        inheritor.location.mutated.should be_false
-      end
-      
-      it "should inherit embedded documents of subobject" do
-        ancestor.location.puppets.create(:name => "Goofy")
-        ancestor.save
-        inheritor.reload
-        inheritor.location.puppets.should have(1).puppet
-      end
+    it "should accept sorting criteria" do
+      Model.all.to_a.should have(3).models
+      stub_time!(1.hour.since)
+      anna.update_attributes(:age => 20)
+      list = Model.roots.desc(:updated_at).to_a
+      list[0].updated_at.should > list[1].updated_at
     end
     
-    context "across several generations" do
-      let(:grand_ancestor) { Model.create!(:name => "Anna", :age => 97) }
-      
-      before do
-        ancestor.inherit_from!(grand_ancestor)
-        inheritor.inherit_from!(ancestor)
-      end
-      
-      it "should apply changes on grand ancestor to inheritor" do
-        inheritor.name.should eql("Anna")
-        grand_ancestor.update_attributes(:name => "Leah")
-        inheritor.reload
-        inheritor.name.should eql("Leah")
-      end
-      
-      it "should not apply changes on grand ancestor to inheritor if predecessor has mutations" do
-        ancestor.update_attributes(:name => "Jenny")
-        grand_ancestor.update_attributes(:name => "Leah")
-        inheritor.reload
-        inheritor.name.should eql("Jenny")
-      end
-      
-      it "should allow resetting mutated attributes" do
-        ancestor.update_attributes(:name => "Sara")
-        ancestor.name.should eql("Sara")
-        inheritor.reload
-        inheritor.name.should eql("Sara")
-        ancestor.inherit!(:reset => :name)
-        ancestor.name.should eql("Anna")
-        inheritor.reload
-        inheritor.name.should eql("Anna")
-      end
-      
-      context "with embedded collections" do
-        before do
-          grand_ancestor.children.create(:name => "Han")
-          grand_ancestor.save
-          ancestor.reload
-          inheritor.reload
-        end
-
-        it "should inherit subobjects" do
-          inheritor.children.should have(1).child
-        end
-
-        it "should add subobjects" do
-          grand_ancestor.children << Child.new(:name => "Leah")
-          grand_ancestor.save
-          inheritor.reload
-          inheritor.children.should have(2).children
-        end
-
-        it "should not add existing subobjects twice" do
-          ancestor.inherit_from!(grand_ancestor)
-          inheritor.reload
-          inheritor.children.should have(1).child
-        end
-
-        it "should remove subobjects" do
-          inheritor.children.should have(1).child
-          grand_ancestor.children.first.destroy
-          grand_ancestor.save
-          grand_ancestor.children.should have(0).children
-          inheritor.reload
-          inheritor.children.should have(0).children
-        end
-
-        it "should update subobjects" do
-          grand_ancestor.children.first.name = "Luke"
-          grand_ancestor.save
-          grand_ancestor.children.first.name.should eql("Luke")
-          inheritor.reload
-          inheritor.children.first.name.should eql("Luke")
-        end
-
-        it "should inherit embedded documents of subobjects" do
-          grand_ancestor.children.first.puppets.create(:name => "Goofy")
-          grand_ancestor.save
-          inheritor.reload
-          inheritor.children.first.puppets.should have(1).puppet
-        end
-      end
-      
-      context "with embedded items" do
-        before do
-          grand_ancestor.create_location(:name => "Home")
-          grand_ancestor.save
-          ancestor.reload
-          inheritor.reload
-        end
-
-        it "should inherit subobject on existing relationship" do
-          inheritor.location.should_not be_nil
-        end
-
-        it "should inherit subobject when relationship gets established" do
-          ancestor = Model.new
-          ancestor.inherit_from!(grand_ancestor)
-          inheritor = Model.new
-          inheritor.inherit_from!(ancestor)
-          inheritor.location.should_not be_nil
-        end
-
-        it "should update subobject" do
-          grand_ancestor.location.name = "Studio"
-          grand_ancestor.save
-          inheritor.reload
-          inheritor.location.name.should eql("Studio")
-        end
-
-        it "should remove subobject" do
-          grand_ancestor.location.destroy
-          grand_ancestor.save
-          inheritor.reload
-          grand_ancestor.location.should be_nil
-          inheritor.location.should be_nil
-        end
-        
-        it "should inherit embedded documents of subobject" do
-          grand_ancestor.location.puppets.create(:name => "Goofy")
-          grand_ancestor.save
-          inheritor.reload
-          inheritor.location.puppets.should have(1).puppet
-        end
-      end
+    it "should accept conditions" do
+      list = Model.roots.where(:name => ancestor.name).to_a
+      list.should have(1).models
     end
   end
 end