mongoid_alize 0.1.0 → 0.2.0

data/spec/app/models/head.rb

@@ -19,4 +19,8 @@ class Head
 
   # a relation with no inverse
   has_many :admirer, :class_name => "Person", :inverse_of => nil
+
+  def density
+    "low"
+  end
 end

data/spec/app/models/person.rb

@@ -17,5 +17,8 @@ class Person
   # the only head that is watching
   belongs_to :seen_by, :class_name => "Head", :inverse_of => :sees
 
+  def location
+    "Paris"
+  end
 end
 

data/spec/mongoid/alize/callback_spec.rb

@@ -1,26 +1,64 @@
 require 'spec_helper'
 
+class Mongoid::Alize::SpecCallback < Mongoid::Alize::Callback
+  def attach
+    klass.class_eval do
+      def denormalize_spec_person
+      end
+    end
+  end
+
+  def direction
+    "spec"
+  end
+end
+
 describe Mongoid::Alize::Callback do
   def klass
-    Mongoid::Alize::Callback
+    Mongoid::Alize::SpecCallback
   end
 
   def args
     [Head, :person, [:name, :created_at]]
   end
 
-  def new_unit
+  def new_callback
     klass.new(*args)
   end
 
   describe "initialize" do
     it "should assign class attributes" do
-      unit = new_unit
-      unit.klass.should == Head
-      unit.relation.should == :person
-      unit.inverse_klass = Person
-      unit.inverse_relation = :head
-      unit.fields.should == [:name, :created_at]
+      callback = new_callback
+      callback.klass.should == Head
+      callback.relation.should == :person
+      callback.inverse_klass = Person
+      callback.inverse_relation = :head
+      callback.fields.should == [:name, :created_at]
+    end
+
+    it "should add force_denormalization attribute to klass and inverse klass" do
+      callback = new_callback
+      Head.new.force_denormalization = true
+      Person.new.force_denormalization = true
+    end
+  end
+
+  describe "with callback " do
+    before do
+      @callback = new_callback
+    end
+
+    describe "#alias_callback" do
+      it "should alias the callback on the klass" do
+        mock(@callback.klass).alias_method("denormalize_spec_person", "_denormalize_spec_person")
+        @callback.send(:alias_callback)
+      end
+
+      it "should not alias the callback if it's already set" do
+        @callback.send(:attach)
+        dont_allow(@callback.klass).alias_method
+        @callback.send(:alias_callback)
+      end
     end
   end
 end

data/spec/mongoid/alize/callbacks/from/many_spec.rb

@@ -6,47 +6,121 @@ describe Mongoid::Alize::Callbacks::From::Many do
   end
 
   def args
-    [Head, :wanted_by, [:name, :created_at]]
+    [Head, :wanted_by, [:name, :location, :created_at]]
   end
 
-  def new_unit
+  def new_callback
     klass.new(*args)
   end
 
   describe "#define_fields" do
     it "should define an Array called {relation}_fields" do
-      unit = new_unit
-      unit.send(:define_fields)
+      callback = new_callback
+      callback.send(:define_fields)
       Head.fields["wanted_by_fields"].type.should == Array
     end
+
+    it "should default the field to empty" do
+      callback = new_callback
+      callback.send(:define_fields)
+      Head.new.wanted_by_fields.should == []
+    end
+
+    it "should raise an already defined field error if the field already exists" do
+      Head.class_eval do
+        field :wanted_by_fields
+      end
+      callback = new_callback
+      expect {
+        callback.send(:define_fields)
+      }.to raise_error(Mongoid::Alize::Errors::AlreadyDefinedField,
+                       "wanted_by_fields is already defined on the Head model.")
+    end
   end
 
   describe "the defined callback" do
     def run_callback
-      @head.send(callback_name)
+      @head.send(:_denormalize_from_wanted_by)
+    end
+
+    def bob_fields
+      { "_id" => @person.id,
+        "name"=> "Bob",
+        "location" => "Paris",
+        "created_at"=> @now.to_s(:utc) }
+    end
+
+    before do
+      now = Time.now
+      stub(Time).now { now }
+      @head = Head.create
+      @person = Person.create(:name => "Bob", :created_at => @now = Time.now)
+
+      @head.relations["wanted_by"].should be_stores_foreign_key
     end
 
-    def callback_name
-      "denormalize_from_wanted_by"
+    describe "valid fields" do
+      before do
+        @callback = new_callback
+        @callback.send(:define_fields)
+        @callback.send(:define_callback)
+      end
+
+      it "should set fields from a changed relation" do
+        @head.wanted_by_ids << @person.id
+        @head.should be_wanted_by_ids_changed
+        run_callback
+        @head.wanted_by_fields.should == [bob_fields]
+      end
+
+      it "should still set fields there are no changes" do
+        @head.should_not be_wanted_by_ids_changed
+        mock.proxy(@head).wanted_by
+        run_callback
+      end
+    end
+
+    describe "with a field that doesn't exist" do
+      before do
+        @callback = klass.new(Head, :wanted_by, [:notreal])
+        @callback.send(:define_fields)
+        @callback.send(:define_callback)
+      end
+
+      it "should raise a no method error" do
+        @head.wanted_by_ids << @person.id
+        @head.wanted_by_fields.should be_nil
+        expect {
+          run_callback
+        }.to raise_error NoMethodError
+      end
+    end
+  end
+
+  describe "in a one to many case" do
+    def run_callback
+      @head.send(:_denormalize_from_sees)
     end
 
     before do
-      @head = Head.create(
-        :wanted_by => [@person = Person.create(:name => "Bob",
-                                        :created_at => @now = Time.now)])
+      now = Time.now
+      stub(Time).now { now }
+      @head = Head.create
+      @person = Person.create(:name => "Bob")
 
-      @unit = new_unit
-      @unit.send(:define_fields)
-      @unit.send(:define_callback)
+      @callback = klass.new(Head, :sees, [:name])
+      @callback.send(:define_fields)
+      @callback.send(:define_callback)
+
+      @head.relations["sees"].should_not be_stores_foreign_key
     end
 
-    it "should pull the fields from the relation" do
-      @head.wanted_by_fields.should be_nil
+    it "should field from a changed relation" do
+      @head.sees << @person
       run_callback
-      @head.wanted_by_fields.should == [{
+      @head.sees_fields.should == [{
         "_id" => @person.id,
-        "name"=> "Bob",
-        "created_at"=> @now.to_s(:utc)
+        "name" => "Bob"
       }]
     end
   end

data/spec/mongoid/alize/callbacks/from/one_spec.rb

@@ -6,55 +6,138 @@ describe Mongoid::Alize::Callbacks::From::One do
   end
 
   def args
-    [Head, :person, [:name, :created_at]]
+    [Head, :person, [:name, :location, :created_at]]
   end
 
-  def new_unit
+  def new_callback
     klass.new(*args)
   end
 
   describe "#define_fields" do
     it "should add properly typed, prefixed fields from the relation" do
-      unit = new_unit
-      unit.send(:define_fields)
+      callback = klass.new(Head, :person, [:name, :created_at])
+      callback.send(:define_fields)
       Head.fields["person_name"].type.should == String
       Head.fields["person_created_at"].type.should == Time
     end
-  end
 
-  describe "the defined callback" do
-    def run_callback
-      @head.send(callback_name)
+    it "should define as a string field that's not defined" do
+      callback = klass.new(Head, :person, [:location])
+      callback.send(:define_fields)
+      Head.fields["person_location"].type.should == String
+    end
+
+    it "should not add the field if the field already exists" do
+      Head.class_eval do
+        field :person_name
+      end
+      callback = klass.new(Head, :person, [:name])
+      dont_allow(Head).field
+      callback.send(:define_fields)
     end
 
-    def callback_name
-      "denormalize_from_person"
+    it "should not add the field if it already exists b/c of another relation" do
+      callback = klass.new(Head, :person, [:id])
+      dont_allow(Head).field
+      callback.send(:define_fields)
+    end
+
+    it "should allow the id and type of the inverse to be denormalized without an extra _" do
+      callback = klass.new(Person, :head, [:id, :type])
+      callback.send(:define_fields)
+      Person.fields["head_id"].type.should == BSON::ObjectId
+      Person.fields["head_type"].type.should == String
+    end
+  end
+
+  describe "the defined callback" do
+    def run_callback(force=false)
+      @head.send(:_denormalize_from_person, force)
     end
 
     before do
-      @head = Head.create(
-        :person => @person = Person.create(:name => @name = "Bob",
-                                           :created_at => @now = Time.now))
-      @unit = new_unit
-      @unit.send(:define_fields)
-      @unit.send(:define_callback)
+      @head = Head.create
+      @person = Person.create(:name => @name = "Bob",
+                              :created_at => @now = Time.now)
+
+      @callback = new_callback
+      @callback.send(:define_fields)
+      @callback.send(:define_callback)
+
+      @head.relations["person"].should be_stores_foreign_key
     end
 
-    it "should set pull fields from the relation" do
-      @head.person_name.should be_nil
-      @head.person_created_at.should be_nil
+    it "should set fields from a changed relation" do
+      @head.person = @person
+      @head.should be_person_id_changed
       run_callback
       @head.person_name.should == @name
       @head.person_created_at.to_i.should == @now.to_i
+      @head.person_location.should == "Paris"
     end
 
-    it "should assign nil values if the relation is nil" do
-      @head.person_name = "not nil"
-      @head.person_created_at = Time.now
+    it "should assign nil values if the changed relation is nil" do
+      @head.person = @person
+      @head.save!
       @head.person = nil
+      @head.should be_person_id_changed
       run_callback
       @head.person_name.should be_nil
-      @head.person_created_at.should be_nil
+    end
+
+    it "should not run if the relation has not changed" do
+      @head.should_not be_person_id_changed
+      dont_allow(@head).person
+      run_callback
+    end
+
+    it "should still run if the relation has not changed but force is passed" do
+      @head.should_not be_person_id_changed
+      mock.proxy(@head).person
+      run_callback(true)
+    end
+
+    it "should still run if the relation has not changed but force_denormalization is set on the class" do
+      @head.should_not be_person_id_changed
+      @head.force_denormalization = true
+      mock.proxy(@head).person
+      run_callback
+    end
+  end
+
+  describe "the defined callback when denormalizing on the has_one side" do
+    def run_callback
+      @person.send(:_denormalize_from_head)
+    end
+
+    before do
+      @person = Person.create
+      @head = Head.create(:size => 5)
+
+      @callback = klass.new(Person, :head, [:size])
+      @callback.send(:define_fields)
+      @callback.send(:define_callback)
+
+      @person.relations["head"].should_not be_stores_foreign_key
+    end
+
+    it "should set values from a changed relation" do
+      @person.head = @head
+      run_callback
+      @person.head_size.should == 5
+    end
+
+    it "should set values from a a nil relation" do
+      @person.head = @head
+      @person.save!
+      @person.head = nil
+      run_callback
+      @person.head_size.should be_nil
+    end
+
+    it "should run even if the relation has not changed" do
+      mock.proxy(@person).head
+      run_callback
     end
   end
 end

data/spec/mongoid/alize/callbacks/to/many_from_many_spec.rb

@@ -6,16 +6,17 @@ describe Mongoid::Alize::Callbacks::To::ManyFromMany do
   end
 
   def args
-    [Person, :wants, [:name, :created_at]]
+    [Person, :wants, [:name, :location, :created_at]]
   end
 
-  def new_unit
+  def new_callback
     klass.new(*args)
   end
 
   def wanted_by_fields
     { "_id" => @person.id,
-        "name"=> "Bob",
+        "name" => "Bob",
+        "location" => "Paris",
         "created_at"=> @now.to_s(:utc) }
   end
 
@@ -33,20 +34,16 @@ describe Mongoid::Alize::Callbacks::To::ManyFromMany do
                                       :created_at => @now = Time.now)])
     @person.wants = [@head]
 
-    @unit = new_unit
+    @callback = new_callback
   end
 
   describe "#define_callback" do
     before do
-      @unit.send(:define_callback)
+      @callback.send(:define_callback)
     end
 
     def run_callback
-      @person.send(callback_name)
-    end
-
-    def callback_name
-      "denormalize_to_wants"
+      @person.send(:_denormalize_to_wants)
     end
 
     it "should push the fields to the relation" do
@@ -71,15 +68,11 @@ describe Mongoid::Alize::Callbacks::To::ManyFromMany do
 
   describe "#define_destroy_callback" do
     before do
-      @unit.send(:define_destroy_callback)
+      @callback.send(:define_destroy_callback)
     end
 
     def run_destroy_callback
-      @person.send(destroy_callback_name)
-    end
-
-    def destroy_callback_name
-      "denormalize_destroy_to_wants"
+      @person.send(:_denormalize_destroy_to_wants)
     end
 
     it "should pull first any existing array entries matching the _id" do