mongoid-pre 2.0.0.beta1 → 2.0.0.pre

data/spec/unit/mongoid/criteria_spec.rb

@@ -120,19 +120,6 @@ describe Mongoid::Criteria do
 
   end
 
-  describe "#avg" do
-
-    before do
-      @context = stub.quacks_like(Mongoid::Contexts::Mongo.allocate)
-      @criteria.instance_variable_set(:@context, @context)
-    end
-
-    it "delegates to the context" do
-      @context.expects(:avg).with(:age)
-      @criteria.avg(:age)
-    end
-  end
-
   describe "#blank?" do
 
     before do
@@ -140,10 +127,10 @@ describe Mongoid::Criteria do
       @criteria.instance_variable_set(:@context, @context)
     end
 
-    context "when the context is blank" do
+    context "when the count is 0" do
 
       before do
-        @context.expects(:blank?).returns(true)
+        @context.expects(:count).returns(0)
       end
 
       it "returns true" do
@@ -151,10 +138,10 @@ describe Mongoid::Criteria do
       end
     end
 
-    context "when the context is not blank" do
+    context "when the count is greater than 0" do
 
       before do
-        @context.expects(:blank?).returns(false)
+        @context.expects(:count).returns(10)
       end
 
       it "returns false" do
@@ -185,7 +172,9 @@ describe Mongoid::Criteria do
       end
 
       it "creates a new context" do
-        Mongoid::Contexts::Mongo.expects(:new).with(@criteria).returns(@context)
+        Mongoid::Contexts::Mongo.expects(:new).with(
+          @criteria.selector, @criteria.options, @criteria.klass
+        ).returns(@context)
         @criteria.context.should == @context
       end
 
@@ -213,19 +202,6 @@ describe Mongoid::Criteria do
 
   end
 
-  describe "#distinct" do
-
-    before do
-      @context = stub.quacks_like(Mongoid::Contexts::Mongo.allocate)
-      @criteria.instance_variable_set(:@context, @context)
-    end
-
-    it "delegates to the context" do
-      @context.expects(:distinct).with(:title)
-      @criteria.distinct(:title)
-    end
-  end
-
   describe "#entries" do
 
     context "filtering" do
@@ -269,7 +245,7 @@ describe Mongoid::Criteria do
         criteria = Mongoid::Criteria.new(Person)
         collection = mock
         Person.expects(:collection).returns(collection)
-        collection.expects(:find).with(criteria.selector, criteria.options).returns([])
+        collection.expects(:find).with(@criteria.selector, @criteria.options).returns([])
         criteria.entries.should == []
       end
 
@@ -300,13 +276,6 @@ describe Mongoid::Criteria do
       @cursor = stub(:count => 10)
     end
 
-    it "delegates to the context#iterate" do
-      @context = stub('context')
-      @criteria.stubs(:context).returns(@context)
-      @context.expects(:iterate)
-      @criteria.each
-    end
-
     context "when the criteria has not been executed" do
 
       before do
@@ -351,12 +320,7 @@ describe Mongoid::Criteria do
 
       before do
         Person.expects(:collection).returns(@collection)
-        @collection.expects(:find).with(
-          { :_type => { "$in" => ["Doctor", "Person"] },
-            :title => "Sir"
-          },
-          { :cache => true }
-        ).returns(@cursor)
+        @collection.expects(:find).with({ :_type => { "$in" => ["Doctor", "Person"] }, :title => "Sir" }, {}).returns(@cursor)
         @cursor.expects(:each).yields(@person)
         @criteria.cache
         @criteria.each do |doc|
@@ -408,22 +372,22 @@ describe Mongoid::Criteria do
 
   describe "#initialize" do
 
-    let(:criteria) { Mongoid::Criteria.new(Person) }
+    context "when class is hereditary" do
 
-    it "sets the selector to an empty hash" do
-      criteria.selector.should == {}
-    end
+      it "sets the _type value on the selector" do
+        criteria = Mongoid::Criteria.new(Person)
+        criteria.selector.should == { :_type => { "$in" => ["Doctor", "Person"] } }
+      end
 
-    it "sets the options to an empty hash" do
-      criteria.options.should == {}
     end
 
-    it "sets the documents to an empty array" do
-      criteria.documents.should == []
-    end
+    context "when class is not hereditary" do
+
+      it "sets no _type value on the selector" do
+        criteria = Mongoid::Criteria.new(Game)
+        criteria.selector.should == {}
+      end
 
-    it "sets the klass to the given class" do
-      criteria.klass.should == Person
     end
 
   end
@@ -469,7 +433,7 @@ describe Mongoid::Criteria do
         before do
           @other = Mongoid::Criteria.new(Person)
           @other.where(:name => "Chloe").order_by([[:name, :asc]])
-          @selector = { :title => "Sir", :age => 30, :name => "Chloe" }
+          @selector = { :_type => { "$in" => ["Doctor", "Person"] }, :title => "Sir", :age => 30, :name => "Chloe" }
           @options = { :skip => 40, :limit => 20, :sort => [[:name, :asc]] }
         end
 
@@ -485,7 +449,7 @@ describe Mongoid::Criteria do
 
         before do
           @other = Mongoid::Criteria.new(Person)
-          @selector = { :title => "Sir", :age => 30 }
+          @selector = { :_type => { "$in" => ["Doctor", "Person"] }, :title => "Sir", :age => 30 }
           @options = { :skip => 40, :limit => 20 }
         end
 
@@ -525,7 +489,7 @@ describe Mongoid::Criteria do
 
     it "merges the criteria with the next one" do
       @new_criteria = @criteria.accepted
-      @new_criteria.selector.should == { :title => "Sir", :terms => true }
+      @new_criteria.selector.should == { :_type => { "$in" => ["Doctor", "Person"] }, :title => "Sir", :terms => true }
     end
 
     context "chaining more than one scope" do
@@ -535,7 +499,8 @@ describe Mongoid::Criteria do
       end
 
       it "returns the final merged criteria" do
-        @criteria.selector.should == { :title => "Sir", :terms => true, :age => { "$gt" => 50 } }
+        @criteria.selector.should ==
+          { :_type => { "$in" => ["Doctor", "Person"] }, :title => "Sir", :terms => true, :age => { "$gt" => 50 } }
       end
 
     end
@@ -651,7 +616,8 @@ describe Mongoid::Criteria do
     end
 
     it "returns the selector plus the options" do
-      @criteria.scoped.should == { :where => { :title => "Sir" }, :skip => 20 }
+      @criteria.scoped.should ==
+        { :where => { :title => "Sir", :_type=>{ "$in" => [ "Doctor", "Person" ] } }, :skip => 20 }
     end
 
   end
@@ -674,35 +640,29 @@ describe Mongoid::Criteria do
 
     context "with a single argument" do
 
-      context "when the arg is a string" do
-
-        before do
-          @id = Mongo::ObjectID.new.to_s
-          @document = stub
-          @criteria = mock
-          Mongoid::Criteria.expects(:new).returns(@criteria)
-        end
+      before do
+        @id = Mongo::ObjectID.new.to_s
+        @document = stub
+        @criteria = mock
+        Mongoid::Criteria.expects(:new).returns(@criteria)
+        @criteria.expects(:id).with(@id).returns(@criteria)
+      end
 
-        it "delegates to #id_criteria" do
-          @criteria.expects(:id_criteria).with(@id).returns(@document)
-          Mongoid::Criteria.translate(Person, @id).should == @document
-        end
+      it "creates a criteria for a string" do
+        @criteria.expects(:one).returns(@document)
+        @document.expects(:blank? => false)
+        Mongoid::Criteria.translate(Person, @id)
       end
 
-      context "when the arg is an object id" do
+      context "when the document is not found" do
 
-        before do
-          @id = Mongo::ObjectID.new
-          @document = stub
-          @criteria = mock
-          Mongoid::Criteria.expects(:new).returns(@criteria)
+        it "raises an error" do
+          @criteria.expects(:one).returns(nil)
+          lambda { Mongoid::Criteria.translate(Person, @id) }.should raise_error
         end
 
-        it "delegates to #id_criteria" do
-          @criteria.expects(:id_criteria).with(@id).returns(@document)
-          Mongoid::Criteria.translate(Person, @id).should == @document
-        end
       end
+
     end
 
     context "multiple arguments" do
@@ -716,41 +676,52 @@ describe Mongoid::Criteria do
             @ids << Mongo::ObjectID.new.to_s
             @documents << stub
           end
-          @criteria = mock
-          Mongoid::Criteria.expects(:new).returns(@criteria)
-        end
+          @collection = stub
+          Person.expects(:collection).returns(@collection)
+        end
+
+        context "when documents are found" do
+
+          it "returns an ids criteria" do
+            @collection.expects(:find).with(
+              { :_type =>
+                { "$in" =>
+                  ["Doctor", "Person"]
+                },
+                :_id =>
+                { "$in" => @ids }
+            }, {}).returns([{ "_id" => "4", "title" => "Sir", "_type" => "Person" }])
+            @criteria = Mongoid::Criteria.translate(Person, @ids)
+          end
 
-        it "delegates to #id_criteria" do
-          @criteria.expects(:id_criteria).with(@ids).returns(@documents)
-          Mongoid::Criteria.translate(Person, @ids).should == @documents
         end
 
-      end
+        context "when documents are not found" do
 
-      context "when Person, :conditions => {}" do
-
-        before do
-          @criteria = Mongoid::Criteria.translate(Person, :conditions => { :title => "Test" })
-        end
-
-        it "returns a criteria with a selector from the conditions" do
-          @criteria.selector.should == { :title => "Test" }
-        end
+          it "returns an ids criteria" do
+            @collection.expects(:find).with(
+              { :_type =>
+                { "$in" =>
+                  ["Doctor", "Person"]
+                },
+                :_id =>
+                { "$in" => @ids }
+            }, {}).returns([])
+            lambda { Mongoid::Criteria.translate(Person, @ids) }.should raise_error
+          end
 
-        it "returns a criteria with klass Person" do
-          @criteria.klass.should == Person
         end
 
       end
 
-      context "when Person, :conditions => {:id => id}" do
+      context "when Person, :conditions => {}" do
 
         before do
-          @criteria = Mongoid::Criteria.translate(Person, :conditions => { :id => "1234e567" })
+          @criteria = Mongoid::Criteria.translate(Person, :conditions => { :title => "Test" })
         end
 
         it "returns a criteria with a selector from the conditions" do
-          @criteria.selector.should == { :_id => "1234e567" }
+          @criteria.selector.should == { :_type => { "$in" => ["Doctor", "Person"] }, :title => "Test" }
         end
 
         it "returns a criteria with klass Person" do
@@ -766,7 +737,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns a criteria with a selector from the conditions" do
-          @criteria.selector.should == { :title => "Test" }
+          @criteria.selector.should == { :_type => { "$in" => ["Doctor", "Person"] }, :title => "Test" }
         end
 
         it "returns a criteria with klass Person" do
@@ -782,7 +753,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns a criteria with a selector from the conditions" do
-          @criteria.selector.should == { :title => "Test" }
+          @criteria.selector.should == { :_type => { "$in" => ["Doctor", "Person"] }, :title => "Test" }
         end
 
         it "returns a criteria with klass Person" do
@@ -797,7 +768,7 @@ describe Mongoid::Criteria do
         end
 
         it "adds the criteria and the options" do
-          @criteria.selector.should == { :title => "Test" }
+          @criteria.selector.should == { :_type => { "$in" => ["Doctor", "Person"] }, :title => "Test" }
           @criteria.options.should == { :skip => 10 }
         end
 

data/spec/unit/mongoid/criterion/exclusion_spec.rb

@@ -12,7 +12,10 @@ describe Mongoid::Criterion::Exclusion do
     it "adds the $ne query to the selector" do
       @criteria.excludes(:title => "Bad Title", :text => "Bad Text")
       @criteria.selector.should ==
-        {
+        { :_type =>
+            { "$in" =>
+              ["Doctor", "Person"]
+            },
           :title =>
             { "$ne" => "Bad Title"},
           :text =>
@@ -29,7 +32,10 @@ describe Mongoid::Criterion::Exclusion do
       it "accepts id" do
         @criteria.excludes(:id => "1")
         @criteria.selector.should ==
-          {
+          { :_type =>
+              { "$in" =>
+                ["Doctor", "Person"]
+              },
             :_id => { "$ne" => "1" }
           }
       end
@@ -37,7 +43,10 @@ describe Mongoid::Criterion::Exclusion do
       it "accepts _id" do
         @criteria.excludes(:_id => "1")
         @criteria.selector.should ==
-          {
+          { :_type =>
+              { "$in" =>
+                ["Doctor", "Person"]
+              },
             :_id => { "$ne" => "1" }
           }
       end
@@ -51,6 +60,7 @@ describe Mongoid::Criterion::Exclusion do
     it "adds the exclusion to the selector" do
       @criteria.not_in(:title => ["title1", "title2"], :text => ["test"])
       @criteria.selector.should == {
+        :_type => { "$in" => ["Doctor", "Person"] },
         :title => { "$nin" => ["title1", "title2"] },
         :text => { "$nin" => ["test"] }
       }

data/spec/unit/mongoid/criterion/inclusion_spec.rb

@@ -12,7 +12,7 @@ describe Mongoid::Criterion::Inclusion do
     it "adds the $all query to the selector" do
       @criteria.all(:title => ["title1", "title2"])
       @criteria.selector.should ==
-        {
+        { :_type => { "$in" => ["Doctor", "Person"] },
           :title => { "$all" => ["title1", "title2"] }
         }
     end
@@ -30,7 +30,7 @@ describe Mongoid::Criterion::Inclusion do
       it "adds the clause to the selector" do
         @criteria.and(:title => "Title", :text => "Text")
         @criteria.selector.should ==
-          {
+          { :_type => { "$in" => ["Doctor", "Person"] },
             :title => "Title",
             :text => "Text"
           }
@@ -43,7 +43,7 @@ describe Mongoid::Criterion::Inclusion do
       it "adds the $where clause to the selector" do
         @criteria.and("this.date < new Date()")
         @criteria.selector.should ==
-          {
+          { :_type => { "$in" => ["Doctor", "Person"] },
             "$where" => "this.date < new Date()"
           }
       end
@@ -61,16 +61,10 @@ describe Mongoid::Criterion::Inclusion do
     it "adds the $in clause to the selector" do
       @criteria.in(:title => ["title1", "title2"], :text => ["test"])
       @criteria.selector.should ==
-        {
-          :title => { "$in" => ["title1", "title2"] }, :text => { "$in" => ["test"] }
-        }
-    end
-
-    it "#any_in is aliased to #in" do
-      @criteria.any_in(:title => ["title1", "title2"], :text => ["test"])
-      @criteria.selector.should ==
-        {
-          :title => { "$in" => ["title1", "title2"] }, :text => { "$in" => ["test"] }
+        { :_type =>
+          { "$in" =>
+            ["Doctor", "Person"]
+          }, :title => { "$in" => ["title1", "title2"] }, :text => { "$in" => ["test"] }
         }
     end
 
@@ -89,7 +83,7 @@ describe Mongoid::Criterion::Inclusion do
         it "adds the clause to the selector" do
           @criteria.where(:title => "Title", :text => "Text")
           @criteria.selector.should ==
-            { :title => "Title", :text => "Text" }
+            { :_type => { "$in" => ["Doctor", "Person"] }, :title => "Title", :text => "Text" }
         end
 
       end
@@ -101,7 +95,7 @@ describe Mongoid::Criterion::Inclusion do
           it "returns those matching an all clause" do
             @criteria.where(:title.all => ["Sir"])
             @criteria.selector.should ==
-              { :title => { "$all" => ["Sir"] } }
+              { :_type => { "$in" => ["Doctor", "Person"] }, :title => { "$all" => ["Sir"] } }
           end
 
         end
@@ -111,7 +105,7 @@ describe Mongoid::Criterion::Inclusion do
           it "returns those matching an exists clause" do
             @criteria.where(:title.exists => true)
             @criteria.selector.should ==
-              { :title => { "$exists" => true } }
+              { :_type => { "$in" => ["Doctor", "Person"] }, :title => { "$exists" => true } }
           end
 
         end
@@ -121,7 +115,7 @@ describe Mongoid::Criterion::Inclusion do
           it "returns those matching a gt clause" do
             @criteria.where(:age.gt => 30)
             @criteria.selector.should ==
-              { :age => { "$gt" => 30 } }
+              { :_type => { "$in" => ["Doctor", "Person"] }, :age => { "$gt" => 30 } }
           end
 
         end
@@ -131,7 +125,7 @@ describe Mongoid::Criterion::Inclusion do
           it "returns those matching a gte clause" do
             @criteria.where(:age.gte => 33)
             @criteria.selector.should ==
-              { :age => { "$gte" => 33 } }
+              { :_type => { "$in" => ["Doctor", "Person"] }, :age => { "$gte" => 33 } }
           end
 
         end
@@ -141,7 +135,7 @@ describe Mongoid::Criterion::Inclusion do
           it "returns those matching an in clause" do
             @criteria.where(:title.in => ["Sir", "Madam"])
             @criteria.selector.should ==
-              { :title => { "$in" => ["Sir", "Madam"] } }
+              { :_type => { "$in" => ["Doctor", "Person"] }, :title => { "$in" => ["Sir", "Madam"] } }
           end
 
         end
@@ -151,7 +145,7 @@ describe Mongoid::Criterion::Inclusion do
           it "returns those matching a lt clause" do
             @criteria.where(:age.lt => 34)
             @criteria.selector.should ==
-              { :age => { "$lt" => 34 } }
+              { :_type => { "$in" => ["Doctor", "Person"] }, :age => { "$lt" => 34 } }
           end
 
         end
@@ -161,7 +155,7 @@ describe Mongoid::Criterion::Inclusion do
           it "returns those matching a lte clause" do
             @criteria.where(:age.lte => 33)
             @criteria.selector.should ==
-              { :age => { "$lte" => 33 } }
+              { :_type => { "$in" => ["Doctor", "Person"] }, :age => { "$lte" => 33 } }
           end
 
         end
@@ -171,7 +165,7 @@ describe Mongoid::Criterion::Inclusion do
           it "returns those matching a ne clause" do
             @criteria.where(:age.ne => 50)
             @criteria.selector.should ==
-              { :age => { "$ne" => 50 } }
+              { :_type => { "$in" => ["Doctor", "Person"] }, :age => { "$ne" => 50 } }
           end
 
         end
@@ -181,7 +175,7 @@ describe Mongoid::Criterion::Inclusion do
           it "returns those matching a nin clause" do
             @criteria.where(:title.nin => ["Esquire", "Congressman"])
             @criteria.selector.should ==
-              { :title => { "$nin" => ["Esquire", "Congressman"] } }
+              { :_type => { "$in" => ["Doctor", "Person"] }, :title => { "$nin" => ["Esquire", "Congressman"] } }
           end
 
         end
@@ -191,7 +185,7 @@ describe Mongoid::Criterion::Inclusion do
           it "returns those matching a size clause" do
             @criteria.where(:aliases.size => 2)
             @criteria.selector.should ==
-              { :aliases => { "$size" => 2 } }
+              { :_type => { "$in" => ["Doctor", "Person"] }, :aliases => { "$size" => 2 } }
           end
 
         end
@@ -205,7 +199,7 @@ describe Mongoid::Criterion::Inclusion do
       it "adds the $where clause to the selector" do
         @criteria.where("this.date < new Date()")
         @criteria.selector.should ==
-          { "$where" => "this.date < new Date()" }
+          { :_type => { "$in" => ["Doctor", "Person"] }, "$where" => "this.date < new Date()" }
       end
 
     end

data/spec/unit/mongoid/criterion/optional_spec.rb

@@ -30,6 +30,16 @@ describe Mongoid::Criterion::Optional do
       it "returns true" do
         @criteria.cached?.should be_true
       end
+
+      it "removes cache from the options" do
+        @criteria.cached?
+        @criteria.options[:cache].should be_nil
+      end
+
+      it "sets the cache instance variable" do
+        @criteria.cached?
+        @criteria.instance_variable_get(:@cached).should be_true
+      end
     end
 
     context "when the criteria has no cache option" do
@@ -102,32 +112,15 @@ describe Mongoid::Criterion::Optional do
 
     context "when passing a single id" do
 
-      context "when the id is a string" do
-
-        it "adds the _id query to the selector" do
-          id = Mongo::ObjectID.new.to_s
-          @criteria.id(id)
-          @criteria.selector.should == { :_id => id }
-        end
-
-        it "returns self" do
-          id = Mongo::ObjectID.new.to_s
-          @criteria.id(id).should == @criteria
-        end
+      it "adds the _id query to the selector" do
+        id = Mongo::ObjectID.new.to_s
+        @criteria.id(id)
+        @criteria.selector.should == { :_type => { "$in" => ["Doctor", "Person"] }, :_id => id }
       end
 
-      context "when the id is an object id" do
-
-        it "adds the _id query to the selector" do
-          id = Mongo::ObjectID.new
-          @criteria.id(id)
-          @criteria.selector.should == { :_id => id }
-        end
-
-        it "returns self" do
-          id = Mongo::ObjectID.new
-          @criteria.id(id).should == @criteria
-        end
+      it "returns self" do
+        id = Mongo::ObjectID.new.to_s
+        @criteria.id(id.to_s).should == @criteria
       end
 
     end
@@ -142,7 +135,7 @@ describe Mongoid::Criterion::Optional do
       it "adds the _id query to the selector" do
         @criteria.id(@ids)
         @criteria.selector.should ==
-          { :_id => { "$in" => @ids } }
+          { :_type => { "$in" => ["Doctor", "Person"] }, :_id => { "$in" => @ids } }
       end
 
     end