mongoid 3.1.6 → 4.0.0

data/spec/mongoid/persistence/operations/embedded/insert_spec.rb

@@ -1,191 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Persistence::Operations::Embedded::Insert do
-
-  let(:document) do
-    Patient.new(title: "Mr")
-  end
-
-  let(:address) do
-    Address.new(street: "Oxford St")
-  end
-
-  let(:collection) do
-    stub("collection")
-  end
-
-  let(:email) do
-    Email.new(address: "test@example.com")
-  end
-
-  before do
-    document.stub(:collection).and_return(collection)
-  end
-
-  let(:query) do
-    stub
-  end
-
-  before(:all) do
-    Mongoid.identity_map_enabled = true
-  end
-
-  after(:all) do
-    Mongoid.identity_map_enabled = false
-  end
-
-  describe "#persist" do
-
-    context "when the insert succeeded" do
-
-      let(:person) do
-        Person.create
-      end
-
-      let(:address) do
-        person.addresses.create(street: "Hobrechtstr")
-      end
-
-      let(:in_map) do
-        Mongoid::IdentityMap.get(Address, address.id)
-      end
-
-      it "does not put the document in the identity map" do
-        in_map.should be_nil
-      end
-    end
-
-    context "when no parent is set" do
-
-      let(:address) do
-        Address.new
-      end
-
-      let(:insert) do
-        described_class.new(address)
-      end
-
-      it "raises an error" do
-        expect {
-          insert.persist
-        }.to raise_error(Mongoid::Errors::NoParent)
-      end
-    end
-
-    def root_insert_expectation
-      ->{
-        collection.should_receive(:insert).with(
-          document.raw_attributes
-        ).and_return("Object")
-      }
-    end
-
-    def root_push_expectation
-      ->{
-        collection.should_receive(:find).with({ "_id" => document.id }).and_return(query)
-        query.should_receive(:update).with(
-          { "$push" => { "addresses" => address.raw_attributes }}
-        ).and_return("Object")
-      }
-    end
-
-    def root_set_expectation
-      ->{
-        collection.should_receive(:find).with({ "_id" => document.id }).and_return(query)
-        query.should_receive(:update).with(
-          { "$set" => { "email" => email.raw_attributes } }
-        ).and_return("Object")
-      }
-    end
-
-    context "when the embedded document is an embeds_one" do
-
-      before do
-        document.email = email
-      end
-
-      context "when the parent is new" do
-
-        let(:insert) do
-          described_class.new(email)
-        end
-
-        it "notifies its changes to parent and inserts the parent" do
-          root_insert_expectation.call
-          insert.persist.should eq(email)
-        end
-      end
-
-      context "when the parent is not new" do
-
-        let(:insert) do
-          described_class.new(email)
-        end
-
-        before do
-          document.instance_variable_set(:@new_record, false)
-        end
-
-        it "performs an in place $set on the embedded document" do
-          root_set_expectation.call
-          insert.persist.should eq(email)
-        end
-      end
-    end
-
-    context "when the embedded document is an embeds_many" do
-
-      before do
-        document.addresses << address
-      end
-
-      context "when the parent is new" do
-
-        let(:insert) do
-          described_class.new(address)
-        end
-
-        it "notifies its changes to the parent and inserts the parent" do
-          root_insert_expectation.call
-          insert.persist.should eq(address)
-        end
-
-        it "sets new_record to false" do
-          root_insert_expectation.call
-          insert.persist.new_record?.should be_false
-        end
-      end
-
-      context "when the parent is not new" do
-
-        let(:insert) do
-          described_class.new(address)
-        end
-
-        before do
-          document.instance_variable_set(:@new_record, false)
-        end
-
-        it "performs a $push on the embedded array" do
-          root_push_expectation.call
-          insert.persist.should eq(address)
-        end
-
-        context "when we add the parent to the child" do
-
-          let(:other_address) do
-            document.addresses.build(street: "Oxford St")
-          end
-
-          it "performs a $push on the embedded array" do
-            collection.should_receive(:find).with({ "_id" => document.id }).and_return(query)
-            query.should_receive(:update).with(
-              { "$push" => { "addresses" => other_address.raw_attributes } }
-            ).and_return("Object")
-            described_class.new(other_address).persist.should eq(other_address)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/mongoid/persistence/operations/embedded/remove_spec.rb

@@ -1,8 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Persistence::Operations::Remove do
-
-  before do
-  end
-
-end

data/spec/mongoid/persistence/operations/insert_spec.rb

@@ -1,149 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Persistence::Operations::Insert do
-
-  before(:all) do
-    Mongoid.identity_map_enabled = true
-  end
-
-  after(:all) do
-    Mongoid.identity_map_enabled = false
-  end
-
-  let(:document) do
-    Patient.new(title: "Mr")
-  end
-
-  let(:address) do
-    Address.new(street: "Oxford St")
-  end
-
-  let(:collection) do
-    stub("collection")
-  end
-
-  let(:query) do
-    stub
-  end
-
-  before do
-    document.stub(:collection).and_return(collection)
-  end
-
-  describe "#persist" do
-
-    context "when the insert succeeded" do
-
-      let(:person) do
-        Person.create
-      end
-
-      let(:in_map) do
-        Mongoid::IdentityMap.get(Person, person.id)
-      end
-
-      it "puts the document in the identity map" do
-        in_map.should eq(person)
-      end
-    end
-  end
-
-  describe "#initialize" do
-
-    let(:insert) do
-      described_class.new(document)
-    end
-
-    it "sets the document" do
-      insert.document.should eq(document)
-    end
-
-    it "sets the collection" do
-      insert.collection.should eq(document.collection)
-    end
-
-    it "defaults validation to true" do
-      insert.should be_validating
-    end
-
-    it "sets the options" do
-      insert.options.should be_empty
-    end
-  end
-
-  describe "#persist" do
-
-    def root_set_expectation
-      ->{
-        collection.should_receive(:insert).with(
-          document.raw_attributes
-        ).and_return("Object")
-      }
-    end
-
-    def root_push_expectation
-      ->{
-        collection.should_receive(:find).with({ "_id" => document.id }).and_return(query)
-        query.should_receive(:update).with(
-          { "addresses" => { "$push" => address.raw_attributes } }
-        ).and_return("Object")
-      }
-    end
-
-    let(:insert) do
-      described_class.new(document)
-    end
-
-    context "when the document is valid" do
-
-      it "inserts the new document" do
-        root_set_expectation.call
-        insert.persist
-      end
-
-      it "returns the document" do
-        root_set_expectation.call
-        insert.persist.should eq(document)
-      end
-
-      it "sets new_record to false" do
-        root_set_expectation.call
-        insert.persist
-        document.new_record?.should be_false
-      end
-    end
-
-    context "when the document is not valid" do
-
-      before do
-        document.stub(:valid?).and_return(false)
-      end
-
-      it "returns the document" do
-        insert.persist.should eq(document)
-      end
-
-      it "leaves the document as a new record" do
-        insert.persist
-        document.new_record?.should be_true
-      end
-    end
-
-    context "when not validating" do
-
-      before do
-        insert.instance_variable_set(:@validating, false)
-      end
-
-      after do
-        insert.instance_variable_set(:@validating, true)
-      end
-
-      it "inserts the document in the database" do
-        root_set_expectation.call
-        insert.persist
-        document.new_record?.should be_false
-      end
-    end
-  end
-end

data/spec/mongoid/persistence/operations/remove_spec.rb

@@ -1,113 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Persistence::Operations::Remove do
-
-  let(:document) do
-    Patient.new(title: "Mr")
-  end
-
-  let(:address) do
-    Address.new(street: "Oxford St")
-  end
-
-  let(:collection) do
-    stub("collection")
-  end
-
-  let(:query) do
-    stub
-  end
-
-  before do
-    document.stub(:collection).and_return(collection)
-  end
-
-  describe "#initialize" do
-
-    let(:remove) do
-      described_class.new(document)
-    end
-
-    it "sets the document" do
-      remove.document.should eq(document)
-    end
-
-    it "sets the collection" do
-      remove.collection.should eq(document.collection)
-    end
-
-    it "defaults validation to true" do
-      remove.should be_validating
-    end
-  end
-
-  describe "#persist" do
-
-    def root_delete_expectation
-      ->{
-        collection.should_receive(:find).with({ "_id" => document.id }).and_return(query)
-        query.should_receive(:remove).and_return(true)
-      }
-    end
-
-    let(:remove) do
-      described_class.new(document)
-    end
-
-    context "when the document is a root document" do
-
-      it "removes the document from the collection" do
-        root_delete_expectation.call
-        remove.persist.should be_true
-      end
-    end
-  end
-
-  describe "#persist" do
-
-    context "when the remove succeeded" do
-
-      let!(:person) do
-        Person.create
-      end
-
-      before do
-        person.delete
-      end
-
-      let(:in_map) do
-        Mongoid::IdentityMap.get(Person, person.id)
-      end
-
-      it "removes the document from the identity map" do
-        in_map.should be_nil
-      end
-    end
-  end
-
-  context "when a dependent option exists" do
-
-    context "when accessing the parent before destroy" do
-
-      let(:artist) do
-        Artist.create(name: "depeche mode")
-      end
-
-      let!(:album) do
-        artist.albums.create
-      end
-
-      before do
-        artist.destroy
-      end
-
-      it "allows the access" do
-        artist.name.should eq("destroyed")
-      end
-
-      it "destroys the associated document" do
-        album.should be_destroyed
-      end
-    end
-  end
-end

data/spec/mongoid/persistence/operations/update_spec.rb

@@ -1,141 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Persistence::Operations::Update do
-
-  let(:document) do
-    Patient.instantiate("_id" => Moped::BSON::ObjectId.new)
-  end
-
-  let(:address) do
-    Address.instantiate("_id" => "oxford-st", "street" => "Oxford St")
-  end
-
-  let(:root_category) do
-    RootCategory.instantiate("_id" => Moped::BSON::ObjectId.new.to_s)
-  end
-
-  let(:category) do
-    Category.instantiate("_id" => Moped::BSON::ObjectId.new.to_s, "name" => 'Programming')
-  end
-
-  let(:collection) do
-    stub("collection")
-  end
-
-  let(:query) do
-    stub
-  end
-
-  before do
-    document.stub(:collection).and_return(collection)
-    root_category.stub(:collection).and_return(collection)
-  end
-
-  describe "#initialize" do
-
-    let(:update) do
-      described_class.new(document)
-    end
-
-    it "sets the document" do
-      update.document.should eq(document)
-    end
-
-    it "sets the collection" do
-      update.collection.should eq(document.collection)
-    end
-
-    it "defaults validation to true" do
-      update.should be_validating
-    end
-  end
-
-  describe "#persist" do
-
-    def root_set_expectation
-      ->{
-        collection.should_receive(:find).with({ "_id" => document.id }).and_return(query)
-        query.should_receive(:update).with({ "$set" => document.setters }).and_return("Object")
-      }
-    end
-
-    def embedded_set_expectation
-      ->{
-        collection.should_receive(:find).with(
-          { "_id" => document.id, "addresses._id" => "oxford-st" }
-        ).and_return(query)
-        query.should_receive(:update).with("$set" => { "addresses.$.city" => "London" }).and_return("Object")
-      }
-    end
-
-    let(:update) do
-      described_class.new(document)
-    end
-
-    context "when the document is changed" do
-
-      before do
-        document.title = "Sir"
-      end
-
-      context "when the document is valid" do
-
-        it "performs a $set for changed fields" do
-          root_set_expectation.call
-          update.persist.should be_true
-        end
-
-        it "moves the changed fields to previously changed" do
-          root_set_expectation.call
-          update.persist
-          document.changed?.should be_false
-        end
-
-      end
-
-      context "when the document is not valid" do
-
-        before do
-          document.stub(:valid?).and_return(false)
-        end
-
-        it "returns false" do
-          update.persist.should be_false
-        end
-      end
-
-      context "when not validating" do
-
-        before do
-          update.instance_variable_set(:@validating, false)
-        end
-
-        after do
-          update.instance_variable_set(:@validating, true)
-        end
-
-        it "updates the document in the database" do
-          root_set_expectation.call
-          update.persist.should be_true
-        end
-      end
-
-      context "when the document is embedded" do
-
-        let(:embedded) do
-          described_class.new(address)
-        end
-
-        before do
-          document.addresses << address
-          address.city = "London"
-        end
-
-        it "performs a $set for the embedded changed fields" do
-          embedded_set_expectation.call
-          embedded.persist
-        end
-      end
-    end
-  end
-end

data/spec/mongoid/persistence/operations/upsert_spec.rb

@@ -1,59 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Persistence::Operations::Upsert do
-
-  describe "#persist" do
-
-    context "when the document is new" do
-
-      let(:band) do
-        Band.new
-      end
-
-      let(:upsert) do
-        described_class.new(band)
-      end
-
-      let!(:persisted) do
-        upsert.persist
-      end
-
-      it "inserts the document in the database" do
-        band.reload.should eq(band)
-      end
-
-      it "returns true" do
-        persisted.should be_true
-      end
-
-      it "runs the upsert callbacks" do
-        band.upserted.should be_true
-      end
-    end
-
-    context "when the document is not new" do
-
-      let(:band) do
-        Band.create.tap do |b|
-          b.name = "Tool"
-        end
-      end
-
-      let(:upsert) do
-        described_class.new(band)
-      end
-
-      let!(:persisted) do
-        upsert.persist
-      end
-
-      it "updates the document in the database" do
-        band.reload.name.should eq("Tool")
-      end
-
-      it "returns true" do
-        persisted.should be_true
-      end
-    end
-  end
-end