mongoid-pre 2.0.0.beta1

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

@@ -0,0 +1,148 @@
+require "spec_helper"
+
+describe Mongoid::Persistence::Update do
+
+  let(:document) do
+    Patient.new(:_id => Mongo::ObjectID.new.to_s)
+  end
+
+  let(:address) do
+    Address.new(:_id => Mongo::ObjectID.new.to_s, :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(: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
+
+    it "sets the options" do
+      update.options.should ==
+        { :multi => false, :safe => Mongoid.persist_in_safe_mode }
+    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
+
+    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
+    end
+
+    context "when the document is not changed" do
+
+      it "returns true" do
+        update.persist.should == true
+      end
+    end
+  end
+end

data/spec/unit/mongoid/persistence_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe Mongoid::Persistence do
+
+  let(:person) do
+    Person.new
+  end
+
+  describe "#insert" do
+
+    let(:insert) do
+      stub.quacks_like(Mongoid::Persistence::Insert.allocate)
+    end
+
+    before do
+      Mongoid::Persistence::Insert.expects(:new).with(person).returns(insert)
+    end
+
+    it "delegates to the insert persistence command" do
+      insert.expects(:persist).returns(person)
+      person.insert.should == person
+    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).returns(update)
+    end
+
+    it "delegates to the update persistence command" do
+      update.expects(:persist).returns(true)
+      person.update.should == true
+    end
+  end
+end

data/spec/unit/mongoid/scope_spec.rb

@@ -0,0 +1,240 @@
+require "spec_helper"
+
+describe Mongoid::Scope do
+
+  before do
+    Person.delete_all
+  end
+
+  describe "#==" do
+
+    before do
+      @scope = Mongoid::Scope.new(Person, {})
+    end
+
+    context "when other is a scope" do
+
+      context "when the parent and conditions match" do
+
+        before do
+          @other = Mongoid::Scope.new(Person, {})
+        end
+
+        it "returns true" do
+          @scope.should == @other
+        end
+
+      end
+
+      context "when the conditions do not match" do
+
+        before do
+          @other = Mongoid::Scope.new(Person, { :where => { :field => "value" } })
+        end
+
+        it "returns false" do
+          @scope.should_not == @other
+        end
+      end
+
+    end
+
+    context "when other is an enumerable" do
+
+      context "when the array contents are equal" do
+
+        before do
+          @other = []
+        end
+
+        it "returns true" do
+          @scope.should == @other
+        end
+
+      end
+
+      context "when the array contents are not equal" do
+
+        before do
+          @other = [ stub ]
+        end
+
+        it "returns false" do
+          @scope.should_not == @other
+        end
+
+      end
+    end
+
+    context "when other is an invalid type" do
+
+      it "returns false" do
+        Mongoid::Scope.new(Person, {}).should_not == stub
+      end
+
+    end
+
+  end
+
+  describe ".initialize" do
+
+    before do
+      @parent = Mongoid::Scope.new(Person, {})
+    end
+
+    context "when parent is another scope" do
+
+      before do
+        @scope = Mongoid::Scope.new(@parent, {})
+      end
+
+      it "does not set the class" do
+        @scope.klass.should be_nil
+      end
+
+    end
+
+    context "when parent is a class" do
+
+      before do
+        @scope = Mongoid::Scope.new(Person, {})
+      end
+
+      it "returns the parent class" do
+        @scope.klass.should == Person
+      end
+
+    end
+
+    context "when a block is passed in" do
+
+      before do
+        @scope = Mongoid::Scope.new(Person, {}) do
+          def extended
+            "extended"
+          end
+        end
+      end
+
+      it "extends the block" do
+        @scope.extended.should == "extended"
+      end
+
+    end
+
+  end
+
+  describe "#method_missing" do
+
+    context "when a scope has been defined for the name" do
+
+      before do
+        @defined = mock
+        @class = mock
+        @class.expects(:scopes).twice.returns({ :testing => @defined })
+        @scope = Mongoid::Scope.new(@class, {})
+      end
+
+      it "calls the matching scope" do
+        @defined.expects(:call).with(@scope, "Testing").returns(true)
+        @scope.testing("Testing").should be_true
+      end
+
+    end
+
+    context "when a scope is not defined for the name" do
+
+      context "when the scope is the parent" do
+
+        before do
+          @target = mock
+          @scope = Mongoid::Scope.new(Person, {})
+          @scope.instance_variable_set("@target", @target)
+        end
+
+        it "sends the call to the target" do
+          @target.expects(:testing).with("Testing").returns(true)
+          @scope.testing("Testing").should be_true
+        end
+
+      end
+
+      context "when the scope is not the parent" do
+
+        before do
+          @parent = mock
+          @criteria = mock
+          @parent.expects(:scopes).returns({})
+          @parent.expects(:is_a?).with(Mongoid::Scope).returns(true)
+          @parent.expects(:fuse)
+          @scope = Mongoid::Scope.new(@parent, {})
+        end
+
+        it "creates a criteria from the parent scope" do
+          @parent.expects(:testing).returns(true)
+          @scope.testing.should be_true
+        end
+
+      end
+
+    end
+
+  end
+
+  describe "#respond_to?" do
+
+    context "when parent is a class" do
+
+      before do
+        @scope = Mongoid::Scope.new(Person, {})
+      end
+
+      it "delegates to the target" do
+        @scope.respond_to?(:only).should be_true
+      end
+
+    end
+
+    context "when parent is a scope" do
+
+      before do
+        @parent = Mongoid::Scope.new(Person, {})
+        @scope = Mongoid::Scope.new(@parent, {})
+      end
+
+      it "delegates to the parent" do
+        @scope.respond_to?(:only).should be_true
+      end
+
+    end
+
+  end
+
+  describe "#scopes" do
+
+    before do
+      @parent = mock
+      @scope = Mongoid::Scope.new(@parent, {})
+    end
+
+    it "delegates to the parent" do
+      @parent.expects(:scopes).returns({})
+      @scope.scopes.should == {}
+    end
+
+  end
+
+  describe "#target" do
+
+    before do
+      @scope = Mongoid::Scope.new(Person, { :where => { :title => "Sir" } })
+    end
+
+    it "returns the conditions criteria" do
+      @scope.target.selector.should ==
+        { :title => "Sir" }
+    end
+
+  end
+
+end

data/spec/unit/mongoid/state_spec.rb

@@ -0,0 +1,83 @@
+require "spec_helper"
+
+describe Mongoid::State do
+
+  describe "#new_record?" do
+
+    context "when the object has been saved" do
+
+      before do
+        @person = Person.new(:_id => "1")
+      end
+
+      it "returns false" do
+        @person.new_record?.should be_false
+      end
+
+    end
+
+    context "when the object has not been saved" do
+
+      before do
+        @person = Person.new
+      end
+
+      it "returns true" do
+        @person.new_record?.should be_true
+      end
+
+    end
+
+  end
+
+  describe "#persisted?" do
+
+    before do
+      @person = Person.new
+    end
+
+    it "delegates to new_record?" do
+      @person.persisted?.should be_false
+    end
+  end
+
+  describe "destroyed?" do
+
+    before do
+      @person = Person.new
+    end
+
+    context "when destroyed is true" do
+
+      before do
+        @person.destroyed = true
+      end
+
+      it "returns true" do
+        @person.destroyed?.should be_true
+      end
+    end
+
+    context "when destroyed is false" do
+
+      before do
+        @person.destroyed = false
+      end
+
+      it "returns true" do
+        @person.destroyed?.should be_false
+      end
+    end
+
+    context "when destroyed is nil" do
+
+      before do
+        @person.destroyed = nil
+      end
+
+      it "returns false" do
+        @person.destroyed?.should be_false
+      end
+    end
+  end
+end