mongoid-locomotive 2.0.0.beta9

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

@@ -0,0 +1,89 @@
+require "spec_helper"
+
+describe Mongoid::Persistence::Remove do
+
+  let(:document) do
+    Patient.new(:title => "Mr")
+  end
+
+  let(:address) do
+    Address.new(:street => "Oxford St")
+  end
+
+  let(:collection) do
+    stub.quacks_like(Mongoid::Collection.allocate)
+  end
+
+  before do
+    document.stubs(:collection).returns(collection)
+  end
+
+  describe "#initialize" do
+
+    let(:remove) do
+      Mongoid::Persistence::Remove.new(document)
+    end
+
+    it "sets the document" do
+      remove.document.should == document
+    end
+
+    it "sets the collection" do
+      remove.collection.should == document.collection
+    end
+
+    it "defaults validation to true" do
+      remove.validate.should == true
+    end
+
+    it "sets the options" do
+      remove.options.should ==
+        { :safe => Mongoid.persist_in_safe_mode }
+    end
+  end
+
+  describe "#persist" do
+
+    def root_delete_expectation
+      lambda {
+        collection.expects(:remove).with(
+          { :_id => document.id },
+          :safe => true
+        ).returns(true)
+      }
+    end
+
+    let(:remove) do
+      Mongoid::Persistence::Remove.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 == true
+      end
+    end
+
+    context "when the document is embedded" do
+
+      before do
+        document.addresses << address
+      end
+
+      let(:remove) do
+        Mongoid::Persistence::Remove.new(address)
+      end
+
+      let(:persister) do
+        stub.quacks_like(Mongoid::Persistence::RemoveEmbedded.allocate)
+      end
+
+      it "delegates to the embedded persister" do
+        Mongoid::Persistence::RemoveEmbedded.expects(:new).with(address, true).returns(persister)
+        persister.expects(:persist).returns(true)
+        remove.persist.should == true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,177 @@
+require "spec_helper"
+
+describe Mongoid::Persistence::Update do
+
+  let(:document) do
+    Patient.instantiate("_id" => BSON::ObjectID.new)
+  end
+
+  let(:address) do
+    Address.instantiate("_id" => "oxford-st", "street" => "Oxford St")
+  end
+
+  let(:root_category) do
+    RootCategory.instantiate("_id" => BSON::ObjectID.new.to_s)
+  end
+
+  let(:category) do
+    Category.instantiate("_id" => BSON::ObjectID.new.to_s, "name" => 'Programming')
+  end
+
+  let(:collection) do
+    stub.quacks_like(Mongoid::Collection.allocate)
+  end
+
+  before do
+    document.stubs(:collection).returns(collection)
+    root_category.stubs(:collection).returns(collection)
+  end
+
+  describe "#initialize" do
+
+    let(:update) do
+      Mongoid::Persistence::Update.new(document)
+    end
+
+    it "sets the document" do
+      update.document.should == document
+    end
+
+    it "sets the collection" do
+      update.collection.should == document.collection
+    end
+
+    it "defaults validation to true" do
+      update.validate.should == true
+    end
+  end
+
+  describe "#persist" do
+
+    def root_set_expectation
+      lambda {
+        collection.expects(:update).with(
+          { "_id" => document.id },
+          { "$set" => document.setters },
+          :multi => false,
+          :safe => true
+        ).returns("Object")
+      }
+    end
+
+    def embedded_set_expectation
+      lambda {
+        collection.expects(:update).with(
+          { "_id" => document.id, "addresses._id" => address.id },
+          { "$set" => address.setters },
+          :multi => false,
+          :safe => true
+        ).returns("Object")
+      }
+    end
+
+    def tree_set_expectation
+      lambda {
+        collection.expects(:update).with(
+          { "_id" => root_category.id, "categories._id" => category.id, "categories.0.categories._id" => leaf_category.id },
+          { "$set" => leaf_category.setters },
+          :multi => false,
+          :safe => true
+        ).returns("Object")
+      }
+    end
+
+    let(:update) do
+      Mongoid::Persistence::Update.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 == true
+        end
+
+        it "moves the changed fields to previously changed" do
+          root_set_expectation.call
+          update.persist
+          document.changed?.should == false
+        end
+
+      end
+
+      context "when the document is not valid" do
+
+        before do
+          document.stubs(:valid?).returns(false)
+        end
+
+        it "returns false" do
+          update.persist.should == false
+        end
+      end
+
+      context "when not validating" do
+
+        before do
+          update.instance_variable_set(:@validate, false)
+          document.stubs(:valid?).returns(false)
+        end
+
+        after do
+          update.instance_variable_set(:@validate, true)
+        end
+
+        it "updates the document in the database" do
+          root_set_expectation.call
+          update.persist.should == true
+        end
+      end
+
+      context "when the document is embedded" do
+
+        let(:embedded) do
+          Mongoid::Persistence::Update.new(address)
+        end
+
+        before do
+          # TODO: What to do about composite keys?
+          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
+
+      context "when the document is a tree" do
+        let(:leaf_category) do
+          Category.instantiate("_id" => BSON::ObjectID.new, "name" => 'Ruby')
+        end
+
+        let(:embedded) do
+          Mongoid::Persistence::Update.new(leaf_category)
+        end
+
+        before do
+          category.categories << leaf_category
+          root_category.categories << category
+          leaf_category.name = 'C++'
+        end
+
+        it "performs a $set for the embedded changed fields" do
+          tree_set_expectation.call
+          embedded.persist
+        end
+      end
+    end
+  end
+end

data/spec/unit/mongoid/persistence_spec.rb

@@ -0,0 +1,452 @@
+require "spec_helper"
+
+describe Mongoid::Persistence do
+
+  let(:person) do
+    Person.new
+  end
+
+  describe ".create" do
+
+    let(:insert) do
+      stub.quacks_like(Mongoid::Persistence::Insert.allocate)
+    end
+
+    let(:patient) do
+      stub.quacks_like(Patient.allocate)
+    end
+
+    before do
+      Patient.expects(:new).returns(patient)
+      patient.expects(:insert).returns(patient)
+    end
+
+    it "delegates to the insert persistence command" do
+      Patient.create
+    end
+
+    it "returns the new document" do
+      Patient.create.should == patient
+    end
+  end
+
+  describe ".create!" do
+
+    let(:insert) do
+      stub.quacks_like(Mongoid::Persistence::Insert.allocate)
+    end
+
+    let(:patient) do
+      stub.quacks_like(Patient.allocate)
+    end
+
+    before do
+      Patient.expects(:new).returns(patient)
+      patient.expects(:insert).returns(patient)
+    end
+
+    context "when validation passes" do
+
+      before do
+        patient.expects(:errors).returns([])
+      end
+
+      it "returns the new document" do
+        Patient.create!.should == patient
+      end
+    end
+
+    context "when validation fails" do
+
+      before do
+        errors = stub(:any? => true, :full_messages => [ "Message" ])
+        patient.expects(:errors).at_least_once.returns(errors)
+      end
+
+      it "raises an error" do
+        lambda { Patient.create! }.should raise_error(Mongoid::Errors::Validations)
+      end
+    end
+  end
+
+  describe ".delete_all" do
+
+    context "when conditions provided" do
+
+      let(:remove_all) do
+        stub.quacks_like(Mongoid::Persistence::RemoveAll.allocate)
+      end
+
+      before do
+        Mongoid::Persistence::RemoveAll.expects(:new).with(
+          Person, false, { :field => "value" }
+        ).returns(remove_all)
+        remove_all.expects(:persist).returns(30)
+      end
+
+      it "removes all documents from the collection for the conditions" do
+        Person.delete_all(:conditions => { :field => "value" })
+      end
+
+      it "returns the number of documents removed" do
+        Person.delete_all(:conditions => { :field => "value" }).should == 30
+      end
+    end
+
+    context "when conditions not provided" do
+
+      let(:remove_all) do
+        stub.quacks_like(Mongoid::Persistence::RemoveAll.allocate)
+      end
+
+      before do
+        Mongoid::Persistence::RemoveAll.expects(:new).with(Person, false, {}).returns(remove_all)
+        remove_all.expects(:persist).returns(30)
+      end
+
+      it "removes all documents from the collection" do
+        Person.delete_all
+      end
+
+      it "returns the number of documents removed" do
+        Person.delete_all.should == 30
+      end
+    end
+  end
+
+  describe ".destroy_all" do
+
+    let(:remove) do
+      stub.quacks_like(Mongoid::Persistence::Remove.allocate)
+    end
+
+    context "when conditions provided" do
+
+      before do
+        Person.expects(:all).with(:conditions => { :title => "Sir" }).returns([ person ])
+        person.expects(:run_callbacks).with(:destroy).yields
+        Mongoid::Persistence::Remove.expects(:new).with(person).returns(remove)
+        remove.expects(:persist).returns(true)
+      end
+
+      it "destroys each found document" do
+        Person.destroy_all(:conditions => { :title => "Sir" })
+      end
+
+      it "returns the number destroyed" do
+        Person.destroy_all(:conditions => { :title => "Sir" }).should == 1
+      end
+    end
+
+    context "when conditions not provided" do
+
+      before do
+        Person.expects(:all).with({}).returns([ person ])
+        person.expects(:run_callbacks).with(:destroy).yields
+        Mongoid::Persistence::Remove.expects(:new).with(person).returns(remove)
+        remove.expects(:persist).returns(true)
+      end
+
+      it "destroys each found document" do
+        Person.destroy_all
+      end
+
+      it "returns the number destroyed" do
+        Person.destroy_all.should == 1
+      end
+    end
+  end
+
+  describe "#delete" do
+
+    let(:remove) do
+      stub.quacks_like(Mongoid::Persistence::Remove.allocate)
+    end
+
+    before do
+      Mongoid::Persistence::Remove.expects(:new).with(person).returns(remove)
+    end
+
+    it "delegates to the remove persistence command" do
+      remove.expects(:persist).returns(true)
+      person.delete.should == true
+    end
+  end
+
+  describe "#destroy" do
+
+    let(:remove) do
+      stub.quacks_like(Mongoid::Persistence::Remove.allocate)
+    end
+
+    before do
+      Mongoid::Persistence::Remove.expects(:new).with(person).returns(remove)
+    end
+
+    it "delegates to the remove persistence command" do
+      person.expects(:run_callbacks).with(:destroy).yields.returns(true)
+      remove.expects(:persist).returns(true)
+      person.destroy.should == true
+    end
+  end
+
+  describe "#insert" do
+
+    let(:insert) do
+      stub.quacks_like(Mongoid::Persistence::Insert.allocate)
+    end
+
+    before do
+      Mongoid::Persistence::Insert.expects(:new).with(person, true).returns(insert)
+    end
+
+    it "delegates to the insert persistence command" do
+      insert.expects(:persist).returns(person)
+      person.insert.should == person
+    end
+  end
+
+  describe "#_remove" do
+
+    let(:remove) do
+      stub.quacks_like(Mongoid::Persistence::Remove.allocate)
+    end
+
+    before do
+      Mongoid::Persistence::Remove.expects(:new).with(person).returns(remove)
+    end
+
+    it "delegates to the remove persistence command" do
+      remove.expects(:persist).returns(true)
+      person._remove.should == true
+    end
+  end
+
+  describe "#save" do
+
+    context "when the document is new" do
+
+      let(:insert) do
+        stub.quacks_like(Mongoid::Persistence::Insert.allocate)
+      end
+
+      before do
+        Mongoid::Persistence::Insert.expects(:new).with(person, true).returns(insert)
+      end
+
+      it "delegates to the insert persistence command" do
+        insert.expects(:persist).returns(person)
+        person.save
+      end
+
+      it "returns a boolean" do
+        person.expects(:persisted?).returns(true)
+        insert.expects(:persist).returns(person)
+        person.save.should == true
+      end
+    end
+
+    context "when the document is not new" do
+
+      let(:update) do
+        stub.quacks_like(Mongoid::Persistence::Update.allocate)
+      end
+
+      before do
+        person.instance_variable_set(:@new_record, false)
+        Mongoid::Persistence::Update.expects(:new).with(person, true).returns(update)
+      end
+
+      it "delegates to the update persistence command" do
+        update.expects(:persist).returns(true)
+        person.save
+      end
+
+      it "returns a boolean" do
+        update.expects(:persist).returns(true)
+        person.save.should == true
+      end
+    end
+  end
+
+  describe "#save!" do
+
+    context "when validation passes" do
+
+      let(:update) do
+        stub.quacks_like(Mongoid::Persistence::Update.allocate)
+      end
+
+      before do
+        person.instance_variable_set(:@new_record, false)
+        Mongoid::Persistence::Update.expects(:new).with(person, true).returns(update)
+        update.expects(:persist).returns(true)
+      end
+
+      it "returns true" do
+        person.save!.should == true
+      end
+    end
+
+    context "when validation failes" do
+
+      let(:update) do
+        stub.quacks_like(Mongoid::Persistence::Update.allocate)
+      end
+
+      before do
+        person.instance_variable_set(:@new_record, false)
+        Mongoid::Persistence::Update.expects(:new).with(person, true).returns(update)
+        update.expects(:persist).returns(false)
+      end
+
+      it "raises an error" do
+        lambda { person.save! }.should raise_error(Mongoid::Errors::Validations)
+      end
+    end
+  end
+
+  describe "#update" do
+
+    let(:update) do
+      stub.quacks_like(Mongoid::Persistence::Update.allocate)
+    end
+
+    before do
+      Mongoid::Persistence::Update.expects(:new).with(person, true).returns(update)
+    end
+
+    it "delegates to the update persistence command" do
+      update.expects(:persist).returns(true)
+      person.update.should == true
+    end
+  end
+
+  describe "#update_attributes" do
+
+    let(:update) do
+      stub.quacks_like(Mongoid::Persistence::Update.allocate)
+    end
+
+    before do
+      person.instance_variable_set(:@new_record, false)
+      Mongoid::Persistence::Update.expects(:new).with(person, true).returns(update)
+    end
+
+    it "writes attributes and performs an update" do
+      update.expects(:persist).returns(true)
+      person.update_attributes(:title => "Mam")
+      person.title.should == "Mam"
+    end
+  end
+
+  describe "#update_attributes!" do
+
+    let(:update) do
+      stub.quacks_like(Mongoid::Persistence::Update.allocate)
+    end
+
+    before do
+      person.instance_variable_set(:@new_record, false)
+      Mongoid::Persistence::Update.expects(:new).with(person, true).returns(update)
+    end
+
+    context "when validation passes" do
+
+      it "writes attributes and performs an update" do
+        update.expects(:persist).returns(true)
+        person.update_attributes!(:title => "Mam").should be_true
+        person.title.should == "Mam"
+      end
+    end
+
+    context "when validation fails" do
+
+      it "raises an error" do
+        update.expects(:persist).returns(false)
+        lambda {
+          person.update_attributes!(:title => "Mam")
+        }.should raise_error(Mongoid::Errors::Validations)
+      end
+    end
+  end
+
+  describe "#upsert" do
+
+    context "when passing a hash as a validation parameter" do
+
+      let(:insert) do
+        stub.quacks_like(Mongoid::Persistence::Insert.allocate)
+      end
+
+      before do
+        Mongoid::Persistence::Insert.expects(:new).with(person, false).returns(insert)
+      end
+
+      it "delegates to the insert persistence command" do
+        insert.expects(:persist).returns(person)
+        person.upsert(:validate => false)
+      end
+    end
+
+    context "when the document is new" do
+
+      let(:insert) do
+        stub.quacks_like(Mongoid::Persistence::Insert.allocate)
+      end
+
+      context "when validation passes" do
+
+        before do
+          Mongoid::Persistence::Insert.expects(:new).with(person, true).returns(insert)
+        end
+
+        it "delegates to the insert persistence command" do
+          person.expects(:persisted?).returns(true)
+          insert.expects(:persist).returns(person)
+          person.upsert
+        end
+
+        it "returns a boolean" do
+          person.expects(:persisted?).returns(true)
+          insert.expects(:persist).returns(person)
+          person.upsert.should == true
+        end
+      end
+
+      context "when validation fails" do
+
+        before do
+          Mongoid::Persistence::Insert.expects(:new).with(person, true).returns(insert)
+        end
+
+        it "returns false" do
+          insert.expects(:persist).returns(person)
+          person.upsert.should == false
+        end
+      end
+    end
+
+    context "when the document is not new" do
+
+      let(:update) do
+        stub.quacks_like(Mongoid::Persistence::Update.allocate)
+      end
+
+      before do
+        person.instance_variable_set(:@new_record, false)
+        Mongoid::Persistence::Update.expects(:new).with(person, true).returns(update)
+      end
+
+      it "delegates to the update persistence command" do
+        update.expects(:persist).returns(true)
+        person.upsert
+      end
+
+      it "returns a boolean" do
+        update.expects(:persist).returns(true)
+        person.upsert.should == true
+      end
+    end
+  end
+end