mongoid 6.4.4 → 7.3.2

data/spec/mongoid/association/referenced/has_one/binding_spec.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Mongoid::Association::Referenced::HasOne::Binding do
+
+  let(:person) do
+    Person.new
+  end
+
+  let(:game) do
+    Game.new
+  end
+
+  let(:association) do
+    Person.relations["game"]
+  end
+
+  describe "#bind_one" do
+
+    let(:binding) do
+      described_class.new(person, game, association)
+    end
+
+    context "when the document is bindable" do
+
+      before do
+        expect(person).to receive(:save).never
+        expect(game).to receive(:save).never
+        binding.bind_one
+      end
+
+      it "sets the inverse relation" do
+        expect(game.person).to eq(person)
+      end
+
+      it "sets the foreign key" do
+        expect(game.person_id).to eq(person.id)
+      end
+    end
+
+    context "when the document is not bindable" do
+
+      before do
+        game.person = person
+      end
+
+      it "does nothing" do
+        expect(person).to receive(:game=).never
+        binding.bind_one
+      end
+    end
+  end
+
+  describe "#unbind_one" do
+
+    let(:binding) do
+      described_class.new(person, game, association)
+    end
+
+    context "when the document is unbindable" do
+
+      before do
+        binding.bind_one
+        expect(person).to receive(:delete).never
+        expect(game).to receive(:delete).never
+        binding.unbind_one
+      end
+
+      it "removes the inverse relation" do
+        expect(game.person).to be_nil
+      end
+
+      it "removed the foreign key" do
+        expect(game.person_id).to be_nil
+      end
+    end
+
+    context "when the document is not unbindable" do
+
+      it "does nothing" do
+        expect(person).to receive(:game=).never
+        binding.unbind_one
+      end
+    end
+  end
+
+  context "when binding frozen documents" do
+
+    let(:person) do
+      Person.new
+    end
+
+    context "when the child is frozen" do
+
+      let(:game) do
+        Game.new.freeze
+      end
+
+      before do
+        person.game = game
+      end
+
+      it "does not set the foreign key" do
+        expect(game.person_id).to be_nil
+      end
+    end
+  end
+
+  context "when unbinding frozen documents" do
+
+    let(:person) do
+      Person.new
+    end
+
+    context "when the child is frozen" do
+
+      let(:game) do
+        Game.new
+      end
+
+      before do
+        person.game = game
+        game.freeze
+        person.game = nil
+      end
+
+      it "does not unset the foreign key" do
+        expect(game.person_id).to eq(person.id)
+      end
+    end
+  end
+end

data/spec/mongoid/association/referenced/has_one/buildable_spec.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Mongoid::Association::Referenced::HasOne::Buildable do
+
+  let(:base) do
+    double(new_record?: false)
+  end
+
+  describe "#build" do
+
+    let(:document) do
+      association.build(base, object)
+    end
+
+    let(:association) do
+      Mongoid::Association::Referenced::HasOne.new(Person, :account)
+    end
+
+    context "when provided an id" do
+
+      let!(:account) do
+        Account.create!(person_id: object, name: 'banking')
+      end
+
+      let(:object) do
+        BSON::ObjectId.new
+      end
+
+      before do
+        expect(Account).to receive(:where).with(association.foreign_key => object).and_call_original
+      end
+
+      it "sets the document" do
+        expect(document).to eq(account)
+      end
+    end
+
+    context "when provided a object" do
+
+      let(:object) do
+        Account.new
+      end
+
+      it "returns the object" do
+        expect(document).to eq(object)
+      end
+
+      context 'when the object is already related to another object' do
+
+        let(:original_person) do
+          Person.new
+        end
+
+        let(:object) do
+          Account.new(person: original_person)
+        end
+
+        let!(:document) do
+          association.build(Person.new, object)
+        end
+
+        it 'clears the object of its previous relation' do
+          expect(original_person.account).to be_nil
+        end
+
+        it 'returns the object' do
+          expect(document).to eq(object)
+        end
+      end
+    end
+
+    context "when the document is not found" do
+
+      let(:object) do
+        BSON::ObjectId.new
+      end
+
+      it "returns nil" do
+        expect(document).to be_nil
+      end
+    end
+
+    context "when the document is persisted" do
+
+      let(:person) do
+        Person.create
+      end
+
+      let!(:game) do
+        Game.create(person: person)
+      end
+
+      it "returns the document" do
+        expect(person.game).to eq(game)
+      end
+    end
+
+    context "when the document have a non standard pk" do
+
+      let(:person) do
+        Person.create
+      end
+
+      let!(:cat) do
+        Cat.create(person: person)
+      end
+
+      it "returns the document" do
+        expect(person.cat).to eq(cat)
+      end
+    end
+  end
+end

data/spec/mongoid/association/referenced/has_one/eager_spec.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Mongoid::Association::Referenced::HasOne::Eager do
+
+  describe ".grouped_doc" do
+
+    let(:person) do
+      Person.create!
+    end
+
+    let(:docs) do
+      Person.all.to_a
+    end
+
+    let(:association) do
+      Person.reflect_on_association(:cat)
+    end
+
+    let(:eager) do
+      described_class.new([association], docs).tap do |b|
+        b.send(:shift_association)
+      end
+    end
+
+    before do
+      Cat.create!(person: person)
+    end
+
+    it "aggregates by the relation primary key" do
+      expect(eager.send(:grouped_docs).keys).to eq([person.username])
+    end
+  end
+
+  describe ".set_on_parent" do
+
+    let(:person) do
+      Person.create!
+    end
+
+    let(:docs) do
+      Person.all.to_a
+    end
+
+    let(:association) do
+      Person.reflect_on_association(:cat)
+    end
+
+    let(:eager) do
+      described_class.new([association], docs).tap do |b|
+        b.send(:shift_association)
+      end
+    end
+
+    before do
+      Cat.create!(person: person)
+      eager
+    end
+
+    it "sets the relation into the parent" do
+      docs.each do |doc|
+        expect(doc).to receive(:set_relation).once.with(:cat, :foo)
+      end
+      eager.send(:set_on_parent, person.username, :foo)
+    end
+
+    context 'when able to make query count assertions' do
+      # Query count assertions require that all queries are sent using the
+      # same connection object.
+      require_no_multi_shard
+
+      it "doesnt call an extra query" do
+        expect_query(0) do
+          eager.send(:set_on_parent, person.username, :foo)
+        end
+      end
+    end
+  end
+
+  describe ".includes" do
+
+    let(:person) do
+      Person.create!
+    end
+
+    before do
+      3.times { Cat.create!(person: person) }
+      Cat.create!(person: Person.create!)
+    end
+
+    context "when including the has_one relation" do
+      # Query count assertions require that all queries are sent using the
+      # same connection object.
+      require_no_multi_shard
+
+      it "queries twice" do
+
+        expect_query(2) do
+
+          Person.all.includes(:cat).each do |person|
+            expect(person.cat).to_not be_nil
+          end
+        end
+      end
+    end
+
+    context "when including more than one has_one relation" do
+      # Query count assertions require that all queries are sent using the
+      # same connection object.
+      require_no_multi_shard
+
+      it "queries 3 times" do
+
+        expect_query(3) do
+
+          Person.all.includes(:cat, :account).each do |person|
+            expect(person.cat).to_not be_nil
+          end
+        end
+      end
+    end
+
+    context "when the relation is not polymorphic" do
+
+      let!(:game) do
+        person.create_game(name: "Tron")
+      end
+
+      let!(:eager) do
+        Person.where(_id: person.id).includes(:game).first
+      end
+
+      it "puts the documents in the parent document" do
+        expect(eager.ivar(:game)).to eq(game)
+      end
+
+      it "does not query when touching the association" do
+        expect_query(0) do
+          expect(eager.game).to eq(game)
+        end
+      end
+
+      it "does not query when updating the association" do
+        expect_query(0) do
+          eager.game.name = "Revenge of Racing of Magic"
+          expect(eager.game.name).to eq("Revenge of Racing of Magic")
+        end
+      end
+    end
+
+    context "when the relation is polymorphic" do
+
+      let!(:book) do
+        Book.create(name: "Game of Thrones")
+      end
+
+      let!(:rating) do
+        book.create_rating(value: 10)
+      end
+
+      let!(:eager) do
+        Book.all.includes(:rating).first
+      end
+
+      it "puts the found documents in the parent document" do
+        expect(eager.ivar(:rating)).to eq(rating)
+      end
+
+      it "does not query when touching the association" do
+        expect_query(0) do
+          expect(eager.rating).to eq(rating)
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/association/referenced/has_one/proxy_spec.rb

@@ -0,0 +1,1143 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Mongoid::Association::Referenced::HasOne::Proxy 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(:association) do
+          Game.relations["person"]
+        end
+
+        before do
+          expect(association).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 "#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 ".embedded?" do
+
+    it "returns false" do
+      expect(described_class).to_not be_embedded
+    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
+
+  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