mongoid 3.1.5 → 8.0.2

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

@@ -1,3841 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Relations::Embedded::Many do
-
-  [ :<<, :push ].each do |method|
-
-    describe "##{method}" do
-
-      context "when the parent is a new record" do
-
-        let(:person) do
-          Person.new
-        end
-
-        let(:address) do
-          Address.new
-        end
-
-        let!(:added) do
-          person.addresses.send(method, address)
-        end
-
-        it "appends to the target" do
-          person.addresses.should eq([ address ])
-        end
-
-        it "sets the base on the inverse relation" do
-          address.addressable.should eq(person)
-        end
-
-        it "sets the same instance on the inverse relation" do
-          address.addressable.should eql(person)
-        end
-
-        it "does not save the new document" do
-          address.should_not be_persisted
-        end
-
-        it "sets the parent on the child" do
-          address._parent.should eq(person)
-        end
-
-        it "sets the metadata on the child" do
-          address.metadata.should_not be_nil
-        end
-
-        it "sets the index on the child" do
-          address._index.should eq(0)
-        end
-
-        it "returns the relation" do
-          added.should eq(person.addresses)
-        end
-
-        context "with a limiting default scope" do
-
-          context "when the document matches the scope" do
-
-            let(:active) do
-              Appointment.new
-            end
-
-            before do
-              person.appointments.send(method, active)
-            end
-
-            it "appends to the target" do
-              person.appointments.target.should eq([ active ])
-            end
-
-            it "appends to the _unscoped" do
-              person.appointments.send(:_unscoped).should eq([ active ])
-            end
-          end
-
-          context "when the document does not match the scope" do
-
-            let(:inactive) do
-              Appointment.new(active: false)
-            end
-
-            before do
-              person.appointments.send(method, inactive)
-            end
-
-            it "doesn't append to the target" do
-              person.appointments.target.should_not eq([ inactive ])
-            end
-
-            it "appends to the _unscoped" do
-              person.appointments.send(:_unscoped).should eq([ inactive ])
-            end
-          end
-        end
-      end
-
-      context "when the parent is not a new record" do
-
-        let(:person) do
-          Person.create
-        end
-
-        let(:address) do
-          Address.new
-        end
-
-        before do
-          person.addresses.send(method, address)
-        end
-
-        it "saves the new document" do
-          address.should be_persisted
-        end
-      end
-
-      context "when appending more than one document at once" do
-
-        let(:person) do
-          Person.create
-        end
-
-        let(:address_one) do
-          Address.new
-        end
-
-        let(:address_two) do
-          Address.new
-        end
-
-        let!(:added) do
-          person.addresses.send(method, [ address_one, address_two ])
-        end
-
-        it "saves the first document" do
-          address_one.should be_persisted
-        end
-
-        it "saves the second document" do
-          address_two.should be_persisted
-        end
-
-        it "returns the relation" do
-          added.should eq(person.addresses)
-        end
-      end
-
-      context "when the parent and child have a cyclic relation" do
-
-        context "when the parent is a new record" do
-
-          let(:parent_role) do
-            Role.new
-          end
-
-          let(:child_role) do
-            Role.new
-          end
-
-          before do
-            parent_role.child_roles.send(method, child_role)
-          end
-
-          it "appends to the target" do
-            parent_role.child_roles.should eq([ child_role ])
-          end
-
-          it "sets the base on the inverse relation" do
-            child_role.parent_role.should eq(parent_role)
-          end
-
-          it "sets the same instance on the inverse relation" do
-            child_role.parent_role.should eql(parent_role)
-          end
-
-          it "does not save the new document" do
-            child_role.should_not be_persisted
-          end
-
-          it "sets the parent on the child" do
-            child_role._parent.should eq(parent_role)
-          end
-
-          it "sets the metadata on the child" do
-            child_role.metadata.should_not be_nil
-          end
-
-          it "sets the index on the child" do
-            child_role._index.should eq(0)
-          end
-        end
-
-        context "when the parent is not a new record" do
-
-          let(:parent_role) do
-            Role.create(name: "CEO")
-          end
-
-          let(:child_role) do
-            Role.new(name: "COO")
-          end
-
-          before do
-            parent_role.child_roles.send(method, child_role)
-          end
-
-          it "saves the new document" do
-            child_role.should be_persisted
-          end
-        end
-      end
-    end
-  end
-
-  describe "#=" do
-
-    context "when the parent is a new record" do
-
-      let(:person) do
-        Person.new
-      end
-
-      let(:address) do
-        Address.new
-      end
-
-      before do
-        person.addresses = [ address ]
-      end
-
-      it "sets the target of the relation" do
-        person.addresses.should eq([ address ])
-      end
-
-      it "sets the _unscoped of the relation" do
-        person.addresses.send(:_unscoped).should eq([ address ])
-      end
-
-      it "sets the base on the inverse relation" do
-        address.addressable.should eq(person)
-      end
-
-      it "sets the same instance on the inverse relation" do
-        address.addressable.should eql(person)
-      end
-
-      it "does not save the target" do
-        address.should_not be_persisted
-      end
-
-      it "sets the parent on the child" do
-        address._parent.should eq(person)
-      end
-
-      it "sets the metadata on the child" do
-        address.metadata.should_not be_nil
-      end
-
-      it "sets the index on the child" do
-        address._index.should eq(0)
-      end
-    end
-
-    context "when the parent is not a new record" do
-
-      let(:person) do
-        Person.create
-      end
-
-      let(:address) do
-        Address.new
-      end
-
-      context "when setting directly" do
-
-        before do
-          person.addresses = [ address ]
-        end
-
-        it "saves the target" do
-          address.should be_persisted
-        end
-      end
-
-      context "when setting via an overridden method from the parent" do
-
-        let!(:person) do
-          Person.create
-        end
-
-        let!(:address) do
-          person.addresses.create(street: "Alt Treptow")
-        end
-
-        let!(:new_address) do
-          Address.new(street: "Tempelhofer Damm")
-        end
-
-        before do
-          person.update_attributes(set_addresses: [ new_address ])
-        end
-
-        it "overwrites the existing addresses" do
-          person.reload.addresses.should eq([ new_address ])
-        end
-      end
-
-      context "when setting via the parent attributes" do
-
-        before do
-          person.attributes = { addresses: [ address ] }
-        end
-
-        it "sets the relation" do
-          person.addresses.should eq([ address ])
-        end
-
-        it "does not save the target" do
-          address.should_not be_persisted
-        end
-
-        context "when setting the relation multiple times" do
-
-          let(:address_two) do
-            Address.new(street: "kudamm")
-          end
-
-          before do
-            person.addresses = [ address_two ]
-            person.save
-          end
-
-          it "sets the new documents" do
-            person.addresses.should eq([ address_two ])
-          end
-
-          it "persits only the new documents" do
-            person.reload.addresses.should eq([ address_two ])
-          end
-        end
-      end
-    end
-
-    context "when setting for inherited docs" do
-
-      context "when the parent collection is already accessed" do
-
-        before do
-          Person.collection
-        end
-
-        context "when setting via the subclass" do
-
-          let(:doctor) do
-            Doctor.new
-          end
-
-          let(:address_one) do
-            Address.new(street: "tauentzien")
-          end
-
-          before do
-            doctor.addresses = [ address_one ]
-            doctor.save
-          end
-
-          it "sets the documents" do
-            doctor.addresses.should eq([ address_one ])
-          end
-
-          it "persists the document" do
-            doctor.reload.addresses.should eq([ address_one ])
-          end
-
-          context "when setting the relation multiple times" do
-
-            let(:address_two) do
-              Address.new(street: "kudamm")
-            end
-
-            before do
-              doctor.addresses = [ address_two ]
-              doctor.save
-            end
-
-            it "sets the new documents" do
-              doctor.addresses.should eq([ address_two ])
-            end
-
-            it "persits only the new documents" do
-              doctor.reload.addresses.should eq([ address_two ])
-            end
-          end
-        end
-      end
-    end
-
-    context "when replacing an existing relation" do
-
-      let(:person) do
-        Person.create(addresses: [
-          Address.new(street: "1st St"),
-          Address.new(street: "2nd St")
-        ])
-      end
-
-      let(:address) do
-        Address.new(street: "3rd St")
-      end
-
-      before do
-        person.addresses = [ address ]
-      end
-
-      it "deletes the old documents" do
-        person.reload.addresses.should eq([ address ])
-      end
-    end
-
-    context "when the relation has an unusual name" do
-
-      module MyCompany
-        module Model
-          class TrackingId
-            include Mongoid::Document
-            include Mongoid::Timestamps
-            store_in collection: "tracking_ids"
-            embeds_many \
-              :validation_history,
-              class_name: "MyCompany::Model::TrackingIdValidationHistory"
-          end
-
-          class TrackingIdValidationHistory
-            include Mongoid::Document
-            field :old_state, type: String
-            field :new_state, type: String
-            field :when_changed, type: DateTime
-            attr_protected :_id
-            embedded_in :tracking_id, class_name: "MyCompany::Model::TrackingId"
-          end
-        end
-      end
-
-      let(:tracking_id) do
-        MyCompany::Model::TrackingId.create
-      end
-
-      let(:history) do
-        MyCompany::Model::TrackingIdValidationHistory.new(old_state: "Test")
-      end
-
-      before do
-        tracking_id.validation_history << history
-      end
-
-      it "allows creation of the embedded document" do
-        tracking_id.validation_history.size.should eq(1)
-      end
-
-      it "saves the relation" do
-        history.should be_persisted
-      end
-
-      it "remains on reload" do
-        tracking_id.reload.validation_history.size.should eq(1)
-      end
-    end
-
-    context "when the relation has address in the name" do
-
-      let(:slave) do
-        Slave.new(first_name: "Test")
-      end
-
-      before do
-        ActiveSupport::Inflector.inflections do |inflect|
-          inflect.singular("address_numbers", "address_number")
-        end
-        slave.address_numbers << AddressNumber.new(country_code: 1)
-        slave.save
-      end
-
-      it "requires an inflection to determine the class" do
-        slave.reload.address_numbers.size.should eq(1)
-      end
-    end
-
-    context "when setting the entire tree via a hash" do
-
-      let(:person) do
-        Person.create
-      end
-
-      let!(:address_one) do
-        person.addresses.create(street: "Tauentzienstr")
-      end
-
-      let!(:address_two) do
-        person.addresses.create(street: "Kudamm")
-      end
-
-      let(:attributes) do
-        person.as_document.dup
-      end
-
-      context "when the attributes have changed" do
-
-        before do
-          attributes["addresses"][0]["city"] = "Berlin"
-          person.update_attributes(attributes)
-        end
-
-        it "sets the new attributes" do
-          person.addresses.first.city.should eq("Berlin")
-        end
-
-        it "persists the changes" do
-          person.reload.addresses.first.city.should eq("Berlin")
-        end
-      end
-    end
-
-    context "when setting an embedded sub-document tree via a hash" do
-
-      let(:person) do
-        Person.create
-      end
-
-      let!(:address_one) do
-        person.addresses.create(street: "Tauentzienstr")
-      end
-
-      let!(:location_one) do
-        person.addresses.first.locations.create(name: "Work")
-      end
-
-      let(:attributes) do
-        person.addresses.first.as_document.dup
-      end
-
-      context "when the attributes have changed" do
-
-        before do
-          attributes["city"] = "Berlin"
-          attributes["locations"][0]["name"] = "Home"
-          person.addresses.first.update_attributes(attributes)
-        end
-
-        it "sets the new attributes on the address" do
-          person.addresses.first.city.should eq("Berlin")
-        end
-
-        it "sets the new attributes on the location" do
-          person.addresses.first.locations.first.name.should eq("Home")
-        end
-
-        it "persists the changes to the address" do
-          person.reload.addresses.first.city.should eq("Berlin")
-        end
-
-        it "persists the changes to the location" do
-          person.reload.addresses.first.locations.first.name.should eq("Home")
-        end
-
-        it "does not persist the locations collection to the person document" do
-          person.reload[:locations].should be_nil
-        end
-      end
-    end
-
-    context "when the parent and child have a cyclic relation" do
-
-      context "when the parent is a new record" do
-
-        let(:parent_role) do
-          Role.new
-        end
-
-        let(:child_role) do
-          Role.new
-        end
-
-        before do
-          parent_role.child_roles = [ child_role ]
-        end
-
-        it "sets the target of the relation" do
-          parent_role.child_roles.should eq([ child_role ])
-        end
-
-        it "sets the base on the inverse relation" do
-          child_role.parent_role.should eq(parent_role)
-        end
-
-        it "sets the same instance on the inverse relation" do
-          child_role.parent_role.should eql(parent_role)
-        end
-
-        it "does not save the target" do
-          child_role.should_not be_persisted
-        end
-
-        it "sets the parent on the child" do
-          child_role._parent.should eq(parent_role)
-        end
-
-        it "sets the metadata on the child" do
-          child_role.metadata.should_not be_nil
-        end
-
-        it "sets the index on the child" do
-          child_role._index.should eq(0)
-        end
-      end
-
-      context "when the parent is not a new record" do
-
-        let(:parent_role) do
-          Role.create(name: "CTO")
-        end
-
-        let(:child_role) do
-          Role.new
-        end
-
-        before do
-          parent_role.child_roles = [ child_role ]
-        end
-
-        it "saves the target" do
-          child_role.should be_persisted
-        end
-      end
-    end
-  end
-
-  describe "#= nil" do
-
-    context "when the relationship is polymorphic" do
-
-      context "when the parent is a new record" do
-
-        let(:person) do
-          Person.new
-        end
-
-        let(:address) do
-          Address.new
-        end
-
-        before do
-          person.addresses = [ address ]
-          person.addresses = nil
-        end
-
-        it "sets the relation to empty" do
-          person.addresses.should be_empty
-        end
-
-        it "sets the unscoped to empty" do
-          person.addresses.send(:_unscoped).should be_empty
-        end
-
-        it "removes the inverse relation" do
-          address.addressable.should be_nil
-        end
-      end
-
-      context "when the inverse is already nil" do
-
-        let(:person) do
-          Person.new
-        end
-
-        before do
-          person.addresses = nil
-        end
-
-        it "sets the relation to empty" do
-          person.addresses.should be_empty
-        end
-      end
-
-      context "when the parent is persisted" do
-
-        let(:person) do
-          Person.create
-        end
-
-        let(:address) do
-          Address.new
-        end
-
-        context "when setting directly" do
-
-          before do
-            person.addresses = [ address ]
-            person.addresses = nil
-          end
-
-          it "sets the relation to empty" do
-            person.addresses.should be_empty
-          end
-
-          it "sets the relation to empty in the database" do
-            person.reload.addresses.should be_empty
-          end
-
-          it "removed the inverse relation" do
-            address.addressable.should be_nil
-          end
-
-          it "deletes the child document" do
-            address.should be_destroyed
-          end
-        end
-
-        context "when setting via attributes" do
-
-          before do
-            person.addresses = [ address ]
-            person.attributes = { addresses: nil }
-          end
-
-          it "sets the relation to empty" do
-            person.addresses.should be_empty
-          end
-
-          it "deletes the child document" do
-            address.should be_destroyed
-          end
-
-          context "when saving the parent" do
-
-            before do
-              person.save
-              person.reload
-            end
-
-            it "persists the deletion" do
-              person.addresses.should be_empty
-            end
-          end
-        end
-      end
-
-      context "when setting on a reload" do
-
-        let(:person) do
-          Person.create
-        end
-
-        let(:address) do
-          Address.new
-        end
-
-        let(:reloaded) do
-          person.reload
-        end
-
-        before do
-          person.reload.addresses = [ address ]
-          person.reload.addresses = nil
-        end
-
-        it "sets the relation to empty" do
-          person.addresses.should be_empty
-        end
-
-        it "sets the relation to empty in the database" do
-          reloaded.addresses.should be_empty
-        end
-      end
-    end
-
-    context "when the relationship is cyclic" do
-
-      context "when the parent is a new record" do
-
-        let(:parent_role) do
-          Role.new
-        end
-
-        let(:child_role) do
-          Role.new
-        end
-
-        before do
-          parent_role.child_roles = [ child_role ]
-          parent_role.child_roles = nil
-        end
-
-        it "sets the relation to empty" do
-          parent_role.child_roles.should be_empty
-        end
-
-        it "removes the inverse relation" do
-          child_role.parent_role.should be_nil
-        end
-      end
-
-      context "when the inverse is already nil" do
-
-        let(:parent_role) do
-          Role.new
-        end
-
-        before do
-          parent_role.child_roles = nil
-        end
-
-        it "sets the relation to empty" do
-          parent_role.child_roles.should be_empty
-        end
-      end
-
-      context "when the documents are not new records" do
-
-        let(:parent_role) do
-          Role.create
-        end
-
-        let(:child_role) do
-          Role.new
-        end
-
-        before do
-          parent_role.child_roles = [ child_role ]
-          parent_role.child_roles = nil
-        end
-
-        it "sets the relation to empty" do
-          parent_role.child_roles.should be_empty
-        end
-
-        it "removed the inverse relation" do
-          child_role.parent_role.should be_nil
-        end
-
-        it "deletes the child document" do
-          child_role.should be_destroyed
-        end
-      end
-    end
-  end
-
-  describe "#as_document" do
-
-    let!(:person) do
-      Person.create
-    end
-
-    context "when the relation has no default scope" do
-
-      let!(:address) do
-        person.addresses.create(street: "one")
-      end
-
-      let(:document) do
-        person.reload.addresses.as_document
-      end
-
-      it "returns the documents as an array of hashes" do
-        document.should eq([ address.as_document ])
-      end
-    end
-
-    context "when the relation has a default scope" do
-
-      context "when the default scope sorts" do
-
-        let(:cough) do
-          Symptom.new(name: "cough")
-        end
-
-        let(:headache) do
-          Symptom.new(name: "headache")
-        end
-
-        before do
-          person.symptoms.concat([ headache, cough ])
-        end
-
-        let(:document) do
-          person.reload.symptoms.as_document
-        end
-
-        it "returns the unscoped documents as an array of hashes" do
-          document.should eq([ headache.as_document, cough.as_document ])
-        end
-      end
-
-      context "when the default scope limits" do
-
-        let(:active) do
-          Appointment.new
-        end
-
-        let(:inactive) do
-          Appointment.new(active: false)
-        end
-
-        before do
-          person.appointments.concat([ active, inactive ])
-        end
-
-        let(:document) do
-          person.reload.appointments.as_document
-        end
-
-        it "returns the unscoped documents as an array of hashes" do
-          document.should eq([ active.as_document, inactive.as_document ])
-        end
-      end
-    end
-  end
-
-  [ :build, :new ].each do |method|
-
-    describe "#build" do
-
-      context "when providing scoped mass assignment" do
-
-        let(:person) do
-          Person.new
-        end
-
-        let(:video) do
-          person.videos.send(
-            method,
-            { title: "Inception", year: 1999 }, as: :admin
-          )
-        end
-
-        it "sets the attributes for the provided role" do
-          video.title.should eq("Inception")
-        end
-
-        it "does not set the attributes for other roles" do
-          video.year.should be_nil
-        end
-      end
-
-      context "when the relation is not cyclic" do
-
-        let(:person) do
-          Person.new
-        end
-
-        let(:address) do
-          person.addresses.send(method, street: "Bond") do |address|
-            address.state = "CA"
-          end
-        end
-
-        it "appends to the target" do
-          person.addresses.should eq([ address ])
-        end
-
-        it "appends to the unscoped" do
-          person.addresses.send(:_unscoped).should eq([ address ])
-        end
-
-        it "sets the base on the inverse relation" do
-          address.addressable.should eq(person)
-        end
-
-        it "does not save the new document" do
-          address.should_not be_persisted
-        end
-
-        it "sets the parent on the child" do
-          address._parent.should eq(person)
-        end
-
-        it "sets the metadata on the child" do
-          address.metadata.should_not be_nil
-        end
-
-        it "sets the index on the child" do
-          address._index.should eq(0)
-        end
-
-        it "writes to the attributes" do
-          address.street.should eq("Bond")
-        end
-
-        it "calls the passed block" do
-          address.state.should eq("CA")
-        end
-      end
-
-      context "when the relation is cyclic" do
-
-        let(:parent_role) do
-          Role.new
-        end
-
-        let(:child_role) do
-          parent_role.child_roles.send(method, name: "CTO")
-        end
-
-        it "appends to the target" do
-          parent_role.child_roles.should eq([ child_role ])
-        end
-
-        it "sets the base on the inverse relation" do
-          child_role.parent_role.should eq(parent_role)
-        end
-
-        it "does not save the new document" do
-          child_role.should_not be_persisted
-        end
-
-        it "sets the parent on the child" do
-          child_role._parent.should eq(parent_role)
-        end
-
-        it "sets the metadata on the child" do
-          child_role.metadata.should_not be_nil
-        end
-
-        it "sets the index on the child" do
-          child_role._index.should eq(0)
-        end
-
-        it "writes to the attributes" do
-          child_role.name.should eq("CTO")
-        end
-      end
-
-      context "when providing nested attributes" do
-
-        let(:person) do
-          Person.create
-        end
-
-        let(:address) do
-          person.addresses.send(
-            method,
-            street: "Bond",
-            locations_attributes: { "1" => { "name" => "Home" } }
-          )
-        end
-
-        context "when followed by a save" do
-
-          before do
-            address.save
-          end
-
-          let(:location) do
-            person.reload.addresses.first.locations.first
-          end
-
-          it "persists the deeply embedded document" do
-            location.name.should eq("Home")
-          end
-        end
-      end
-    end
-  end
-
-  describe ".builder" do
-
-    let(:base) do
-      Person.new
-    end
-
-    let(:target) do
-      [ address ]
-    end
-
-    let(:metadata) do
-      Person.relations["addresses"]
-    end
-
-    let(:relation) do
-      described_class.new(base, target, metadata)
-    end
-
-    let(:document) do
-      Address.new
-    end
-
-    it "returns the many builder" do
-      described_class.builder(base, metadata, document).should
-        be_a(Mongoid::Relations::Builders::Embedded::Many)
-    end
-  end
-
-  describe "#clear" do
-
-    context "when the parent has been persisted" do
-
-      let(:person) do
-        Person.create
-      end
-
-      context "when the children are persisted" do
-
-        let!(:address) do
-          person.addresses.create(street: "High St")
-        end
-
-        let!(:relation) do
-          person.addresses.clear
-        end
-
-        it "clears out the relation" do
-          person.addresses.should be_empty
-        end
-
-        it "clears the unscoped" do
-          person.addresses.send(:_unscoped).should be_empty
-        end
-
-        it "marks the documents as deleted" do
-          address.should be_destroyed
-        end
-
-        it "deletes the documents from the db" do
-          person.reload.addresses.should be_empty
-        end
-
-        it "returns the relation" do
-          relation.should be_empty
-        end
-      end
-
-      context "when the children are not persisted" do
-
-        let!(:address) do
-          person.addresses.build(street: "High St")
-        end
-
-        let!(:relation) do
-          person.addresses.clear
-        end
-
-        it "clears out the relation" do
-          person.addresses.should be_empty
-        end
-      end
-    end
-
-    context "when the parent is not persisted" do
-
-      let(:person) do
-        Person.new
-      end
-
-      let!(:address) do
-        person.addresses.build(street: "High St")
-      end
-
-      let!(:relation) do
-        person.addresses.clear
-      end
-
-      it "clears out the relation" do
-        person.addresses.should be_empty
-      end
-    end
-  end
-
-  describe "#concat" do
-
-    context "when the parent is a new record" do
-
-      let(:person) do
-        Person.new
-      end
-
-      let(:address) do
-        Address.new
-      end
-
-      before do
-        person.addresses.concat([ address ])
-      end
-
-      it "appends to the target" do
-        person.addresses.should eq([ address ])
-      end
-
-      it "appends to the unscoped" do
-        person.addresses.send(:_unscoped).should eq([ address ])
-      end
-
-      it "sets the base on the inverse relation" do
-        address.addressable.should eq(person)
-      end
-
-      it "sets the same instance on the inverse relation" do
-        address.addressable.should eql(person)
-      end
-
-      it "does not save the new document" do
-        address.should_not be_persisted
-      end
-
-      it "sets the parent on the child" do
-        address._parent.should eq(person)
-      end
-
-      it "sets the metadata on the child" do
-        address.metadata.should_not be_nil
-      end
-
-      it "sets the index on the child" do
-        address._index.should eq(0)
-      end
-    end
-
-    context "when the parent is not a new record" do
-
-      let(:person) do
-        Person.create
-      end
-
-      let(:address) do
-        Address.new
-      end
-
-      before do
-        person.addresses.concat([ address ])
-      end
-
-      it "saves the new document" do
-        address.should be_persisted
-      end
-    end
-
-    context "when concatenating an empty array" do
-
-      let(:person) do
-        Person.create
-      end
-
-      before do
-        person.addresses.should_not_receive(:batch_insert)
-        person.addresses.concat([])
-      end
-
-      it "doesn't update the target" do
-        person.addresses.should be_empty
-      end
-    end
-
-    context "when appending more than one document at once" do
-
-      let(:person) do
-        Person.create
-      end
-
-      let(:address_one) do
-        Address.new
-      end
-
-      let(:address_two) do
-        Address.new
-      end
-
-      before do
-        person.addresses.concat([ address_one, address_two ])
-      end
-
-      it "saves the first document" do
-        address_one.should be_persisted
-      end
-
-      it "saves the second document" do
-        address_two.should be_persisted
-      end
-    end
-
-    context "when the parent and child have a cyclic relation" do
-
-      context "when the parent is a new record" do
-
-        let(:parent_role) do
-          Role.new
-        end
-
-        let(:child_role) do
-          Role.new
-        end
-
-        before do
-          parent_role.child_roles.concat([ child_role ])
-        end
-
-        it "appends to the target" do
-          parent_role.child_roles.should eq([ child_role ])
-        end
-
-        it "sets the base on the inverse relation" do
-          child_role.parent_role.should eq(parent_role)
-        end
-
-        it "sets the same instance on the inverse relation" do
-          child_role.parent_role.should eql(parent_role)
-        end
-
-        it "does not save the new document" do
-          child_role.should_not be_persisted
-        end
-
-        it "sets the parent on the child" do
-          child_role._parent.should eq(parent_role)
-        end
-
-        it "sets the metadata on the child" do
-          child_role.metadata.should_not be_nil
-        end
-
-        it "sets the index on the child" do
-          child_role._index.should eq(0)
-        end
-      end
-
-      context "when the parent is not a new record" do
-
-        let(:parent_role) do
-          Role.create(name: "CEO")
-        end
-
-        let(:child_role) do
-          Role.new(name: "COO")
-        end
-
-        before do
-          parent_role.child_roles.concat([ child_role ])
-        end
-
-        it "saves the new document" do
-          child_role.should be_persisted
-        end
-      end
-    end
-  end
-
-  describe "#count" do
-
-    let(:person) do
-      Person.create
-    end
-
-    before do
-      person.addresses.create(street: "Upper")
-      person.addresses.build(street: "Bond")
-    end
-
-    it "returns the number of persisted documents" do
-      person.addresses.count.should eq(1)
-    end
-  end
-
-  describe "#create" do
-
-    context "when providing scoped mass assignment" do
-
-      let(:person) do
-        Person.create
-      end
-
-      let(:video) do
-        person.videos.create(
-          { title: "Inception", year: 1999 }, as: :admin
-        )
-      end
-
-      it "sets the attributes for the provided role" do
-        video.title.should eq("Inception")
-      end
-
-      it "does not set the attributes for other roles" do
-        video.year.should be_nil
-      end
-    end
-
-    context "when the relation is not cyclic" do
-
-      let(:person) do
-        Person.create
-      end
-
-      let!(:address) do
-        person.addresses.create(street: "Bond") do |address|
-          address.state = "CA"
-        end
-      end
-
-      it "appends to the target" do
-        person.reload.addresses.should eq([ address ])
-      end
-
-      it "appends to the unscoped" do
-        person.reload.addresses.send(:_unscoped).should eq([ address ])
-      end
-
-      it "sets the base on the inverse relation" do
-        address.addressable.should eq(person)
-      end
-
-      it "saves the document" do
-        address.should be_persisted
-      end
-
-      it "sets the parent on the child" do
-        address._parent.should eq(person)
-      end
-
-      it "sets the metadata on the child" do
-        address.metadata.should_not be_nil
-      end
-
-      it "sets the index on the child" do
-        address._index.should eq(0)
-      end
-
-      it "writes to the attributes" do
-        address.street.should eq("Bond")
-      end
-
-      it "calls the passed block" do
-        address.state.should eq("CA")
-      end
-
-      context "when embedding a multi word named document" do
-
-        let!(:component) do
-          person.address_components.create(street: "Test")
-        end
-
-        it "saves the embedded document" do
-          person.reload.address_components.first.should eq(component)
-        end
-      end
-    end
-
-    context "when the relation is cyclic" do
-
-      let!(:entry) do
-        Entry.create(title: "hi")
-      end
-
-      let!(:child_entry) do
-        entry.child_entries.create(title: "hello")
-      end
-
-      it "creates a new child" do
-        child_entry.should be_persisted
-      end
-    end
-  end
-
-  describe "#create!" do
-
-    let(:person) do
-      Person.create
-    end
-
-    context "when providing scoped mass assignment" do
-
-      let(:video) do
-        person.videos.create!(
-          { title: "Inception", year: 1999 }, as: :admin
-        )
-      end
-
-      it "sets the attributes for the provided role" do
-        video.title.should eq("Inception")
-      end
-
-      it "does not set the attributes for other roles" do
-        video.year.should be_nil
-      end
-    end
-
-    context "when validation passes" do
-
-      let(:address) do
-        person.addresses.create!(street: "Bond")
-      end
-
-      it "appends to the target" do
-        person.addresses.should eq([ address ])
-      end
-
-      it "appends to the unscoped" do
-        person.addresses.send(:_unscoped).should eq([ address ])
-      end
-
-      it "sets the base on the inverse relation" do
-        address.addressable.should eq(person)
-      end
-
-      it "saves the document" do
-        address.should be_persisted
-      end
-
-      it "sets the parent on the child" do
-        address._parent.should eq(person)
-      end
-
-      it "sets the metadata on the child" do
-        address.metadata.should_not be_nil
-      end
-
-      it "sets the index on the child" do
-        address._index.should eq(0)
-      end
-
-      it "writes to the attributes" do
-        address.street.should eq("Bond")
-      end
-    end
-
-    context "when validation fails" do
-
-      it "raises an error" do
-        expect {
-          person.addresses.create!(street: "1")
-        }.to raise_error(Mongoid::Errors::Validations)
-      end
-    end
-  end
-
-  describe "#delete" do
-
-    let(:person) do
-      Person.new
-    end
-
-    let(:address_one) do
-      Address.new(street: "first")
-    end
-
-    let(:address_two) do
-      Address.new(street: "second")
-    end
-
-    before do
-      person.addresses << [ address_one, address_two ]
-    end
-
-    context "when the document exists in the relation" do
-
-      let!(:deleted) do
-        person.addresses.delete(address_one)
-      end
-
-      it "deletes the document" do
-        person.addresses.should eq([ address_two ])
-      end
-
-      it "deletes the document from the unscoped" do
-        person.addresses.send(:_unscoped).should eq([ address_two ])
-      end
-
-      it "reindexes the relation" do
-        address_two._index.should eq(0)
-      end
-
-      it "returns the document" do
-        deleted.should eq(address_one)
-      end
-    end
-
-    context "when the document does not exist" do
-
-      it "returns nil" do
-        person.addresses.delete(Address.new).should be_nil
-      end
-    end
-  end
-
-  describe "#delete_if" do
-
-    let(:person) do
-      Person.create
-    end
-
-    context "when the documents are new" do
-
-      let!(:address_one) do
-        person.addresses.build(street: "Bond")
-      end
-
-      let!(:address_two) do
-        person.addresses.build(street: "Upper")
-      end
-
-      context "when a block is provided" do
-
-        let!(:deleted) do
-          person.addresses.delete_if do |doc|
-            doc.street == "Bond"
-          end
-        end
-
-        it "removes the matching documents" do
-          person.addresses.size.should eq(1)
-        end
-
-        it "removes from the unscoped" do
-          person.addresses.send(:_unscoped).size.should eq(1)
-        end
-
-        it "returns the relation" do
-          deleted.should eq(person.addresses)
-        end
-      end
-
-      context "when no block is provided" do
-
-        let!(:deleted) do
-          person.addresses.delete_if
-        end
-
-        it "returns an enumerator" do
-          deleted.should be_a(Enumerator)
-        end
-      end
-    end
-
-    context "when the documents persisted" do
-
-      let!(:address_one) do
-        person.addresses.create(street: "Bond")
-      end
-
-      let!(:address_two) do
-        person.addresses.create(street: "Upper")
-      end
-
-      context "when a block is provided" do
-
-        let!(:deleted) do
-          person.addresses.delete_if do |doc|
-            doc.street == "Bond"
-          end
-        end
-
-        it "deletes the matching documents" do
-          person.addresses.count.should eq(1)
-        end
-
-        it "deletes the matching documents from the db" do
-          person.reload.addresses.count.should eq(1)
-        end
-
-        it "returns the relation" do
-          deleted.should eq(person.addresses)
-        end
-      end
-    end
-
-    context "when the documents are empty" do
-
-      context "when a block is provided" do
-
-        let!(:deleted) do
-          person.addresses.delete_if do |doc|
-            doc.street == "Bond"
-          end
-        end
-
-        it "deletes the matching documents" do
-          person.addresses.count.should eq(0)
-        end
-
-        it "deletes all the documents from the db" do
-          person.reload.addresses.count.should eq(0)
-        end
-
-        it "returns the relation" do
-          deleted.should eq(person.addresses)
-        end
-      end
-    end
-  end
-
-  [ :delete_all, :destroy_all ].each do |method|
-
-    describe "##{method}" do
-
-      let(:person) do
-        Person.create
-      end
-
-      context "when the documents are new" do
-
-        let!(:address_one) do
-          person.addresses.build(street: "Bond")
-        end
-
-        let!(:address_two) do
-          person.addresses.build(street: "Upper")
-        end
-
-        context "when conditions are provided" do
-
-          let!(:deleted) do
-            person.addresses.send(
-              method,
-              { street: "Bond" }
-            )
-          end
-
-          it "removes the matching documents" do
-            person.addresses.size.should eq(1)
-          end
-
-          it "removes from the unscoped" do
-            person.addresses.send(:_unscoped).size.should eq(1)
-          end
-
-          it "returns the number deleted" do
-            deleted.should eq(1)
-          end
-        end
-
-        context "when conditions are not provided" do
-
-          let!(:deleted) do
-            person.addresses.send(method)
-          end
-
-          it "removes all documents" do
-            person.addresses.size.should eq(0)
-          end
-
-          it "returns the number deleted" do
-            deleted.should eq(2)
-          end
-        end
-      end
-
-      context "when the documents persisted" do
-
-        let!(:address_one) do
-          person.addresses.create(street: "Bond")
-        end
-
-        let!(:address_two) do
-          person.addresses.create(street: "Upper")
-        end
-
-        context "when conditions are provided" do
-
-          let!(:deleted) do
-            person.addresses.send(
-              method,
-              { street: "Bond" }
-            )
-          end
-
-          it "deletes the matching documents" do
-            person.addresses.count.should eq(1)
-          end
-
-          it "deletes the matching documents from the db" do
-            person.reload.addresses.count.should eq(1)
-          end
-
-          it "returns the number deleted" do
-            deleted.should eq(1)
-          end
-        end
-
-        context "when conditions are not provided" do
-
-          let!(:deleted) do
-            person.addresses.send(method)
-          end
-
-          it "deletes all the documents" do
-            person.addresses.count.should eq(0)
-          end
-
-          it "deletes all the documents from the db" do
-            person.reload.addresses.count.should eq(0)
-          end
-
-          it "returns the number deleted" do
-            deleted.should eq(2)
-          end
-        end
-
-        context "when removing and resaving" do
-
-          let(:owner) do
-            PetOwner.create(title: "AKC")
-          end
-
-          before do
-            owner.pet = Pet.new(name: "Fido")
-            owner.pet.vet_visits << VetVisit.new(date: Date.today)
-            owner.save!
-            owner.pet.vet_visits.destroy_all
-          end
-
-          it "removes the documents" do
-            owner.pet.vet_visits.should be_empty
-          end
-
-          it "allows addition and a resave" do
-            owner.pet.vet_visits << VetVisit.new(date: Date.today)
-            owner.save!
-            owner.pet.vet_visits.first.should be_persisted
-          end
-        end
-      end
-
-      context "when the documents empty" do
-
-        context "when scoped" do
-          let!(:deleted) do
-            person.addresses.without_postcode.send(method)
-          end
-
-          it "deletes all the documents" do
-            person.addresses.count.should eq(0)
-          end
-
-          it "deletes all the documents from the db" do
-            person.reload.addresses.count.should eq(0)
-          end
-
-          it "returns the number deleted" do
-            deleted.should eq(0)
-          end
-        end
-
-        context "when conditions are provided" do
-
-          let!(:deleted) do
-            person.addresses.send(
-              method,
-              conditions: { street: "Bond" }
-            )
-          end
-
-          it "deletes all the documents" do
-            person.addresses.count.should eq(0)
-          end
-
-          it "deletes all the documents from the db" do
-            person.reload.addresses.count.should eq(0)
-          end
-
-          it "returns the number deleted" do
-            deleted.should eq(0)
-          end
-        end
-
-        context "when conditions are not provided" do
-
-          let!(:deleted) do
-            person.addresses.send(method)
-          end
-
-          it "deletes all the documents" do
-            person.addresses.count.should eq(0)
-          end
-
-          it "deletes all the documents from the db" do
-            person.reload.addresses.count.should eq(0)
-          end
-
-          it "returns the number deleted" do
-            deleted.should eq(0)
-          end
-        end
-      end
-    end
-  end
-
-  describe ".embedded?" do
-
-    it "returns true" do
-      described_class.should be_embedded
-    end
-  end
-
-  describe ".foreign_key_suffix" do
-
-    it "returns nil" do
-      described_class.foreign_key_suffix.should be_nil
-    end
-  end
-
-  describe "#exists?" do
-
-    let!(:person) do
-      Person.create
-    end
-
-    context "when documents exist in the database" do
-
-      before do
-        person.addresses.create(street: "Bond St")
-      end
-
-      it "returns true" do
-        person.addresses.exists?.should be_true
-      end
-    end
-
-    context "when no documents exist in the database" do
-
-      before do
-        person.addresses.build(street: "Hyde Park Dr")
-      end
-
-      it "returns false" do
-        person.addresses.exists?.should be_false
-      end
-    end
-  end
-
-  describe "#find" do
-
-    let(:person) do
-      Person.new
-    end
-
-    let!(:address_one) do
-      person.addresses.build(street: "Bond", city: "London")
-    end
-
-    let!(:address_two) do
-      person.addresses.build(street: "Upper", city: "London")
-    end
-
-    context "when providing an id" do
-
-      context "when the id matches" do
-
-        let(:address) do
-          person.addresses.find(address_one.id)
-        end
-
-        it "returns the matching document" do
-          address.should eq(address_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 {
-              person.addresses.find(Moped::BSON::ObjectId.new)
-            }.to raise_error(Mongoid::Errors::DocumentNotFound)
-          end
-        end
-
-        context "when config set not to raise error" do
-
-          let(:address) do
-            person.addresses.find(Moped::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
-            address.should be_nil
-          end
-        end
-      end
-    end
-
-    context "when providing an array of ids" do
-
-      context "when the ids match" do
-
-        let(:addresses) do
-          person.addresses.find([ address_one.id, address_two.id ])
-        end
-
-        it "returns the matching documents" do
-          addresses.should eq([ address_one, address_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.addresses.find([ Moped::BSON::ObjectId.new ])
-            }.to raise_error(Mongoid::Errors::DocumentNotFound)
-          end
-        end
-
-        context "when config set not to raise error" do
-
-          let(:addresses) do
-            person.addresses.find([ Moped::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
-            addresses.should be_empty
-          end
-        end
-      end
-    end
-  end
-
-  describe "#find_or_create_by" do
-
-    let(:person) do
-      Person.create
-    end
-
-    let!(:address) do
-      person.addresses.build(street: "Bourke", city: "Melbourne")
-    end
-
-    context "when the document exists" do
-
-      let(:found) do
-        person.addresses.find_or_create_by(street: "Bourke")
-      end
-
-      it "returns the document" do
-        found.should eq(address)
-      end
-    end
-
-    context "when the document does not exist" do
-
-      let(:found) do
-        person.addresses.find_or_create_by(street: "King") do |address|
-          address.state = "CA"
-        end
-      end
-
-      it "sets the new document attributes" do
-        found.street.should eq("King")
-      end
-
-      it "returns a newly persisted document" do
-        found.should be_persisted
-      end
-
-      it "calls the passed block" do
-        found.state.should eq("CA")
-      end
-    end
-
-    context "when the child belongs to another document" do
-
-      let(:product) do
-        Product.create
-      end
-
-      let(:purchase) do
-        Purchase.create
-      end
-
-      let(:line_item) do
-        purchase.line_items.find_or_create_by(
-          product_id: product.id,
-          product_type: product.class.name
-        )
-      end
-
-      it "properly creates the document" do
-        line_item.product.should eq(product)
-      end
-    end
-  end
-
-  describe "#find_or_initialize_by" do
-
-    let(:person) do
-      Person.new
-    end
-
-    let!(:address) do
-      person.addresses.build(street: "Bourke", city: "Melbourne")
-    end
-
-    context "when the document exists" do
-
-      let(:found) do
-        person.addresses.find_or_initialize_by(street: "Bourke")
-      end
-
-      it "returns the document" do
-        found.should eq(address)
-      end
-    end
-
-    context "when the document does not exist" do
-
-      let(:found) do
-        person.addresses.find_or_initialize_by(street: "King") do |address|
-          address.state = "CA"
-        end
-      end
-
-      it "sets the new document attributes" do
-        found.street.should eq("King")
-      end
-
-      it "returns a non persisted document" do
-        found.should_not be_persisted
-      end
-
-      it "calls the passed block" do
-        found.state.should eq("CA")
-      end
-    end
-  end
-
-  describe ".macro" do
-
-    it "returns embeds_many" do
-      described_class.macro.should eq(:embeds_many)
-    end
-  end
-
-  describe "#max" do
-
-    let(:person) do
-      Person.new
-    end
-
-    let(:address_one) do
-      Address.new(number: 5)
-    end
-
-    let(:address_two) do
-      Address.new(number: 10)
-    end
-
-    before do
-      person.addresses.push(address_one, address_two)
-    end
-
-    let(:max) do
-      person.addresses.max do |a,b|
-        a.number <=> b.number
-      end
-    end
-
-    it "returns the document with the max value of the supplied field" do
-      max.should eq(address_two)
-    end
-  end
-
-  describe "#max_by" do
-
-    let(:person) do
-      Person.new
-    end
-
-    let(:address_one) do
-      Address.new(number: 5)
-    end
-
-    let(:address_two) do
-      Address.new(number: 10)
-    end
-
-    before do
-      person.addresses.push(address_one, address_two)
-    end
-
-    let(:max) do
-      person.addresses.max_by(&:number)
-    end
-
-    it "returns the document with the max value of the supplied field" do
-      max.should eq(address_two)
-    end
-  end
-
-  describe "#method_missing" do
-
-    let!(:person) do
-      Person.create
-    end
-
-    let!(:address_one) do
-      person.addresses.create(
-        street: "Market",
-        state: "CA",
-        services: [ "1", "2" ]
-      )
-    end
-
-    let!(:address_two) do
-      person.addresses.create(
-        street: "Madison",
-        state: "NY",
-        services: [ "1", "2" ]
-      )
-    end
-
-    context "when providing a single criteria" do
-
-      context "when using a simple criteria" do
-
-        let(:addresses) do
-          person.addresses.where(state: "CA")
-        end
-
-        it "applies the criteria to the documents" do
-          addresses.should eq([ address_one ])
-        end
-      end
-
-      context "when using an $or criteria" do
-
-        let(:addresses) do
-          person.addresses.any_of({ state: "CA" }, { state: "NY" })
-        end
-
-        it "applies the criteria to the documents" do
-          addresses.should eq([ address_one, address_two ])
-        end
-      end
-
-      context "when using array comparison" do
-
-        let(:addresses) do
-          person.addresses.where(services: [ "1", "2" ])
-        end
-
-        it "applies the criteria to the documents" do
-          addresses.should eq([ address_one, address_two ])
-        end
-      end
-    end
-
-    context "when providing a criteria class method" do
-
-      let(:addresses) do
-        person.addresses.california
-      end
-
-      it "applies the criteria to the documents" do
-        addresses.should eq([ address_one ])
-      end
-    end
-
-    context "when chaining criteria" do
-
-      let(:addresses) do
-        person.addresses.california.where(:street.in => [ "Market" ])
-      end
-
-      it "applies the criteria to the documents" do
-        addresses.should eq([ address_one ])
-      end
-    end
-
-    context "when delegating methods" do
-
-      describe "#distinct" do
-
-        it "returns the distinct values for the fields" do
-          person.addresses.distinct(:street).should =~
-            [ "Market",  "Madison"]
-        end
-      end
-    end
-  end
-
-  describe "#min" do
-
-    let(:person) do
-      Person.new
-    end
-
-    let(:address_one) do
-      Address.new(number: 5)
-    end
-
-    let(:address_two) do
-      Address.new(number: 10)
-    end
-
-    before do
-      person.addresses.push(address_one, address_two)
-    end
-
-    let(:min) do
-      person.addresses.min do |a,b|
-        a.number <=> b.number
-      end
-    end
-
-    it "returns the min value of the supplied field" do
-      min.should eq(address_one)
-    end
-  end
-
-  describe "#min_by" do
-
-    let(:person) do
-      Person.new
-    end
-
-    let(:address_one) do
-      Address.new(number: 5)
-    end
-
-    let(:address_two) do
-      Address.new(number: 10)
-    end
-
-    before do
-      person.addresses.push(address_one, address_two)
-    end
-
-    let(:min) do
-      person.addresses.min_by(&:number)
-    end
-
-    it "returns the min value of the supplied field" do
-      min.should eq(address_one)
-    end
-  end
-
-  describe ".nested_builder" do
-
-    let(:metadata) do
-      Person.relations["addresses"]
-    end
-
-    it "returns the many nested builder class" do
-      described_class.nested_builder(metadata, {}, {}).should
-        be_a(Mongoid::Relations::Builders::NestedAttributes::Many)
-    end
-  end
-
-  describe "#pop" do
-
-    let(:person) do
-      Person.create
-    end
-
-    context "when no argument is provided" do
-
-      let!(:address_one) do
-        person.addresses.create(street: "sonnenallee")
-      end
-
-      let!(:address_two) do
-        person.addresses.create(street: "hermannstr")
-      end
-
-      let!(:popped) do
-        person.addresses.pop
-      end
-
-      it "returns the popped document" do
-        popped.should eq(address_two)
-      end
-
-      it "removes the document from the relation" do
-        person.addresses.should eq([ address_one ])
-      end
-
-      it "persists the pop" do
-        person.reload.addresses.should eq([ address_one ])
-      end
-    end
-
-    context "when an integer is provided" do
-
-      let!(:address_one) do
-        person.addresses.create(street: "sonnenallee")
-      end
-
-      let!(:address_two) do
-        person.addresses.create(street: "hermannstr")
-      end
-
-      context "when the number is not larger than the relation" do
-
-        let!(:popped) do
-          person.addresses.pop(2)
-        end
-
-        it "returns the popped documents" do
-          popped.should eq([ address_one, address_two ])
-        end
-
-        it "removes the document from the relation" do
-          person.addresses.should be_empty
-        end
-
-        it "persists the pop" do
-          person.reload.addresses.should be_empty
-        end
-      end
-
-      context "when the number is larger than the relation" do
-
-        let!(:popped) do
-          person.addresses.pop(4)
-        end
-
-        it "returns the popped documents" do
-          popped.should eq([ address_one, address_two ])
-        end
-
-        it "removes the document from the relation" do
-          person.addresses.should be_empty
-        end
-
-        it "persists the pop" do
-          person.reload.addresses.should be_empty
-        end
-      end
-    end
-
-    context "when the relation is empty" do
-
-      context "when providing no number" do
-
-        it "returns nil" do
-          person.addresses.pop.should be_nil
-        end
-      end
-
-      context "when providing a number" do
-
-        it "returns nil" do
-          person.addresses.pop(2).should be_nil
-        end
-      end
-    end
-  end
-
-  describe "#scoped" do
-
-    let(:person) do
-      Person.new
-    end
-
-    let(:scoped) do
-      person.addresses.scoped
-    end
-
-    it "returns the relation criteria" do
-      scoped.should be_a(Mongoid::Criteria)
-    end
-
-    it "returns with an empty selector" do
-      scoped.selector.should be_empty
-    end
-  end
-
-  describe "#respond_to?" do
-
-    let(:person) do
-      Person.new
-    end
-
-    let(:addresses) do
-      person.addresses
-    end
-
-    Array.public_instance_methods.each do |method|
-
-      context "when checking #{method}" do
-
-        it "returns true" do
-          addresses.respond_to?(method).should be_true
-        end
-      end
-    end
-
-    Mongoid::Relations::Embedded::Many.public_instance_methods.each do |method|
-
-      context "when checking #{method}" do
-
-        it "returns true" do
-          addresses.respond_to?(method).should be_true
-        end
-      end
-    end
-
-    Address.scopes.keys.each do |method|
-
-      context "when checking #{method}" do
-
-        it "returns true" do
-          addresses.respond_to?(method).should be_true
-        end
-      end
-    end
-
-    it "supports 'include_private = boolean'" do
-      expect { addresses.respond_to?(:Rational, true) }.not_to raise_error
-    end
-  end
-
-  [ :size, :length ].each do |method|
-
-    describe "##{method}" do
-
-      let(:person) do
-        Person.create
-      end
-
-      before do
-        person.addresses.create(street: "Upper")
-        person.addresses.build(street: "Bond")
-      end
-
-      it "returns the number of persisted documents" do
-        person.addresses.send(method).should eq(2)
-      end
-    end
-  end
-
-  describe "#unscoped" do
-
-    let(:person) do
-      Person.new
-    end
-
-    let(:unscoped) do
-      person.videos.unscoped
-    end
-
-    it "returns the relation criteria" do
-      unscoped.should be_a(Mongoid::Criteria)
-    end
-
-    it "returns with empty options" do
-      unscoped.options.should be_empty
-    end
-
-    it "returns with an empty selector" do
-      unscoped.selector.should be_empty
-    end
-  end
-
-  describe "#update_all" do
-
-    context "when there are no documents present" do
-
-      let(:person) do
-        Person.create
-      end
-
-      it "updates nothing" do
-        person.addresses.update_all(street: "test").should be_false
-      end
-    end
-
-    context "when documents are present" do
-
-      let(:person) do
-        Person.create
-      end
-
-      let!(:address) do
-        person.addresses.create(street: "Hobrecht", number: 27)
-      end
-
-      context "when updating with a where clause" do
-
-        before do
-          person.addresses.
-            where(street: "Hobrecht").
-            update_all(number: 26, post_code: "12437")
-        end
-
-        it "resets the matching dirty flags" do
-          address.should_not be_changed
-        end
-
-        it "updates the first field" do
-          address.reload.number.should eq(26)
-        end
-
-        it "updates the second field" do
-          address.reload.post_code.should eq("12437")
-        end
-
-        it "does not wipe out other fields" do
-          address.reload.street.should eq("Hobrecht")
-        end
-      end
-    end
-  end
-
-  describe ".valid_options" do
-
-    it "returns the valid options" do
-      described_class.valid_options.should eq(
-        [
-          :as, :cascade_callbacks, :cyclic, :order, :versioned,
-          :store_as, :before_add, :after_add, :before_remove, :after_remove
-        ]
-      )
-    end
-  end
-
-  describe ".validation_default" do
-
-    it "returns true" do
-      described_class.validation_default.should be_true
-    end
-  end
-
-  context "when deeply embedding documents" do
-
-    context "when updating the bottom level" do
-
-      let!(:person) do
-        Person.create
-      end
-
-      let!(:address) do
-        person.addresses.create(street: "Joachimstr")
-      end
-
-      let!(:location) do
-        address.locations.create(name: "work")
-      end
-
-      context "when updating with a hash" do
-
-        before do
-          address.update_attributes(locations: [{ name: "home" }])
-        end
-
-        it "updates the attributes" do
-          address.locations.first.name.should eq("home")
-        end
-
-        it "overwrites the existing documents" do
-          address.locations.count.should eq(1)
-        end
-
-        it "persists the changes" do
-          address.reload.locations.count.should eq(1)
-        end
-      end
-    end
-
-    context "when building the tree through hashes" do
-
-      let(:circus) do
-        Circus.new(hash)
-      end
-
-      let(:animal) do
-        circus.animals.first
-      end
-
-      let(:animal_name) do
-        "Lion"
-      end
-
-      let(:tag_list) do
-        "tigers, bears, oh my"
-      end
-
-      context "when the hash uses stringified keys" do
-
-        let(:hash) do
-          { 'animals' => [{ 'name' => animal_name, 'tag_list' => tag_list }] }
-        end
-
-        it "sets up the hierarchy" do
-          animal.circus.should eq(circus)
-        end
-
-        it "assigns the attributes" do
-          animal.name.should eq(animal_name)
-        end
-
-        it "uses custom writer methods" do
-          animal.tag_list.should eq(tag_list)
-        end
-      end
-
-      context "when the hash uses symbolized keys" do
-
-        let(:hash) do
-          { animals: [{ name: animal_name, tag_list: tag_list }] }
-        end
-
-        it "sets up the hierarchy" do
-          animal.circus.should eq(circus)
-        end
-
-        it "assigns the attributes" do
-          animal.name.should eq(animal_name)
-        end
-
-        it "uses custom writer methods" do
-          animal.tag_list.should eq(tag_list)
-        end
-      end
-    end
-
-    context "when building the tree through pushes" do
-
-      let(:quiz) do
-        Quiz.new
-      end
-
-      let(:page) do
-        Page.new
-      end
-
-      let(:page_question) do
-        PageQuestion.new
-      end
-
-      before do
-        quiz.pages << page
-        page.page_questions << page_question
-      end
-
-      let(:question) do
-        quiz.pages.first.page_questions.first
-      end
-
-      it "sets up the hierarchy" do
-        question.should eq(page_question)
-      end
-    end
-
-    context "when building the tree through builds" do
-
-      let!(:quiz) do
-        Quiz.new
-      end
-
-      let!(:page) do
-        quiz.pages.build
-      end
-
-      let!(:page_question) do
-        page.page_questions.build
-      end
-
-      let(:question) do
-        quiz.pages.first.page_questions.first
-      end
-
-      it "sets up the hierarchy" do
-        question.should eq(page_question)
-      end
-    end
-
-    context "when creating a persisted tree" do
-
-      let(:quiz) do
-        Quiz.create
-      end
-
-      let(:page) do
-        Page.new
-      end
-
-      let(:page_question) do
-        PageQuestion.new
-      end
-
-      let(:question) do
-        quiz.pages.first.page_questions.first
-      end
-
-      before do
-        quiz.pages << page
-        page.page_questions << page_question
-      end
-
-      it "sets up the hierarchy" do
-        question.should eq(page_question)
-      end
-
-      context "when reloading" do
-
-        let(:from_db) do
-          quiz.reload
-        end
-
-        let(:reloaded_question) do
-          from_db.pages.first.page_questions.first
-        end
-
-        it "reloads the entire tree" do
-          reloaded_question.should eq(question)
-        end
-      end
-    end
-  end
-
-  context "when deeply nesting documents" do
-
-    context "when all documents are new" do
-
-      let(:person) do
-        Person.new
-      end
-
-      let(:address) do
-        Address.new
-      end
-
-      let(:location) do
-        Location.new
-      end
-
-      before do
-        address.locations << location
-        person.addresses << address
-      end
-
-      context "when saving the root" do
-
-        before do
-          person.save
-        end
-
-        it "persists the first level document" do
-          person.reload.addresses.first.should eq(address)
-        end
-
-        it "persists the second level document" do
-          person.reload.addresses[0].locations.should eq([ location ])
-        end
-      end
-    end
-  end
-
-  context "when attempting nil pushes and substitutes" do
-
-    let(:home_phone) do
-      Phone.new(number: "555-555-5555")
-    end
-
-    let(:office_phone) do
-      Phone.new(number: "666-666-6666")
-    end
-
-    describe "replacing the entire embedded list" do
-
-      context "when an embeds many relationship contains a nil as the first item" do
-
-        let(:person) do
-          Person.create!
-        end
-
-        let(:phone_list) do
-          [nil, home_phone, office_phone]
-        end
-
-        before do
-          person.phone_numbers = phone_list
-          person.save!
-        end
-
-        it "ignores the nil and persist the remaining items" do
-          reloaded = Person.find(person.id)
-          reloaded.phone_numbers.should eq([ home_phone, office_phone ])
-        end
-      end
-
-      context "when an embeds many relationship contains a nil in the middle of the list" do
-
-        let(:person) do
-          Person.create!
-        end
-
-        let(:phone_list) do
-          [home_phone, nil, office_phone]
-        end
-
-        before do
-          person.phone_numbers = phone_list
-          person.save!
-        end
-
-        it "ignores the nil and persist the remaining items" do
-          reloaded = Person.find(person.id)
-          reloaded.phone_numbers.should eq([ home_phone, office_phone ])
-        end
-      end
-
-      context "when an embeds many relationship contains a nil at the end of the list" do
-
-        let(:person) do
-          Person.create!
-        end
-
-        let(:phone_list) do
-          [home_phone, office_phone, nil]
-        end
-
-        before do
-          person.phone_numbers = phone_list
-          person.save!
-        end
-
-        it "ignores the nil and persist the remaining items" do
-          reloaded = Person.find(person.id)
-          reloaded.phone_numbers.should eq([ home_phone, office_phone ])
-        end
-      end
-    end
-
-    describe "appending to the embedded list" do
-
-      context "when appending a nil to the first position in an embedded list" do
-
-        let(:person) do
-          Person.create! phone_numbers: []
-        end
-
-        before do
-          person.phone_numbers << nil
-          person.phone_numbers << home_phone
-          person.phone_numbers << office_phone
-          person.save!
-        end
-
-        it "ignores the nil and persist the remaining items" do
-          reloaded = Person.find(person.id)
-          reloaded.phone_numbers.should eq(person.phone_numbers)
-        end
-      end
-
-      context "when appending a nil into the middle of an embedded list" do
-
-        let(:person) do
-          Person.create! phone_numbers: []
-        end
-
-        before do
-          person.phone_numbers << home_phone
-          person.phone_numbers << nil
-          person.phone_numbers << office_phone
-          person.save!
-        end
-
-        it "ignores the nil and persist the remaining items" do
-          reloaded = Person.find(person.id)
-          reloaded.phone_numbers.should eq(person.phone_numbers)
-        end
-      end
-
-      context "when appending a nil to the end of an embedded list" do
-
-        let(:person) do
-          Person.create! phone_numbers: []
-        end
-
-        before do
-          person.phone_numbers << home_phone
-          person.phone_numbers << office_phone
-          person.phone_numbers << nil
-          person.save!
-        end
-
-        it "ignores the nil and persist the remaining items" do
-          reloaded = Person.find(person.id)
-          reloaded.phone_numbers.should eq(person.phone_numbers)
-        end
-      end
-    end
-  end
-
-  context "when accessing the parent in a destroy callback" do
-
-    let!(:league) do
-      League.create
-    end
-
-    let!(:division) do
-      league.divisions.create
-    end
-
-    before do
-      league.destroy
-    end
-
-    it "retains the reference to the parent" do
-      league.name.should eq("Destroyed")
-    end
-  end
-
-  context "when updating the parent with all attributes" do
-
-    let!(:person) do
-      Person.create
-    end
-
-    let!(:address) do
-      person.addresses.create
-    end
-
-    before do
-      person.update_attributes(person.attributes)
-    end
-
-    it "does not duplicate the embedded documents" do
-      person.addresses.should eq([ address ])
-    end
-
-    it "does not persist duplicate embedded documents" do
-      person.reload.addresses.should eq([ address ])
-    end
-  end
-
-  context "when embedding children named versions" do
-
-    let(:acolyte) do
-      Acolyte.create(name: "test")
-    end
-
-    context "when creating a child" do
-
-      let(:version) do
-        acolyte.versions.create(number: 1)
-      end
-
-      it "allows the operation" do
-        version.number.should eq(1)
-      end
-
-      context "when reloading the parent" do
-
-        let(:from_db) do
-          acolyte.reload
-        end
-
-        it "saves the child versions" do
-          from_db.versions.should eq([ version ])
-        end
-      end
-    end
-  end
-
-  context "when validating the parent before accessing the child" do
-
-    let!(:account) do
-      Account.new(name: "Testing").tap do |acct|
-        acct.memberships.build
-        acct.save
-      end
-    end
-
-    let(:from_db) do
-      Account.first
-    end
-
-    context "when saving" do
-
-      before do
-        account.name = ""
-        account.save
-      end
-
-      it "does not lose the parent reference" do
-        from_db.memberships.first.account.should eq(account)
-      end
-    end
-
-    context "when updating attributes" do
-
-      before do
-        from_db.update_attributes(name: "")
-      end
-
-      it "does not lose the parent reference" do
-        from_db.memberships.first.account.should eq(account)
-      end
-    end
-  end
-
-  context "when moving an embedded document from one parent to another" do
-
-    let!(:person_one) do
-      Person.create
-    end
-
-    let!(:person_two) do
-      Person.create
-    end
-
-    let!(:address) do
-      person_one.addresses.create(street: "Kudamm")
-    end
-
-    before do
-      person_two.addresses << address
-    end
-
-    it "adds the document to the new paarent" do
-      person_two.addresses.should eq([ address ])
-    end
-
-    it "sets the new parent on the document" do
-      address._parent.should eq(person_two)
-    end
-
-    context "when reloading the documents" do
-
-      before do
-        person_one.reload
-        person_two.reload
-      end
-
-      it "persists the change to the new parent" do
-        person_two.addresses.should eq([ address ])
-      end
-
-      it "keeps the address on the previous document" do
-        person_one.addresses.should eq([ address ])
-      end
-    end
-  end
-
-  context "when the relation has a default scope" do
-
-    let!(:person) do
-      Person.create
-    end
-
-    context "when the default scope is a sort" do
-
-      let(:cough) do
-        Symptom.new(name: "cough")
-      end
-
-      let(:headache) do
-        Symptom.new(name: "headache")
-      end
-
-      let(:nausea) do
-        Symptom.new(name: "nausea")
-      end
-
-      before do
-        person.symptoms.concat([ nausea, cough, headache ])
-      end
-
-      context "when accessing the relation" do
-
-        let(:symptoms) do
-          person.reload.symptoms
-        end
-
-        it "applies the default scope" do
-          symptoms.should eq([ cough, headache, nausea ])
-        end
-      end
-
-      context "when modifying the relation" do
-
-        let(:constipation) do
-          Symptom.new(name: "constipation")
-        end
-
-        before do
-          person.symptoms.push(constipation)
-        end
-
-        context "when reloading" do
-
-          let(:symptoms) do
-            person.reload.symptoms
-          end
-
-          it "applies the default scope" do
-            symptoms.should eq([ constipation, cough, headache, nausea ])
-          end
-        end
-      end
-
-      context "when unscoping the relation" do
-
-        let(:unscoped) do
-          person.reload.symptoms.unscoped
-        end
-
-        it "removes the default scope" do
-          unscoped.should eq([ nausea, cough, headache ])
-        end
-      end
-    end
-  end
-
-  context "when indexing the documents" do
-
-    let!(:person) do
-      Person.create
-    end
-
-    context "when the documents have a limiting default scope" do
-
-      let(:active) do
-        Appointment.new
-      end
-
-      let(:inactive) do
-        Appointment.new(active: false)
-      end
-
-      before do
-        person.appointments.concat([ inactive, active ])
-      end
-
-      let(:relation) do
-        person.reload.appointments
-      end
-
-      it "retains the unscoped index for the excluded document" do
-        relation.send(:_unscoped).first._index.should eq(0)
-      end
-
-      it "retains the unscoped index for the included document" do
-        relation.first._index.should eq(1)
-      end
-
-      context "when a reindexing operation occurs" do
-
-        before do
-          relation.send(:reindex)
-        end
-
-        it "retains the unscoped index for the excluded document" do
-          relation.send(:_unscoped).first._index.should eq(0)
-        end
-
-        it "retains the unscoped index for the included document" do
-          relation.first._index.should eq(1)
-        end
-      end
-    end
-  end
-
-  context "when the embedded document has an array field" do
-
-    let!(:person) do
-      Person.create
-    end
-
-    let!(:video) do
-      person.videos.create
-    end
-
-    context "when saving the array on a persisted document" do
-
-      before do
-        video.genres = [ "horror", "scifi" ]
-        video.save
-      end
-
-      it "sets the value" do
-        video.genres.should eq([ "horror", "scifi" ])
-      end
-
-      it "persists the value" do
-        video.reload.genres.should eq([ "horror", "scifi" ])
-      end
-
-      context "when reloading the parent" do
-
-        let!(:loaded_person) do
-          Person.find(person.id)
-        end
-
-        let!(:loaded_video) do
-          loaded_person.videos.find(video.id)
-        end
-
-        context "when writing a new array value" do
-
-          before do
-            loaded_video.genres = [ "comedy" ]
-            loaded_video.save
-          end
-
-          it "sets the new value" do
-            loaded_video.genres.should eq([ "comedy" ])
-          end
-
-          it "persists the new value" do
-            loaded_video.reload.genres.should eq([ "comedy" ])
-          end
-        end
-      end
-    end
-  end
-
-  context "when destroying an embedded document" do
-
-    let(:person) do
-      Person.create
-    end
-
-    let!(:address_one) do
-      person.addresses.create(street: "hobrecht")
-    end
-
-    let!(:address_two) do
-      person.addresses.create(street: "maybachufer")
-    end
-
-    before do
-      address_one.destroy
-    end
-
-    it "destroys the document" do
-      address_one.should be_destroyed
-    end
-
-    it "reindexes the relation" do
-      address_two._index.should eq(0)
-    end
-
-    it "removes the document from the unscoped" do
-      person.addresses.send(:_unscoped).should_not include(address_one)
-    end
-
-    context "when subsequently updating the next document" do
-
-      before do
-        address_two.update_attribute(:number, 10)
-      end
-
-      let(:addresses) do
-        person.reload.addresses
-      end
-
-      it "updates the correct document" do
-        addresses.first.number.should eq(10)
-      end
-
-      it "does not add additional documents" do
-        addresses.count.should eq(1)
-      end
-    end
-  end
-
-  context "when adding a document" do
-
-    let(:person) do
-      Person.new
-    end
-
-    let(:address_one) do
-      Address.new(street: "hobrecht")
-    end
-
-    let(:first_add) do
-      person.addresses.push(address_one)
-    end
-
-    context "when chaining a second add" do
-
-      let(:address_two) do
-        Address.new(street: "friedel")
-      end
-
-      let(:result) do
-        first_add.push(address_two)
-      end
-
-      it "adds both documents" do
-        result.should eq([ address_one, address_two ])
-      end
-    end
-  end
-
-  context "when using dot notation in a criteria" do
-
-    let(:person) do
-      Person.new
-    end
-
-    let!(:address) do
-      person.addresses.build(street: "hobrecht")
-    end
-
-    let!(:location) do
-      address.locations.build(number: 5)
-    end
-
-    let(:criteria) do
-      person.addresses.where("locations.number" => { "$gt" => 3 })
-    end
-
-    it "allows the dot notation criteria" do
-      criteria.should eq([ address ])
-    end
-  end
-
-  context "when updating multiple levels in one update" do
-
-    let!(:person) do
-      Person.create(
-        addresses: [
-          { locations: [{ name: "home" }]}
-        ]
-      )
-    end
-
-    context "when updating with hashes" do
-
-      let(:from_db) do
-        Person.find(person.id)
-      end
-
-      before do
-        from_db.update_attributes(
-          addresses: [
-            { locations: [{ name: "work" }]}
-          ]
-        )
-      end
-
-      let(:updated) do
-        person.reload.addresses.first.locations.first
-      end
-
-      it "updates the nested document" do
-        updated.name.should eq("work")
-      end
-    end
-  end
-
-  context "when the embedded relation sorts on a boolean" do
-
-    let(:circuit) do
-      Circuit.create
-    end
-
-    let!(:bus_one) do
-      circuit.buses.create(saturday: true)
-    end
-
-    let!(:bus_two) do
-      circuit.buses.create(saturday: false)
-    end
-
-    it "orders properly with the boolean" do
-      circuit.reload.buses.should eq([ bus_two, bus_one ])
-    end
-  end
-
-  context "when batch replacing multiple relations in a single update" do
-
-    let(:document) do
-      Person.create
-    end
-
-    let(:person) do
-      Person.find(document.id)
-    end
-
-    let!(:symptom_one) do
-      person.symptoms.create
-    end
-
-    let!(:symptom_two) do
-      person.symptoms.create
-    end
-
-    let!(:appointment_one) do
-      person.appointments.create
-    end
-
-    let!(:appointment_two) do
-      person.appointments.create
-    end
-
-    before do
-      person.update_attributes(
-        appointments: [ appointment_one.as_document, appointment_two.as_document ],
-        symptoms: [ symptom_one.as_document, symptom_two.as_document ]
-      )
-    end
-
-    it "does not duplicate the first relation" do
-      person.reload.symptoms.count.should eq(2)
-    end
-
-    it "does not duplicate the second relation" do
-      person.reload.appointments.count.should eq(2)
-    end
-  end
-
-  context "when pushing with a before_add callback" do
-
-    let(:artist) do
-      Artist.new
-    end
-
-    let(:song) do
-      Song.new
-    end
-
-    context "when no errors are raised" do
-
-      before do
-        artist.songs << song
-      end
-
-      it "executes the callback" do
-        artist.before_add_called.should be_true
-      end
-
-      it "executes the callback as proc" do
-        song.before_add_called.should be_true
-      end
-
-      it "adds the document to the relation" do
-        artist.songs.should eq([song])
-      end
-    end
-
-    context "with errors" do
-
-      before do
-        artist.should_receive(:before_add_song).and_raise
-      end
-
-      it "does not add the document to the relation" do
-        expect {
-          artist.songs << song
-        }.to raise_error
-        artist.songs.should be_empty
-      end
-    end
-  end
-
-  context "when pushing with an after_add callback" do
-
-    let(:artist) do
-      Artist.new
-    end
-
-    let(:label) do
-      Label.new
-    end
-
-    it "executes the callback" do
-      artist.labels << label
-      artist.after_add_called.should be_true
-    end
-
-    context "when errors are raised" do
-
-      before do
-        artist.should_receive(:after_add_label).and_raise
-      end
-
-      it "adds the document to the relation" do
-        expect {
-          artist.labels << label
-        }.to raise_error
-        artist.labels.should eq([ label ])
-      end
-    end
-  end
-
-  context "#delete or #clear with before_remove callback" do
-
-    let(:artist) do
-      Artist.new
-    end
-
-    let(:song) do
-      Song.new
-    end
-
-    before do
-      artist.songs << song
-    end
-
-    context "when no errors are raised" do
-
-      describe "#delete" do
-
-        before do
-          artist.songs.delete(song)
-        end
-
-        it "executes the callback" do
-          artist.before_remove_embedded_called.should be_true
-        end
-
-        it "removes the document from the relation" do
-          artist.songs.should be_empty
-        end
-      end
-
-      describe "#clear" do
-
-        before do
-          artist.songs.clear
-        end
-
-        it "executes the callback" do
-          artist.before_remove_embedded_called.should be_true
-        end
-
-        it "shoud clear the relation" do
-          artist.songs.should be_empty
-        end
-      end
-
-      context "when errors are raised" do
-
-        before do
-          artist.should_receive(:before_remove_song).and_raise
-        end
-
-        describe "#delete" do
-
-          it "does not remove the document from the relation" do
-            expect {
-              artist.songs.delete(song)
-            }.to raise_error
-            artist.songs.should eq([ song ])
-          end
-        end
-
-        describe "#clear" do
-
-          it "removes the documents from the relation" do
-            expect {
-              artist.songs.clear
-            }.to raise_error
-            artist.songs.should eq([ song ])
-          end
-        end
-      end
-    end
-  end
-
-  context "#delete or #clear with after_remove callback" do
-
-    let(:artist) do
-      Artist.new
-    end
-
-    let(:label) do
-      Label.new
-    end
-
-    before do
-      artist.labels << label
-    end
-
-    context "when no errors are raised" do
-
-      describe "#delete" do
-        before do
-          artist.labels.delete(label)
-        end
-
-        it "executes the callback" do
-          artist.after_remove_embedded_called.should be_true
-        end
-      end
-
-      describe "#clear" do
-
-        before do
-          artist.labels.clear
-        end
-
-        it "executes the callback" do
-          artist.labels.clear
-          artist.after_remove_embedded_called.should be_true
-        end
-      end
-    end
-
-    context "when errors are raised" do
-
-      before do
-        artist.should_receive(:after_remove_label).and_raise
-      end
-
-      describe "#delete" do
-
-        before do
-          expect {
-            artist.labels.delete(label)
-          }.to raise_error
-        end
-
-        it "removes the document from the relation" do
-          artist.labels.should be_empty
-        end
-      end
-
-      describe "#clear" do
-
-        before do
-          expect {
-            artist.labels.clear
-          }.to raise_error
-        end
-
-        it "should remove from collection" do
-          artist.labels.should be_empty
-        end
-      end
-    end
-  end
-
-  context "when saving at the parent level" do
-
-    let!(:server) do
-      Server.new(name: "staging")
-    end
-
-    let!(:filesystem) do
-      server.filesystems.build
-    end
-
-    context "when the parent has an after create callback" do
-
-      before do
-        server.save
-      end
-
-      it "does not push the embedded documents twice" do
-        server.reload.filesystems.count.should eq(1)
-      end
-    end
-  end
-
-  context "when embedded documents are stored without ids" do
-
-    let!(:band) do
-      Band.create(name: "Moderat")
-    end
-
-    before do
-      band.collection.
-        find(_id: band.id).
-        update("$set" => { records: [{ name: "Moderat" }]})
-    end
-
-    context "when loading the documents" do
-
-      before do
-        band.reload
-      end
-
-      let(:record) do
-        band.records.first
-      end
-
-      it "creates proper documents from the db" do
-        record.name.should eq("Moderat")
-      end
-
-      it "assigns ids to the documents" do
-        record.id.should_not be_nil
-      end
-
-      context "when subsequently updating the documents" do
-
-        before do
-          record.update_attribute(:name, "Apparat")
-        end
-
-        it "updates the document" do
-          record.name.should eq("Apparat")
-        end
-
-        it "persists the change" do
-          record.reload.name.should eq("Apparat")
-        end
-      end
-    end
-  end
-
-  context "when embedded documents get marshalled" do
-
-    let(:person) do
-      Person.create
-    end
-
-    let!(:addresses) do
-      person.addresses
-    end
-
-    let!(:dumped) do
-      Marshal.dump(addresses)
-    end
-
-    let!(:loaded) do
-      Marshal.load(dumped)
-    end
-
-    it "keeps the proxy extensions when remarshalling" do
-      loaded.extension.should eq("Testing")
-    end
-  end
-end