mongoid 1.2.6 → 1.2.7

data/spec/unit/mongoid/collection_spec.rb

@@ -40,6 +40,36 @@ describe Mongoid::Collection do
     end
   end
 
+  describe "#directed" do
+
+    before do
+      slaves.expects(:empty?).returns(false)
+    end
+
+    context "when an enslave option is not passed" do
+
+      before do
+        Person.enslave
+      end
+
+      after do
+        Person.enslaved = false
+      end
+
+      it "uses the default" do
+        collection.directed.should == slaves
+      end
+    end
+
+    context "when an enslave option is passed" do
+
+      it "overwrites the default" do
+        collection.directed(:enslave => true).should == slaves
+      end
+    end
+
+  end
+
   describe "#find" do
 
     before do

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

@@ -19,7 +19,7 @@ describe Mongoid::Commands::DeleteAll do
 
       it "deletes each document that the criteria finds" do
         @klass.expects(:collection).returns(@collection)
-        @collection.expects(:remove).with(@conditions[:conditions].merge(:_type => "Person"))
+        @collection.expects(:remove).with(@conditions[:conditions].merge(:_type => "Person"), :safe => true)
         Mongoid::Commands::DeleteAll.execute(@klass, @conditions)
       end
 
@@ -33,7 +33,7 @@ describe Mongoid::Commands::DeleteAll do
 
       it "drops the collection" do
         @klass.expects(:collection).returns(@collection)
-        @collection.expects(:remove).with(:_type => "Person")
+        @collection.expects(:remove).with({ :_type => "Person" }, { :safe => true })
         Mongoid::Commands::DeleteAll.execute(@klass)
       end
 
@@ -47,7 +47,7 @@ describe Mongoid::Commands::DeleteAll do
 
       it "drops the collection" do
         @klass.expects(:collection).returns(@collection)
-        @collection.expects(:remove).with(:_type => "Person")
+        @collection.expects(:remove).with({ :_type => "Person" }, { :safe => true })
         Mongoid::Commands::DeleteAll.execute(@klass, {})
       end
 

data/spec/unit/mongoid/commands_spec.rb

@@ -37,6 +37,22 @@ describe Mongoid::Commands 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

data/spec/unit/mongoid/config_spec.rb

@@ -155,4 +155,11 @@ describe Mongoid::Config do
 
   end
 
+  describe "#use_object_ids" do
+
+    it "defaults to false" do
+      config.use_object_ids.should == false
+    end
+  end
+
 end

data/spec/unit/mongoid/contexts/enumerable_spec.rb

@@ -8,9 +8,10 @@ describe Mongoid::Contexts::Enumerable do
     @melbourne = Address.new(:number => 20, :street => "Bourke Street")
     @new_york = Address.new(:number => 20, :street => "Broadway")
     @docs = [ @london, @shanghai, @melbourne, @new_york ]
-    @selector = { :street => "Bourke Street" }
-    @options = { :fields => [ :number ] }
-    @context = Mongoid::Contexts::Enumerable.new(@selector, @options, @docs)
+    @criteria = Mongoid::Criteria.new(Address)
+    @criteria.documents = @docs
+    @criteria.where(:street => "Bourke Street").only(:number)
+    @context = Mongoid::Contexts::Enumerable.new(@criteria)
   end
 
   describe "#aggregate" do
@@ -40,6 +41,11 @@ describe Mongoid::Contexts::Enumerable do
 
   describe "#execute" do
 
+    before do
+      @criteria = Mongoid::Criteria.new(Address)
+      @criteria.documents = @docs
+    end
+
     it "returns the matching documents from the array" do
       @context.execute.should == [ @melbourne ]
     end
@@ -47,7 +53,8 @@ describe Mongoid::Contexts::Enumerable do
     context "when selector is empty" do
 
       before do
-        @context = Mongoid::Contexts::Enumerable.new({}, @options, @docs)
+        @criteria.only(:number)
+        @context = Mongoid::Contexts::Enumerable.new(@criteria)
       end
 
       it "returns all the documents" do
@@ -58,8 +65,8 @@ describe Mongoid::Contexts::Enumerable do
     context "when skip and limit are in the options" do
 
       before do
-        @options = { :skip => 2, :limit => 2 }
-        @context = Mongoid::Contexts::Enumerable.new({}, @options, @docs)
+        @criteria.skip(2).limit(2)
+        @context = Mongoid::Contexts::Enumerable.new(@criteria)
       end
 
       it "properly narrows down the matching results" do
@@ -67,6 +74,19 @@ describe Mongoid::Contexts::Enumerable do
       end
     end
 
+    context "when limit is set without skip in the options" do
+
+      before do
+        @criteria.limit(2)
+        @context = Mongoid::Contexts::Enumerable.new(@criteria)
+      end
+
+      it "properly narrows down the matching results" do
+        @context.execute.size.should == 2
+      end
+
+  end
+
   end
 
   describe "#first" do
@@ -105,7 +125,10 @@ describe Mongoid::Contexts::Enumerable do
     let(:documents) { [stub] }
 
     before do
-      @context = Mongoid::Contexts::Enumerable.new(selector, options, documents)
+      @criteria = Mongoid::Criteria.new(Address)
+      @criteria.documents = documents
+      @criteria.where(selector).skip(20)
+      @context = Mongoid::Contexts::Enumerable.new(@criteria)
     end
 
     it "sets the selector" do
@@ -160,7 +183,8 @@ describe Mongoid::Contexts::Enumerable do
 
       before do
         @criteria = Mongoid::Criteria.new(Person).extras({ :page => 5 })
-        @context = Mongoid::Contexts::Enumerable.new({}, @criteria.options, [])
+        @criteria.documents = []
+        @context = Mongoid::Contexts::Enumerable.new(@criteria)
       end
 
       it "returns the page option" do
@@ -173,7 +197,8 @@ describe Mongoid::Contexts::Enumerable do
 
       before do
         @criteria = Mongoid::Criteria.new(Person)
-        @context = Mongoid::Contexts::Enumerable.new({}, @criteria.options, [])
+        @criteria.documents = []
+        @context = Mongoid::Contexts::Enumerable.new(@criteria)
       end
 
       it "returns 1" do
@@ -188,7 +213,7 @@ describe Mongoid::Contexts::Enumerable do
 
     before do
       @criteria = Person.criteria.skip(2).limit(2)
-      @context = Mongoid::Contexts::Enumerable.new({}, @criteria.options, @docs)
+      @context = Mongoid::Contexts::Enumerable.new(@criteria)
       @results = @context.paginate
     end
 
@@ -212,7 +237,9 @@ describe Mongoid::Contexts::Enumerable do
     context "when a limit option does not exist" do
 
       before do
-        @context = Mongoid::Contexts::Enumerable.new({}, { :limit => 50 }, [])
+        @criteria = Person.criteria.limit(50)
+        @criteria.documents = []
+        @context = Mongoid::Contexts::Enumerable.new(@criteria)
       end
 
       it "returns the limit" do
@@ -231,4 +258,117 @@ describe Mongoid::Contexts::Enumerable do
 
   end
 
+  context "#id_criteria" do
+
+    let(:criteria) do
+      criteria = Mongoid::Criteria.new(Address)
+      criteria.documents = []
+      criteria
+    end
+    let(:context) { criteria.context }
+
+    context "with a single argument" do
+
+      let(:id) { Mongo::ObjectID.new.to_s }
+
+      before do
+        criteria.expects(:id).with(id).returns(criteria)
+      end
+
+      context "when the document is found" do
+
+        let(:document) { stub }
+
+        it "returns a matching document" do
+          context.expects(:one).returns(document)
+          document.expects(:blank? => false)
+          context.id_criteria(id).should == document
+        end
+
+      end
+
+      context "when the document is not found" do
+
+        it "raises an error" do
+          context.expects(:one).returns(nil)
+          lambda { context.id_criteria(id) }.should raise_error
+        end
+
+      end
+
+    end
+
+    context "multiple arguments" do
+
+      context "when an array of ids" do
+
+        let(:ids) do
+          (0..2).inject([]) { |ary, i| ary << Mongo::ObjectID.new.to_s }
+        end
+
+        context "when documents are found" do
+
+          let(:docs) do
+            (0..2).inject([]) { |ary, i| ary << stub }
+          end
+
+          before do
+            criteria.expects(:id).with(ids).returns(criteria)
+          end
+
+          it "returns matching documents" do
+            context.expects(:execute).returns(docs)
+            context.id_criteria(ids).should == docs
+          end
+
+        end
+
+        context "when documents are not found" do
+
+          it "raises an error" do
+            context.expects(:execute).returns([])
+            lambda { context.id_criteria(ids) }.should raise_error
+          end
+
+        end
+
+      end
+
+      context "when an array of object ids" do
+
+        let(:ids) do
+          (0..2).inject([]) { |ary, i| ary << Mongo::ObjectID.new }
+        end
+
+        context "when documents are found" do
+
+          let(:docs) do
+            (0..2).inject([]) { |ary, i| ary << stub }
+          end
+
+          before do
+            criteria.expects(:id).with(ids).returns(criteria)
+          end
+
+          it "returns matching documents" do
+            context.expects(:execute).returns(docs)
+            context.id_criteria(ids).should == docs
+          end
+
+        end
+
+        context "when documents are not found" do
+
+          it "raises an error" do
+            context.expects(:execute).returns([])
+            lambda { context.id_criteria(ids) }.should raise_error
+          end
+
+        end
+
+      end
+    end
+
+  end
+
 end

data/spec/unit/mongoid/contexts/mongo_spec.rb

@@ -5,9 +5,9 @@ describe Mongoid::Contexts::Mongo do
   describe "#aggregate" do
 
     before do
-      @selector = {}
-      @options = { :fields => [:field1] }
-      @context = Mongoid::Contexts::Mongo.new(@selector, @options, Person)
+      @criteria = Mongoid::Criteria.new(Person)
+      @criteria.only(:field1)
+      @context = Mongoid::Contexts::Mongo.new(@criteria)
     end
 
     context "when klass not provided" do
@@ -19,7 +19,7 @@ describe Mongoid::Contexts::Mongo do
       end
 
       it "calls group on the collection with the aggregate js" do
-        @collection.expects(:group).with([:field1], {}, {:count => 0}, @reduce, true)
+        @collection.expects(:group).with([:field1], {:_type => {'$in' => ['Doctor', 'Person']}}, {:count => 0}, @reduce, true)
         @context.aggregate
       end
 
@@ -30,9 +30,9 @@ describe Mongoid::Contexts::Mongo do
   describe "#count" do
 
     before do
-      @selector = { :_type => { "$in" => ["Doctor", "Person"] }, :test => "Testing" }
-      @options = {}
-      @context = Mongoid::Contexts::Mongo.new(@selector, @options, Person)
+      @criteria = Mongoid::Criteria.new(Person)
+      @criteria.where(:test => 'Testing')
+      @context = Mongoid::Contexts::Mongo.new(@criteria)
     end
 
     context "when criteria has not been executed" do
@@ -56,7 +56,7 @@ describe Mongoid::Contexts::Mongo do
       end
 
       it "returns the count from the cursor without creating the documents" do
-        @collection.expects(:find).with(@selector, {}).returns(@cursor)
+        @collection.expects(:find).with(@criteria.selector, {}).returns(@cursor)
         @cursor.expects(:count).returns(10)
         @context.count.should == 10
       end
@@ -74,7 +74,9 @@ describe Mongoid::Contexts::Mongo do
       @cursor = stub(:count => 500)
       @collection = mock
       @klass = stub(:collection => @collection, :hereditary => false, :instantiate => @person)
-      @context = Mongoid::Contexts::Mongo.new(selector, options, @klass)
+      @criteria = Mongoid::Criteria.new(@klass)
+      @criteria.where(selector).skip(20)
+      @context = Mongoid::Contexts::Mongo.new(@criteria)
     end
 
     it "calls find on the collection" do
@@ -97,7 +99,7 @@ describe Mongoid::Contexts::Mongo do
       context "when _type not in the field list" do
 
         before do
-          options[:fields] = [ :title ]
+          @criteria.only(:title)
           @expected_options = { :skip => 20, :fields => [ :title, :_type ] }
         end
 
@@ -115,10 +117,10 @@ describe Mongoid::Contexts::Mongo do
   describe "#group" do
 
     before do
-      @selector = { :_type => { "$in" => ["Doctor", "Person"] } }
-      @options = { :fields => [ :field1 ] }
+      @criteria = Mongoid::Criteria.new(Person)
+      @criteria.only(:field1)
       @grouping = [{ "title" => "Sir", "group" => [{ "title" => "Sir", "age" => 30, "_type" => "Person" }] }]
-      @context = Mongoid::Contexts::Mongo.new(@selector, @options, Person)
+      @context = Mongoid::Contexts::Mongo.new(@criteria)
     end
 
     context "when klass provided" do
@@ -130,7 +132,13 @@ describe Mongoid::Contexts::Mongo do
       end
 
       it "calls group on the collection with the aggregate js" do
-        @collection.expects(:group).with([:field1], {:_type => { "$in" => ["Doctor", "Person"] }}, {:group => []}, @reduce, true).returns(@grouping)
+        @collection.expects(:group).with(
+          [:field1],
+          {:_type => { "$in" => ["Doctor", "Person"] }},
+          {:group => []},
+          @reduce,
+          true
+        ).returns(@grouping)
         @context.group
       end
 
@@ -145,11 +153,13 @@ describe Mongoid::Contexts::Mongo do
     let(:klass) { Person }
 
     before do
-      @context = Mongoid::Contexts::Mongo.new(selector, options, klass)
+      @criteria = Mongoid::Criteria.new(klass)
+      @criteria.where(selector).skip(20)
+      @context = Mongoid::Contexts::Mongo.new(@criteria)
     end
 
     it "sets the selector" do
-      @context.selector.should == selector
+      @context.selector.should == @criteria.selector
     end
 
     it "sets the options" do
@@ -160,6 +170,9 @@ describe Mongoid::Contexts::Mongo do
       @context.klass.should == klass
     end
 
+    it "set the selector to query across the _type of the Criteria's klass when it is hereditary" do
+      @context.selector[:_type].should == {'$in' => Person._types}
+    end
   end
 
   describe "#last" do
@@ -172,10 +185,10 @@ describe Mongoid::Contexts::Mongo do
     context "when documents exist" do
 
       before do
-        @selector = {}
-        @options = { :sort => [[:title, :asc]] }
-        @context = Mongoid::Contexts::Mongo.new(@selector, @options, Person)
-        @collection.expects(:find_one).with(@selector, { :sort => [[:title, :desc]] }).returns(
+        @criteria = Mongoid::Criteria.new(Person)
+        @criteria.order_by([[:title, :asc]])
+        @context = Mongoid::Contexts::Mongo.new(@criteria)
+        @collection.expects(:find_one).with({:_type => {'$in' => ['Doctor', 'Person']}}, { :sort => [[:title, :desc]] }).returns(
           { "title" => "Sir", "_type" => "Person" }
         )
       end
@@ -189,10 +202,10 @@ describe Mongoid::Contexts::Mongo do
     context "when no documents exist" do
 
       before do
-        @selector = {}
-        @options = { :sort => [[:_id, :asc]] }
-        @context = Mongoid::Contexts::Mongo.new(@selector, @options, Person)
-        @collection.expects(:find_one).with(@selector, { :sort => [[:_id, :desc]] }).returns(nil)
+        @criteria = Mongoid::Criteria.new(Person)
+        @criteria.order_by([[:_id, :asc]])
+        @context = Mongoid::Contexts::Mongo.new(@criteria)
+        @collection.expects(:find_one).with({:_type => {'$in' => ['Doctor', 'Person']}}, { :sort => [[:_id, :desc]] }).returns(nil)
       end
 
       it "returns nil" do
@@ -204,10 +217,10 @@ describe Mongoid::Contexts::Mongo do
     context "when no sorting options provided" do
 
       before do
-        @selector = {}
-        @options = { :sort => [[:_id, :asc]] }
-        @context = Mongoid::Contexts::Mongo.new(@selector, @options, Person)
-        @collection.expects(:find_one).with(@selector, { :sort => [[:_id, :desc]] }).returns(
+        @criteria = Mongoid::Criteria.new(Person)
+        @criteria.order_by([[:_id, :asc]])
+        @context = Mongoid::Contexts::Mongo.new(@criteria)
+        @collection.expects(:find_one).with({:_type => {'$in' => ['Doctor', 'Person']}}, { :sort => [[:_id, :desc]] }).returns(
           { "title" => "Sir", "_type" => "Person" }
         )
       end
@@ -226,13 +239,14 @@ describe Mongoid::Contexts::Mongo do
       @reduce = Mongoid::Contexts::Mongo::MAX_REDUCE.gsub("[field]", "age")
       @collection = mock
       Person.expects(:collection).returns(@collection)
-      @context = Mongoid::Contexts::Mongo.new({}, {}, Person)
+      @criteria = Mongoid::Criteria.new(Person)
+      @context = Mongoid::Contexts::Mongo.new(@criteria)
     end
 
     it "calls group on the collection with the aggregate js" do
       @collection.expects(:group).with(
         nil,
-        {},
+        {:_type => {'$in' => ['Doctor', 'Person']}},
         {:max => "start"},
         @reduce,
         true
@@ -248,13 +262,14 @@ describe Mongoid::Contexts::Mongo do
       @reduce = Mongoid::Contexts::Mongo::MIN_REDUCE.gsub("[field]", "age")
       @collection = mock
       Person.expects(:collection).returns(@collection)
-      @context = Mongoid::Contexts::Mongo.new({}, {}, Person)
+      @criteria = Mongoid::Criteria.new(Person)
+      @context = Mongoid::Contexts::Mongo.new(@criteria)
     end
 
     it "calls group on the collection with the aggregate js" do
       @collection.expects(:group).with(
         nil,
-        {},
+        {:_type => {'$in' => ['Doctor', 'Person']}},
         {:min => "start"},
         @reduce,
         true
@@ -269,10 +284,10 @@ describe Mongoid::Contexts::Mongo do
     context "when documents exist" do
 
       before do
-        @collection = mock
         Person.expects(:collection).returns(@collection)
-        @context = Mongoid::Contexts::Mongo.new({}, {}, Person)
-        @collection.expects(:find_one).with({}, {}).returns(
+        @criteria = Mongoid::Criteria.new(Person)
+        @context = Mongoid::Contexts::Mongo.new(@criteria)
+        @collection.expects(:find_one).with({:_type => {'$in' => ['Doctor', 'Person']}}, {}).returns(
           { "title"=> "Sir", "_type" => "Person" }
         )
       end
@@ -288,8 +303,9 @@ describe Mongoid::Contexts::Mongo do
       before do
         @collection = mock
         Person.expects(:collection).returns(@collection)
-        @context = Mongoid::Contexts::Mongo.new({}, {}, Person)
-        @collection.expects(:find_one).with({}, {}).returns(nil)
+        @criteria = Mongoid::Criteria.new(Person)
+        @context = Mongoid::Contexts::Mongo.new(@criteria)
+        @collection.expects(:find_one).with({:_type => {'$in' => ['Doctor', 'Person']}}, {}).returns(nil)
       end
 
       it "returns nil" do
@@ -306,7 +322,7 @@ describe Mongoid::Contexts::Mongo do
 
       before do
         @criteria = Mongoid::Criteria.new(Person).extras({ :page => 5 })
-        @context = Mongoid::Contexts::Mongo.new({}, @criteria.options, Person)
+        @context = Mongoid::Contexts::Mongo.new(@criteria)
       end
 
       it "returns the page option" do
@@ -319,7 +335,7 @@ describe Mongoid::Contexts::Mongo do
 
       before do
         @criteria = Mongoid::Criteria.new(Person)
-        @context = Mongoid::Contexts::Mongo.new({}, @criteria.options, Person)
+        @context = Mongoid::Contexts::Mongo.new(@criteria)
       end
 
       it "returns 1" do
@@ -336,7 +352,7 @@ describe Mongoid::Contexts::Mongo do
       @collection = mock
       Person.expects(:collection).returns(@collection)
       @criteria = Person.where(:_id => "1").skip(60).limit(20)
-      @context = Mongoid::Contexts::Mongo.new(@criteria.selector, @criteria.options, Person)
+      @context = Mongoid::Contexts::Mongo.new(@criteria)
       @collection.expects(:find).with(
         {:_type => { "$in" => ["Doctor", "Person"] }, :_id => "1"}, :skip => 60, :limit => 20
       ).returns([])
@@ -357,14 +373,15 @@ describe Mongoid::Contexts::Mongo do
       before do
         @reduce = Mongoid::Contexts::Mongo::SUM_REDUCE.gsub("[field]", "age")
         @collection = mock
-        @context = Mongoid::Contexts::Mongo.new({}, {}, Person)
+        @criteria = Mongoid::Criteria.new(Person)
+        @context = Mongoid::Contexts::Mongo.new(@criteria)
         Person.expects(:collection).returns(@collection)
       end
 
       it "calls group on the collection with the aggregate js" do
         @collection.expects(:group).with(
           nil,
-          {},
+          {:_type => {'$in' => ['Doctor', 'Person']}},
           {:sum => "start"},
           @reduce,
           true
@@ -376,4 +393,113 @@ describe Mongoid::Contexts::Mongo do
 
   end
 
+  context "#id_criteria" do
+
+    let(:criteria) { Mongoid::Criteria.new(Person) }
+    let(:context) { criteria.context }
+
+    context "with a single argument" do
+
+      let(:id) { Mongo::ObjectID.new.to_s }
+
+      before do
+        criteria.expects(:id).with(id).returns(criteria)
+      end
+
+      context "when the document is found" do
+
+        let(:document) { stub }
+
+        it "returns a matching document" do
+          context.expects(:one).returns(document)
+          document.expects(:blank? => false)
+          context.id_criteria(id).should == document
+        end
+
+      end
+
+      context "when the document is not found" do
+
+        it "raises an error" do
+          context.expects(:one).returns(nil)
+          lambda { context.id_criteria(id) }.should raise_error
+        end
+
+      end
+
+    end
+
+    context "multiple arguments" do
+
+      context "when an array of ids" do
+
+        let(:ids) do
+          (0..2).inject([]) { |ary, i| ary << Mongo::ObjectID.new.to_s }
+        end
+
+        context "when documents are found" do
+
+          let(:docs) do
+            (0..2).inject([]) { |ary, i| ary << stub }
+          end
+
+          before do
+            criteria.expects(:id).with(ids).returns(criteria)
+          end
+
+          it "returns matching documents" do
+            context.expects(:execute).returns(docs)
+            context.id_criteria(ids).should == docs
+          end
+
+        end
+
+        context "when documents are not found" do
+
+          it "raises an error" do
+            context.expects(:execute).returns([])
+            lambda { context.id_criteria(ids) }.should raise_error
+          end
+
+        end
+
+      end
+
+      context "when an array of object ids" do
+
+        let(:ids) do
+          (0..2).inject([]) { |ary, i| ary << Mongo::ObjectID.new }
+        end
+
+        context "when documents are found" do
+
+          let(:docs) do
+            (0..2).inject([]) { |ary, i| ary << stub }
+          end
+
+          before do
+            criteria.expects(:id).with(ids).returns(criteria)
+          end
+
+          it "returns matching documents" do
+            context.expects(:execute).returns(docs)
+            context.id_criteria(ids).should == docs
+          end
+
+        end
+
+        context "when documents are not found" do
+
+          it "raises an error" do
+            context.expects(:execute).returns([])
+            lambda { context.id_criteria(ids) }.should raise_error
+          end
+
+        end
+
+      end
+    end
+
+  end
+
 end