mongoid 6.4.4 → 7.3.2

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

@@ -0,0 +1,377 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+require_relative '../has_many_models'
+
+describe Mongoid::Association::Referenced::BelongsTo::Eager do
+
+  describe ".grouped_docs" do
+
+    let(:docs) do
+      Post.all.to_a
+    end
+
+    let(:person) do
+      Person.create!
+    end
+
+    let(:association) do
+      Post.reflect_on_association(:person)
+    end
+
+    let(:eager) do
+      described_class.new([association], docs).tap do |b|
+        b.send(:shift_association)
+      end
+    end
+
+    before do
+      Post.create!(person: person)
+    end
+
+    it "aggregates by the parent id" do
+      expect(eager.send(:grouped_docs).keys).to eq([person.id])
+    end
+  end
+
+  describe ".set_on_parent" do
+
+    let(:docs) do
+      Post.all.to_a
+    end
+
+    let(:person) do
+      Person.create!
+    end
+
+    let(:association) do
+      Post.reflect_on_association(:person)
+    end
+
+    let(:eager) do
+      described_class.new([association], docs).tap do |b|
+        b.send(:shift_association)
+      end
+    end
+
+    before do
+      Post.create!(person: person)
+    end
+
+    it "sets the association into the parent" do
+      docs.each do |doc|
+        expect(doc).to receive(:set_relation).with(:person, :foo)
+      end
+      eager.send(:set_on_parent, person.id, :foo)
+    end
+  end
+
+  describe ".includes" do
+
+    let(:person) do
+      Person.create!
+    end
+
+    before do
+      3.times { |i| Account.create!(person: person, name: "savings#{i}") }
+    end
+
+    context "when including the belongs_to association" 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
+          Account.all.includes(:person).each do |account|
+            expect(account.person).to_not be_nil
+          end
+        end
+      end
+    end
+
+    context "when the association is not polymorphic" do
+      # Query count assertions require that all queries are sent using the
+      # same connection object.
+      require_no_multi_shard
+
+      let(:eager) do
+        Post.includes(:person).last
+      end
+
+      context "when the eager load has returned documents" do
+
+        let!(:post) do
+          person.posts.create(title: "testing")
+        end
+
+        before { eager }
+
+        it "puts the documents in the parent document" do
+          expect(eager.ivar(:person)).to eq(person)
+        end
+
+        it "does not query when touching the association" do
+          expect_no_queries do
+            expect(eager.person).to eq(person)
+          end
+        end
+
+        it "does not query when updating the association" do
+          expect_no_queries do
+            eager.person.username = "arthurnn"
+          end
+        end
+      end
+
+      context "when the eager load has not returned documents" do
+
+        let!(:post) do
+          Post.create(title: "testing")
+        end
+
+        before { eager }
+
+        it "does not set anything on the parent" do
+          expect(eager.ivar(:person)).to be nil
+        end
+
+        it "has a nil association" do
+          expect(eager.person).to be nil
+        end
+      end
+    end
+
+    context "when the association is polymorphic" do
+
+      context "without namespaces" do
+
+        let!(:stand_alone_rating) do
+          Rating.create(value: 7)
+        end
+
+        let!(:bar) do
+          Bar.create(name: "FooBar")
+        end
+
+        let(:bar_rating) do
+          bar.create_rating(value: 5)
+        end
+
+        let!(:movie) do
+          Movie.create(name: "Bladerunner")
+        end
+
+        let(:movie_rating) do
+          movie.ratings.create(value: 10)
+        end
+
+        let(:eager) do
+          Rating.includes(:ratable).entries
+        end
+
+        context "when the eager load has returned documents" do
+
+          before do
+            bar_rating
+            movie_rating
+            eager
+          end
+
+          it "puts the documents in the parent document" do
+            expect(eager.map { |e| e.ivar(:ratable) }).to eq([nil, bar, movie])
+          end
+
+          it "does not query when touching the association" do
+            expect_no_queries do
+              expect(eager.map(&:ratable)).to eq([nil, bar, movie])
+            end
+          end
+
+          it "does not query when updating the association" do
+            expect_no_queries do
+              eager.last.ratable.name = "Easy rider"
+            end
+          end
+        end
+
+        context "when the eager load has not returned documents" do
+
+          before { eager }
+
+          it "does not set anything on the parent" do
+            expect(eager.map { |e| e.ivar(:ratable) }).to all(be nil)
+          end
+
+          it "has a nil association" do
+            expect(eager.map(&:ratable)).to all(be nil)
+          end
+        end
+      end
+
+      context "with namespaces" do
+
+        let!(:stand_alone_review) do
+          Publication::Review.create(summary: "awful")
+        end
+
+        let!(:encyclopedia) do
+          Publication::Encyclopedia.create(title: "Encyclopedia Britannica")
+        end
+
+        let(:encyclopedia_review) do
+          encyclopedia.reviews.create(summary: "inspiring")
+        end
+
+        let!(:pull_request) do
+          Coding::PullRequest.create(title: "Add eager loading for polymorphic belongs_to associations")
+        end
+
+        let(:pull_request_review) do
+          pull_request.reviews.create(summary: "Looks good to me")
+        end
+
+        let(:eager) do
+          Publication::Review.includes(:reviewable).entries
+        end
+
+        context "when the eager load has returned documents" do
+
+          before do
+            encyclopedia_review
+            pull_request_review
+            eager
+          end
+
+          it "puts the documents in the parent document" do
+            expect(eager.map { |e| e.ivar(:reviewable) }).to eq([nil, encyclopedia, pull_request])
+          end
+
+          it "does not query when touching the association" do
+            expect_no_queries do
+              expect(eager.map(&:reviewable)).to eq([nil, encyclopedia, pull_request])
+            end
+          end
+
+          it "does not query when updating the association" do
+            expect_no_queries do
+              eager.last.reviewable.title = "Load stuff eagerly"
+            end
+          end
+        end
+
+        context "when the eager load has not returned documents" do
+
+          before { eager }
+
+          it "does not set anything on the parent" do
+            expect(eager.map { |e| e.ivar(:reviewable) }).to all(be nil)
+          end
+
+          it "has a nil association" do
+            expect(eager.map(&:reviewable)).to all(be nil)
+          end
+        end
+      end
+
+      context 'when eager loading multiple associations' do
+        let(:reviewable) do
+          Publication::Encyclopedia.create!(title: "Encyclopedia Britannica")
+        end
+
+        let!(:reviewable_review) do
+          Publication::Review.create!(summary: "awful",
+            reviewable: reviewable)
+        end
+
+        let(:reviewer) do
+          Dog.create!
+        end
+
+        let!(:reviewer_review) do
+          Publication::Review.create(summary: "okay",
+            reviewer: reviewer)
+        end
+
+        let(:template) do
+          Template.create!
+        end
+
+        let!(:template_review) do
+          Publication::Review.create(summary: "Looks good to me",
+            template: template)
+        end
+
+        let(:eager) do
+          Publication::Review.includes(:reviewable, :reviewer, :template).entries
+        end
+
+        it 'loads all associations eagerly' do
+          loaded = expect_query(4) do
+            eager
+          end
+
+          expect_no_queries do
+            eager.map(&:reviewable).compact.should == [reviewable]
+          end
+
+          expect_no_queries do
+            eager.map(&:reviewer).compact.should == [reviewer]
+          end
+
+          expect_no_queries do
+            eager.map(&:template).compact.should == [template]
+          end
+        end
+      end
+
+      context 'when eager loading an association that has type but not value set' do
+
+        let!(:reviewer_review) do
+          Publication::Review.create(summary: "okay",
+            reviewer_type: 'Dog')
+        end
+
+        let(:eager) do
+          Publication::Review.includes(:reviewable, :reviewer, :template).entries
+        end
+
+        it 'does not error' do
+          eager.map(&:reviewer).should == [nil]
+        end
+      end
+    end
+
+    context "when setting the foreign key id directly" do
+
+      it "works" do
+        id = BSON::ObjectId.new
+        game = Game.new(:person_id => id)
+        expect(game.person_id).to eql(id)
+      end
+    end
+
+    context "when all the values for the belongs_to association are nil" do
+      # Query count assertions require that all queries are sent using the
+      # same connection object.
+      require_no_multi_shard
+
+      before do
+        2.times { |i| HmmTicket.create!(person: nil) }
+      end
+
+      it "only queries once for the parent documents" do
+        found_ticket = false
+        expect_query(1) do
+          HmmTicket.all.includes(:person).each do |ticket|
+            expect(ticket.person).to eq nil
+            found_ticket = true
+          end
+        end
+        expect(found_ticket).to be true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,1369 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Mongoid::Association::Referenced::BelongsTo::Proxy do
+
+  before(:all) do
+    Person.reset_callbacks(:validate)
+  end
+
+  let(:person) do
+    Person.create
+  end
+
+  describe "#=" do
+
+    context "when the relation is named target" do
+
+      let(:target) do
+        User.new
+      end
+
+      context "when the relation is referenced from an embeds many" do
+
+        context "when setting via create" do
+
+          let(:service) do
+            person.services.create(target: target)
+          end
+
+          it "sets the target relation" do
+            expect(service.target).to eq(target)
+          end
+        end
+      end
+    end
+
+    context "when the inverse relation has no reference defined" do
+
+      let(:agent) do
+        Agent.new(title: "007")
+      end
+
+      let(:game) do
+        Game.new(name: "Donkey Kong")
+      end
+
+      before do
+        agent.game = game
+      end
+
+      it "sets the relation" do
+        expect(agent.game).to eq(game)
+      end
+
+      it "sets the foreign_key" do
+        expect(agent.game_id).to eq(game.id)
+      end
+    end
+
+    context "when referencing a document from an embedded document" do
+
+      let(:person) do
+        Person.create
+      end
+
+      let(:address) do
+        person.addresses.create(street: "Wienerstr")
+      end
+
+      let(:account) do
+        Account.create(name: "1", number: 1000000)
+      end
+
+      before do
+        address.account = account
+      end
+
+      it "sets the relation" do
+        expect(address.account).to eq(account)
+      end
+
+      it "does not erase the association metadata" do
+        expect(address._association).to_not be_nil
+      end
+
+      it "allows saving of the embedded document" do
+        expect(address.save).to be true
+      end
+    end
+
+    context "when the parent is a references one" do
+
+      context "when the relation is not polymorphic" do
+
+        context "when the child is a new record" do
+
+          let(:person) do
+            Person.new
+          end
+
+          let(:game) do
+            Game.new
+          end
+
+          before do
+            game.person = person
+          end
+
+          it "sets the target of the relation" do
+            expect(game.person._target).to eq(person)
+          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(person.game).to eq(game)
+          end
+
+          it "sets the same instance on the inverse relation" do
+            expect(person.game).to eql(game)
+          end
+
+          it "does not save the target" do
+            expect(person).to_not be_persisted
+          end
+
+          it "drops private visibility from private methods" do
+            # This is unfortunate but it appears that Ruby does not
+            # have a way to distinguish how method_missing was invoked
+            # (i.e. via an explicit send or method call).
+            # See https://jira.mongodb.org/browse/MONGOID-5009
+            game.person.secret_name.should == 'secret'
+          end
+
+          it "allows private methods to be invoked" do
+            game.person.send(:secret_name).should == 'secret'
+          end
+
+          it "properly exposes delegated methods visibility" do
+            expect(defined?(game.person.id)).to eq("method")
+            expect(defined?(game.person.secret_name)).to be_nil
+          end
+        end
+
+        context "when the child is not a new record" do
+
+          let(:person) do
+            Person.new
+          end
+
+          let(:game) do
+            Game.create
+          end
+
+          before do
+            game.person = person
+          end
+
+          it "sets the target of the relation" do
+            expect(game.person._target).to eq(person)
+          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(person.game).to eq(game)
+          end
+
+          it "sets the same instance on the inverse relation" do
+            expect(person.game).to eql(game)
+          end
+
+          it "does not saves the target" do
+            expect(person).to_not be_persisted
+          end
+        end
+      end
+
+      context "when the relation is polymorphic" do
+
+        context "when the parent is a subclass" do
+
+          let(:canvas) do
+            Canvas::Test.create
+          end
+
+          let(:comment) do
+            Comment.create(title: "test")
+          end
+
+          before do
+            comment.commentable = canvas
+            comment.save
+          end
+
+          it "sets the correct value in the type field" do
+            expect(comment.commentable_type).to eq("Canvas::Test")
+          end
+
+          it "can retrieve the document from the database" do
+            expect(comment.reload.commentable).to eq(canvas)
+          end
+        end
+
+        context "when the child is a new record" do
+
+          let(:bar) do
+            Bar.new
+          end
+
+          let(:rating) do
+            Rating.new
+          end
+
+          before do
+            rating.ratable = bar
+          end
+
+          it "sets the target of the relation" do
+            expect(rating.ratable._target).to eq(bar)
+          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(bar.rating).to eq(rating)
+          end
+
+          it "sets the same instance on the inverse relation" do
+            expect(bar.rating).to eql(rating)
+          end
+
+          it "does not save the target" do
+            expect(bar).to_not be_persisted
+          end
+        end
+
+        context "when the child is not a new record" do
+
+          let(:bar) do
+            Bar.new
+          end
+
+          let(:rating) do
+            Rating.create
+          end
+
+          before do
+            rating.ratable = bar
+          end
+
+          it "sets the target of the relation" do
+            expect(rating.ratable._target).to eq(bar)
+          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(bar.rating).to eq(rating)
+          end
+
+          it "sets the same instance on the inverse relation" do
+            expect(bar.rating).to eql(rating)
+          end
+
+          it "does not saves the target" do
+            expect(bar).to_not be_persisted
+          end
+        end
+      end
+    end
+
+    context "when the parent is a references many" do
+
+      context "when the relation is not polymorphic" do
+
+        context 'when the child has persistence options set' do
+
+          let(:person) do
+            Person.new
+          end
+
+          let(:post) do
+            Post.new
+          end
+
+          before do
+            post.with(collection: 'other-posts') do |p|
+              person.with(collection: 'other-people') do |per|
+                p.person = person
+                per.save
+                p.save
+              end
+            end
+          end
+
+          let(:other_people_count) do
+            Person.with(collection: 'other-people') do |person_class|
+              person_class.count
+            end
+          end
+
+          let(:other_posts_count) do
+            Post.with(collection: 'other-posts') do |post_class|
+              post_class.count
+            end
+          end
+
+          it 'applies the persistence options when saving the child' do
+            expect(other_people_count).to eq(1)
+            expect(other_posts_count).to eq(1)
+          end
+        end
+
+        context "when the child is a new record" do
+
+          let(:person) do
+            Person.new
+          end
+
+          let(:post) do
+            Post.new
+          end
+
+          before do
+            post.person = person
+          end
+
+          it "sets the target of the relation" do
+            expect(post.person._target).to eq(person)
+          end
+
+          it "sets the foreign key on the relation" do
+            expect(post.person_id).to eq(person.id)
+          end
+
+          it "does not save the target" do
+            expect(person).to_not be_persisted
+          end
+        end
+
+        context "when the child is not a new record" do
+
+          let(:person) do
+            Person.new
+          end
+
+          let(:post) do
+            Post.create
+          end
+
+          before do
+            post.person = person
+          end
+
+          it "sets the target of the relation" do
+            expect(post.person._target).to eq(person)
+          end
+
+          it "sets the foreign key of the relation" do
+            expect(post.person_id).to eq(person.id)
+          end
+
+          it "does not saves the target" do
+            expect(person).to_not be_persisted
+          end
+        end
+      end
+
+      context "when the relation is polymorphic" do
+
+        context "when multiple relations against the same class exist" do
+
+          let(:face) do
+            Face.new
+          end
+
+          let(:eye) do
+            Eye.new
+          end
+
+          it "raises an error" do
+            expect {
+              eye.eyeable = face
+            }.to raise_error(Mongoid::Errors::InvalidSetPolymorphicRelation)
+          end
+        end
+
+        context "when multiple relations of the same name but different class exist" do
+
+          let(:eye) do
+            Eye.new
+          end
+
+          let(:eye_bowl) do
+            EyeBowl.new
+          end
+
+          it "should assign as expected" do
+            eye.suspended_in = eye_bowl
+            expect(eye.suspended_in._target).to eq(eye_bowl)
+          end
+        end
+
+        context "when one relation against the same class exists" do
+
+          context "when the child is a new record" do
+
+            let(:movie) do
+              Movie.new
+            end
+
+            let(:rating) do
+              Rating.new
+            end
+
+            before do
+              rating.ratable = movie
+            end
+
+            it "sets the target of the relation" do
+              expect(rating.ratable._target).to eq(movie)
+            end
+
+            it "sets the foreign key on the relation" do
+              expect(rating.ratable_id).to eq(movie.id)
+            end
+
+            it "does not save the target" do
+              expect(movie).to_not be_persisted
+            end
+          end
+
+          context "when the child is not a new record" do
+
+            let(:movie) do
+              Movie.new
+            end
+
+            let(:rating) do
+              Rating.create
+            end
+
+            before do
+              rating.ratable = movie
+            end
+
+            it "sets the target of the relation" do
+              expect(rating.ratable._target).to eq(movie)
+            end
+
+            it "sets the foreign key of the relation" do
+              expect(rating.ratable_id).to eq(movie.id)
+            end
+
+            it "does not saves the target" do
+              expect(movie).to_not be_persisted
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "#= nil" do
+
+    context "when dependent is destroy" do
+
+      let(:account) do
+        Account.create!(name: 'checkings')
+      end
+
+      let(:drug) do
+        Drug.create!
+      end
+
+      let(:person) do
+        Person.create!
+      end
+
+      context "when relation is has_one" do
+
+        around(:each) do |example|
+          original_account_dependents = Account.dependents
+          Account.dependents = []
+          example.run
+          Account.dependents = original_account_dependents
+        end
+
+        before do
+          Account.belongs_to :person, dependent: :destroy
+          Person.has_one :account
+          person.account = account
+          person.save
+        end
+
+        after :all do
+          Account.belongs_to :person, dependent: :nullify
+          Person.has_one :account, validate: false
+        end
+
+        context "when parent exists" do
+
+          context "when child touch the parent" do
+
+            let!(:account_from_db) { account.reload }
+
+            it "queries only the parent" do
+              expect_query(1) do
+                expect(account_from_db.person.id).to eq(person.id)
+              end
+            end
+          end
+
+          context "when child is destroyed" do
+
+            before do
+              account.destroy
+            end
+
+            it "deletes child" do
+              expect(account).to be_destroyed
+            end
+
+            it "deletes parent" do
+              expect(person).to be_destroyed
+            end
+          end
+        end
+      end
+
+      context "when relation is has_many" do
+
+        around(:each) do |example|
+          original_drug_dependents = Drug.dependents
+          Drug.dependents = []
+          example.run
+          Drug.dependents = original_drug_dependents
+        end
+
+        before do
+          Drug.belongs_to :person, dependent: :destroy
+          Person.has_many :drugs
+          person.drugs = [drug]
+          person.save
+        end
+
+        after :all do
+          Drug.belongs_to :person, dependent: :nullify
+          Person.has_many :drugs, validate: false
+        end
+
+        context "when parent exists" do
+
+          context "when child is destroyed" do
+
+            before do
+              drug.destroy
+            end
+
+            it "deletes child" do
+              expect(drug).to be_destroyed
+            end
+
+            it "deletes parent" do
+              expect(person).to be_destroyed
+            end
+          end
+        end
+      end
+    end
+
+    context "when dependent is delete" do
+
+      let(:account) do
+        Account.create
+      end
+
+      let(:drug) do
+        Drug.create
+      end
+
+      let(:person) do
+        Person.create
+      end
+
+      context "when relation is has_one" do
+
+        around(:each) do |example|
+          original_account_dependents = Account.dependents
+          Account.dependents = []
+          example.run
+          Account.dependents = original_account_dependents
+        end
+
+        before do
+          Account.belongs_to :person, dependent: :delete_all
+          Person.has_one :account
+          person.account = account
+          person.save
+        end
+
+        after :all do
+          Account.belongs_to :person, dependent: :nullify
+          Person.has_one :account, validate: false
+        end
+
+        context "when parent is persisted" do
+
+          context "when child is destroyed" do
+
+            before do
+              account.destroy
+            end
+
+            it "deletes child" do
+              expect(account).to be_destroyed
+            end
+
+            it "deletes parent" do
+              expect(person).to be_destroyed
+            end
+          end
+        end
+      end
+
+      context "when relation is has_many" do
+
+        around(:each) do |example|
+          original_drug_dependents = Drug.dependents
+          Drug.dependents = []
+          example.run
+          Drug.dependents = original_drug_dependents
+        end
+
+        before do
+          Drug.belongs_to :person, dependent: :delete_all
+          Person.has_many :drugs
+          person.drugs = [drug]
+          person.save
+        end
+
+        after :all do
+          Drug.belongs_to :person, dependent: :nullify
+          Person.has_many :drugs, validate: false
+        end
+
+        context "when parent exists" do
+
+          context "when child is destroyed" do
+
+            before do
+              drug.destroy
+            end
+
+            it "deletes child" do
+              expect(drug).to be_destroyed
+            end
+
+            it "deletes parent" do
+              expect(person).to be_destroyed
+            end
+          end
+        end
+      end
+    end
+
+    context "when dependent is nullify" do
+
+      let(:account) do
+        Account.create
+      end
+
+      let(:drug) do
+        Drug.create
+      end
+
+      let(:person) do
+        Person.create
+      end
+
+      context "when relation is has_one" do
+
+        around(:each) do |example|
+          original_account_dependents = Account.dependents
+          Account.dependents = []
+          example.run
+          Account.dependents = original_account_dependents
+        end
+
+        before do
+          Account.belongs_to :person, dependent: :nullify
+          Person.has_one :account
+          person.account = account
+          person.save
+        end
+
+        context "when parent is persisted" do
+
+          context "when child is destroyed" do
+
+            before do
+              account.destroy
+            end
+
+            it "deletes child" do
+              expect(account).to be_destroyed
+            end
+
+            it "doesn't delete parent" do
+              expect(person).to_not be_destroyed
+            end
+
+            it "removes the link" do
+              expect(person.account).to be_nil
+            end
+          end
+        end
+      end
+
+      context "when relation is has_many" do
+
+        around(:each) do |example|
+          original_drug_dependents = Drug.dependents
+          Drug.dependents = []
+          example.run
+          Drug.dependents = original_drug_dependents
+        end
+
+        before do
+          Drug.belongs_to :person, dependent: :nullify
+          Person.has_many :drugs
+          person.drugs = [drug]
+          person.save
+        end
+
+        context "when parent exists" do
+
+          context "when child is destroyed" do
+
+            before do
+              drug.destroy
+            end
+
+            it "deletes child" do
+              expect(drug).to be_destroyed
+            end
+
+            it "doesn't deletes parent" do
+              expect(person).to_not be_destroyed
+            end
+
+            it "removes the link" do
+              expect(person.drugs).to eq([])
+            end
+          end
+        end
+      end
+    end
+
+    context "when the inverse relation has no reference defined" do
+
+      let(:agent) do
+        Agent.new(title: "007")
+      end
+
+      let(:game) do
+        Game.new(name: "Donkey Kong")
+      end
+
+      before do
+        agent.game = game
+        agent.game = nil
+      end
+
+      it "removes the relation" do
+        expect(agent.game).to be_nil
+      end
+
+      it "removes the foreign_key" do
+        expect(agent.game_id).to be_nil
+      end
+    end
+
+    context "when the parent is a references one" 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
+            game.person = person
+            game.person = nil
+          end
+
+          it "sets the relation to nil" do
+            expect(game.person).to be_nil
+          end
+
+          it "removed the inverse relation" do
+            expect(person.game).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.create
+          end
+
+          before do
+            game.person = person
+            game.person = nil
+          end
+
+          it "sets the relation to nil" do
+            expect(game.person).to be_nil
+          end
+
+          it "removed the inverse relation" do
+            expect(person.game).to be_nil
+          end
+
+          it "removes the foreign key value" do
+            expect(game.person_id).to be_nil
+          end
+
+          it "does not delete the child" do
+            expect(game).to_not be_destroyed
+          end
+        end
+      end
+
+      context "when the relation is polymorphic" do
+
+        context "when one relation against the same class exists" do
+
+          context "when the parent is a new record" do
+
+            let(:bar) do
+              Bar.new
+            end
+
+            let(:rating) do
+              Rating.new
+            end
+
+            before do
+              rating.ratable = bar
+              rating.ratable = nil
+            end
+
+            it "sets the relation to nil" do
+              expect(rating.ratable).to be_nil
+            end
+
+            it "removed the inverse relation" do
+              expect(bar.rating).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.new
+            end
+
+            let(:rating) do
+              Rating.create
+            end
+
+            before do
+              rating.ratable = bar
+              rating.ratable = nil
+            end
+
+            it "sets the relation to nil" do
+              expect(rating.ratable).to be_nil
+            end
+
+            it "removed the inverse relation" do
+              expect(bar.rating).to be_nil
+            end
+
+            it "removes the foreign key value" do
+              expect(rating.ratable_id).to be_nil
+            end
+          end
+        end
+      end
+    end
+
+    context "when the parent is a references many" 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(:post) do
+            Post.new
+          end
+
+          before do
+            post.person = person
+            post.person = nil
+          end
+
+          it "sets the relation to nil" do
+            expect(post.person).to be_nil
+          end
+
+          it "removed the inverse relation" do
+            expect(person.posts).to be_empty
+          end
+
+          it "removes the foreign key value" do
+            expect(post.person_id).to be_nil
+          end
+        end
+
+        context "when the parent is not a new record" do
+
+          let(:person) do
+            Person.new
+          end
+
+          let(:post) do
+            Post.create
+          end
+
+          before do
+            post.person = person
+            post.person = nil
+          end
+
+          it "sets the relation to nil" do
+            expect(post.person).to be_nil
+          end
+
+          it "removed the inverse relation" do
+            expect(person.posts).to be_empty
+          end
+
+          it "removes the foreign key value" do
+            expect(post.person_id).to be_nil
+          end
+        end
+      end
+
+      context "when the relation is polymorphic" do
+
+        context "when the parent is a new record" do
+
+          let(:movie) do
+            Movie.new
+          end
+
+          let(:rating) do
+            Rating.new
+          end
+
+          before do
+            rating.ratable = movie
+            rating.ratable = nil
+          end
+
+          it "sets the relation to nil" do
+            expect(rating.ratable).to be_nil
+          end
+
+          it "removed the inverse relation" do
+            expect(movie.ratings).to be_empty
+          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(:movie) do
+            Movie.new
+          end
+
+          let(:rating) do
+            Rating.create
+          end
+
+          before do
+            rating.ratable = movie
+            rating.ratable = nil
+          end
+
+          it "sets the relation to nil" do
+            expect(rating.ratable).to be_nil
+          end
+
+          it "removed the inverse relation" do
+            expect(movie.ratings).to be_empty
+          end
+
+          it "removes the foreign key value" do
+            expect(rating.ratable_id).to be_nil
+          end
+        end
+      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
+      game.person
+    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 the relation is self referencing" do
+
+    let(:game_one) do
+      Game.new(name: "Diablo")
+    end
+
+    let(:game_two) do
+      Game.new(name: "Warcraft")
+    end
+
+    context "when setting the parent" do
+
+      before do
+        game_one.parent = game_two
+      end
+
+      it "sets the parent" do
+        expect(game_one.parent).to eq(game_two)
+      end
+
+      it "does not set the parent recursively" do
+        expect(game_two.parent).to be_nil
+      end
+    end
+  end
+
+  context "when the relation belongs to a has many and has one" do
+
+    before(:all) do
+      class A
+        include Mongoid::Document
+        has_many :bs, inverse_of: :a
+      end
+
+      class B
+        include Mongoid::Document
+        belongs_to :a, inverse_of: :bs
+        belongs_to :c, inverse_of: :b
+      end
+
+      class C
+        include Mongoid::Document
+        has_one :b, inverse_of: :c
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, :A)
+      Object.send(:remove_const, :B)
+      Object.send(:remove_const, :C)
+    end
+
+    context "when setting the has one" do
+
+      let(:a) do
+        A.new
+      end
+
+      let(:b) do
+        B.new
+      end
+
+      let(:c) do
+        C.new
+      end
+
+      before do
+        b.c = c
+      end
+
+      context "when subsequently setting the has many" do
+
+        before do
+          b.a = a
+        end
+
+        context "when setting the has one again" do
+
+          before do
+            b.c = c
+          end
+
+          it "allows the reset of the has one" do
+            expect(b.c).to eq(c)
+          end
+        end
+      end
+    end
+  end
+
+  context "when replacing the relation with another" do
+
+    let!(:person) do
+      Person.create
+    end
+
+    let!(:post) do
+      Post.create(title: "test")
+    end
+
+    let!(:game) do
+      person.create_game(name: "Tron")
+    end
+
+    before do
+      post.person = game.person
+      post.save
+    end
+
+    it "clones the relation" do
+      expect(post.person).to eq(person)
+    end
+
+    it "sets the foreign key" do
+      expect(post.person_id).to eq(person.id)
+    end
+
+    it "does not remove the previous relation" do
+      expect(game.person).to eq(person)
+    end
+
+    it "does not remove the previous foreign key" do
+      expect(game.person_id).to eq(person.id)
+    end
+
+    context "when reloading" do
+
+      before do
+        post.reload
+        game.reload
+      end
+
+      it "persists the relation" do
+        expect(post.reload.person).to eq(person)
+      end
+
+      it "persists the foreign key" do
+        expect(post.reload.person_id).to eq(game.person_id)
+      end
+
+      it "does not remove the previous relation" do
+        expect(game.person).to eq(person)
+      end
+
+      it "does not remove the previous foreign key" do
+        expect(game.person_id).to eq(person.id)
+      end
+    end
+  end
+
+  context "when the document belongs to a has one and has many" do
+
+    let(:movie) do
+      Movie.create(name: "Infernal Affairs")
+    end
+
+    let(:account) do
+      Account.create(name: "Leung")
+    end
+
+    context "when creating the document" do
+
+      let(:comment) do
+        Comment.create(movie: movie, account: account)
+      end
+
+      it "sets the correct has one" do
+        expect(comment.account).to eq(account)
+      end
+
+      it "sets the correct has many" do
+        expect(comment.movie).to eq(movie)
+      end
+    end
+  end
+
+  context "when reloading the relation" do
+
+    let!(:person_one) do
+      Person.create
+    end
+
+    let!(:person_two) do
+      Person.create(title: "Sir")
+    end
+
+    let!(:game) do
+      Game.create(name: "Starcraft 2")
+    end
+
+    before do
+      game.person = person_one
+      game.save
+    end
+
+    context "when the relation references the same document" do
+
+      before do
+        Person.collection.find({ _id: person_one.id }).
+            update_one({ "$set" => { title: "Madam" }})
+      end
+
+      let(:reloaded) do
+        game.person(true)
+      end
+
+      it "reloads the document from the database" do
+        expect(reloaded.title).to eq("Madam")
+      end
+
+      it "sets a new document instance" do
+        expect(reloaded).to_not equal(person_one)
+      end
+    end
+
+    context "when the relation references a different document" do
+
+      before do
+        game.person_id = person_two.id
+        game.save
+      end
+
+      let(:reloaded) do
+        game.person(true)
+      end
+
+      it "reloads the new document from the database" do
+        expect(reloaded.title).to eq("Sir")
+      end
+
+      it "sets a new document instance" do
+        expect(reloaded).to_not equal(person_one)
+      end
+    end
+  end
+
+  context "when creating with a reference to an integer id parent" do
+
+    let!(:jar) do
+      Jar.create do |doc|
+        doc._id = 1
+      end
+    end
+
+    let(:cookie) do
+      Cookie.create(jar_id: "1")
+    end
+
+    it "allows strings to be passed as the id" do
+      expect(cookie.jar).to eq(jar)
+    end
+
+    it "persists the relation" do
+      expect(cookie.reload.jar).to eq(jar)
+    end
+  end
+
+  context "when setting the relation via the foreign key" do
+
+    context "when the relation exists" do
+
+      let!(:person_one) do
+        Person.create
+      end
+
+      let!(:person_two) do
+        Person.create
+      end
+
+      let!(:game) do
+        Game.create(person: person_one)
+      end
+
+      before do
+        game.person_id = person_two.id
+      end
+
+      it "sets the new document on the relation" do
+        expect(game.person).to eq(person_two)
+      end
+    end
+  end
+
+  describe "#method_missing" do
+      let!(:person) do
+        Person.create
+      end
+
+      let!(:game) do
+        Game.create(person: person)
+      end
+
+    it 'handles keyword args' do
+      expect do
+        game.person.set_personal_data(ssn: '123', age: 25)
+      end.not_to raise_error
+    end
+
+  end
+end