mongoid_heroku_stable 4.0.0

data/spec/mongoid/inspectable_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+describe Mongoid::Inspectable do
+
+  describe "#inspect" do
+
+    context "when not allowing dynamic fields" do
+
+      let(:person) do
+        Person.new(title: "CEO")
+      end
+
+      let(:inspected) do
+        person.inspect
+      end
+
+      it "includes the model type" do
+        expect(inspected).to include("#<Person")
+      end
+
+      it "displays the id" do
+        expect(inspected).to include("_id: #{person.id}")
+      end
+
+      it "displays defined fields" do
+        expect(inspected).to include("title: \"CEO\"")
+      end
+
+      it "displays field aliases" do
+        expect(inspected).to include("t(test):")
+      end
+    end
+
+    context "when allowing dynamic fields" do
+
+      let(:person) do
+        Person.new(title: "CEO", some_attribute: "foo")
+      end
+
+      let(:inspected) do
+        person.inspect
+      end
+
+      it "includes dynamic attributes" do
+        expect(inspected).to include("some_attribute: \"foo\"")
+      end
+    end
+  end
+end

data/spec/mongoid/interceptable_spec.rb

@@ -0,0 +1,1564 @@
+require "spec_helper"
+
+describe Mongoid::Interceptable do
+
+  class TestClass
+    include Mongoid::Interceptable
+
+    attr_reader :before_save_called, :after_save_called
+
+    before_save do |object|
+      @before_save_called = true
+    end
+
+    after_save do |object|
+      @after_save_called = true
+    end
+  end
+
+  describe ".included" do
+
+    let(:klass) do
+      TestClass
+    end
+
+    it "includes the before_create callback" do
+      expect(klass).to respond_to(:before_create)
+    end
+
+    it "includes the after_create callback" do
+      expect(klass).to respond_to(:after_create)
+    end
+
+    it "includes the before_destroy callback" do
+      expect(klass).to respond_to(:before_destroy)
+    end
+
+    it "includes the after_destroy callback" do
+      expect(klass).to respond_to(:after_destroy)
+    end
+
+    it "includes the before_save callback" do
+      expect(klass).to respond_to(:before_save)
+    end
+
+    it "includes the after_save callback" do
+      expect(klass).to respond_to(:after_save)
+    end
+
+    it "includes the before_update callback" do
+      expect(klass).to respond_to(:before_update)
+    end
+
+    it "includes the after_update callback" do
+      expect(klass).to respond_to(:after_update)
+    end
+
+    it "includes the before_validation callback" do
+      expect(klass).to respond_to(:before_validation)
+    end
+
+    it "includes the after_validation callback" do
+      expect(klass).to respond_to(:after_validation)
+    end
+
+    it "includes the after_initialize callback" do
+      expect(klass).to respond_to(:after_initialize)
+    end
+
+    it "includes the after_build callback" do
+      expect(klass).to respond_to(:after_build)
+    end
+  end
+
+  describe ".after_find" do
+
+    let!(:player) do
+      Player.create
+    end
+
+    context "when the callback is on a root document" do
+
+      context "when when the document is instantiated" do
+
+        it "does not execute the callback" do
+          expect(player.impressions).to eq(0)
+        end
+      end
+
+      context "when the document is found via #find" do
+
+        let(:from_db) do
+          Player.find(player.id)
+        end
+
+        it "executes the callback" do
+          expect(from_db.impressions).to eq(1)
+        end
+      end
+
+      context "when the document is found in a criteria" do
+
+        let(:from_db) do
+          Player.where(id: player.id).first
+        end
+
+        it "executes the callback" do
+          expect(from_db.impressions).to eq(1)
+        end
+      end
+
+      context "when the document is reloaded" do
+
+        let(:from_db) do
+          Player.find(player.id)
+        end
+
+        before do
+          from_db.reload
+        end
+
+        it "executes the callback" do
+          expect(from_db.impressions).to eq(1)
+        end
+      end
+    end
+
+    context "when the callback is on an embedded document" do
+
+      let!(:implant) do
+        player.implants.create
+      end
+
+      context "when when the document is instantiated" do
+
+        it "does not execute the callback" do
+          expect(implant.impressions).to eq(0)
+        end
+      end
+
+      context "when the document is found via #find" do
+
+        let(:from_db) do
+          Player.find(player.id).implants.first
+        end
+
+        it "executes the callback" do
+          expect(from_db.impressions).to eq(1)
+        end
+      end
+
+      context "when the document is found in a criteria" do
+
+        let(:from_db) do
+          Player.find(player.id).implants.find(implant.id)
+        end
+
+        it "executes the callback" do
+          expect(from_db.impressions).to eq(1)
+        end
+      end
+    end
+  end
+
+  describe ".after_initialize" do
+
+    let(:game) do
+      Game.new
+    end
+
+    it "runs after document instantiation" do
+      expect(game.name).to eq("Testing")
+    end
+  end
+
+  describe ".after_build" do
+
+    let(:weapon) do
+      Player.new(frags: 5).weapons.build
+    end
+
+    it "runs after document build (references_many)" do
+      expect(weapon.name).to eq("Holy Hand Grenade (5)")
+    end
+
+    let(:implant) do
+      Player.new(frags: 5).implants.build
+    end
+
+    it "runs after document build (embeds_many)" do
+      expect(implant.name).to eq('Cochlear Implant (5)')
+    end
+
+    let(:powerup) do
+      Player.new(frags: 5).build_powerup
+    end
+
+    it "runs after document build (references_one)" do
+      expect(powerup.name).to eq("Quad Damage (5)")
+    end
+
+    let(:augmentation) do
+      Player.new(frags: 5).build_augmentation
+    end
+
+    it "runs after document build (embeds_one)" do
+      expect(augmentation.name).to eq("Infolink (5)")
+    end
+  end
+
+  describe ".before_create" do
+
+    let(:artist) do
+      Artist.new(name: "Depeche Mode")
+    end
+
+    context "callback returns true" do
+
+      before do
+        artist.should_receive(:before_create_stub).once.and_return(true)
+        artist.save
+      end
+
+      it "gets saved" do
+        expect(artist.persisted?).to be_true
+      end
+    end
+
+    context "callback returns false" do
+
+      before do
+        artist.should_receive(:before_create_stub).once.and_return(false)
+        artist.save
+      end
+
+      it "does not get saved" do
+        expect(artist.persisted?).to be_false
+      end
+    end
+  end
+
+  describe ".before_save" do
+
+    context "when creating" do
+
+      let(:artist) do
+        Artist.new(name: "Depeche Mode")
+      end
+
+      after do
+        artist.delete
+      end
+
+      context "when the callback returns true" do
+
+        before do
+          artist.should_receive(:before_save_stub).once.and_return(true)
+        end
+
+        it "the save returns true" do
+          expect(artist.save).to be_true
+        end
+      end
+
+      context "when callback returns false" do
+
+        before do
+          artist.should_receive(:before_save_stub).once.and_return(false)
+        end
+
+        it "the save returns false" do
+          expect(artist.save).to be_false
+        end
+      end
+    end
+
+    context "when updating" do
+
+      let(:artist) do
+        Artist.create(name: "Depeche Mode").tap do |artist|
+          artist.name = "The Mountain Goats"
+        end
+      end
+
+      after do
+        artist.delete
+      end
+
+      context "when the callback returns true" do
+
+        before do
+          artist.should_receive(:before_save_stub).once.and_return(true)
+        end
+
+        it "the save returns true" do
+          expect(artist.save).to be_true
+        end
+      end
+
+      context "when the callback returns false" do
+
+        before do
+          artist.should_receive(:before_save_stub).once.and_return(false)
+        end
+
+        it "the save returns false" do
+          expect(artist.save).to be_false
+        end
+      end
+    end
+  end
+
+  describe ".before_destroy" do
+
+    let(:artist) do
+      Artist.create(name: "Depeche Mode")
+    end
+
+    before do
+      artist.name = "The Mountain Goats"
+    end
+
+    after do
+      artist.delete
+    end
+
+    context "when the callback returns true" do
+
+      before do
+        artist.should_receive(:before_destroy_stub).once.and_return(true)
+      end
+
+      it "the destroy returns true" do
+        expect(artist.destroy).to be_true
+      end
+    end
+
+    context "when the callback returns false" do
+
+      before do
+        artist.should_receive(:before_destroy_stub).once.and_return(false)
+      end
+
+      it "the destroy returns false" do
+        expect(artist.destroy).to be_false
+      end
+    end
+
+    context "when cascading callbacks" do
+
+      let!(:moderat) do
+        Band.create!(name: "Moderat")
+      end
+
+      let!(:record) do
+        moderat.records.create(name: "Moderat")
+      end
+
+      before do
+        moderat.destroy
+      end
+
+      it "executes the child destroy callbacks" do
+        expect(record.before_destroy_called).to be_true
+      end
+    end
+  end
+
+  describe "#run_after_callbacks" do
+
+    let(:object) do
+      TestClass.new
+    end
+
+    before do
+      object.run_after_callbacks(:save)
+    end
+
+    it "runs the after callbacks" do
+      expect(object.after_save_called).to be_true
+    end
+
+    it "does not run the before callbacks" do
+      expect(object.before_save_called).to be_false
+    end
+  end
+
+  describe "#run_before_callbacks" do
+
+    let(:object) do
+      TestClass.new
+    end
+
+    before do
+      object.run_before_callbacks(:save)
+    end
+
+    it "runs the before callbacks" do
+      expect(object.before_save_called).to be_true
+    end
+
+    it "does not run the after callbacks" do
+      expect(object.after_save_called).to be_false
+    end
+  end
+
+  context "when cascading callbacks" do
+
+    context "when the parent has a custom callback" do
+
+      context "when the child does not have the same callback defined" do
+
+        let(:band) do
+          Band.new
+        end
+
+        let!(:record) do
+          band.records.build
+        end
+
+        context "when running the callbacks directly" do
+
+          before(:all) do
+            Band.define_model_callbacks(:rearrange)
+          end
+
+          after(:all) do
+            Band.reset_callbacks(:rearrange)
+          end
+
+          it "does not cascade to the child" do
+            expect(band.run_callbacks(:rearrange)).to be_true
+          end
+        end
+
+        context "when the callbacks get triggered by a destroy" do
+
+          before(:all) do
+            Band.define_model_callbacks(:rearrange)
+            Band.set_callback(:validation, :before) do
+              run_callbacks(:rearrange)
+            end
+          end
+
+          after(:all) do
+            Band.reset_callbacks(:rearrange)
+          end
+
+          let(:attributes) do
+            {
+              records_attributes: {
+                "0" => { "_id" => record.id, "_destroy" => true }
+              }
+            }
+          end
+
+          it "does not cascade to the child" do
+            Band.accepts_nested_attributes_for :records, allow_destroy: true
+            expect(band.update_attributes(attributes)).to be_true
+          end
+        end
+      end
+    end
+
+    context "when a document can exist in more than 1 level" do
+
+      let(:band) do
+        Band.new
+      end
+
+      let(:record) do
+        band.records.build
+      end
+
+      let(:note) do
+        Note.new
+      end
+
+      context "when adding the document at multiple levels" do
+
+        before do
+          band.notes.push(note)
+          record.notes.push(note)
+        end
+
+        context "when saving the root" do
+
+          it "only executes the callbacks once for each embed" do
+            note.should_receive(:update_saved).twice
+            band.save
+          end
+        end
+      end
+    end
+
+    context "when cascading after initialize" do
+
+      let!(:person) do
+        Person.create
+      end
+
+      before do
+        person.services.create!(sid: 1)
+      end
+
+      it "doesn't cascade the initialize" do
+        Service.any_instance.should_receive(:after_initialize_called=).never
+        expect(Person.find(person.id)).to eq(person)
+      end
+    end
+
+    context "when attempting to cascade on a referenced relation" do
+
+      it "raises an error" do
+        expect {
+          Band.has_and_belongs_to_many :tags, cascade_callbacks: true
+        }.to raise_error(Mongoid::Errors::InvalidOptions)
+      end
+    end
+
+    context "when the documents are embedded one level" do
+
+      describe "#after_create" do
+
+        context "when the child is new" do
+
+          context "when the parent is new" do
+
+            let(:band) do
+              Band.new(name: "Moderat")
+            end
+
+            let!(:label) do
+              band.build_label(name: "Mute")
+            end
+
+            before do
+              band.save
+            end
+
+            it "executes the callback" do
+              expect(label.after_create_called).to be_true
+            end
+          end
+
+          context "when the parent is persisted" do
+
+            let(:band) do
+              Band.create(name: "Moderat")
+            end
+
+            let!(:label) do
+              band.build_label(name: "Mute")
+            end
+
+            before do
+              band.save
+            end
+
+            it "executes the callback" do
+              expect(label.after_create_called).to be_true
+            end
+          end
+        end
+
+        context "when the child is persisted" do
+
+          let(:band) do
+            Band.create(name: "Moderat")
+          end
+
+          let!(:label) do
+            band.create_label(name: "Mute")
+          end
+
+          before do
+            label.after_create_called = false
+            band.save
+          end
+
+          it "does not execute the callback" do
+            expect(label.after_create_called).to be_false
+          end
+        end
+      end
+
+      describe "#after_save" do
+
+        context "when the child is new" do
+
+          context "when the parent is new" do
+
+            let(:band) do
+              Band.new(name: "Moderat")
+            end
+
+            let!(:label) do
+              band.build_label(name: "Mute")
+            end
+
+            before do
+              band.save
+            end
+
+            it "executes the callback" do
+              expect(label.after_save_called).to be_true
+            end
+          end
+
+          context "when the parent is persisted" do
+
+            let(:band) do
+              Band.create(name: "Moderat")
+            end
+
+            let!(:label) do
+              band.build_label(name: "Mute")
+            end
+
+            before do
+              band.save
+            end
+
+            it "executes the callback" do
+              expect(label.after_save_called).to be_true
+            end
+          end
+        end
+
+        context "when the child is persisted" do
+
+          let(:band) do
+            Band.create(name: "Moderat")
+          end
+
+          let!(:label) do
+            band.create_label(name: "Mute")
+          end
+
+          before do
+            band.save
+          end
+
+          it "executes the callback" do
+            expect(label.after_save_called).to be_true
+          end
+        end
+      end
+
+      describe "#after_update" do
+
+        context "when the child is new" do
+
+          context "when the parent is new" do
+
+            let(:band) do
+              Band.new(name: "Moderat")
+            end
+
+            let!(:label) do
+              band.build_label(name: "Mute")
+            end
+
+            before do
+              band.save
+            end
+
+            it "does not execute the callback" do
+              expect(label.after_update_called).to be_false
+            end
+          end
+
+          context "when the parent is persisted" do
+
+            let(:band) do
+              Band.create(name: "Moderat")
+            end
+
+            let!(:label) do
+              band.build_label(name: "Mute")
+            end
+
+            before do
+              band.save
+            end
+
+            it "does not execute the callback" do
+              expect(label.after_update_called).to be_false
+            end
+          end
+        end
+
+        context "when the child is persisted" do
+
+          let(:band) do
+            Band.create(name: "Moderat")
+          end
+
+          context "when the child is dirty" do
+
+            let!(:label) do
+              band.create_label(name: "Mute")
+            end
+
+            before do
+              label.name = "Nothing"
+              band.save
+            end
+
+            it "executes the callback" do
+              expect(label.after_update_called).to be_true
+            end
+          end
+
+          context "when the child is not dirty" do
+
+            let!(:label) do
+              band.build_label(name: "Mute")
+            end
+
+            before do
+              band.save
+            end
+
+            it "does not execute the callback" do
+              expect(label.after_update_called).to be_false
+            end
+          end
+        end
+      end
+
+      describe "#after_validation" do
+
+        context "when the child is new" do
+
+          context "when the parent is new" do
+
+            let(:band) do
+              Band.new(name: "Moderat")
+            end
+
+            let!(:label) do
+              band.build_label(name: "Mute")
+            end
+
+            before do
+              band.save
+            end
+
+            it "executes the callback" do
+              expect(label.after_validation_called).to be_true
+            end
+          end
+
+          context "when the parent is persisted" do
+
+            let(:band) do
+              Band.create(name: "Moderat")
+            end
+
+            let!(:label) do
+              band.build_label(name: "Mute")
+            end
+
+            before do
+              band.save
+            end
+
+            it "executes the callback" do
+              expect(label.after_validation_called).to be_true
+            end
+          end
+        end
+
+        context "when the child is persisted" do
+
+          let(:band) do
+            Band.create(name: "Moderat")
+          end
+
+          let!(:label) do
+            band.create_label(name: "Mute")
+          end
+
+          before do
+            band.save
+          end
+
+          it "executes the callback" do
+            expect(label.after_validation_called).to be_true
+          end
+        end
+      end
+
+      describe "#before_create" do
+
+        context "when the child is new" do
+
+          context "when the parent is new" do
+
+            let(:band) do
+              Band.new(name: "Moderat")
+            end
+
+            let!(:record) do
+              band.records.build(name: "Moderat")
+            end
+
+            before do
+              band.save
+            end
+
+            it "executes the callback" do
+              expect(record.before_create_called).to be_true
+            end
+          end
+
+          context "when the parent is persisted" do
+
+            let(:band) do
+              Band.create(name: "Moderat")
+            end
+
+            let!(:record) do
+              band.records.build(name: "Moderat")
+            end
+
+            before do
+              band.save
+            end
+
+            it "executes the callback" do
+              expect(record.before_create_called).to be_true
+            end
+          end
+        end
+
+        context "when the child is persisted" do
+
+          let(:band) do
+            Band.create(name: "Moderat")
+          end
+
+          let!(:record) do
+            band.records.create(name: "Moderat")
+          end
+
+          before do
+            record.before_create_called = false
+            band.save
+          end
+
+          it "does not execute the callback" do
+            expect(record.before_create_called).to be_false
+          end
+        end
+      end
+
+      describe "#before_save" do
+
+        context "when the child is new" do
+
+          context "when the parent is new" do
+
+            let(:band) do
+              Band.new(name: "Moderat")
+            end
+
+            let!(:record) do
+              band.records.build(name: "Moderat")
+            end
+
+            before do
+              band.save
+            end
+
+            it "executes the callback" do
+              expect(record.before_save_called).to be_true
+            end
+
+            it "persists the change" do
+              expect(band.reload.records.first.before_save_called).to be_true
+            end
+          end
+
+          context "when the parent is persisted" do
+
+            let(:band) do
+              Band.create(name: "Moderat")
+            end
+
+            let!(:record) do
+              band.records.build(name: "Moderat")
+            end
+
+            before do
+              band.save
+            end
+
+            it "executes the callback" do
+              expect(record.before_save_called).to be_true
+            end
+
+            it "persists the change" do
+              expect(band.reload.records.first.before_save_called).to be_true
+            end
+          end
+        end
+
+        context "when the child is persisted" do
+
+          let(:band) do
+            Band.create(name: "Moderat")
+          end
+
+          let!(:record) do
+            band.records.create(name: "Moderat")
+          end
+
+          before do
+            band.save
+          end
+
+          it "executes the callback" do
+            expect(record.before_save_called).to be_true
+          end
+
+          it "persists the change" do
+            expect(band.reload.records.first.before_save_called).to be_true
+          end
+        end
+      end
+
+      describe "#before_update" do
+
+        context "when the child is new" do
+
+          context "when the parent is new" do
+
+            let(:band) do
+              Band.new(name: "Moderat")
+            end
+
+            let!(:record) do
+              band.records.build(name: "Moderat")
+            end
+
+            before do
+              band.save
+            end
+
+            it "does not execute the callback" do
+              expect(record.before_update_called).to be_false
+            end
+          end
+
+          context "when the parent is persisted" do
+
+            let(:band) do
+              Band.create(name: "Moderat")
+            end
+
+            let!(:record) do
+              band.records.build(name: "Moderat")
+            end
+
+            before do
+              band.save
+            end
+
+            it "does not execute the callback" do
+              expect(record.before_update_called).to be_false
+            end
+          end
+        end
+
+        context "when the child is persisted" do
+
+          let(:band) do
+            Band.create(name: "Moderat")
+          end
+
+          let!(:record) do
+            band.records.create(name: "Moderat")
+          end
+
+          context "when the child is dirty" do
+
+            before do
+              record.name = "Nothing"
+              band.save
+            end
+
+            it "executes the callback" do
+              expect(record.before_update_called).to be_true
+            end
+
+            it "persists the change" do
+              expect(band.reload.records.first.before_update_called).to be_true
+            end
+          end
+
+          context "when the child is not dirty" do
+
+            before do
+              band.save
+            end
+
+            it "does not execute the callback" do
+              expect(record.before_update_called).to be_false
+            end
+          end
+        end
+      end
+
+      describe "#before_validation" do
+
+        context "when the child is new" do
+
+          context "when the parent is new" do
+
+            let(:band) do
+              Band.new(name: "Moderat")
+            end
+
+            let!(:record) do
+              band.records.build(name: "Moderat")
+            end
+
+            before do
+              band.save
+            end
+
+            it "executes the callback" do
+              expect(record.before_validation_called).to be_true
+            end
+
+            it "persists the change" do
+              expect(band.reload.records.first.before_validation_called).to be_true
+            end
+          end
+
+          context "when the parent is persisted" do
+
+            let(:band) do
+              Band.create(name: "Moderat")
+            end
+
+            let!(:record) do
+              band.records.build(name: "Moderat")
+            end
+
+            before do
+              band.save
+            end
+
+            it "executes the callback" do
+              expect(record.before_validation_called).to be_true
+            end
+
+            it "persists the change" do
+              expect(band.reload.records.first.before_validation_called).to be_true
+            end
+          end
+        end
+
+        context "when the child is persisted" do
+
+          let(:band) do
+            Band.create(name: "Moderat")
+          end
+
+          let!(:record) do
+            band.records.create(name: "Moderat")
+          end
+
+          before do
+            band.save
+          end
+
+          it "executes the callback" do
+            expect(record.before_validation_called).to be_true
+          end
+
+          it "persists the change" do
+            expect(band.reload.records.first.before_validation_called).to be_true
+          end
+        end
+      end
+    end
+
+    context "when the document is embedded multiple levels" do
+
+      describe "#before_create" do
+
+        context "when the child is new" do
+
+          context "when the root is new" do
+
+            let(:band) do
+              Band.new(name: "Moderat")
+            end
+
+            let!(:record) do
+              band.records.build(name: "Moderat")
+            end
+
+            let!(:track) do
+              record.tracks.build(name: "Berlin")
+            end
+
+            before do
+              band.save
+            end
+
+            it "executes the callback" do
+              expect(track.before_create_called).to be_true
+            end
+          end
+
+          context "when the root is persisted" do
+
+            let(:band) do
+              Band.create(name: "Moderat")
+            end
+
+            let!(:record) do
+              band.records.build(name: "Moderat")
+            end
+
+            let!(:track) do
+              record.tracks.build(name: "Berlin")
+            end
+
+            before do
+              band.save
+            end
+
+            it "executes the callback" do
+              expect(track.before_create_called).to be_true
+            end
+          end
+        end
+
+        context "when the child is persisted" do
+
+          let(:band) do
+            Band.create(name: "Moderat")
+          end
+
+          let!(:record) do
+            band.records.create(name: "Moderat")
+          end
+
+          let!(:track) do
+            record.tracks.create(name: "Berlin")
+          end
+
+          before do
+            track.before_create_called = false
+            band.save
+          end
+
+          it "does not execute the callback" do
+            expect(track.before_create_called).to be_false
+          end
+        end
+      end
+
+      describe "#before_save" do
+
+        context "when the child is new" do
+
+          context "when the root is new" do
+
+            let(:band) do
+              Band.new(name: "Moderat")
+            end
+
+            let!(:record) do
+              band.records.build(name: "Moderat")
+            end
+
+            let!(:track) do
+              record.tracks.build(name: "Berlin")
+            end
+
+            before do
+              band.save
+            end
+
+            let(:reloaded) do
+              band.reload.records.first
+            end
+
+            it "executes the callback" do
+              expect(track.before_save_called).to be_true
+            end
+
+            it "persists the change" do
+              expect(reloaded.tracks.first.before_save_called).to be_true
+            end
+          end
+
+          context "when the parent is persisted" do
+
+            let(:band) do
+              Band.create(name: "Moderat")
+            end
+
+            let!(:record) do
+              band.records.build(name: "Moderat")
+            end
+
+            let!(:track) do
+              record.tracks.build(name: "Berlin")
+            end
+
+            before do
+              band.save
+            end
+
+            let(:reloaded) do
+              band.reload.records.first
+            end
+
+            it "executes the callback" do
+              expect(track.before_save_called).to be_true
+            end
+
+            it "persists the change" do
+              expect(reloaded.tracks.first.before_save_called).to be_true
+            end
+          end
+        end
+
+        context "when the child is persisted" do
+
+          let(:band) do
+            Band.create(name: "Moderat")
+          end
+
+          let!(:record) do
+            band.records.create(name: "Moderat")
+          end
+
+          let!(:track) do
+            record.tracks.create(name: "Berlin")
+          end
+
+          before do
+            band.save
+          end
+
+          let(:reloaded) do
+            band.reload.records.first
+          end
+
+          it "executes the callback" do
+            expect(track.before_save_called).to be_true
+          end
+
+          it "persists the change" do
+            expect(reloaded.tracks.first.before_save_called).to be_true
+          end
+        end
+      end
+
+      describe "#before_update" do
+
+        context "when the child is new" do
+
+          context "when the parent is new" do
+
+            let(:band) do
+              Band.new(name: "Moderat")
+            end
+
+            let!(:record) do
+              band.records.build(name: "Moderat")
+            end
+
+            let!(:track) do
+              record.tracks.build(name: "Berlin")
+            end
+
+            before do
+              band.save
+            end
+
+            it "does not execute the callback" do
+              expect(track.before_update_called).to be_false
+            end
+          end
+
+          context "when the parent is persisted" do
+
+            let(:band) do
+              Band.create(name: "Moderat")
+            end
+
+            let!(:record) do
+              band.records.build(name: "Moderat")
+            end
+
+            let!(:track) do
+              record.tracks.build(name: "Berlin")
+            end
+
+            before do
+              band.save
+            end
+
+            it "does not execute the callback" do
+              expect(track.before_update_called).to be_false
+            end
+          end
+        end
+
+        context "when the child is persisted" do
+
+          let(:band) do
+            Band.create(name: "Moderat")
+          end
+
+          let!(:record) do
+            band.records.create(name: "Moderat")
+          end
+
+          let!(:track) do
+            record.tracks.create(name: "Berlin")
+          end
+
+          context "when the child is dirty" do
+
+            before do
+              track.name = "Rusty Nails"
+              band.save
+            end
+
+            let(:reloaded) do
+              band.reload.records.first
+            end
+
+            it "executes the callback" do
+              expect(track.before_update_called).to be_true
+            end
+
+            it "persists the change" do
+              expect(reloaded.tracks.first.before_update_called).to be_true
+            end
+          end
+
+          context "when the child is not dirty" do
+
+            before do
+              band.save
+            end
+
+            it "does not execute the callback" do
+              expect(track.before_update_called).to be_false
+            end
+          end
+        end
+      end
+
+      describe "#before_validation" do
+
+        context "when the child is new" do
+
+          context "when the parent is new" do
+
+            let(:band) do
+              Band.new(name: "Moderat")
+            end
+
+            let!(:record) do
+              band.records.build(name: "Moderat")
+            end
+
+            let!(:track) do
+              record.tracks.build(name: "Berlin")
+            end
+
+            before do
+              band.save
+            end
+
+            it "executes the callback" do
+              expect(track.before_validation_called).to be_true
+            end
+          end
+
+          context "when the parent is persisted" do
+
+            let(:band) do
+              Band.create(name: "Moderat")
+            end
+
+            let!(:record) do
+              band.records.build(name: "Moderat")
+            end
+
+            let!(:track) do
+              record.tracks.build(name: "Berlin")
+            end
+
+            before do
+              band.save
+            end
+
+            it "executes the callback" do
+              expect(track.before_validation_called).to be_true
+            end
+          end
+        end
+
+        context "when the child is persisted" do
+
+          let(:band) do
+            Band.create(name: "Moderat")
+          end
+
+          let!(:record) do
+            band.records.create(name: "Moderat")
+          end
+
+          let!(:track) do
+            record.tracks.create(name: "Berlin")
+          end
+
+          before do
+            band.save
+          end
+
+          it "executes the callback" do
+            expect(track.before_validation_called).to be_true
+          end
+        end
+      end
+    end
+  end
+
+  context "callback on valid?" do
+
+    it "goes in all validation callback in good order" do
+      shin = ValidationCallback.new
+      shin.valid?
+      expect(shin.history).to eq([:before_validation, :validate, :after_validation])
+    end
+  end
+
+  context "when creating child documents in callbacks" do
+
+    let(:parent) do
+      ParentDoc.new
+    end
+
+    before do
+      parent.save
+    end
+
+    it "does not duplicate the child documents" do
+      parent.children.create(position: 1)
+      expect(ParentDoc.find(parent.id).children.size).to eq(1)
+    end
+  end
+
+  context "when callbacks cancel persistence" do
+
+    let(:address) do
+      Address.new(street: "123 Sesame")
+    end
+
+    before(:all) do
+      Person.before_save do |doc|
+        doc.mode != :prevent_save
+      end
+    end
+
+    after(:all) do
+      Person.reset_callbacks(:save)
+    end
+
+    context "when creating a document" do
+
+      let(:person) do
+        Person.new(mode: :prevent_save, title: "Associate", addresses: [ address ])
+      end
+
+      it "fails to save" do
+        expect(person).to be_valid
+        expect(person.save).to be_false
+      end
+
+      it "is a new record" do
+        expect(person).to be_a_new_record
+        expect { person.save }.not_to change { person.new_record? }
+      end
+
+      it "is left dirty" do
+        expect(person).to be_changed
+        expect { person.save }.not_to change { person.changed? }
+      end
+
+      it "child documents are left dirty" do
+        expect(address).to be_changed
+        expect { person.save }.not_to change { address.changed? }
+      end
+    end
+
+    context "when updating a document" do
+
+      let(:person) do
+        Person.create.tap do |person|
+          person.attributes = {
+            mode: :prevent_save,
+            title: "Associate",
+            addresses: [ address ]
+          }
+        end
+      end
+
+      it "#save returns false" do
+        expect(person).to be_valid
+        expect(person.save).to be_false
+      end
+
+      it "is a not a new record" do
+        expect(person).to_not be_a_new_record
+        expect { person.save }.not_to change { person.new_record? }
+      end
+
+      it "is left dirty" do
+        expect(person).to be_changed
+        expect { person.save }.not_to change { person.changed? }
+      end
+
+      it "child documents are left dirty" do
+        expect(address).to be_changed
+        expect { person.save }.not_to change { address.changed? }
+      end
+    end
+  end
+
+  context "when loading a model multiple times" do
+
+    before do
+      load "spec/app/models/callback_test.rb"
+      load "spec/app/models/callback_test.rb"
+    end
+
+    let(:callback) do
+      CallbackTest.new
+    end
+
+    context "when saving the document" do
+
+      it "only executes the callbacks once" do
+        callback.should_receive(:execute).once
+        callback.save
+      end
+    end
+  end
+end