mongoid_alize 0.2.0 → 0.3.1

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

@@ -1,99 +1,197 @@
 require 'spec_helper'
 
-describe Mongoid::Alize::Callbacks::To::ManyFromOne do
+describe Mongoid::Alize::ToCallback do
   def klass
-    Mongoid::Alize::Callbacks::To::ManyFromOne
-  end
-
-  def args
-    [Person, :seen_by, [:name, :location, :created_at]]
+    Mongoid::Alize::ToCallback
   end
 
   def new_callback
     klass.new(*args)
   end
 
-  def sees_fields
-    { "_id" => @person.id,
-      "name"=> "Bob",
-      "location" => "Paris",
-      "created_at"=> @now.to_s(:utc) }
+  def define_and_create(callback_name=:define_callback)
+    @callback = new_callback
+    @callback.send(:define_fields)
+    create_models
+    @callback.send(callback_name)
   end
 
-  def other_see
-    { "_id" => "SomeObjectId" }
-  end
+  describe "with metadata in advance" do
+    def create_models
+      @head = Head.create(
+        :sees => [@person = Person.create(:name => "Bob",
+                                          :created_at => @now = Time.now)])
+      @person.seen_by = @head
+    end
 
-  before do
-    Head.class_eval do
-      field :sees_fields, :type => Array
+    def args
+      [Person, :seen_by, [:name, :location, :created_at]]
     end
 
-    @head = Head.create(
-      :sees => [@person = Person.create(:name => "Bob",
-                                      :created_at => @now = Time.now)])
-    @person.seen_by = @head
-    @callback = new_callback
-  end
+    def sees_fields
+      { "_id" => @person.id,
+        "name"=> "Bob",
+        "location" => "Paris",
+        "created_at"=> @now.to_s(:utc) }
+    end
+
+    def other_see
+      { "_id" => "SomeObjectId" }
+    end
 
-  describe "#define_callback" do
     before do
-      @callback.send(:define_callback)
+      Head.class_eval do
+        field :sees_fields, :type => Array, :default => []
+      end
     end
 
-    def run_callback
-      @person.send(:_denormalize_to_seen_by)
+    describe "#define_callback" do
+      def run_callback
+        @person.send(:_denormalize_to_seen_by)
+      end
+
+      before do
+        define_and_create
+      end
+
+      it "should push the fields to the relation" do
+        @head.sees_fields.should == []
+        run_callback
+        @head.sees_fields.should == [sees_fields]
+      end
+
+      it "should pull first any existing array entries matching the _id" do
+        @head.sees_fields = [other_see]
+        @head.save!
+
+        run_callback
+        run_callback
+
+        # to make sure persisted in both DB and updated in memory
+        @head.sees_fields.should == [other_see, sees_fields]
+        @head.reload
+        @head.sees_fields.should == [other_see, sees_fields]
+      end
+
+      it "should do nothing if the inverse is nil" do
+        @person.seen_by = nil
+        run_callback
+      end
     end
 
-    it "should push the fields to the relation" do
-      @head.sees_fields.should be_nil
-      run_callback
-      @head.sees_fields.should == [sees_fields]
+    describe "#define_destroy_callback" do
+      def run_destroy_callback
+        @person.send(:_denormalize_destroy_to_seen_by)
+      end
+
+      before do
+        define_and_create(:define_destroy_callback)
+      end
+
+      it "should pull first any existing array entries matching the _id" do
+        @head.sees_fields = [sees_fields, other_see]
+        @head.save!
+
+        run_destroy_callback
+
+        # to make sure persisted in both DB and updated in memory
+        @head.sees_fields.should == [other_see]
+        @head.reload
+        @head.sees_fields.should == [other_see]
+      end
+
+      it "should do nothing if the inverse is nil" do
+        @person.seen_by = nil
+        run_destroy_callback
+      end
     end
+  end
 
-    it "should pull first any existing array entries matching the _id" do
-      @head.sees_fields = [other_see]
-      @head.save!
+  describe "with a polymorphic model" do
+    def create_models
+      @person = Person.create(:name => @name = "Bob", :created_at => @now = Time.now)
+      @head = Head.create(:size => @size = 10)
+      @person.above = @head
+    end
 
-      run_callback
-      run_callback
+    def args
+      [Person, :above, [:name]]
+    end
 
-      # to make sure persisted in both DB and updated in memory
-      @head.sees_fields.should == [other_see, sees_fields]
-      @head.reload
-      @head.sees_fields.should == [other_see, sees_fields]
+    def below_people_fields
+      { "_id" => @person.id,
+        "name"=> @name }
     end
 
-    it "should do nothing if the inverse is nil" do
-      @person.seen_by = nil
-      run_callback
+    def other_below_people
+      { "_id" => "SomeObjectId" }
     end
-  end
 
-  describe "#define_destroy_callback" do
     before do
-      @callback.send(:define_destroy_callback)
+      Head.class_eval do
+        field :below_people_fields, :type => Array, :default => []
+      end
     end
 
-    def run_destroy_callback
-      @person.send(:_denormalize_destroy_to_seen_by)
+    describe "#define_callback" do
+      def run_callback
+        @person.send(:_denormalize_to_above)
+      end
+
+      before do
+        define_and_create
+      end
+
+      it "should push the fields to the relation" do
+        @head.below_people_fields.should == []
+        run_callback
+        @head.below_people_fields.should == [below_people_fields]
+      end
+
+      it "should pull first any existing array entries matching the _id" do
+        @head.below_people_fields = [other_below_people]
+        @head.save!
+
+        run_callback
+        run_callback
+
+        # to make sure persisted in both DB and updated in memory
+        @head.below_people_fields.should == [other_below_people, below_people_fields]
+        @head.reload
+        @head.below_people_fields.should == [other_below_people, below_people_fields]
+      end
+
+      it "should do nothing if the inverse is nil" do
+        @person.above = nil
+        run_callback
+      end
     end
 
-    it "should pull first any existing array entries matching the _id" do
-      @head.sees_fields = [sees_fields, other_see]
-      @head.save!
+    describe "#define_destroy_callback" do
+      def run_destroy_callback
+        @person.send(:_denormalize_destroy_to_above)
+      end
 
-      run_destroy_callback
+      before do
+        define_and_create(:define_destroy_callback)
+      end
 
-      # to make sure persisted in both DB and updated in memory
-      @head.sees_fields.should == [other_see]
-      @head.reload
-      @head.sees_fields.should == [other_see]
-    end
+      it "should pull first any existing array entries matching the _id" do
+        @head.below_people_fields = [below_people_fields, other_below_people]
+        @head.save!
+
+        run_destroy_callback
+
+        # to make sure persisted in both DB and updated in memory
+        @head.below_people_fields.should == [other_below_people]
+        @head.reload
+        @head.below_people_fields.should == [other_below_people]
+      end
 
-    it "should do nothing if the inverse is nil" do
-      @person.seen_by = nil
-      run_destroy_callback
+      it "should do nothing if the inverse is nil" do
+        @person.above = nil
+        run_destroy_callback
+      end
     end
   end
 end

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

@@ -1,70 +1,138 @@
 require 'spec_helper'
 
-describe Mongoid::Alize::Callbacks::To::OneFromMany do
+describe Mongoid::Alize::ToCallback do
   def klass
-    Mongoid::Alize::Callbacks::To::OneFromMany
-  end
-
-  def args
-    [Person, :heads, [:name, :location, :created_at]]
+    Mongoid::Alize::ToCallback
   end
 
   def new_callback
     klass.new(*args)
   end
 
-  before do
-    Head.class_eval do
-      field :captor_name, :type => String
-      field :captor_location, :type => String
-      field :captor_created_at, :type => Time
-    end
-
-    @head = Head.create(
-      :captor => @person = Person.create(:name => "Bob",
-                                         :created_at => @now = Time.now))
-    @person.heads = [@head]
-
+  def define_and_create(callback_name=:define_callback)
     @callback = new_callback
+    @callback.send(:define_fields)
+    create_models
+    @callback.send(callback_name)
   end
 
-  describe "#define_callback" do
+  describe "with metadata in advance" do
+    def create_models
+      @head = Head.create(
+        :captor => @person = Person.create(:name => "Bob", :created_at => @now = Time.now))
+      @person.heads = [@head]
+    end
+
+    def args
+      [Person, :heads, [:name, :location, :created_at]]
+    end
+
     before do
-      @callback.send(:define_callback)
+      Head.class_eval do
+        field :captor_fields, :type => Hash, :default => nil
+      end
     end
 
-    def run_callback
-      @person.send(:_denormalize_to_heads)
+    describe "#define_callback" do
+      def captor_fields
+        { "name"=> "Bob",
+          "location" => "Paris",
+          "created_at"=> @now.to_s(:utc) }
+      end
+
+      def run_callback
+        @person.send(:_denormalize_to_heads)
+      end
+
+      before do
+        define_and_create
+      end
+
+      it "should push the fields to the relation" do
+        @head.captor_fields.should be_nil
+        run_callback
+        @head.captor_fields.should == captor_fields
+      end
     end
 
-    it "should push the fields to the relation" do
-      @head.captor_name.should be_nil
-      @head.captor_location.should be_nil
-      @head.captor_created_at.should be_nil
-      run_callback
-      @head.captor_name.should == "Bob"
-      @head.captor_location.should == "Paris"
-      @head.captor_created_at.to_i.should == @now.to_i
+    describe "#define_destroy_callback" do
+      def run_destroy_callback
+        @person.send(:_denormalize_destroy_to_heads)
+      end
+
+      before do
+        define_and_create(:define_destroy_callback)
+      end
+
+      it "should remove the fields from the relation" do
+        @head.captor_fields = { "hi" => "hello" }
+        run_destroy_callback
+        @head.captor_fields.should be_nil
+      end
+
+      it "should do nothing if the relation doesn't exist" do
+        @head.captor = nil
+        run_destroy_callback
+      end
     end
   end
 
-  describe "#define_destroy_callback" do
-    def run_destroy_callback
-      @person.send(:_denormalize_destroy_to_heads)
+  describe "with a polymorphic relationship" do
+    def create_models
+      @person = Person.create(:name => "Bob", :created_at => @now = Time.now)
+      @head = Head.create(:size => @size = 10)
+      @person.above = @head
+    end
+
+    def args
+      [Head, :below_people, [:size]]
     end
 
     before do
-      @callback.send(:define_destroy_callback)
+      Person.class_eval do
+        field :above_fields, :type => Hash, :default => nil
+      end
+    end
+
+    describe "#define_callback" do
+      def above_fields
+        { "size"=> @size }
+      end
+
+      def run_callback
+        @head.send(:_denormalize_to_below_people)
+      end
+
+      before do
+        define_and_create
+      end
+
+      it "should push the fields to the relation" do
+        @person.above_fields.should be_nil
+        run_callback
+        @person.above_fields.should == above_fields
+      end
     end
 
-    it "should remove the fields from the relation" do
-      @head.captor_name = "Chuck"
-      @head.captor_location = "Paris"
-      @head.captor_created_at = Time.now
-      run_destroy_callback
-      @head.captor_name.should be_nil
-      @head.captor_location.should be_nil
-      @head.captor_created_at.should be_nil
+    describe "#define_destroy_callback" do
+      before do
+        define_and_create(:define_destroy_callback)
+      end
+
+      def run_destroy_callback
+        @head.send(:_denormalize_destroy_to_below_people)
+      end
+
+      it "should remove the fields from the relation" do
+        @person.above_fields = { "hi" => "hello" }
+        run_destroy_callback
+        @person.above_fields.should be_nil
+      end
+
+      it "should do nothing if the relation doesn't exist" do
+        @person.above = nil
+        run_destroy_callback
+      end
     end
   end
 end

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

@@ -1,79 +1,199 @@
 require 'spec_helper'
 
-describe Mongoid::Alize::Callbacks::To::OneFromOne do
+describe Mongoid::Alize::ToCallback do
   def klass
-    Mongoid::Alize::Callbacks::To::OneFromOne
-  end
-
-  def args
-    [Person, :head, [:name, :location, :created_at]]
+    Mongoid::Alize::ToCallback
   end
 
   def new_callback
     klass.new(*args)
   end
 
-  before do
-    Head.class_eval do
-      field :person_name, :type => String
-      field :person_location, :type => String
-      field :person_created_at, :type => Time
+  def define_and_create(callback_name=:define_callback)
+    @callback = new_callback
+    @callback.send(:define_fields)
+    create_models
+    @callback.send(callback_name)
+  end
+
+  describe "with metadata in advance" do
+    def args
+      [Person, :head, [:name, :location, :created_at]]
     end
 
-    @head = Head.create(
-      :person => @person = Person.create(:name => "Bob",
-                                      :created_at => @now = Time.now))
+    def create_models
+      @head = Head.create(
+        :person => @person = Person.create(:name => "Bob",
+                                           :created_at => @now = Time.now))
+    end
 
-    @callback = new_callback
+    before do
+      Head.class_eval do
+        field :person_fields, :type => Hash, :default => nil
+      end
+    end
+
+    describe "define_callback" do
+      def person_fields
+        { "name"=> "Bob",
+          "location" => "Paris",
+          "created_at"=> @now.to_s(:utc) }
+      end
+
+      def run_callback
+        @person.send(:_denormalize_to_head)
+      end
+
+      before do
+        define_and_create
+      end
+
+      it "should push the fields to the relation" do
+        @head.person_fields.should == nil
+        run_callback
+        @head.person_fields.should == person_fields
+      end
+    end
+
+    describe "define_destroy_callback" do
+      def run_destroy_callback
+        @person.send(:_denormalize_destroy_to_head)
+      end
+
+      before do
+        define_and_create(:define_destroy_callback)
+      end
+
+      it "should nillify the fields in the relation" do
+        @head.person_fields = { "hi" => "hello" }
+        run_destroy_callback
+        @head.person_fields.should be_nil
+      end
+
+      it "should do nothing if the relation doesn't exist" do
+        @head.person = nil
+        run_destroy_callback
+      end
+    end
   end
 
-  describe "define_callback" do
-    before do
-      @callback.send(:define_callback)
+  describe "to a polymorphic child" do
+    def args
+      [Person, :nearest_head, [:name, :location, :created_at]]
     end
 
-    def run_callback
-      @person.send(:_denormalize_to_head)
+    def create_models
+      @head = Head.create(
+        :nearest => @person = Person.create(:name => @name = "Bob",
+                                           :created_at => @now = Time.now))
     end
 
-    it "should push the fields to the relation" do
-      @head.person_name.should be_nil
-      @head.person_location.should be_nil
-      @head.person_created_at.should be_nil
-      run_callback
-      @head.person_name.should == "Bob"
-      @head.person_location.should == "Paris"
-      @head.person_created_at.to_i.should == @now.to_i
+    before do
+      Head.class_eval do
+        field :nearest_fields, :type => Hash, :default => nil
+      end
+    end
+
+    describe "define_callback" do
+      def nearest_fields
+        { "name"=> "Bob",
+          "location" => "Paris",
+          "created_at"=> @now.to_s(:utc) }
+      end
+
+      def run_callback
+        @person.send(:_denormalize_to_nearest_head)
+      end
+
+      before do
+        define_and_create
+      end
+
+      it "should push the fields to the relation" do
+        @head.nearest_fields.should be_nil
+        run_callback
+        @head.nearest_fields.should == nearest_fields
+      end
     end
 
-    it "should do nothing if the relation doesn't exist" do
-      @head.person = nil
-      run_callback
+    describe "define_destroy_callback" do
+      def run_destroy_callback
+        @person.send(:_denormalize_destroy_to_nearest_head)
+      end
+
+      before do
+        define_and_create(:define_destroy_callback)
+      end
+
+      it "should nillify the fields in the relation" do
+        @head.nearest_fields = { "hi" => "hello" }
+        run_destroy_callback
+        @head.nearest_fields.should be_nil
+      end
+
+      it "should do nothing if the relation doesn't exist" do
+        @head.nearest = nil
+        run_destroy_callback
+      end
     end
   end
 
-  describe "define_destroy_callback" do
-    before do
-      @callback.send(:define_destroy_callback)
+  describe "to a polymorphic parent" do
+    def args
+      [Head, :nearest, [:size]]
     end
 
-    def run_destroy_callback
-      @person.send(:_denormalize_destroy_to_head)
+    def create_models
+      @head = Head.create(
+        :nearest => @person = Person.create(:name => @name = "Bob",
+                                           :created_at => @now = Time.now))
     end
 
-    it "should nillify the fields in the relation" do
-      @head.person_name = "Chuck"
-      @head.person_location = "Paris"
-      @head.person_created_at = Time.now
-      run_destroy_callback
-      @head.person_name.should be_nil
-      @head.person_location.should be_nil
-      @head.person_created_at.should be_nil
+    before do
+      Person.class_eval do
+        field :nearest_head_fields, :type => Hash, :default => nil
+      end
     end
 
-    it "should do nothing if the relation doesn't exist" do
-      @head.person = nil
-      run_destroy_callback
+    describe "define_callback" do
+      def nearest_head_fields
+        { "size"=> @size }
+      end
+
+      def run_callback
+        @head.send(:_denormalize_to_nearest)
+      end
+
+      before do
+        define_and_create
+      end
+
+      it "should push the fields to the relation" do
+        @person.nearest_head_fields.should be_nil
+        run_callback
+        @person.nearest_head_fields.should == nearest_head_fields
+      end
+    end
+
+    describe "define_destroy_callback" do
+      def run_destroy_callback
+        @head.send(:_denormalize_destroy_to_nearest)
+      end
+
+      before do
+        define_and_create(:define_destroy_callback)
+      end
+
+      it "should nillify the fields in the relation" do
+        @person.nearest_head_fields = { "hi" => "hello" }
+        run_destroy_callback
+        @person.nearest_head_fields.should be_nil
+      end
+
+      it "should do nothing if the relation doesn't exist" do
+        @person.nearest_head = nil
+        run_destroy_callback
+      end
     end
   end
 end