mongoid_heroku_stable 4.0.0

data/spec/mongoid/relations/options_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+describe Mongoid::Relations::Options do
+
+  describe ".validate!" do
+
+    let(:relation) do
+      Mongoid::Relations::Embedded::Many
+    end
+
+    context "when the options are valid for the relation" do
+
+      let(:options) do
+        { relation: relation, as: :addressable }
+      end
+
+      it "returns true" do
+        expect(described_class.validate!(options)).to be_true
+      end
+    end
+
+    context "when the options are invalid for the relation" do
+
+      let(:options) do
+        { name: :addresses, relation: relation, polymorphic: true }
+      end
+
+      it "raises an error" do
+        expect {
+          described_class.validate!(options)
+        }.to raise_error(Mongoid::Errors::InvalidOptions)
+      end
+    end
+  end
+end

data/spec/mongoid/relations/polymorphic_spec.rb

@@ -0,0 +1,128 @@
+require "spec_helper"
+
+describe Mongoid::Relations::Polymorphic do
+
+  describe "#polymorph" do
+
+    let(:klass) do
+      Class.new.tap { |c| c.send(:include, Mongoid::Document) }
+    end
+
+    context "when the relation is polymorphic" do
+
+      context "when the relation stores a foreign key" do
+
+        let(:metadata) do
+          Mongoid::Relations::Metadata.new(
+            name: :ratable,
+            polymorphic: true,
+            relation: Mongoid::Relations::Referenced::In
+          )
+        end
+
+        let!(:polymorphed) do
+          klass.polymorph(metadata)
+        end
+
+        it "sets polymorphic to true" do
+          expect(klass).to be_polymorphic
+        end
+
+        it "adds the foreign key type field" do
+          expect(klass.fields["ratable_type"]).to_not be_nil
+        end
+
+        it "returns self" do
+          expect(polymorphed).to eq(klass)
+        end
+      end
+
+      context "when the relation does not store a foreign key" do
+
+        let(:metadata) do
+          Mongoid::Relations::Metadata.new(
+            name: :ratings,
+            as: :ratable,
+            relation: Mongoid::Relations::Referenced::Many
+          )
+        end
+
+        before do
+          klass.polymorph(metadata)
+        end
+
+        it "sets polymorphic to true" do
+          expect(klass).to be_polymorphic
+        end
+
+        it "does not add the foreign key type field" do
+          expect(klass.fields["ratable_type"]).to be_nil
+        end
+
+        it "does not add the foreign key inverse field field" do
+          expect(klass.fields["ratable_field"]).to be_nil
+        end
+      end
+    end
+
+    context "when the relation is not polymorphic" do
+
+      let(:metadata) do
+        Mongoid::Relations::Metadata.new(
+          name: :ratings,
+          relation: Mongoid::Relations::Referenced::Many
+        )
+      end
+
+      before do
+        klass.polymorph(metadata)
+      end
+
+      it "sets polymorphic to false" do
+        expect(klass).to_not be_polymorphic
+      end
+
+      it "does not add the foreign key type field" do
+        expect(klass.fields["ratable_type"]).to be_nil
+      end
+
+      it "does not add the foreign key inverse field field" do
+        expect(klass.fields["ratable_field"]).to be_nil
+      end
+    end
+  end
+
+  describe ".polymorphic?" do
+
+    context "when the document is in a polymorphic relation" do
+
+      it "returns true" do
+        expect(Movie).to be_polymorphic
+      end
+    end
+
+    context "when the document is not in a polymorphic relation" do
+
+      it "returns false" do
+        expect(Survey).to_not be_polymorphic
+      end
+    end
+  end
+
+  describe "#polymorphic?" do
+
+    context "when the document is in a polymorphic relation" do
+
+      it "returns true" do
+        expect(Movie.new).to be_polymorphic
+      end
+    end
+
+    context "when the document is not in a polymorphic relation" do
+
+      it "returns false" do
+        expect(Survey.new).to_not be_polymorphic
+      end
+    end
+  end
+end

data/spec/mongoid/relations/proxy_spec.rb

@@ -0,0 +1,48 @@
+require "spec_helper"
+
+describe Mongoid::Relations::Proxy do
+
+  describe "#extend" do
+
+    before(:all) do
+      Person.reset_callbacks(:validate)
+      module Testable
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, :Testable)
+    end
+
+    let(:person) do
+      Person.create
+    end
+
+    let(:name) do
+      person.build_name
+    end
+
+    before do
+      name.namable.extend(Testable)
+    end
+
+    it "extends the proxied object" do
+      expect(person).to be_a(Testable)
+    end
+
+    context "when extending from the relation definition" do
+
+      let!(:address) do
+        person.addresses.create(street: "hobrecht")
+      end
+
+      let(:found) do
+        person.addresses.find_by_street("hobrecht")
+      end
+
+      it "extends the proxy" do
+        expect(found).to eq(address)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,1435 @@
+require "spec_helper"
+
+describe Mongoid::Relations::Referenced::In 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 metadata" do
+        expect(address.metadata).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
+        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 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
+      end
+
+      let(:drug) do
+        Drug.create
+      end
+
+      let(:person) do
+        Person.create
+      end
+
+      context "when relation is has_one" do
+
+        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 is destroyed" do
+
+            before do
+              account.delete
+            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
+
+        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.delete
+            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
+
+        before do
+          Account.belongs_to :person, dependent: :delete
+          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 deleted" do
+
+            before do
+              account.delete
+            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
+
+        before do
+          Drug.belongs_to :person, dependent: :delete
+          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.delete
+            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
+
+        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 deleted" do
+
+            before do
+              account.delete
+            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
+
+        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.delete
+            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 ".builder" do
+
+    let(:builder_klass) do
+      Mongoid::Relations::Builders::Referenced::In
+    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 ".eager_load" do
+
+    before do
+      Mongoid.identity_map_enabled = true
+    end
+
+    after do
+      Mongoid.identity_map_enabled = false
+    end
+
+    context "when the relation is not polymorphic" do
+
+      let!(:person) do
+        Person.create
+      end
+
+      let!(:post) do
+        person.posts.create(title: "testing")
+      end
+
+      let(:metadata) do
+        Post.relations["person"]
+      end
+
+      let(:eager) do
+        described_class.eager_load(metadata, Post.all)
+      end
+
+      let!(:map) do
+        Mongoid::IdentityMap.get(Person, person.id)
+      end
+
+      it "puts the document in the identity map" do
+        expect(map).to eq(person)
+      end
+    end
+
+    context "when the relation is polymorphic" do
+
+      let(:metadata) do
+        Rating.relations["ratable"]
+      end
+
+      it "raises an error" do
+        expect {
+          described_class.eager_load(metadata, Rating.all)
+        }.to raise_error(Mongoid::Errors::EagerLoad)
+      end
+    end
+
+    context "when the ids has been duplicated" do
+
+      let!(:person) do
+        Person.create
+      end
+
+      let!(:posts) do
+        2.times {|i| person.posts.create(title: "testing#{i}") }
+        person.posts
+      end
+
+      let(:metadata) do
+        Post.relations["person"]
+      end
+
+      let(:eager) do
+        described_class.eager_load(metadata, posts.map(&:person_id))
+      end
+
+      it "duplication should be removed" do
+        expect(eager.count).to eq(1)
+      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 belongs_to" do
+      expect(described_class.macro).to eq(:belongs_to)
+    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
+
+  describe ".stores_foreign_key?" do
+
+    it "returns true" do
+      expect(described_class.stores_foreign_key?).to be_true
+    end
+  end
+
+  describe ".valid_options" do
+
+    it "returns the valid options" do
+      expect(described_class.valid_options).to eq(
+        [
+          :autobuild,
+          :autosave,
+          :dependent,
+          :foreign_key,
+          :index,
+          :polymorphic,
+          :primary_key,
+          :touch
+        ]
+      )
+    end
+  end
+
+  describe ".validation_default" do
+
+    it "returns false" do
+      expect(described_class.validation_default).to be_false
+    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({ "$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 the parent and child are persisted" do
+
+    context "when the identity map is enabled" do
+
+      before do
+        Mongoid.identity_map_enabled = true
+      end
+
+      after do
+        Mongoid.identity_map_enabled = false
+      end
+
+      let(:series) do
+        Series.create
+      end
+
+      let!(:book_one) do
+        series.books.create
+      end
+
+      let!(:book_two) do
+        series.books.create
+      end
+
+      let(:id) do
+        Book.first.id
+      end
+
+      context "when asking for the inverse multiple times" do
+
+        before do
+          Book.find(id).series.books.to_a
+        end
+
+        it "does not append and save duplicate docs" do
+          expect(Book.find(id).series.books.to_a.length).to eq(2)
+        end
+
+        it "returns the same documents from the map" do
+          expect(Book.find(id)).to equal(Book.find(id))
+        end
+      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
+end