mongoid 5.4.1 → 7.4.0

data/spec/mongoid/relations/referenced/one_spec.rb

@@ -1,1240 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Relations::Referenced::One do
-
-  describe "#=" do
-
-    context "when the relationship is an illegal embedded reference" do
-
-      let(:game) do
-        Game.new
-      end
-
-      let(:video) do
-        Video.new
-      end
-
-      it "raises a mixed relation error" do
-        expect {
-          game.video = video
-        }.to raise_error(Mongoid::Errors::MixedRelations)
-      end
-    end
-
-    context "when the relation is cyclic" do
-
-      let(:user) do
-        User.new
-      end
-
-      let(:role) do
-        Role.new
-      end
-
-      before do
-        user.role = role
-      end
-
-      it "does not raise an error" do
-        expect(user.role).to eq(role)
-      end
-    end
-
-    context "when the relation is not polymorphic" do
-
-      context "when the parent is a new record" do
-
-        let(:person) do
-          Person.new
-        end
-
-        let(:game) do
-          Game.new
-        end
-
-        let(:metadata) do
-          Game.relations["person"]
-        end
-
-        before do
-          expect(metadata).to receive(:criteria).never
-          person.game = game
-        end
-
-        it "sets the target of the relation" do
-          expect(person.game.target).to eq(game)
-        end
-
-        it "sets the foreign key on the relation" do
-          expect(game.person_id).to eq(person.id)
-        end
-
-        it "sets the base on the inverse relation" do
-          expect(game.person).to eq(person)
-        end
-
-        it "sets the same instance on the inverse relation" do
-          expect(game.person).to eql(person)
-        end
-
-        it "does not save the target" do
-          expect(game).to_not be_persisted
-        end
-      end
-
-      context "when the parent is not a new record" do
-
-        let(:person) do
-          Person.create
-        end
-
-        let(:game) do
-          Game.new
-        end
-
-        before do
-          person.game = game
-        end
-
-        it "sets the target of the relation" do
-          expect(person.game.target).to eq(game)
-        end
-
-        it "sets the foreign key of the relation" do
-          expect(game.person_id).to eq(person.id)
-        end
-
-        it "sets the base on the inverse relation" do
-          expect(game.person).to eq(person)
-        end
-
-        it "sets the same instance on the inverse relation" do
-          expect(game.person).to eql(person)
-        end
-
-        it "saves the target" do
-          expect(game).to be_persisted
-        end
-
-        context "when reloading the parent" do
-
-          before do
-            person.reload
-          end
-
-          context "when setting a new document on the relation" do
-
-            before do
-              person.game = Game.new
-            end
-
-            it "detaches the previous relation" do
-              expect {
-                game.reload
-              }.to raise_error(Mongoid::Errors::DocumentNotFound)
-            end
-          end
-        end
-      end
-
-      context "when relation have a different primary_key" do
-
-        let(:person) do
-          Person.create
-        end
-
-        let(:cat) do
-          Cat.new
-        end
-
-        before do
-          person.cat = cat
-        end
-
-        it "sets the target of the relation" do
-          expect(person.cat.target).to eq(cat)
-        end
-
-        it "sets the foreign key of the relation" do
-          expect(cat.person_id).to eq(person.username)
-        end
-
-        it "sets the base on the inverse relation" do
-          expect(cat.person).to eq(person)
-        end
-
-        it "sets the same instance on the inverse relation" do
-          expect(cat.person).to eql(person)
-        end
-
-        it "saves the target" do
-          expect(cat).to be_persisted
-        end
-      end
-    end
-
-    context "when the relation is polymorphic" do
-
-      context "when the parent is a new record" do
-
-        let(:bar) do
-          Bar.new
-        end
-
-        let(:rating) do
-          Rating.new
-        end
-
-        before do
-          bar.rating = rating
-        end
-
-        it "sets the target of the relation" do
-          expect(bar.rating.target).to eq(rating)
-        end
-
-        it "sets the foreign key on the relation" do
-          expect(rating.ratable_id).to eq(bar.id)
-        end
-
-        it "sets the base on the inverse relation" do
-          expect(rating.ratable).to eq(bar)
-        end
-
-        it "sets the same instance on the inverse relation" do
-          expect(rating.ratable).to eql(bar)
-        end
-
-        it "does not save the target" do
-          expect(rating).to_not be_persisted
-        end
-      end
-
-      context "when the parent is not a new record" do
-
-        let(:bar) do
-          Bar.create
-        end
-
-        let(:rating) do
-          Rating.new
-        end
-
-        before do
-          bar.rating = rating
-        end
-
-        it "sets the target of the relation" do
-          expect(bar.rating.target).to eq(rating)
-        end
-
-        it "sets the foreign key of the relation" do
-          expect(rating.ratable_id).to eq(bar.id)
-        end
-
-        it "sets the base on the inverse relation" do
-          expect(rating.ratable).to eq(bar)
-        end
-
-        it "sets the same instance on the inverse relation" do
-          expect(rating.ratable).to eql(bar)
-        end
-
-        it "saves the target" do
-          expect(rating).to be_persisted
-        end
-      end
-
-      context "when replacing an existing persisted (dependent: :destroy) relation" do
-
-        let!(:person) do
-          Person.create
-        end
-
-        let!(:game) do
-          person.create_game(name: "Starcraft")
-        end
-
-        context "with a new one created via the parent" do
-
-          let!(:new_game) do
-            person.create_game(name: "Starcraft 2")
-          end
-
-          it "sets the new relation on the parent" do
-            expect(person.game).to eq(new_game)
-          end
-
-          it "removes the old foreign key reference" do
-            expect(game.person_id).to be_nil
-          end
-
-          it "removes the reference to the parent" do
-            expect(game.person).to be_nil
-          end
-
-          it "destroys the old child" do
-            expect(game).to be_destroyed
-          end
-
-          it "leaves the old child unpersisted" do
-            expect(game.persisted?).to be false
-          end
-
-          it "leaves the new child persisted" do
-            expect(new_game.persisted?).to be true
-          end
-        end
-
-        context "with a new one built via the parent" do
-
-          let!(:new_game) do
-            person.build_game(name: "Starcraft 2")
-          end
-
-          it "sets the new relation on the parent" do
-            expect(person.game).to eq(new_game)
-          end
-
-          it "removes the old foreign key reference" do
-            expect(game.person_id).to be_nil
-          end
-
-          it "removes the reference to the parent" do
-            expect(game.person).to be_nil
-          end
-
-          it "does not destroy the old child" do
-            expect(game).to_not be_destroyed
-          end
-
-          it "leaves the old child persisted" do
-            expect(game.persisted?).to be true
-          end
-
-          it "leaves the new child unpersisted" do
-            expect(new_game.persisted?).to be false
-          end
-        end
-      end
-
-      context "when replacing an existing unpersisted (dependent: :destroy) relation" do
-
-        let!(:person) do
-          Person.create
-        end
-
-        let!(:game) do
-          person.build_game(name: "Starcraft")
-        end
-
-        context "with a new one created via the parent" do
-
-          let!(:new_game) do
-            person.create_game(name: "Starcraft 2")
-          end
-
-          it "sets the new relation on the parent" do
-            expect(person.game).to eq(new_game)
-          end
-
-          it "removes the old foreign key reference" do
-            expect(game.person_id).to be_nil
-          end
-
-          it "removes the reference to the parent" do
-            expect(game.person).to be_nil
-          end
-
-          it "destroys the old child" do
-            expect(game).to be_destroyed
-          end
-
-          it "leaves the old child unpersisted" do
-            expect(game.persisted?).to be false
-          end
-
-          it "leaves the new child persisted" do
-            expect(new_game.persisted?).to be true
-          end
-        end
-
-        context "with a new one built via the parent" do
-
-          let!(:new_game) do
-            person.build_game(name: "Starcraft 2")
-          end
-
-          it "sets the new relation on the parent" do
-            expect(person.game).to eq(new_game)
-          end
-
-          it "removes the old foreign key reference" do
-            expect(game.person_id).to be_nil
-          end
-
-          it "removes the reference to the parent" do
-            expect(game.person).to be_nil
-          end
-
-          it "does not destroy the old child" do
-            expect(game).to_not be_destroyed
-          end
-
-          it "leaves the old child unpersisted" do
-            expect(game.persisted?).to be false
-          end
-
-          it "leaves the new child unpersisted" do
-            expect(new_game.persisted?).to be false
-          end
-        end
-      end
-
-      context "when replacing an existing persisted (dependent: :nullify) relation" do
-
-        let!(:person) do
-          Person.create
-        end
-
-        let!(:cat) do
-          person.create_cat(name: "Cuddles")
-        end
-
-        context "with a new one created via the parent" do
-
-          let!(:new_cat) do
-            person.create_cat(name: "Brutus")
-          end
-
-          it "sets the new relation on the parent" do
-            expect(person.cat).to eq(new_cat)
-          end
-
-          it "removes the old foreign key reference" do
-            expect(cat.person_id).to be_nil
-          end
-
-          it "removes the reference to the parent" do
-            expect(cat.person).to be_nil
-          end
-
-          it "does not destroy the old child" do
-            expect(cat).to_not be_destroyed
-          end
-
-          it "leaves the old child persisted" do
-            expect(cat.persisted?).to be true
-          end
-
-          it "leaves the new child persisted" do
-            expect(new_cat.persisted?).to be true
-          end
-        end
-
-        context "with a new one built via the parent" do
-
-          let!(:new_cat) do
-            person.build_cat(name: "Brutus")
-          end
-
-          it "sets the new relation on the parent" do
-            expect(person.cat).to eq(new_cat)
-          end
-
-          it "removes the old foreign key reference" do
-            expect(cat.person_id).to be_nil
-          end
-
-          it "removes the reference to the parent" do
-            expect(cat.person).to be_nil
-          end
-
-          it "does not destroy the old child" do
-            expect(cat).to_not be_destroyed
-          end
-
-          it "leaves the old child persisted" do
-            expect(cat.persisted?).to be true
-          end
-
-          it "leaves the new child unpersisted" do
-            expect(new_cat.persisted?).to be false
-          end
-        end
-      end
-
-      context "when replacing an existing unpersisted (dependent: :nullify) relation" do
-
-        let!(:person) do
-          Person.create
-        end
-
-        let!(:cat) do
-          person.build_cat(name: "Cuddles")
-        end
-
-        context "with a new one created via the parent" do
-
-          let!(:new_cat) do
-            person.create_cat(name: "Brutus")
-          end
-
-          it "sets the new relation on the parent" do
-            expect(person.cat).to eq(new_cat)
-          end
-
-          it "removes the old foreign key reference" do
-            expect(cat.person_id).to be_nil
-          end
-
-          it "removes the reference to the parent" do
-            expect(cat.person).to be_nil
-          end
-
-          it "does not destroy the old child" do
-            expect(cat).to_not be_destroyed
-          end
-
-          it "leaves the old child unpersisted" do
-            expect(cat.persisted?).to be false
-          end
-
-          it "leaves the new child persisted" do
-            expect(new_cat.persisted?).to be true
-          end
-        end
-
-        context "with a new one built via the parent" do
-
-          let!(:new_cat) do
-            person.build_cat(name: "Brutus")
-          end
-
-          it "sets the new relation on the parent" do
-            expect(person.cat).to eq(new_cat)
-          end
-
-          it "removes the old foreign key reference" do
-            expect(cat.person_id).to be_nil
-          end
-
-          it "removes the reference to the parent" do
-            expect(cat.person).to be_nil
-          end
-
-          it "does not destroy the old child" do
-            expect(cat).to_not be_destroyed
-          end
-
-          it "leaves the old child unpersisted" do
-            expect(cat.persisted?).to be false
-          end
-
-          it "leaves the new child unpersisted" do
-            expect(new_cat.persisted?).to be false
-          end
-        end
-      end
-
-      context "when replacing an existing relation with a new one" do
-
-        let!(:person) do
-          Person.create
-        end
-
-        context "when dependent is destroy" do
-
-          let!(:game) do
-            person.create_game(name: "Starcraft")
-          end
-
-          let!(:new_game) do
-            Game.create(name: "Starcraft 2")
-          end
-
-          before do
-            person.game = new_game
-          end
-
-          it "sets the new relation on the parent" do
-            expect(person.game).to eq(new_game)
-          end
-
-          it "removes the old foreign key reference" do
-            expect(game.person_id).to be_nil
-          end
-
-          it "removes the reference to the parent" do
-            expect(game.person).to be_nil
-          end
-
-          it "destroys the old child" do
-            expect(game).to be_destroyed
-          end
-        end
-
-        context "when dependent is not set" do
-
-          let!(:account) do
-            person.create_account(name: "savings")
-          end
-
-          let!(:new_account) do
-            Account.create(name: "checking")
-          end
-
-          before do
-            person.account = new_account
-          end
-
-          it "sets the new relation on the parent" do
-            expect(person.account).to eq(new_account)
-          end
-
-          it "removes the old foreign key reference" do
-            expect(account.person_id).to be_nil
-          end
-
-          it "removes the reference to the parent" do
-            expect(account.person).to be_nil
-          end
-
-          it "nullifies the old child" do
-            expect(account).to_not be_destroyed
-          end
-        end
-      end
-    end
-  end
-
-  describe "#= nil" do
-
-    context "when the relation is not polymorphic" do
-
-      context "when the parent is a new record" do
-
-        let(:person) do
-          Person.new
-        end
-
-        let(:game) do
-          Game.new
-        end
-
-        before do
-          person.game = game
-          person.game = nil
-        end
-
-        it "sets the relation to nil" do
-          expect(person.game).to be_nil
-        end
-
-        it "removed the inverse relation" do
-          expect(game.person).to be_nil
-        end
-
-        it "removes the foreign key value" do
-          expect(game.person_id).to be_nil
-        end
-      end
-
-      context "when the parent is not a new record" do
-
-        let(:person) do
-          Person.create
-        end
-
-        let(:game) do
-          Game.new
-        end
-
-        before do
-          person.game = game
-          person.game = nil
-        end
-
-        it "sets the relation to nil" do
-          expect(person.game).to be_nil
-        end
-
-        it "removed the inverse relation" do
-          expect(game.person).to be_nil
-        end
-
-        it "removes the foreign key value" do
-          expect(game.person_id).to be_nil
-        end
-
-        it "deletes the target from the database" do
-          expect(game).to be_destroyed
-        end
-      end
-    end
-
-    context "when the relation is polymorphic" do
-
-      context "when the parent is a new record" do
-
-        let(:bar) do
-          Bar.new
-        end
-
-        let(:rating) do
-          Rating.new
-        end
-
-        before do
-          bar.rating = rating
-          bar.rating = nil
-        end
-
-        it "sets the relation to nil" do
-          expect(bar.rating).to be_nil
-        end
-
-        it "removed the inverse relation" do
-          expect(rating.ratable).to be_nil
-        end
-
-        it "removes the foreign key value" do
-          expect(rating.ratable_id).to be_nil
-        end
-      end
-
-      context "when the parent is not a new record" do
-
-        let(:bar) do
-          Bar.create
-        end
-
-        let(:rating) do
-          Rating.new
-        end
-
-        before do
-          bar.rating = rating
-          bar.rating = nil
-        end
-
-        it "sets the relation to nil" do
-          expect(bar.rating).to be_nil
-        end
-
-        it "removed the inverse relation" do
-          expect(rating.ratable).to be_nil
-        end
-
-        it "removes the foreign key value" do
-          expect(rating.ratable_id).to be_nil
-        end
-
-        it "applies the appropriate dependent option" do
-          expect(rating).to_not be_destroyed
-        end
-      end
-    end
-  end
-
-  describe "#build_#\{name}" do
-
-    context "when the relationship is an illegal embedded reference" do
-
-      let(:game) do
-        Game.new
-      end
-
-      it "raises a mixed relation error" do
-        expect {
-          game.build_video(title: "Tron")
-        }.to raise_error(Mongoid::Errors::MixedRelations)
-      end
-    end
-
-    context "when the relation is not polymorphic" do
-
-      context "when using object ids" do
-
-        let(:person) do
-          Person.create
-        end
-
-        let(:game) do
-          person.build_game(score: 50)
-        end
-
-        it "returns a new document" do
-          expect(game.score).to eq(50)
-        end
-
-        it "sets the foreign key on the document" do
-          expect(game.person_id).to eq(person.id)
-        end
-
-        it "sets the inverse relation" do
-          expect(game.person).to eq(person)
-        end
-
-        it "does not save the built document" do
-          expect(game).to_not be_persisted
-        end
-      end
-
-      context "when providing no attributes" do
-
-        let(:person) do
-          Person.create
-        end
-
-        let(:game) do
-          person.build_game
-        end
-
-        it "sets the foreign key on the document" do
-          expect(game.person_id).to eq(person.id)
-        end
-
-        it "sets the inverse relation" do
-          expect(game.person).to eq(person)
-        end
-
-        it "does not save the built document" do
-          expect(game).to_not be_persisted
-        end
-      end
-
-      context "when providing nil attributes" do
-
-        let(:person) do
-          Person.create
-        end
-
-        let(:game) do
-          person.build_game(nil)
-        end
-
-        it "sets the foreign key on the document" do
-          expect(game.person_id).to eq(person.id)
-        end
-
-        it "sets the inverse relation" do
-          expect(game.person).to eq(person)
-        end
-
-        it "does not save the built document" do
-          expect(game).to_not be_persisted
-        end
-      end
-    end
-
-    context "when the relation is polymorphic" do
-
-      context "when using object ids" do
-
-        let(:bar) do
-          Bar.create
-        end
-
-        let(:rating) do
-          bar.build_rating(value: 5)
-        end
-
-        it "returns a new document" do
-          expect(rating.value).to eq(5)
-        end
-
-        it "sets the foreign key on the document" do
-          expect(rating.ratable_id).to eq(bar.id)
-        end
-
-        it "sets the inverse relation" do
-          expect(rating.ratable).to eq(bar)
-        end
-
-        it "does not save the built document" do
-          expect(rating).to_not be_persisted
-        end
-      end
-    end
-  end
-
-  describe ".builder" do
-
-    let(:builder_klass) do
-      Mongoid::Relations::Builders::Referenced::One
-    end
-
-    let(:document) do
-      double
-    end
-
-    let(:metadata) do
-      double(extension?: false)
-    end
-
-    it "returns the embedded in builder" do
-      expect(
-        described_class.builder(nil, metadata, document)
-      ).to be_a_kind_of(builder_klass)
-    end
-  end
-
-  describe "#create_#\{name}" do
-
-    context "when the relationship is an illegal embedded reference" do
-
-      let(:game) do
-        Game.new
-      end
-
-      it "raises a mixed relation error" do
-        expect {
-          game.create_video(title: "Tron")
-        }.to raise_error(Mongoid::Errors::MixedRelations)
-      end
-    end
-
-    context "when the relation is not polymorphic" do
-
-      let(:person) do
-        Person.create
-      end
-
-      let(:game) do
-        person.create_game(score: 50)
-      end
-
-      it "returns a new document" do
-        expect(game.score).to eq(50)
-      end
-
-      it "sets the foreign key on the document" do
-        expect(game.person_id).to eq(person.id)
-      end
-
-      it "sets the inverse relation" do
-        expect(game.person).to eq(person)
-      end
-
-      it "saves the document" do
-        expect(game).to be_persisted
-      end
-    end
-
-    context "when providing no attributes" do
-
-      let(:person) do
-        Person.create
-      end
-
-      let(:game) do
-        person.create_game
-      end
-
-      it "sets the foreign key on the document" do
-        expect(game.person_id).to eq(person.id)
-      end
-
-      it "sets the inverse relation" do
-        expect(game.person).to eq(person)
-      end
-
-      it "saves the document" do
-        expect(game).to be_persisted
-      end
-    end
-
-    context "when providing nil attributes" do
-
-      let(:person) do
-        Person.create
-      end
-
-      let(:game) do
-        person.create_game(nil)
-      end
-
-      it "sets the foreign key on the document" do
-        expect(game.person_id).to eq(person.id)
-      end
-
-      it "sets the inverse relation" do
-        expect(game.person).to eq(person)
-      end
-
-      it "saves the document" do
-        expect(game).to be_persisted
-      end
-    end
-
-    context "when the relation is polymorphic" do
-
-      let(:bar) do
-        Bar.create
-      end
-
-      let(:rating) do
-        bar.create_rating(value: 5)
-      end
-
-      it "returns a new document" do
-        expect(rating.value).to eq(5)
-      end
-
-      it "sets the foreign key on the document" do
-        expect(rating.ratable_id).to eq(bar.id)
-      end
-
-      it "sets the inverse relation" do
-        expect(rating.ratable).to eq(bar)
-      end
-
-      it "saves the document" do
-        expect(rating).to be_persisted
-      end
-    end
-  end
-
-  describe ".criteria" do
-
-    let(:id) do
-      BSON::ObjectId.new
-    end
-
-    context "when the relation is polymorphic" do
-
-      let(:metadata) do
-        Book.relations["rating"]
-      end
-
-      let(:criteria) do
-        described_class.criteria(metadata, id, Book)
-      end
-
-      it "includes the type in the criteria" do
-        expect(criteria.selector).to eq(
-          {
-            "ratable_id"    => id,
-            "ratable_type"  => "Book"
-          }
-        )
-      end
-    end
-
-    context "when the relation is not polymorphic" do
-
-      let(:metadata) do
-        Person.relations["game"]
-      end
-
-      let(:criteria) do
-        described_class.criteria(metadata, id, Person)
-      end
-
-      it "does not include the type in the criteria" do
-        expect(criteria.selector).to eq({ "person_id" => id })
-      end
-    end
-  end
-
-  describe ".embedded?" do
-
-    it "returns false" do
-      expect(described_class).to_not be_embedded
-    end
-  end
-
-  describe ".foreign_key_suffix" do
-
-    it "returns _id" do
-      expect(described_class.foreign_key_suffix).to eq("_id")
-    end
-  end
-
-  describe ".macro" do
-
-    it "returns has_one" do
-      expect(described_class.macro).to eq(:has_one)
-    end
-  end
-
-  describe "#nullify" do
-
-    let(:person) do
-      Person.create
-    end
-
-    let!(:game) do
-      person.create_game(name: "Starcraft II")
-    end
-
-    context "when the instance has been set" do
-
-      before do
-        person.game.nullify
-      end
-
-      it "removes the foreign key from the target" do
-        expect(game.person_id).to be_nil
-      end
-
-      it "removes the reference from the target" do
-        expect(game.person).to be_nil
-      end
-    end
-
-    context "when the instance has been reloaded" do
-
-      let(:from_db) do
-        Person.find(person.id)
-      end
-
-      let(:game_reloaded) do
-        Game.find(game.id)
-      end
-
-      before do
-        from_db.game.nullify
-      end
-
-      it "removes the foreign key from the target" do
-        expect(game_reloaded.person_id).to be_nil
-      end
-
-      it "removes the reference from the target" do
-        expect(game_reloaded.person).to be_nil
-      end
-    end
-  end
-
-  describe "#respond_to?" do
-
-    let(:person) do
-      Person.new
-    end
-
-    let!(:game) do
-      person.build_game(name: "Tron")
-    end
-
-    let(:document) do
-      person.game
-    end
-
-    Mongoid::Document.public_instance_methods(true).each do |method|
-
-      context "when checking #{method}" do
-
-        it "returns true" do
-          expect(document.respond_to?(method)).to be true
-        end
-      end
-    end
-  end
-
-  describe ".stores_foreign_key?" do
-
-    it "returns false" do
-      expect(described_class.stores_foreign_key?).to be false
-    end
-  end
-
-  describe ".valid_options" do
-
-    it "returns the valid options" do
-      expect(described_class.valid_options).to eq(
-        [ :as, :autobuild, :autosave, :dependent, :foreign_key, :primary_key ]
-      )
-    end
-  end
-
-  describe ".validation_default" do
-
-    it "returns true" do
-      expect(described_class.validation_default).to be true
-    end
-  end
-
-  context "when reloading the relation" do
-
-    let!(:person) do
-      Person.create
-    end
-
-    let!(:game_one) do
-      Game.create(name: "Warcraft 3")
-    end
-
-    let!(:game_two) do
-      Game.create(name: "Starcraft 2")
-    end
-
-    before do
-      person.game = game_one
-    end
-
-    context "when the relation references the same document" do
-
-      before do
-        Game.collection.find({ _id: game_one.id }).
-          update_one({ "$set" => { name: "Diablo 2" }})
-      end
-
-      let(:reloaded) do
-        person.game(true)
-      end
-
-      it "reloads the document from the database" do
-        expect(reloaded.name).to eq("Diablo 2")
-      end
-
-      it "sets a new document instance" do
-        expect(reloaded).to_not equal(game_one)
-      end
-    end
-
-    context "when the relation references a different document" do
-
-      before do
-        person.game = game_two
-      end
-
-      let(:reloaded) do
-        person.game(true)
-      end
-
-      it "reloads the new document from the database" do
-        expect(reloaded.name).to eq("Starcraft 2")
-      end
-
-      it "sets a new document instance" do
-        expect(reloaded).to_not equal(game_one)
-      end
-    end
-  end
-
-  context "when dependent is set to delete for child" do
-
-    context "when autobuild is true for child" do
-
-      let(:explosion) do
-        Explosion.create
-      end
-
-      let(:bomb) do
-        bomb = Bomb.create
-        bomb.explosion = explosion
-        bomb
-      end
-
-      let(:clear_child) do
-        bomb.explosion.clear
-      end
-
-      it "clearing the child raises no error" do
-        expect{ clear_child }.not_to raise_error
-      end
-    end
-  end
-end