mongoid 1.2.14 → 1.9.0

data/spec/unit/mongoid/commands/create_spec.rb

@@ -1,30 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Commands::Create do
-
-  describe "#execute" do
-
-    before do
-      @document = stub(:run_callbacks)
-    end
-
-    it "executes a save command" do
-      Mongoid::Commands::Save.expects(:execute).with(@document, true).returns(@document)
-      Mongoid::Commands::Create.execute(@document)
-    end
-
-    it "runs the before and after create callbacks" do
-      @document.expects(:run_callbacks).with(:before_create)
-      Mongoid::Commands::Save.expects(:execute).with(@document, true).returns(@document)
-      @document.expects(:run_callbacks).with(:after_create)
-      Mongoid::Commands::Create.execute(@document)
-    end
-
-    it "returns the document" do
-      Mongoid::Commands::Save.expects(:execute).with(@document, true).returns(@document)
-      Mongoid::Commands::Create.execute(@document).should == @document
-    end
-
-  end
-
-end

data/spec/unit/mongoid/commands/delete_all_spec.rb

@@ -1,58 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Commands::DeleteAll do
-
-  describe "#execute" do
-
-    before do
-      @doc = mock
-      @docs = [@doc]
-      @klass = stub(:name => "Person")
-    end
-
-    context "when conditions supplied" do
-
-      before do
-        @collection = mock
-        @conditions = { :conditions => { :title => "Sir" } }
-      end
-
-      it "deletes each document that the criteria finds" do
-        @klass.expects(:collection).returns(@collection)
-        @collection.expects(:remove).with(@conditions[:conditions].merge(:_type => "Person"), :safe => true)
-        Mongoid::Commands::DeleteAll.execute(@klass, @conditions)
-      end
-
-    end
-
-    context "when no conditions supplied" do
-
-      before do
-        @collection = mock
-      end
-
-      it "drops the collection" do
-        @klass.expects(:collection).returns(@collection)
-        @collection.expects(:remove).with({ :_type => "Person" }, { :safe => true })
-        Mongoid::Commands::DeleteAll.execute(@klass)
-      end
-
-    end
-
-    context "when empty conditions supplied" do
-
-      before do
-        @collection = mock
-      end
-
-      it "drops the collection" do
-        @klass.expects(:collection).returns(@collection)
-        @collection.expects(:remove).with({ :_type => "Person" }, { :safe => true })
-        Mongoid::Commands::DeleteAll.execute(@klass, {})
-      end
-
-    end
-
-  end
-
-end

data/spec/unit/mongoid/commands/delete_spec.rb

@@ -1,38 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Commands::Delete do
-
-  describe "#execute" do
-
-    before do
-      @collection = mock
-      @document = stub(:collection => @collection, :id => "1", :_parent => false)
-    end
-
-    it "removes the document from its collection" do
-      @collection.expects(:remove).with({ :_id => @document.id })
-      Mongoid::Commands::Delete.execute(@document)
-    end
-
-    it "sets the destroyed flag to true" do
-      @collection.expects(:remove).with({ :_id => @document.id }).returns(true)
-      @document.expects(:destroyed=).with(true)
-      Mongoid::Commands::Delete.execute(@document)
-    end
-
-    context "when the document is embedded" do
-
-      before do
-        @parent = Person.new
-        @address = Address.new(:street => "Genoa Pl")
-        @parent.addresses << @address
-      end
-
-      it "removes the document from the parent attributes" do
-        @parent.addresses.should == [@address]
-        Mongoid::Commands::Delete.execute(@address)
-        @parent.addresses.should be_empty
-      end
-    end
-  end
-end

data/spec/unit/mongoid/commands/destroy_all_spec.rb

@@ -1,23 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Commands::DestroyAll do
-
-  describe "#execute" do
-
-    before do
-      @doc = mock
-      @docs = [@doc]
-      @klass = stub(:name => "Person")
-      @conditions = { :conditions => { :title => "Sir" } }
-      @expected = { :conditions => { :title => "Sir", :_type => "Person" } }
-    end
-
-    it "destroys each document that the criteria finds" do
-      @klass.expects(:find).with(:all, @expected).returns(@docs)
-      Mongoid::Commands::Destroy.expects(:execute).with(@doc)
-      Mongoid::Commands::DestroyAll.execute(@klass, @conditions)
-    end
-
-  end
-
-end

data/spec/unit/mongoid/commands/destroy_spec.rb

@@ -1,50 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Commands::Destroy do
-
-  describe "#execute" do
-
-    before do
-      @collection = stub_everything
-      @document = stub(:run_callbacks => true,
-                       :collection => @collection,
-                       :id => "1",
-                       :_parent => false)
-    end
-
-    it "runs the before and after destroy callbacks" do
-      @document.expects(:run_callbacks).with(:before_destroy)
-      @document.expects(:run_callbacks).with(:after_destroy)
-      Mongoid::Commands::Destroy.execute(@document)
-    end
-
-    it "removes the document from its collection" do
-      @collection.expects(:remove).with({ :_id => @document.id })
-      Mongoid::Commands::Destroy.execute(@document)
-    end
-
-    it "sets the destroy flag on the document" do
-      @collection.expects(:remove).with({ :_id => @document.id }).returns(true)
-      @document.expects(:destroyed=).with(true)
-      Mongoid::Commands::Destroy.execute(@document)
-    end
-
-    context "when the document is embedded" do
-
-      before do
-        @parent = Person.new
-        @address = Address.new(:street => "Genoa Pl")
-        @parent.addresses << @address
-        @collection = mock
-        Person.expects(:collection).returns(@collection)
-      end
-
-      it "removes the document from the parent attributes" do
-        @parent.addresses.should == [@address]
-        @collection.expects(:save).returns(true)
-        Mongoid::Commands::Destroy.execute(@address)
-        @parent.addresses.should be_empty
-      end
-    end
-  end
-end

data/spec/unit/mongoid/commands/save_spec.rb

@@ -1,105 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Commands::Save do
-
-  describe "#execute" do
-
-    before do
-      @parent_collection = stub(:save => true)
-      @doc_collection = stub(:save => true)
-      @parent = stub(:collection => @parent_collection,
-                     :valid? => true,
-                     :run_callbacks => true,
-                     :_parent => nil,
-                     :raw_attributes => {},
-                     :new_record= => false)
-      @document = stub(:collection => @doc_collection,
-                       :run_callbacks => true,
-                       :_parent => @parent,
-                       :raw_attributes => {},
-                       :new_record= => false)
-    end
-
-    context "when document is valid" do
-
-      before do
-        @document.expects(:valid?).returns(true)
-      end
-
-      it "runs the before and after callbacks" do
-        @document.expects(:run_callbacks).with(:before_save)
-        @document.expects(:run_callbacks).with(:after_save)
-        Mongoid::Commands::Save.execute(@document)
-      end
-
-      it "returns true" do
-        Mongoid::Commands::Save.execute(@document).should be_true
-      end
-
-      context "when the document has a parent" do
-
-        it "executes a save on the parent" do
-          @parent_collection.expects(:save).with(@parent.raw_attributes, :safe => true)
-          Mongoid::Commands::Save.execute(@document)
-        end
-
-      end
-
-      context "when the document has no parent" do
-
-        before do
-          @document.expects(:_parent).returns(nil)
-        end
-
-        it "calls save on the document collection" do
-          @doc_collection.expects(:save).with(@document.raw_attributes, :safe => true)
-          Mongoid::Commands::Save.execute(@document)
-        end
-
-      end
-
-    end
-
-    context "when document is invalid" do
-
-      before do
-        @document.expects(:valid?).returns(false)
-      end
-
-      it "returns false" do
-        Mongoid::Commands::Save.execute(@document).should be_false
-      end
-
-    end
-
-    context "when saving without validation" do
-
-      before do
-        @document.stubs(:valid?).returns(false)
-      end
-
-      it "ignores validation and returns true" do
-        Mongoid::Commands::Save.execute(@document, false).should be_true
-      end
-
-    end
-
-  end
-
-  context "when the document is embedded" do
-
-    before do
-      @child_name = Name.new(:first_name => "Testy")
-    end
-
-    context "when parent reference does not exist" do
-
-      it "raises an error" do
-        lambda { @child_name.save }.should raise_error
-      end
-
-    end
-
-  end
-
-end

data/spec/unit/mongoid/commands_spec.rb

@@ -1,275 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Commands do
-
-  before do
-    @person = Person.new(:_id => Mongo::ObjectID.new.to_s)
-  end
-
-  describe "#delete" do
-
-    it "delegates to the Delete command" do
-      Mongoid::Commands::Delete.expects(:execute).with(@person)
-      @person.delete
-    end
-
-  end
-
-  describe "#destroy" do
-
-    it "delegates to the Destroy command" do
-      Mongoid::Commands::Destroy.expects(:execute).with(@person)
-      @person.destroy
-    end
-
-  end
-
-  describe "#save" do
-
-    it "delegates to the Save command" do
-      Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(true)
-      @person.save
-    end
-
-    context "when document is new" do
-
-      before do
-        @person = Person.new
-      end
-
-      context "when validation fails" do
-
-        it "it raises an error" do
-          Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(false)
-          @person.save.should be_false
-        end
-
-        it "should run callback before_create and no after_create" do
-          @person.expects(:run_callbacks).with(:before_create)
-          Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(false)
-          @person.expects(:run_callbacks).with(:after_create).never
-          @person.save.should be_false
-        end
-
-      end
-
-      it "delegates to the save command" do
-        Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(true)
-        @person.save
-      end
-
-      it "runs the before and after create callbacks" do
-        @person.expects(:run_callbacks).with(:before_create)
-        Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(true)
-        @person.expects(:run_callbacks).with(:after_create)
-        @person.save
-      end
-
-    end
-
-    context "when not validating" do
-
-      before do
-        @person = Person.new
-      end
-
-      it "passes the validate param to the command" do
-        Mongoid::Commands::Save.expects(:execute).with(@person, false).returns(true)
-        @person.save(false)
-      end
-
-    end
-
-    context "when the database raises an error" do
-
-      before do
-        @person = Person.new
-      end
-
-      it "lets the error bubble up" do
-        Mongoid::Commands::Save.expects(:execute).raises(Mongo::OperationFailure.new("Operation Failed"))
-        lambda { @person.save }.should raise_error
-      end
-
-    end
-
-  end
-
-  describe "#save!" do
-
-    context "when validation passes" do
-
-      it "it returns the person" do
-        Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(true)
-        @person.save!
-      end
-
-    end
-
-    context "when validation fails" do
-
-      it "it raises an error" do
-        Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(false)
-        lambda { @person.save! }.should raise_error
-      end
-
-    end
-
-    context "when document is new" do
-
-      before do
-        @person = Person.new
-      end
-
-      it "delegates to the save command" do
-        Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(true)
-        @person.save!
-      end
-
-      context "when validation fails" do
-
-        it "it raises an error " do
-          Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(false)
-          lambda { @person.save! }.should raise_error
-        end
-
-      end
-
-      it "runs the before and after create callbacks" do
-        @person.expects(:run_callbacks).with(:before_create)
-        Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(true)
-        @person.expects(:run_callbacks).with(:after_create)
-        @person.save!
-      end
-
-    end
-
-  end
-
-  describe "#update_attributes" do
-
-    it "delegates to the Save command" do
-      Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(true)
-      @person.update_attributes({})
-    end
-
-    it "executes the before and after update callbacks" do
-      @person.expects(:run_callbacks).with(:before_update)
-      Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(true)
-      @person.expects(:run_callbacks).with(:after_update)
-      @person.update_attributes({})
-    end
-
-  end
-
-  describe "#update_attributes!" do
-
-    context "when validation passes" do
-
-      it "it returns the person" do
-        Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(true)
-        @person.update_attributes({}).should be_true
-      end
-
-    end
-
-    context "when validation fails" do
-
-      it "it raises an error" do
-        Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(false)
-        lambda { @person.update_attributes!({}) }.should raise_error
-      end
-
-    end
-
-  end
-
-  describe ".create" do
-
-    it "delegates to the Create command" do
-      Mongoid::Commands::Create.expects(:execute)
-      Person.create
-    end
-
-    it "returns the document" do
-      Mongoid::Commands::Create.expects(:execute).returns(Person.new)
-      Person.create.should_not be_nil
-    end
-
-    context "when the database raises an error" do
-
-      before do
-        @person = Person.new
-        Mongoid::Commands::Save.expects(:execute).raises(Mongo::OperationFailure.new("Operation Failed"))
-      end
-
-      it "lets the error bubble up" do
-        lambda { Person.create }.should raise_error
-      end
-
-    end
-
-  end
-
-  describe ".create!" do
-
-    it "delegates to the Create command" do
-      Mongoid::Commands::Create.expects(:execute).returns(Person.new)
-      Person.create!
-    end
-
-    it "returns the document" do
-      Mongoid::Commands::Create.expects(:execute).returns(Person.new)
-      Person.create!.should_not be_nil
-    end
-
-    context "when validation fails" do
-
-      it "raises an error" do
-        person = stub(:errors => stub(:empty? => false))
-        Mongoid::Commands::Create.expects(:execute).returns(person)
-        lambda { Person.create! }.should raise_error(Mongoid::Errors::Validations)
-      end
-
-    end
-
-  end
-
-  describe ".delete_all" do
-
-    it "delegates to the DeleteAll command" do
-      Mongoid::Commands::DeleteAll.expects(:execute).with(Person, {})
-      Person.delete_all
-    end
-
-  end
-
-  describe ".destroy_all" do
-
-    it "delegates to the DestroyAll command" do
-      Mongoid::Commands::DestroyAll.expects(:execute).with(Person, {})
-      Person.destroy_all
-    end
-
-  end
-
-  describe "#valid?" do
-
-    before do
-      @comment = Comment.new
-    end
-
-    it "validates the document" do
-      @comment.valid?.should be_false
-    end
-
-    it "runs the validation callbacks" do
-      @comment.expects(:run_callbacks).with(:validate)
-      @comment.expects(:run_callbacks).with(:before_validation)
-      @comment.expects(:run_callbacks).with(:after_validation)
-      @comment.valid?
-    end
-
-  end
-
-end