sepastian-mongoid-rails4 4.0.0.alpha

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

@@ -0,0 +1,3600 @@
+require "spec_helper"
+
+describe Mongoid::Relations::Referenced::Many do
+
+  before :all do
+    Mongoid.raise_not_found_error = true
+
+    Drug.belongs_to :person, primary_key: :username
+    Person.has_many :drugs, validate: false, primary_key: :username
+  end
+
+  after :all do
+    Drug.belongs_to :person, counter_cache: true
+    Person.has_many :drugs, validate: false
+  end
+
+  [ :<<, :push ].each do |method|
+
+    describe "##{method}" do
+
+      context "when providing the base class in child contructor" do
+
+        let(:person) do
+          Person.create
+        end
+
+        let!(:post) do
+          person.posts.send(method, Post.new(person: person))
+        end
+
+        it "only adds the relation once" do
+          expect(person.posts.size).to eq(1)
+        end
+
+        it "only persists the relation once" do
+          expect(person.reload.posts.size).to eq(1)
+        end
+      end
+
+      context "when the relations are not polymorphic" do
+
+        context "when the parent is a new record" do
+
+          let(:person) do
+            Person.new
+          end
+
+          context "when the child is new" do
+
+            let(:post) do
+              Post.new
+            end
+
+            let!(:added) do
+              person.posts.send(method, post)
+            end
+
+            it "sets the foreign key on the relation" do
+              expect(post.person_id).to eq(person.id)
+            end
+
+            it "sets the base on the inverse relation" do
+              expect(post.person).to eq(person)
+            end
+
+            it "sets the same instance on the inverse relation" do
+              expect(post.person).to eql(person)
+            end
+
+            it "does not save the target" do
+              expect(post).to be_new_record
+            end
+
+            it "adds the document to the target" do
+              expect(person.posts.size).to eq(1)
+            end
+
+            it "returns the relation" do
+              expect(added).to eq(person.posts)
+            end
+          end
+
+          context "when the child is persisted" do
+
+            let(:post) do
+              Post.create
+            end
+
+            before do
+              person.posts.send(method, post)
+            end
+
+            it "sets the foreign key on the relation" do
+              expect(post.person_id).to eq(person.id)
+            end
+
+            it "sets the base on the inverse relation" do
+              expect(post.person).to eq(person)
+            end
+
+            it "sets the same instance on the inverse relation" do
+              expect(post.person).to eql(person)
+            end
+
+            it "does not save the parent" do
+              expect(person).to be_new_record
+            end
+
+            it "adds the document to the target" do
+              expect(person.posts.size).to eq(1)
+            end
+
+            context "when subsequently saving the parent" do
+
+              before do
+                person.save
+                post.save
+              end
+
+              it "returns the correct count of the relation" do
+                expect(person.posts.count).to eq(1)
+              end
+            end
+          end
+        end
+
+        context "when appending in a parent create block" do
+
+          let!(:post) do
+            Post.create(title: "testing")
+          end
+
+          let!(:person) do
+            Person.create do |doc|
+              doc.posts << post
+            end
+          end
+
+          it "adds the documents to the relation" do
+            expect(person.posts).to eq([ post ])
+          end
+
+          it "sets the foreign key on the inverse relation" do
+            expect(post.person_id).to eq(person.id)
+          end
+
+          it "saves the target" do
+            expect(post).to be_persisted
+          end
+
+          it "adds the correct number of documents" do
+            expect(person.posts.size).to eq(1)
+          end
+
+          it "persists the link" do
+            expect(person.reload.posts).to eq([ post ])
+          end
+        end
+
+        context "when the parent is not a new record" do
+
+          let(:person) do
+            Person.create
+          end
+
+          let(:post) do
+            Post.new
+          end
+
+          before do
+            person.posts.send(method, post)
+          end
+
+          it "sets the foreign key on the relation" do
+            expect(post.person_id).to eq(person.id)
+          end
+
+          it "sets the base on the inverse relation" do
+            expect(post.person).to eq(person)
+          end
+
+          it "sets the same instance on the inverse relation" do
+            expect(post.person).to eql(person)
+          end
+
+          it "saves the target" do
+            expect(post).to be_persisted
+          end
+
+          it "adds the document to the target" do
+            expect(person.posts.count).to eq(1)
+          end
+
+          it "increments the counter cache" do
+            expect(person[:posts_count]).to eq(1)
+            expect(person.posts_count).to eq(1)
+          end
+
+          it "doesnt change the list of changes" do
+            expect(person.changed).to eq([])
+          end
+
+          context "when saving another post" do
+
+            before do
+              person.posts.send(method, Post.new)
+            end
+
+            it "increments the counter cache" do
+              expect(person.posts_count).to eq(2)
+            end
+          end
+
+          context "when documents already exist on the relation" do
+
+            let(:post_two) do
+              Post.new(title: "Test")
+            end
+
+            before do
+              person.posts.send(method, post_two)
+            end
+
+            it "sets the foreign key on the relation" do
+              expect(post_two.person_id).to eq(person.id)
+            end
+
+            it "sets the base on the inverse relation" do
+              expect(post_two.person).to eq(person)
+            end
+
+            it "sets the same instance on the inverse relation" do
+              expect(post_two.person).to eql(person)
+            end
+
+            it "saves the target" do
+              expect(post_two).to be_persisted
+            end
+
+            it "adds the document to the target" do
+              expect(person.posts.count).to eq(2)
+            end
+
+            it "increments the counter cache" do
+              expect(person.reload.posts_count).to eq(2)
+            end
+
+            it "contains the initial document in the target" do
+              expect(person.posts).to include(post)
+            end
+
+            it "contains the added document in the target" do
+              expect(person.posts).to include(post_two)
+            end
+          end
+        end
+      end
+
+      context "when.adding to the relation" do
+
+        let(:person) do
+          Person.create
+        end
+
+        context "when the operation succeeds" do
+
+          let(:post) do
+            Post.new
+          end
+
+          before do
+            person.posts.send(method, post)
+          end
+
+          it "adds the document to the relation" do
+            expect(person.posts).to eq([ post ])
+          end
+        end
+
+        context "when the operation fails" do
+
+          let!(:existing) do
+            Post.create
+          end
+
+          let(:post) do
+            Post.new do |doc|
+              doc._id = existing.id
+            end
+          end
+
+          it "raises an error" do
+            expect {
+              person.posts.send(method, post)
+            }.to raise_error(Moped::Errors::OperationFailure)
+          end
+        end
+      end
+
+      context "when the relations are 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
+            movie.ratings.send(method, rating)
+          end
+
+          it "sets the foreign key on the relation" do
+            expect(rating.ratable_id).to eq(movie.id)
+          end
+
+          it "sets the base on the inverse relation" do
+            expect(rating.ratable).to eq(movie)
+          end
+
+          it "does not save the target" do
+            expect(rating).to be_new_record
+          end
+
+          it "adds the document to the target" do
+            expect(movie.ratings.size).to eq(1)
+          end
+        end
+
+        context "when the parent is not a new record" do
+
+          let(:movie) do
+            Movie.create
+          end
+
+          let(:rating) do
+            Rating.new
+          end
+
+          before do
+            movie.ratings.send(method, rating)
+          end
+
+          it "sets the foreign key on the relation" do
+            expect(rating.ratable_id).to eq(movie.id)
+          end
+
+          it "sets the base on the inverse relation" do
+            expect(rating.ratable).to eq(movie)
+          end
+
+          it "saves the target" do
+            expect(rating).to be_persisted
+          end
+
+          it "adds the document to the target" do
+            expect(movie.ratings.count).to eq(1)
+          end
+        end
+      end
+    end
+  end
+
+  describe "#=" 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
+          person.posts = [ post ]
+        end
+
+        it "sets the target of the relation" do
+          expect(person.posts.target).to eq([ post ])
+        end
+
+        it "sets the foreign key on the relation" do
+          expect(post.person_id).to eq(person.id)
+        end
+
+        it "sets the base on the inverse relation" do
+          expect(post.person).to eq(person)
+        end
+
+        it "does not save the target" do
+          expect(post).to_not be_persisted
+        end
+      end
+
+      context "when the parent is not a new record" do
+
+        let(:person) do
+          Person.create
+        end
+
+        let(:post) do
+          Post.new
+        end
+
+        before do
+          person.posts = [ post ]
+        end
+
+        it "sets the target of the relation" do
+          expect(person.posts.target).to eq([ post ])
+        end
+
+        it "sets the foreign key of the relation" do
+          expect(post.person_id).to eq(person.id)
+        end
+
+        it "sets the base on the inverse relation" do
+          expect(post.person).to eq(person)
+        end
+
+        it "saves the target" do
+          expect(post).to be_persisted
+        end
+
+        context "when replacing the relation with the same documents" do
+
+          context "when using the same in memory instance" do
+
+            before do
+              person.posts = [ post ]
+            end
+
+            it "keeps the relation intact" do
+              expect(person.posts).to eq([ post ])
+            end
+
+            it "does not delete the relation" do
+              expect(person.reload.posts).to eq([ post ])
+            end
+          end
+
+          context "when using a new instance" do
+
+            let(:from_db) do
+              Person.find(person.id)
+            end
+
+            before do
+              from_db.posts = [ post ]
+            end
+
+            it "keeps the relation intact" do
+              expect(from_db.posts).to eq([ post ])
+            end
+
+            it "does not delete the relation" do
+              expect(from_db.reload.posts).to eq([ post ])
+            end
+          end
+        end
+
+        context "when replacing the with a combination of old and new docs" do
+
+          let(:new_post) do
+            Post.create(title: "new post")
+          end
+
+          context "when using the same in memory instance" do
+
+            before do
+              person.posts = [ post, new_post ]
+            end
+
+            it "keeps the relation intact" do
+              expect(person.posts.size).to eq(2)
+            end
+
+            it "keeps the first post" do
+              expect(person.posts).to include(post)
+            end
+
+            it "keeps the second post" do
+              expect(person.posts).to include(new_post)
+            end
+
+            it "does not delete the relation" do
+              expect(person.reload.posts).to eq([ post, new_post ])
+            end
+          end
+
+          context "when using a new instance" do
+
+            let(:from_db) do
+              Person.find(person.id)
+            end
+
+            before do
+              from_db.posts = [ post, new_post ]
+            end
+
+            it "keeps the relation intact" do
+              expect(from_db.posts).to eq([ post, new_post ])
+            end
+
+            it "does not delete the relation" do
+              expect(from_db.reload.posts).to eq([ post, new_post ])
+            end
+          end
+        end
+
+        context "when replacing the with a combination of only new docs" do
+
+          let(:new_post) do
+            Post.create(title: "new post")
+          end
+
+          context "when using the same in memory instance" do
+
+            before do
+              person.posts = [ new_post ]
+            end
+
+            it "keeps the relation intact" do
+              expect(person.posts).to eq([ new_post ])
+            end
+
+            it "does not delete the relation" do
+              expect(person.reload.posts).to eq([ new_post ])
+            end
+          end
+
+          context "when using a new instance" do
+
+            let(:from_db) do
+              Person.find(person.id)
+            end
+
+            before do
+              from_db.posts = [ new_post ]
+            end
+
+            it "keeps the relation intact" do
+              expect(from_db.posts).to eq([ new_post ])
+            end
+
+            it "does not delete the relation" do
+              expect(from_db.reload.posts).to eq([ new_post ])
+            end
+          end
+        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
+          movie.ratings = [ rating ]
+        end
+
+        it "sets the target of the relation" do
+          expect(movie.ratings.target).to eq([ rating ])
+        end
+
+        it "sets the foreign key on the relation" do
+          expect(rating.ratable_id).to eq(movie.id)
+        end
+
+        it "sets the base on the inverse relation" do
+          expect(rating.ratable).to eq(movie)
+        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(:movie) do
+          Movie.create
+        end
+
+        let(:rating) do
+          Rating.new
+        end
+
+        before do
+          movie.ratings = [ rating ]
+        end
+
+        it "sets the target of the relation" do
+          expect(movie.ratings.target).to eq([ rating ])
+        end
+
+        it "sets the foreign key of the relation" do
+          expect(rating.ratable_id).to eq(movie.id)
+        end
+
+        it "sets the base on the inverse relation" do
+          expect(rating.ratable).to eq(movie)
+        end
+
+        it "saves the target" do
+          expect(rating).to be_persisted
+        end
+      end
+    end
+  end
+
+  describe "#= []" do
+
+    context "when the parent is persisted" do
+
+      let(:posts) do
+        [ Post.create(title: "1"), Post.create(title: "2") ]
+      end
+
+      let(:person) do
+        Person.create(posts: posts)
+      end
+
+      context "when the parent has multiple children" do
+
+        before do
+          person.posts = []
+        end
+
+        it "removes all the children" do
+          expect(person.posts).to be_empty
+        end
+
+        it "persists the changes" do
+          expect(person.posts(true)).to be_empty
+        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(:post) do
+          Post.new
+        end
+
+        before do
+          person.posts = [ post ]
+          person.posts = nil
+        end
+
+        it "sets the relation to an empty array" do
+          expect(person.posts).to be_empty
+        end
+
+        it "removed the inverse relation" do
+          expect(post.person).to be_nil
+        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.create
+        end
+
+        context "when dependent is destructive" do
+
+          let(:post) do
+            Post.new
+          end
+
+          before do
+            person.posts = [ post ]
+            person.posts = nil
+          end
+
+          it "sets the relation to empty" do
+            expect(person.posts).to be_empty
+          end
+
+          it "removed the inverse relation" do
+            expect(post.person).to be_nil
+          end
+
+          it "removes the foreign key value" do
+            expect(post.person_id).to be_nil
+          end
+
+          it "deletes the target from the database" do
+            expect(post).to be_destroyed
+          end
+        end
+
+        context "when dependent is not destructive" do
+
+          let(:drug) do
+            Drug.new(name: "Oxycodone")
+          end
+
+          before do
+            person.drugs = [ drug ]
+            person.drugs = nil
+          end
+
+          it "sets the relation to empty" do
+            expect(person.drugs).to be_empty
+          end
+
+          it "removed the inverse relation" do
+            expect(drug.person).to be_nil
+          end
+
+          it "removes the foreign key value" do
+            expect(drug.person_id).to be_nil
+          end
+
+          it "nullifies the relation" do
+            expect(drug).to_not be_destroyed
+          end
+        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
+          movie.ratings = [ rating ]
+          movie.ratings = nil
+        end
+
+        it "sets the relation to an empty array" do
+          expect(movie.ratings).to be_empty
+        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(:movie) do
+          Movie.create
+        end
+
+        let(:rating) do
+          Rating.new
+        end
+
+        before do
+          movie.ratings = [ rating ]
+          movie.ratings = nil
+        end
+
+        it "sets the relation to empty" do
+          expect(movie.ratings).to be_empty
+        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
+
+        context "when dependent is nullify" do
+
+          it "does not delete the target from the database" do
+            expect(rating).to_not be_destroyed
+          end
+        end
+      end
+    end
+  end
+
+  describe "#\{name}_ids=" do
+
+    let(:person) do
+      Person.new
+    end
+
+    let(:post_one) do
+      Post.create
+    end
+
+    let(:post_two) do
+      Post.create
+    end
+
+    before do
+      person.post_ids = [ post_one.id, post_two.id ]
+    end
+
+    it "calls setter with documents find by given ids" do
+      expect(person.posts).to eq([ post_one, post_two ])
+    end
+  end
+
+  describe "#\{name}_ids" do
+
+    let(:posts) do
+      [ Post.create, Post.create ]
+    end
+
+    let(:person) do
+      Person.create(posts: posts)
+    end
+
+    it "returns ids of documents that are in the relation" do
+      expect(person.post_ids).to eq(posts.map(&:id))
+    end
+  end
+
+  [ :build, :new ].each do |method|
+
+    describe "##{method}" do
+
+      context "when the relation is not polymorphic" do
+
+        context "when the parent is a new record" do
+
+          let(:person) do
+            Person.new(title: "sir")
+          end
+
+          let!(:post) do
+            person.posts.send(method, title: "$$$")
+          end
+
+          it "sets the foreign key on the relation" do
+            expect(post.person_id).to eq(person.id)
+          end
+
+          it "sets the base on the inverse relation" do
+            expect(post.person).to eq(person)
+          end
+
+          it "sets the attributes" do
+            expect(post.title).to eq("$$$")
+          end
+
+          it "sets the post processed defaults" do
+            expect(post.person_title).to eq(person.title)
+          end
+
+          it "does not save the target" do
+            expect(post).to be_new_record
+          end
+
+          it "adds the document to the target" do
+            expect(person.posts.size).to eq(1)
+          end
+
+          it "does not perform validation" do
+            expect(post.errors).to be_empty
+          end
+        end
+
+        context "when the parent is not a new record" do
+
+          let(:person) do
+            Person.create
+          end
+
+          let!(:post) do
+            person.posts.send(method, text: "Testing")
+          end
+
+          it "sets the foreign key on the relation" do
+            expect(post.person_id).to eq(person.id)
+          end
+
+          it "sets the base on the inverse relation" do
+            expect(post.person).to eq(person)
+          end
+
+          it "sets the attributes" do
+            expect(post.text).to eq("Testing")
+          end
+
+          it "does not save the target" do
+            expect(post).to be_new_record
+          end
+
+          it "adds the document to the target" do
+            expect(person.posts.size).to eq(1)
+          end
+        end
+      end
+
+      context "when the relation is polymorphic" do
+
+        context "when the parent is a subclass" do
+
+          let(:video_game) do
+            VideoGame.create
+          end
+
+          let(:rating) do
+            video_game.ratings.build
+          end
+
+          it "sets the parent on the child" do
+            expect(rating.ratable).to eq(video_game)
+          end
+
+          it "sets the correct polymorphic type" do
+            expect(rating.ratable_type).to eq("VideoGame")
+          end
+        end
+
+        context "when the parent is a new record" do
+
+          let(:movie) do
+            Movie.new
+          end
+
+          let!(:rating) do
+            movie.ratings.send(method, value: 3)
+          end
+
+          it "sets the foreign key on the relation" do
+            expect(rating.ratable_id).to eq(movie.id)
+          end
+
+          it "sets the base on the inverse relation" do
+            expect(rating.ratable).to eq(movie)
+          end
+
+          it "sets the attributes" do
+            expect(rating.value).to eq(3)
+          end
+
+          it "does not save the target" do
+            expect(rating).to be_new_record
+          end
+
+          it "adds the document to the target" do
+            expect(movie.ratings.size).to eq(1)
+          end
+
+          it "does not perform validation" do
+            expect(rating.errors).to be_empty
+          end
+        end
+
+        context "when the parent is not a new record" do
+
+          let(:movie) do
+            Movie.create
+          end
+
+          let!(:rating) do
+            movie.ratings.send(method, value: 4)
+          end
+
+          it "sets the foreign key on the relation" do
+            expect(rating.ratable_id).to eq(movie.id)
+          end
+
+          it "sets the base on the inverse relation" do
+            expect(rating.ratable).to eq(movie)
+          end
+
+          it "sets the attributes" do
+            expect(rating.value).to eq(4)
+          end
+
+          it "does not save the target" do
+            expect(rating).to be_new_record
+          end
+
+          it "adds the document to the target" do
+            expect(movie.ratings.size).to eq(1)
+          end
+        end
+      end
+    end
+  end
+
+  describe ".builder" do
+
+    let(:builder_klass) do
+      Mongoid::Relations::Builders::Referenced::Many
+    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 "#clear" do
+
+    context "when the relation is not polymorphic" do
+
+      context "when the parent has been persisted" do
+
+        let!(:person) do
+          Person.create
+        end
+
+        context "when the children are persisted" do
+
+          let!(:post) do
+            person.posts.create(title: "Testing")
+          end
+
+          let!(:relation) do
+            person.posts.clear
+          end
+
+          it "clears out the relation" do
+            expect(person.posts).to be_empty
+          end
+
+          it "marks the documents as deleted" do
+            expect(post).to be_destroyed
+          end
+
+          it "deletes the documents from the db" do
+            expect(person.reload.posts).to be_empty
+          end
+
+          it "returns the relation" do
+            expect(relation).to be_empty
+          end
+        end
+
+        context "when the children are not persisted" do
+
+          let!(:post) do
+            person.posts.build(title: "Testing")
+          end
+
+          let!(:relation) do
+            person.posts.clear
+          end
+
+          it "clears out the relation" do
+            expect(person.posts).to be_empty
+          end
+        end
+      end
+
+      context "when the parent is not persisted" do
+
+        let(:person) do
+          Person.new
+        end
+
+        let!(:post) do
+          person.posts.build(title: "Testing")
+        end
+
+        let!(:relation) do
+          person.posts.clear
+        end
+
+        it "clears out the relation" do
+          expect(person.posts).to be_empty
+        end
+      end
+    end
+
+    context "when the relation is polymorphic" do
+
+      context "when the parent has been persisted" do
+
+        let!(:movie) do
+          Movie.create
+        end
+
+        context "when the children are persisted" do
+
+          let!(:rating) do
+            movie.ratings.create(value: 1)
+          end
+
+          let!(:relation) do
+            movie.ratings.clear
+          end
+
+          it "clears out the relation" do
+            expect(movie.ratings).to be_empty
+          end
+
+          it "handles the proper dependent strategy" do
+            expect(rating).to_not be_destroyed
+          end
+
+          it "deletes the documents from the db" do
+            expect(movie.reload.ratings).to be_empty
+          end
+
+          it "returns the relation" do
+            expect(relation).to be_empty
+          end
+        end
+
+        context "when the children are not persisted" do
+
+          let!(:rating) do
+            movie.ratings.build(value: 3)
+          end
+
+          let!(:relation) do
+            movie.ratings.clear
+          end
+
+          it "clears out the relation" do
+            expect(movie.ratings).to be_empty
+          end
+        end
+      end
+
+      context "when the parent is not persisted" do
+
+        let(:movie) do
+          Movie.new
+        end
+
+        let!(:rating) do
+          movie.ratings.build(value: 2)
+        end
+
+        let!(:relation) do
+          movie.ratings.clear
+        end
+
+        it "clears out the relation" do
+          expect(movie.ratings).to be_empty
+        end
+      end
+    end
+  end
+
+  describe "#concat" do
+
+    context "when the relations are 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
+          person.posts.concat([ post ])
+        end
+
+        it "sets the foreign key on the relation" do
+          expect(post.person_id).to eq(person.id)
+        end
+
+        it "sets the base on the inverse relation" do
+          expect(post.person).to eq(person)
+        end
+
+        it "sets the same instance on the inverse relation" do
+          expect(post.person).to eql(person)
+        end
+
+        it "does not save the target" do
+          expect(post).to be_new_record
+        end
+
+        it "adds the document to the target" do
+          expect(person.posts.size).to eq(1)
+        end
+      end
+
+      context "when appending in a parent create block" do
+
+        let!(:post) do
+          Post.create(title: "testing")
+        end
+
+        let!(:person) do
+          Person.create do |doc|
+            doc.posts.concat([ post ])
+          end
+        end
+
+        it "adds the documents to the relation" do
+          expect(person.posts).to eq([ post ])
+        end
+
+        it "sets the foreign key on the inverse relation" do
+          expect(post.person_id).to eq(person.id)
+        end
+
+        it "saves the target" do
+          expect(post).to be_persisted
+        end
+
+        it "adds the correct number of documents" do
+          expect(person.posts.size).to eq(1)
+        end
+
+        it "persists the link" do
+          expect(person.reload.posts).to eq([ post ])
+        end
+      end
+
+      context "when the parent is not a new record" do
+
+        let(:person) do
+          Person.create
+        end
+
+        let(:post) do
+          Post.new
+        end
+
+        let(:post_three) do
+          Post.new
+        end
+
+        before do
+          person.posts.concat([ post, post_three ])
+        end
+
+        it "sets the foreign key on the relation" do
+          expect(post.person_id).to eq(person.id)
+        end
+
+        it "sets the base on the inverse relation" do
+          expect(post.person).to eq(person)
+        end
+
+        it "sets the same instance on the inverse relation" do
+          expect(post.person).to eql(person)
+        end
+
+        it "saves the target" do
+          expect(post).to be_persisted
+        end
+
+        it "adds the document to the target" do
+          expect(person.posts.count).to eq(2)
+        end
+
+        context "when documents already exist on the relation" do
+
+          let(:post_two) do
+            Post.new(title: "Test")
+          end
+
+          before do
+            person.posts.concat([ post_two ])
+          end
+
+          it "sets the foreign key on the relation" do
+            expect(post_two.person_id).to eq(person.id)
+          end
+
+          it "sets the base on the inverse relation" do
+            expect(post_two.person).to eq(person)
+          end
+
+          it "sets the same instance on the inverse relation" do
+            expect(post_two.person).to eql(person)
+          end
+
+          it "saves the target" do
+            expect(post_two).to be_persisted
+          end
+
+          it "adds the document to the target" do
+            expect(person.posts.count).to eq(3)
+          end
+
+          it "contains the initial document in the target" do
+            expect(person.posts).to include(post)
+          end
+
+          it "contains the added document in the target" do
+            expect(person.posts).to include(post_two)
+          end
+        end
+      end
+    end
+  end
+
+  context "when the relations are 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
+        movie.ratings.concat([ rating ])
+      end
+
+      it "sets the foreign key on the relation" do
+        expect(rating.ratable_id).to eq(movie.id)
+      end
+
+      it "sets the base on the inverse relation" do
+        expect(rating.ratable).to eq(movie)
+      end
+
+      it "does not save the target" do
+        expect(rating).to be_new_record
+      end
+
+      it "adds the document to the target" do
+        expect(movie.ratings.size).to eq(1)
+      end
+    end
+
+    context "when the parent is not a new record" do
+
+      let(:movie) do
+        Movie.create
+      end
+
+      let(:rating) do
+        Rating.new
+      end
+
+      before do
+        movie.ratings.concat([ rating ])
+      end
+
+      it "sets the foreign key on the relation" do
+        expect(rating.ratable_id).to eq(movie.id)
+      end
+
+      it "sets the base on the inverse relation" do
+        expect(rating.ratable).to eq(movie)
+      end
+
+      it "saves the target" do
+        expect(rating).to be_persisted
+      end
+
+      it "adds the document to the target" do
+        expect(movie.ratings.count).to eq(1)
+      end
+    end
+  end
+
+  describe "#count" do
+
+    let(:movie) do
+      Movie.create
+    end
+
+    context "when documents have been persisted" do
+
+      let!(:rating) do
+        movie.ratings.create(value: 1)
+      end
+
+      it "returns the number of persisted documents" do
+        expect(movie.ratings.count).to eq(1)
+      end
+    end
+
+    context "when documents have not been persisted" do
+
+      let!(:rating) do
+        movie.ratings.build(value: 1)
+      end
+
+      it "returns 0" do
+        expect(movie.ratings.count).to eq(0)
+      end
+    end
+
+    context "when new documents exist in the database" do
+
+      context "when the documents are part of the relation" do
+
+        before do
+          Rating.create(ratable: movie)
+        end
+
+        it "returns the count from the db" do
+          expect(movie.ratings.count).to eq(1)
+        end
+      end
+
+      context "when the documents are not part of the relation" do
+
+        before do
+          Rating.create
+        end
+
+        it "returns the count from the db" do
+          expect(movie.ratings.count).to eq(0)
+        end
+      end
+    end
+  end
+
+  describe "#create" 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
+          person.posts.create(text: "Testing")
+        end
+
+        it "raises an unsaved document error" do
+          expect { post }.to raise_error(Mongoid::Errors::UnsavedDocument)
+        end
+      end
+
+      context "when.creating the document" do
+
+        context "when the operation is successful" do
+
+          let(:person) do
+            Person.create
+          end
+
+          let!(:post) do
+            person.posts.create(text: "Testing")
+          end
+
+          it "creates the document" do
+            expect(person.posts).to eq([ post ])
+          end
+        end
+
+        context "when the operation fails" do
+
+          let(:person) do
+            Person.create
+          end
+
+          let!(:existing) do
+            Post.create
+          end
+
+          it "raises an error" do
+            expect {
+              person.posts.create do |doc|
+                doc._id = existing.id
+              end
+            }.to raise_error(Moped::Errors::OperationFailure)
+          end
+        end
+      end
+
+      context "when the parent is not a new record" do
+
+        let(:person) do
+          Person.create
+        end
+
+        let!(:post) do
+          person.posts.create(text: "Testing") do |post|
+            post.content = "The Content"
+          end
+        end
+
+        it "sets the foreign key on the relation" do
+          expect(post.person_id).to eq(person.id)
+        end
+
+        it "sets the base on the inverse relation" do
+          expect(post.person).to eq(person)
+        end
+
+        it "sets the attributes" do
+          expect(post.text).to eq("Testing")
+        end
+
+        it "saves the target" do
+          expect(post).to_not be_a_new_record
+        end
+
+        it "calls the passed block" do
+          expect(post.content).to eq("The Content")
+        end
+
+        it "adds the document to the target" do
+          expect(person.posts.count).to eq(1)
+        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
+          movie.ratings.create(value: 1)
+        end
+
+        it "raises an unsaved document error" do
+          expect { rating }.to raise_error(Mongoid::Errors::UnsavedDocument)
+        end
+      end
+
+      context "when the parent is not a new record" do
+
+        let(:movie) do
+          Movie.create
+        end
+
+        let!(:rating) do
+          movie.ratings.create(value: 3)
+        end
+
+        it "sets the foreign key on the relation" do
+          expect(rating.ratable_id).to eq(movie.id)
+        end
+
+        it "sets the base on the inverse relation" do
+          expect(rating.ratable).to eq(movie)
+        end
+
+        it "sets the attributes" do
+          expect(rating.value).to eq(3)
+        end
+
+        it "saves the target" do
+          expect(rating).to_not be_new_record
+        end
+
+        it "adds the document to the target" do
+          expect(movie.ratings.count).to eq(1)
+        end
+      end
+    end
+
+    context "when using a diferent primary_key" do
+
+      let(:person) do
+        Person.create!(username: 'arthurnn')
+      end
+
+      let(:drug) do
+        person.drugs.create!
+      end
+
+      it 'saves pk value on fk field' do
+        expect(drug.person_id).to eq('arthurnn')
+      end
+    end
+  end
+
+  describe "#create!" 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
+          person.posts.create!(title: "Testing")
+        end
+
+        it "raises an unsaved document error" do
+          expect { post }.to raise_error(Mongoid::Errors::UnsavedDocument)
+        end
+      end
+
+      context "when the parent is not a new record" do
+
+        let(:person) do
+          Person.create
+        end
+
+        let!(:post) do
+          person.posts.create!(title: "Testing")
+        end
+
+        it "sets the foreign key on the relation" do
+          expect(post.person_id).to eq(person.id)
+        end
+
+        it "sets the base on the inverse relation" do
+          expect(post.person).to eq(person)
+        end
+
+        it "sets the attributes" do
+          expect(post.title).to eq("Testing")
+        end
+
+        it "saves the target" do
+          expect(post).to_not be_a_new_record
+        end
+
+        it "adds the document to the target" do
+          expect(person.posts.count).to eq(1)
+        end
+
+        context "when validation fails" do
+
+          it "raises an error" do
+            expect {
+              person.posts.create!(title: "$$$")
+            }.to raise_error(Mongoid::Errors::Validations)
+          end
+        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
+          movie.ratings.create!(value: 1)
+        end
+
+        it "raises an unsaved document error" do
+          expect { rating }.to raise_error(Mongoid::Errors::UnsavedDocument)
+        end
+      end
+
+      context "when the parent is not a new record" do
+
+        let(:movie) do
+          Movie.create
+        end
+
+        let!(:rating) do
+          movie.ratings.create!(value: 4)
+        end
+
+        it "sets the foreign key on the relation" do
+          expect(rating.ratable_id).to eq(movie.id)
+        end
+
+        it "sets the base on the inverse relation" do
+          expect(rating.ratable).to eq(movie)
+        end
+
+        it "sets the attributes" do
+          expect(rating.value).to eq(4)
+        end
+
+        it "saves the target" do
+          expect(rating).to_not be_new_record
+        end
+
+        it "adds the document to the target" do
+          expect(movie.ratings.count).to eq(1)
+        end
+
+        context "when validation fails" do
+
+          it "raises an error" do
+            expect {
+              movie.ratings.create!(value: 1000)
+            }.to raise_error(Mongoid::Errors::Validations)
+          end
+        end
+      end
+    end
+  end
+
+  describe ".criteria" do
+
+    let(:id) do
+      BSON::ObjectId.new
+    end
+
+    context "when the relation is polymorphic" do
+
+      let(:metadata) do
+        Movie.relations["ratings"]
+      end
+
+      let(:criteria) do
+        described_class.criteria(metadata, id, Movie)
+      end
+
+      it "includes the type in the criteria" do
+        expect(criteria.selector).to eq(
+          {
+            "ratable_id"    => id,
+            "ratable_type"  => "Movie"
+          }
+        )
+      end
+    end
+
+    context "when the relation is not polymorphic" do
+
+      let(:metadata) do
+        Person.relations["posts"]
+      end
+
+      let(:criteria) do
+        described_class.criteria(metadata, id, Person)
+      end
+
+      it "does not include the type in the criteria" do
+        expect(criteria.selector).to eq({ "person_id" => id })
+      end
+    end
+  end
+
+  describe "#delete" do
+
+    let!(:person) do
+      Person.create(username: 'arthurnn')
+    end
+
+    context "when the document is found" do
+
+      context "when no dependent option is set" do
+
+        context "when we are assigning attributes" do
+
+          let!(:drug) do
+            person.drugs.create
+          end
+
+          before do
+            Mongoid::Threaded.begin_execution(:assign)
+          end
+
+          after do
+            Mongoid::Threaded.exit_execution(:assign)
+          end
+
+          let(:deleted) do
+            person.drugs.delete(drug)
+          end
+
+          it "does not cascade" do
+            expect(deleted.changes.keys).to eq([ "person_id" ])
+          end
+        end
+
+        context "when the document is loaded" do
+
+          let!(:drug) do
+            person.drugs.create
+          end
+
+          let!(:deleted) do
+            person.drugs.delete(drug)
+          end
+
+          it "returns the document" do
+            expect(deleted).to eq(drug)
+          end
+
+          it "deletes the foreign key" do
+            expect(drug.person_id).to be_nil
+          end
+
+          it "removes the document from the relation" do
+            expect(person.drugs).to_not include(drug)
+          end
+        end
+
+        context "when the document is not loaded" do
+
+          let!(:drug) do
+            Drug.create(person_id: person.username)
+          end
+
+          let!(:deleted) do
+            person.drugs.delete(drug)
+          end
+
+          it "returns the document" do
+            expect(deleted).to eq(drug)
+          end
+
+          it "deletes the foreign key" do
+            expect(drug.person_id).to be_nil
+          end
+
+          it "removes the document from the relation" do
+            expect(person.drugs).to_not include(drug)
+          end
+        end
+      end
+
+      context "when dependent is delete" do
+
+        context "when the document is loaded" do
+
+          let!(:post) do
+            person.posts.create(title: "test")
+          end
+
+          let!(:deleted) do
+            person.posts.delete(post)
+          end
+
+          it "returns the document" do
+            expect(deleted).to eq(post)
+          end
+
+          it "deletes the document" do
+            expect(post).to be_destroyed
+          end
+
+          it "removes the document from the relation" do
+            expect(person.posts).to_not include(post)
+          end
+        end
+
+        context "when the document is not loaded" do
+
+          let!(:post) do
+            Post.create(title: "foo", person_id: person.id)
+          end
+
+          let!(:deleted) do
+            person.posts.delete(post)
+          end
+
+          it "returns the document" do
+            expect(deleted).to eq(post)
+          end
+
+          it "deletes the document" do
+            expect(post).to be_destroyed
+          end
+
+          it "removes the document from the relation" do
+            expect(person.posts).to_not include(post)
+          end
+        end
+      end
+    end
+
+    context "when the document is not found" do
+
+      let!(:post) do
+        Post.create(title: "foo")
+      end
+
+      let!(:deleted) do
+        person.posts.delete(post)
+      end
+
+      it "returns nil" do
+        expect(deleted).to be_nil
+      end
+
+      it "does not delete the document" do
+        expect(post).to be_persisted
+      end
+    end
+  end
+
+  [ :delete_all, :destroy_all ].each do |method|
+
+    describe "##{method}" do
+
+      context "when the relation is not polymorphic" do
+
+        context "when conditions are provided" do
+
+          let(:person) do
+            Person.create(username: 'durran')
+          end
+
+          before do
+            person.posts.create(title: "Testing")
+            person.posts.create(title: "Test")
+          end
+
+          it "removes the correct posts" do
+            person.posts.send(method, { title: "Testing" })
+            expect(person.posts.count).to eq(1)
+            expect(person.reload.posts_count).to eq(1) if method == :destroy_all
+          end
+
+          it "deletes the documents from the database" do
+            person.posts.send(method, { title: "Testing" })
+            expect(Post.where(title: "Testing").count).to eq(0)
+          end
+
+          it "returns the number of documents deleted" do
+            expect(person.posts.send(method, { title: "Testing" })).to eq(1)
+          end
+        end
+
+        context "when conditions are not provided" do
+
+          let(:person) do
+            Person.create
+          end
+
+          before do
+            person.posts.create(title: "Testing")
+            person.posts.create(title: "Test")
+          end
+
+          it "removes the correct posts" do
+            person.posts.send(method)
+            expect(person.posts.count).to eq(0)
+          end
+
+          it "deletes the documents from the database" do
+            person.posts.send(method)
+            expect(Post.where(title: "Testing").count).to eq(0)
+          end
+
+          it "returns the number of documents deleted" do
+            expect(person.posts.send(method)).to eq(2)
+          end
+        end
+      end
+
+      context "when the relation is polymorphic" do
+
+        context "when conditions are provided" do
+
+          let(:movie) do
+            Movie.create(title: "Bladerunner")
+          end
+
+          before do
+            movie.ratings.create(value: 1)
+            movie.ratings.create(value: 2)
+          end
+
+          it "removes the correct ratings" do
+            movie.ratings.send(method, { value: 1 })
+            expect(movie.ratings.count).to eq(1)
+          end
+
+          it "deletes the documents from the database" do
+            movie.ratings.send(method, { value: 1 })
+            expect(Rating.where(value: 1).count).to eq(0)
+          end
+
+          it "returns the number of documents deleted" do
+            expect(movie.ratings.send(method, { value: 1 })).to eq(1)
+          end
+        end
+
+        context "when conditions are not provided" do
+
+          let(:movie) do
+            Movie.create(title: "Bladerunner")
+          end
+
+          before do
+            movie.ratings.create(value: 1)
+            movie.ratings.create(value: 2)
+          end
+
+          it "removes the correct ratings" do
+            movie.ratings.send(method)
+            expect(movie.ratings.count).to eq(0)
+          end
+
+          it "deletes the documents from the database" do
+            movie.ratings.send(method)
+            expect(Rating.where(value: 1).count).to eq(0)
+          end
+
+          it "returns the number of documents deleted" do
+            expect(movie.ratings.send(method)).to eq(2)
+          end
+        end
+      end
+    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
+
+      context "when the eager load has returned documents" do
+
+        let!(:person) do
+          Person.create
+        end
+
+        let!(:post) do
+          person.posts.create(title: "testing")
+        end
+
+        let(:metadata) do
+          Person.relations["posts"]
+        end
+
+        let!(:eager) do
+          described_class.eager_load(metadata, Person.all.map(&:_id))
+        end
+
+        let(:map) do
+          Mongoid::IdentityMap.get(Post, {"person_id" => person.id})
+        end
+
+        it "puts the documents in the identity map" do
+          expect(map).to eq({ post.id => post })
+        end
+      end
+
+      context "when the eager load has not returned documents" do
+
+        let!(:person) do
+          Person.create
+        end
+
+        let(:metadata) do
+          Person.relations["posts"]
+        end
+
+        let!(:eager) do
+          described_class.eager_load(metadata, Person.all.map(&:_id))
+        end
+
+        let(:map) do
+          Mongoid::IdentityMap.get(Post, {"person_id" => person.id})
+        end
+
+        it "puts an empty array in the identity map" do
+          expect(map).to be_empty
+        end
+      end
+
+      context "when the eager load has not returned documents for some" do
+
+        let!(:person_one) do
+          Person.create
+        end
+
+        let!(:person_two) do
+          Person.create
+        end
+
+        let!(:post) do
+          person_one.posts.create(title: "testing")
+        end
+
+        let(:metadata) do
+          Person.relations["posts"]
+        end
+
+        let!(:eager) do
+          described_class.eager_load(metadata, Person.all.map(&:_id))
+        end
+
+        let(:map_one) do
+          Mongoid::IdentityMap.get(Post, {"person_id" => person_one.id})
+        end
+
+        let(:map_two) do
+          Mongoid::IdentityMap.get(Post, {"person_id" => person_two.id})
+        end
+
+        it "puts the found documents in the identity map" do
+          expect(map_one).to eq({ post.id => post })
+        end
+
+        it "puts an empty array for parents with no docs" do
+          expect(map_two).to be_empty
+        end
+      end
+    end
+
+    context "when the relation is polymorphic" do
+
+      let!(:movie) do
+        Movie.create(name: "Bladerunner")
+      end
+
+      let!(:book) do
+        Book.create(name: "Game of Thrones")
+      end
+
+      let!(:movie_rating) do
+        movie.ratings.create(value: 10)
+      end
+
+      let!(:book_rating) do
+        book.create_rating(value: 10)
+      end
+
+      let(:metadata) do
+        Movie.relations["ratings"]
+      end
+
+      let!(:eager) do
+        described_class.eager_load(metadata, Movie.all.map(&:_id))
+      end
+
+      let(:map) do
+        Mongoid::IdentityMap.get(Rating, {"ratable_id" => movie.id})
+      end
+
+      it "puts the documents in the identity map" do
+        expect(map).to eq({ movie_rating.id => movie_rating })
+      end
+    end
+  end
+
+  describe ".embedded?" do
+
+    it "returns false" do
+      expect(described_class).to_not be_embedded
+    end
+  end
+
+  describe "#exists?" do
+
+    let!(:person) do
+      Person.create
+    end
+
+    context "when documents exist in the database" do
+
+      before do
+        person.posts.create
+      end
+
+      it "returns true" do
+        expect(person.posts.exists?).to be_true
+      end
+    end
+
+    context "when no documents exist in the database" do
+
+      before do
+        person.posts.build
+      end
+
+      it "returns false" do
+        expect(person.posts.exists?).to be_false
+      end
+    end
+  end
+
+  describe "#find" 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
+
+      context "when the document is in the map" do
+
+        let(:person) do
+          Person.create
+        end
+
+        before do
+          person.posts.create(title: "Test")
+        end
+
+        context "when the document does not belong to the relation" do
+
+          let!(:post) do
+            Post.create(title: "testing")
+          end
+
+          it "raises an error" do
+            expect {
+              person.posts.find(post.id)
+            }.to raise_error(Mongoid::Errors::DocumentNotFound)
+          end
+        end
+      end
+    end
+
+    context "when the relation is not polymorphic" do
+
+      let(:person) do
+        Person.create
+      end
+
+      let!(:post_one) do
+        person.posts.create(title: "Test")
+      end
+
+      let!(:post_two) do
+        person.posts.create(title: "OMG I has relations")
+      end
+
+      context "when providing an id" do
+
+        context "when the id matches" do
+
+          let(:post) do
+            person.posts.find(post_one.id)
+          end
+
+          it "returns the matching document" do
+            expect(post).to eq(post_one)
+          end
+        end
+
+        context "when the id matches but is not scoped to the relation" do
+
+          let(:post) do
+            Post.create(title: "Unscoped")
+          end
+
+          it "raises an error" do
+            expect {
+              person.posts.find(post.id)
+            }.to raise_error(Mongoid::Errors::DocumentNotFound)
+          end
+        end
+
+        context "when the id does not match" do
+
+          context "when config set to raise error" do
+
+            before do
+              Mongoid.raise_not_found_error = true
+            end
+
+            it "raises an error" do
+              expect {
+                person.posts.find(BSON::ObjectId.new)
+              }.to raise_error(Mongoid::Errors::DocumentNotFound)
+            end
+          end
+
+          context "when config set not to raise error" do
+
+            let(:post) do
+              person.posts.find(BSON::ObjectId.new)
+            end
+
+            before do
+              Mongoid.raise_not_found_error = false
+            end
+
+            after do
+              Mongoid.raise_not_found_error = true
+            end
+
+            it "returns nil" do
+              expect(post).to be_nil
+            end
+          end
+        end
+      end
+
+      context "when providing an array of ids" do
+
+        context "when the ids match" do
+
+          let(:posts) do
+            person.posts.find([ post_one.id, post_two.id ])
+          end
+
+          it "returns the matching documents" do
+            expect(posts).to eq([ post_one, post_two ])
+          end
+        end
+
+        context "when the ids do not match" do
+
+          context "when config set to raise error" do
+
+            before do
+              Mongoid.raise_not_found_error = true
+            end
+
+            it "raises an error" do
+              expect {
+                person.posts.find([ BSON::ObjectId.new ])
+              }.to raise_error(Mongoid::Errors::DocumentNotFound)
+            end
+          end
+
+          context "when config set not to raise error" do
+
+            let(:posts) do
+              person.posts.find([ BSON::ObjectId.new ])
+            end
+
+            before do
+              Mongoid.raise_not_found_error = false
+            end
+
+            after do
+              Mongoid.raise_not_found_error = true
+            end
+
+            it "returns an empty array" do
+              expect(posts).to be_empty
+            end
+          end
+        end
+      end
+    end
+
+    context "when the relation is polymorphic" do
+
+      let(:movie) do
+        Movie.create
+      end
+
+      let!(:rating_one) do
+        movie.ratings.create(value: 1)
+      end
+
+      let!(:rating_two) do
+        movie.ratings.create(value: 5)
+      end
+
+      context "when providing an id" do
+
+        context "when the id matches" do
+
+          let(:rating) do
+            movie.ratings.find(rating_one.id)
+          end
+
+          it "returns the matching document" do
+            expect(rating).to eq(rating_one)
+          end
+        end
+
+        context "when the id does not match" do
+
+          context "when config set to raise error" do
+
+            before do
+              Mongoid.raise_not_found_error = true
+            end
+
+            it "raises an error" do
+              expect {
+                movie.ratings.find(BSON::ObjectId.new)
+              }.to raise_error(Mongoid::Errors::DocumentNotFound)
+            end
+          end
+
+          context "when config set not to raise error" do
+
+            let(:rating) do
+              movie.ratings.find(BSON::ObjectId.new)
+            end
+
+            before do
+              Mongoid.raise_not_found_error = false
+            end
+
+            after do
+              Mongoid.raise_not_found_error = true
+            end
+
+            it "returns nil" do
+              expect(rating).to be_nil
+            end
+          end
+        end
+      end
+
+      context "when providing an array of ids" do
+
+        context "when the ids match" do
+
+          let(:ratings) do
+            movie.ratings.find([ rating_one.id, rating_two.id ])
+          end
+
+          it "returns the matching documents" do
+            expect(ratings).to eq([ rating_one, rating_two ])
+          end
+        end
+
+        context "when the ids do not match" do
+
+          context "when config set to raise error" do
+
+            before do
+              Mongoid.raise_not_found_error = true
+            end
+
+            it "raises an error" do
+              expect {
+                movie.ratings.find([ BSON::ObjectId.new ])
+              }.to raise_error(Mongoid::Errors::DocumentNotFound)
+            end
+          end
+
+          context "when config set not to raise error" do
+
+            let(:ratings) do
+              movie.ratings.find([ BSON::ObjectId.new ])
+            end
+
+            before do
+              Mongoid.raise_not_found_error = false
+            end
+
+            after do
+              Mongoid.raise_not_found_error = true
+            end
+
+            it "returns an empty array" do
+              expect(ratings).to be_empty
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "#find_or_create_by" do
+
+    context "when the relation is not polymorphic" do
+
+      let(:person) do
+        Person.create
+      end
+
+      let!(:post) do
+        person.posts.create(title: "Testing")
+      end
+
+      context "when the document exists" do
+
+        let(:found) do
+          person.posts.find_or_create_by(title: "Testing")
+        end
+
+        it "returns the document" do
+          expect(found).to eq(post)
+        end
+
+        it "keeps the document in the relation" do
+          expect(found.person).to eq(person)
+        end
+      end
+
+      context "when the document does not exist" do
+
+        context "when there is no criteria attached" do
+
+          let(:found) do
+            person.posts.find_or_create_by(title: "Test") do |post|
+              post.content = "The Content"
+            end
+          end
+
+          it "sets the new document attributes" do
+            expect(found.title).to eq("Test")
+          end
+
+          it "returns a newly persisted document" do
+            expect(found).to be_persisted
+          end
+
+          it "calls the passed block" do
+            expect(found.content).to eq("The Content")
+          end
+
+          it "keeps the document in the relation" do
+            expect(found.person).to eq(person)
+          end
+        end
+
+        context "when a criteria is attached" do
+
+          let(:found) do
+            person.posts.recent.find_or_create_by(title: "Test")
+          end
+
+          it "sets the new document attributes" do
+            expect(found.title).to eq("Test")
+          end
+
+          it "returns a newly persisted document" do
+            expect(found).to be_persisted
+          end
+
+          it "keeps the document in the relation" do
+            expect(found.person).to eq(person)
+          end
+        end
+      end
+    end
+
+    context "when the relation is polymorphic" do
+
+      let(:movie) do
+        Movie.create
+      end
+
+      let!(:rating) do
+        movie.ratings.create(value: 1)
+      end
+
+      context "when the document exists" do
+
+        let(:found) do
+          movie.ratings.find_or_create_by(value: 1)
+        end
+
+        it "returns the document" do
+          expect(found).to eq(rating)
+        end
+
+        it "keeps the document in the relation" do
+          expect(found.ratable).to eq(movie)
+        end
+      end
+
+      context "when the document does not exist" do
+
+        let(:found) do
+          movie.ratings.find_or_create_by(value: 3)
+        end
+
+        it "sets the new document attributes" do
+          expect(found.value).to eq(3)
+        end
+
+        it "returns a newly persisted document" do
+          expect(found).to be_persisted
+        end
+
+        it "keeps the document in the relation" do
+          expect(found.ratable).to eq(movie)
+        end
+      end
+    end
+  end
+
+  describe "#find_or_initialize_by" do
+
+    context "when the relation is not polymorphic" do
+
+      let(:person) do
+        Person.create
+      end
+
+      let!(:post) do
+        person.posts.create(title: "Testing")
+      end
+
+      context "when the document exists" do
+
+        let(:found) do
+          person.posts.find_or_initialize_by(title: "Testing")
+        end
+
+        it "returns the document" do
+          expect(found).to eq(post)
+        end
+      end
+
+      context "when the document does not exist" do
+
+        let(:found) do
+          person.posts.find_or_initialize_by(title: "Test") do |post|
+            post.content = "The Content"
+          end
+        end
+
+        it "sets the new document attributes" do
+          expect(found.title).to eq("Test")
+        end
+
+        it "returns a non persisted document" do
+          expect(found).to_not be_persisted
+        end
+
+        it "calls the passed block" do
+          expect(found.content).to eq("The Content")
+        end
+      end
+    end
+
+    context "when the relation is polymorphic" do
+
+      let(:movie) do
+        Movie.create
+      end
+
+      let!(:rating) do
+        movie.ratings.create(value: 1)
+      end
+
+      context "when the document exists" do
+
+        let(:found) do
+          movie.ratings.find_or_initialize_by(value: 1)
+        end
+
+        it "returns the document" do
+          expect(found).to eq(rating)
+        end
+      end
+
+      context "when the document does not exist" do
+
+        let(:found) do
+          movie.ratings.find_or_initialize_by(value: 3)
+        end
+
+        it "sets the new document attributes" do
+          expect(found.value).to eq(3)
+        end
+
+        it "returns a non persisted document" do
+          expect(found).to_not be_persisted
+        end
+      end
+    end
+  end
+
+  describe ".foreign_key_suffix" do
+
+    it "returns _id" do
+      expect(described_class.foreign_key_suffix).to eq("_id")
+    end
+  end
+
+  describe "#initialize" do
+
+    context "when an illegal mixed relation exists" do
+
+      let(:post) do
+        Post.new
+      end
+
+      it "raises an error" do
+        expect {
+          post.videos
+        }.to raise_error(Mongoid::Errors::MixedRelations)
+      end
+    end
+
+    context "when a cyclic relation exists" do
+
+      let(:post) do
+        Post.new
+      end
+
+      it "does not raise an error" do
+        expect(post.roles).to be_empty
+      end
+    end
+  end
+
+  describe ".macro" do
+
+    it "returns has_many" do
+      expect(described_class.macro).to eq(:has_many)
+    end
+  end
+
+  describe "#max" do
+
+    let(:person) do
+      Person.create
+    end
+
+    let(:post_one) do
+      Post.create(rating: 5)
+    end
+
+    let(:post_two) do
+      Post.create(rating: 10)
+    end
+
+    before do
+      person.posts.push(post_one, post_two)
+    end
+
+    let(:max) do
+      person.posts.max do |a,b|
+        a.rating <=> b.rating
+      end
+    end
+
+    it "returns the document with the max value of the supplied field" do
+      expect(max).to eq(post_two)
+    end
+  end
+
+  describe "#max_by" do
+
+    let(:person) do
+      Person.create
+    end
+
+    let(:post_one) do
+      Post.create(rating: 5)
+    end
+
+    let(:post_two) do
+      Post.create(rating: 10)
+    end
+
+    before do
+      person.posts.push(post_one, post_two)
+    end
+
+    let(:max) do
+      person.posts.max_by(&:rating)
+    end
+
+    it "returns the document with the max value of the supplied field" do
+      expect(max).to eq(post_two)
+    end
+  end
+
+  describe "#method_missing" do
+
+    let!(:person) do
+      Person.create
+    end
+
+    let!(:post_one) do
+      person.posts.create(title: "First", content: "Posting")
+    end
+
+    let!(:post_two) do
+      person.posts.create(title: "Second", content: "Testing")
+    end
+
+    context "when providing a single criteria" do
+
+      let(:posts) do
+        person.posts.where(title: "First")
+      end
+
+      it "applies the criteria to the documents" do
+        expect(posts).to eq([ post_one ])
+      end
+    end
+
+    context "when providing a criteria class method" do
+
+      let(:posts) do
+        person.posts.posting
+      end
+
+      it "applies the criteria to the documents" do
+        expect(posts).to eq([ post_one ])
+      end
+    end
+
+    context "when chaining criteria" do
+
+      let(:posts) do
+        person.posts.posting.where(:title.in => [ "First" ])
+      end
+
+      it "applies the criteria to the documents" do
+        expect(posts).to eq([ post_one ])
+      end
+    end
+
+    context "when delegating methods" do
+
+      describe "#distinct" do
+
+        let(:values) do
+          person.posts.distinct(:title)
+        end
+
+        it "returns the distinct values for the fields" do
+          expect(values).to include("First")
+          expect(values).to include("Second")
+        end
+      end
+    end
+  end
+
+  describe "#min" do
+
+    let(:person) do
+      Person.create
+    end
+
+    let(:post_one) do
+      Post.create(rating: 5)
+    end
+
+    let(:post_two) do
+      Post.create(rating: 10)
+    end
+
+    before do
+      person.posts.push(post_one, post_two)
+    end
+
+    let(:min) do
+      person.posts.min do |a, b|
+        a.rating <=> b.rating
+      end
+    end
+
+    it "returns the min value of the supplied field" do
+      expect(min).to eq(post_one)
+    end
+  end
+
+  describe "#min_by" do
+
+    let(:person) do
+      Person.create
+    end
+
+    let(:post_one) do
+      Post.create(rating: 5)
+    end
+
+    let(:post_two) do
+      Post.create(rating: 10)
+    end
+
+    before do
+      person.posts.push(post_one, post_two)
+    end
+
+    let(:min) do
+      person.posts.min_by(&:rating)
+    end
+
+    it "returns the min value of the supplied field" do
+      expect(min).to eq(post_one)
+    end
+  end
+
+  describe "#nullify_all" do
+
+    context "when the inverse has not been loaded" do
+
+      let(:person) do
+        Person.create
+      end
+
+      let!(:post_one) do
+        person.posts.create(title: "One")
+      end
+
+      let!(:post_two) do
+        person.posts.create(title: "Two")
+      end
+
+      let(:from_db) do
+        Person.first
+      end
+
+      before do
+        from_db.posts.nullify_all
+      end
+
+      it "loads the targets before nullifying" do
+        expect(from_db.posts).to be_empty
+      end
+
+      it "persists the base nullifications" do
+        expect(Person.first.posts).to be_empty
+      end
+
+      it "persists the inverse nullifications" do
+        Post.all.each do |post|
+          expect(post.person).to be_nil
+        end
+      end
+    end
+
+    context "when the relation is not polymorphic" do
+
+      let(:person) do
+        Person.create
+      end
+
+      let!(:post_one) do
+        person.posts.create(title: "One")
+      end
+
+      let!(:post_two) do
+        person.posts.create(title: "Two")
+      end
+
+      before do
+        person.posts.nullify_all
+      end
+
+      it "removes all the foreign keys from the target" do
+        [ post_one, post_two ].each do |post|
+          expect(post.person_id).to be_nil
+        end
+      end
+
+      it "removes all the references from the target" do
+        [ post_one, post_two ].each do |post|
+          expect(post.person).to be_nil
+        end
+      end
+
+      it "saves the documents" do
+        expect(post_one.reload.person).to be_nil
+      end
+
+      context "when adding a nullified document back to the relation" do
+
+        before do
+          person.posts.push(post_one)
+        end
+
+        it "persists the relation" do
+          expect(person.posts(true)).to eq([ post_one ])
+        end
+      end
+    end
+
+    context "when the relation is polymorphic" do
+
+      let(:movie) do
+        Movie.create(title: "Oldboy")
+      end
+
+      let!(:rating_one) do
+        movie.ratings.create(value: 10)
+      end
+
+      let!(:rating_two) do
+        movie.ratings.create(value: 9)
+      end
+
+      before do
+        movie.ratings.nullify_all
+      end
+
+      it "removes all the foreign keys from the target" do
+        [ rating_one, rating_two ].each do |rating|
+          expect(rating.ratable_id).to be_nil
+        end
+      end
+
+      it "removes all the references from the target" do
+        [ rating_one, rating_two ].each do |rating|
+          expect(rating.ratable).to be_nil
+        end
+      end
+    end
+  end
+
+  describe "#respond_to?" do
+
+    let(:person) do
+      Person.new
+    end
+
+    let(:posts) do
+      person.posts
+    end
+
+    Array.public_instance_methods.each do |method|
+
+      context "when checking #{method}" do
+
+        it "returns true" do
+          expect(posts.respond_to?(method)).to be_true
+        end
+      end
+    end
+
+    Mongoid::Relations::Referenced::Many.public_instance_methods.each do |method|
+
+      context "when checking #{method}" do
+
+        it "returns true" do
+          expect(posts.respond_to?(method)).to be_true
+        end
+      end
+    end
+
+    Post.scopes.keys.each do |method|
+
+      context "when checking #{method}" do
+
+        it "returns true" do
+          expect(posts.respond_to?(method)).to be_true
+        end
+      end
+    end
+  end
+
+  describe ".stores_foreign_key?" do
+
+    it "returns false" do
+      expect(described_class.stores_foreign_key?).to be_false
+    end
+  end
+
+  describe "#scoped" do
+
+    let(:person) do
+      Person.new
+    end
+
+    let(:scoped) do
+      person.posts.scoped
+    end
+
+    it "returns the relation criteria" do
+      expect(scoped).to be_a(Mongoid::Criteria)
+    end
+
+    it "returns with an empty selector" do
+      expect(scoped.selector).to eq({ "person_id" => person.id })
+    end
+  end
+
+  [ :size, :length ].each do |method|
+
+    describe "##{method}" do
+
+      let(:movie) do
+        Movie.create
+      end
+
+      context "when documents have been persisted" do
+
+        let!(:rating) do
+          movie.ratings.create(value: 1)
+        end
+
+        it "returns 1" do
+          expect(movie.ratings.send(method)).to eq(1)
+        end
+      end
+
+      context "when documents have not been persisted" do
+
+        before do
+          movie.ratings.build(value: 1)
+          movie.ratings.create(value: 2)
+        end
+
+        it "returns the total number of documents" do
+          expect(movie.ratings.send(method)).to eq(2)
+        end
+      end
+    end
+  end
+
+  describe "#unscoped" do
+
+    context "when the relation has no default scope" do
+
+      let!(:person) do
+        Person.create
+      end
+
+      let!(:post_one) do
+        person.posts.create(title: "first")
+      end
+
+      let!(:post_two) do
+        Post.create(title: "second")
+      end
+
+      let(:unscoped) do
+        person.posts.unscoped
+      end
+
+      it "returns only the associated documents" do
+        expect(unscoped).to eq([ post_one ])
+      end
+    end
+
+    context "when the relation has a default scope" do
+
+      let!(:church) do
+        Church.create
+      end
+
+      let!(:acolyte_one) do
+        church.acolytes.create(name: "first")
+      end
+
+      let!(:acolyte_two) do
+        Acolyte.create(name: "second")
+      end
+
+      let(:unscoped) do
+        church.acolytes.unscoped
+      end
+
+      it "only returns associated documents" do
+        expect(unscoped).to eq([ acolyte_one ])
+      end
+
+      it "removes the default scoping options" do
+        expect(unscoped.options).to eq({})
+      end
+    end
+  end
+
+  describe ".valid_options" do
+
+    it "returns the valid options" do
+      expect(described_class.valid_options).to eq(
+        [
+          :after_add,
+          :after_remove,
+          :as,
+          :autosave,
+          :before_add,
+          :before_remove,
+          :dependent,
+          :foreign_key,
+          :order,
+          :primary_key
+        ]
+      )
+    end
+  end
+
+  describe ".validation_default" do
+
+    it "returns true" do
+      expect(described_class.validation_default).to be_true
+    end
+  end
+
+  context "when the association has an order defined" do
+
+    let(:person) do
+      Person.create
+    end
+
+    let(:post_one) do
+      OrderedPost.create(rating: 10, title: '1')
+    end
+
+    let(:post_two) do
+      OrderedPost.create(rating: 20, title: '2')
+    end
+
+    let(:post_three) do
+      OrderedPost.create(rating: 20, title: '3')
+    end
+
+    before do
+      person.ordered_posts.nullify_all
+      person.ordered_posts.push(post_one, post_two, post_three)
+    end
+
+    it "order documents" do
+      expect(person.ordered_posts(true)).to eq(
+        [post_two, post_three, post_one]
+      )
+    end
+
+    it "chaining order criterias" do
+      expect(person.ordered_posts.order_by(:title.desc).to_a).to eq(
+        [post_three, post_two, post_one]
+      )
+    end
+  end
+
+  context "when reloading the relation" do
+
+    let!(:person) do
+      Person.create
+    end
+
+    let!(:post_one) do
+      Post.create(title: "one")
+    end
+
+    let!(:post_two) do
+      Post.create(title: "two")
+    end
+
+    before do
+      person.posts << post_one
+    end
+
+    context "when the relation references the same documents" do
+
+      before do
+        Post.collection.find({ _id: post_one.id }).
+          update({ "$set" => { title: "reloaded" }})
+      end
+
+      let(:reloaded) do
+        person.posts(true)
+      end
+
+      it "reloads the document from the database" do
+        expect(reloaded.first.title).to eq("reloaded")
+      end
+    end
+
+    context "when the relation references different documents" do
+
+      before do
+        person.posts << post_two
+      end
+
+      let(:reloaded) do
+        person.posts(true)
+      end
+
+      it "reloads the first document from the database" do
+        expect(reloaded).to include(post_one)
+      end
+
+      it "reloads the new document from the database" do
+        expect(reloaded).to include(post_two)
+      end
+    end
+  end
+
+  context "when the parent is using integer ids" do
+
+    let(:jar) do
+      Jar.create do |doc|
+        doc._id = 1
+      end
+    end
+
+    it "allows creation of the document" do
+      expect(jar.id).to eq(1)
+    end
+  end
+
+  context "when adding a document" do
+
+    let(:person) do
+      Person.new
+    end
+
+    let(:post_one) do
+      Post.new
+    end
+
+    let(:first_add) do
+      person.posts.push(post_one)
+    end
+
+    context "when chaining a second add" do
+
+      let(:post_two) do
+        Post.new
+      end
+
+      let(:result) do
+        first_add.push(post_two)
+      end
+
+      it "adds both documents" do
+        expect(result).to eq([ post_one, post_two ])
+      end
+    end
+  end
+
+  context "when pushing with a before_add callback" do
+
+    let(:artist) do
+      Artist.new
+    end
+
+    let(:album) do
+      Album.new
+    end
+
+    context "when execution raises no errors" do
+
+      before do
+        artist.albums << album
+      end
+
+      it "it executes method callbacks" do
+        expect(artist.before_add_referenced_called).to be_true
+      end
+
+      it "it executes proc callbacks" do
+        expect(album.before_add_called).to be_true
+      end
+
+      it "adds the document to the relation" do
+        expect(artist.albums).to eq([ album ])
+      end
+    end
+
+    context "when execution raises errors" do
+
+      before do
+        artist.should_receive(:before_add_album).and_raise
+      end
+
+      it "does not add the document to the relation" do
+        expect {
+          artist.albums << album
+        }.to raise_error
+        expect(artist.albums).to be_empty
+      end
+    end
+  end
+
+  context "when pushing with an after_add callback" do
+
+    let(:artist) do
+      Artist.new
+    end
+
+    let(:album) do
+      Album.new
+    end
+
+    it "executes the callback" do
+      artist.albums << album
+      expect(artist.after_add_referenced_called).to be_true
+    end
+
+    context "when execution raises errors" do
+
+      before do
+        artist.should_receive(:after_add_album).and_raise
+      end
+
+      it "adds the document to the relation" do
+        expect {
+          artist.albums << album
+        }.to raise_error
+        expect(artist.albums).to eq([ album ])
+      end
+    end
+  end
+
+  context "when #delete or #clear with before_remove callback" do
+
+    let(:artist) do
+      Artist.new
+    end
+
+    let(:album) do
+      Album.new
+    end
+
+    before do
+      artist.albums << album
+    end
+
+    context "when executing raises no errors" do
+
+      describe "#delete" do
+
+        before do
+          artist.albums.delete album
+        end
+
+        it "executes the callback" do
+          expect(artist.before_remove_referenced_called).to be_true
+        end
+
+        it "removes the document from the relation" do
+          expect(artist.albums).to be_empty
+        end
+      end
+
+      describe "#clear" do
+
+        before do
+          artist.albums.clear
+        end
+
+        it "executes the callback" do
+          expect(artist.before_remove_referenced_called).to be_true
+        end
+
+        it "clears the relation" do
+          expect(artist.albums).to be_empty
+        end
+      end
+
+      context "when execution raises errors" do
+
+        before do
+          artist.should_receive(:before_remove_album).and_raise
+        end
+
+        describe "#delete" do
+
+          before do
+            expect {
+              artist.albums.delete album
+            }.to raise_error
+          end
+
+          it "does not remove the document from the relation" do
+            expect(artist.albums).to eq([ album ])
+          end
+        end
+
+        describe "#clear" do
+
+          before do
+            expect {
+              artist.albums.clear
+            }.to raise_error
+          end
+
+          it "does not clear the relation" do
+            expect(artist.albums).to eq([ album ])
+          end
+        end
+      end
+    end
+  end
+
+  context "when #delete or #clear with after_remove callback" do
+
+    let(:artist) do
+      Artist.new
+    end
+
+    let(:album) do
+      Album.new
+    end
+
+    before do
+      artist.albums << album
+    end
+
+    context "without errors" do
+
+      describe "#delete" do
+
+        before do
+          artist.albums.delete album
+        end
+
+        it "executes the callback" do
+          expect(artist.after_remove_referenced_called).to be_true
+        end
+      end
+
+      describe "#clear" do
+
+        before do
+          artist.albums.clear
+        end
+
+        it "executes the callback" do
+          artist.albums.clear
+          expect(artist.after_remove_referenced_called).to be_true
+        end
+      end
+    end
+
+    context "when errors are raised" do
+
+      before do
+        artist.should_receive(:after_remove_album).and_raise
+      end
+
+      describe "#delete" do
+
+        before do
+          expect {
+            artist.albums.delete album
+          }.to raise_error
+        end
+
+        it "removes the documents from the relation" do
+          expect(artist.albums).to be_empty
+        end
+      end
+
+      describe "#clear" do
+
+        before do
+          expect {
+            artist.albums.clear
+          }.to raise_error
+        end
+
+        it "removes the documents from the relation" do
+          expect(artist.albums).to be_empty
+        end
+      end
+    end
+  end
+
+  context "when executing a criteria call on an ordered relation" do
+
+    let(:person) do
+      Person.create
+    end
+
+    let!(:post_one) do
+      person.ordered_posts.create(rating: 1)
+    end
+
+    let!(:post_two) do
+      person.ordered_posts.create(rating: 5)
+    end
+
+    let(:criteria) do
+      person.ordered_posts.only(:_id, :rating)
+    end
+
+    it "does not drop the ordering" do
+      expect(criteria).to eq([ post_two, post_one ])
+    end
+  end
+end