mongoid 1.2.6 → 1.2.7

data/spec/unit/mongoid/contexts_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe Mongoid::Contexts do
+
+  context ".context_for" do
+    let(:klass) { stub('klass', :embedded => false) }
+    let(:criteria) { stub('criteria', :klass => klass) }
+
+    context "when criteria is for a top-level Mongoid::Document" do
+      it "creates a Mongo context" do
+        Mongoid::Contexts::Mongo.expects(:new).with(criteria)
+        Mongoid::Contexts.context_for(criteria)
+      end
+    end
+
+    context "when criteria is for an embedded Mongoid::Document" do
+      it "creates a Mongo context" do
+        klass.stubs(:embedded).returns(true)
+        Mongoid::Contexts::Enumerable.expects(:new).with(criteria)
+        Mongoid::Contexts.context_for(criteria)
+      end
+    end
+  end
+
+end

data/spec/unit/mongoid/criteria_spec.rb

@@ -172,9 +172,7 @@ describe Mongoid::Criteria do
       end
 
       it "creates a new context" do
-        Mongoid::Contexts::Mongo.expects(:new).with(
-          @criteria.selector, @criteria.options, @criteria.klass
-        ).returns(@context)
+        Mongoid::Contexts::Mongo.expects(:new).with(@criteria).returns(@context)
         @criteria.context.should == @context
       end
 
@@ -245,7 +243,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
 
@@ -372,24 +370,23 @@ describe Mongoid::Criteria do
 
   describe "#initialize" do
 
-    context "when class is hereditary" do
-
-      it "sets the _type value on the selector" do
-        criteria = Mongoid::Criteria.new(Person)
-        criteria.selector.should == { :_type => { "$in" => ["Doctor", "Person"] } }
-      end
+    let(:criteria) { Mongoid::Criteria.new(Person) }
 
+    it "sets the selector to an empty hash" do
+      criteria.selector.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 options to an empty hash" do
+      criteria.options.should == {}
+    end
 
+    it "sets the documents to an empty array" do
+      criteria.documents.should == []
     end
 
+    it "sets the klass to the given class" do
+      criteria.klass.should == Person
+    end
   end
 
   describe "#last" do
@@ -433,7 +430,7 @@ describe Mongoid::Criteria do
         before do
           @other = Mongoid::Criteria.new(Person)
           @other.where(:name => "Chloe").order_by([[:name, :asc]])
-          @selector = { :_type => { "$in" => ["Doctor", "Person"] }, :title => "Sir", :age => 30, :name => "Chloe" }
+          @selector = { :title => "Sir", :age => 30, :name => "Chloe" }
           @options = { :skip => 40, :limit => 20, :sort => [[:name, :asc]] }
         end
 
@@ -449,7 +446,7 @@ describe Mongoid::Criteria do
 
         before do
           @other = Mongoid::Criteria.new(Person)
-          @selector = { :_type => { "$in" => ["Doctor", "Person"] }, :title => "Sir", :age => 30 }
+          @selector = { :title => "Sir", :age => 30 }
           @options = { :skip => 40, :limit => 20 }
         end
 
@@ -489,7 +486,7 @@ describe Mongoid::Criteria do
 
     it "merges the criteria with the next one" do
       @new_criteria = @criteria.accepted
-      @new_criteria.selector.should == { :_type => { "$in" => ["Doctor", "Person"] }, :title => "Sir", :terms => true }
+      @new_criteria.selector.should == { :title => "Sir", :terms => true }
     end
 
     context "chaining more than one scope" do
@@ -499,8 +496,7 @@ describe Mongoid::Criteria do
       end
 
       it "returns the final merged criteria" do
-        @criteria.selector.should ==
-          { :_type => { "$in" => ["Doctor", "Person"] }, :title => "Sir", :terms => true, :age => { "$gt" => 50 } }
+        @criteria.selector.should == { :title => "Sir", :terms => true, :age => { "$gt" => 50 } }
       end
 
     end
@@ -616,8 +612,7 @@ describe Mongoid::Criteria do
     end
 
     it "returns the selector plus the options" do
-      @criteria.scoped.should ==
-        { :where => { :title => "Sir", :_type=>{ "$in" => [ "Doctor", "Person" ] } }, :skip => 20 }
+      @criteria.scoped.should == { :where => { :title => "Sir" }, :skip => 20 }
     end
 
   end
@@ -640,29 +635,35 @@ describe Mongoid::Criteria do
 
     context "with a single argument" do
 
-      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
+      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
 
-      it "creates a criteria for a string" do
-        @criteria.expects(:one).returns(@document)
-        @document.expects(:blank? => false)
-        Mongoid::Criteria.translate(Person, @id)
+        it "delegates to #id_criteria" do
+          @criteria.expects(:id_criteria).with(@id).returns(@document)
+          Mongoid::Criteria.translate(Person, @id).should == @document
+        end
       end
 
-      context "when the document is not found" do
+      context "when the arg is an object id" do
 
-        it "raises an error" do
-          @criteria.expects(:one).returns(nil)
-          lambda { Mongoid::Criteria.translate(Person, @id) }.should raise_error
+        before do
+          @id = Mongo::ObjectID.new
+          @document = stub
+          @criteria = mock
+          Mongoid::Criteria.expects(:new).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
       end
-
     end
 
     context "multiple arguments" do
@@ -676,40 +677,13 @@ describe Mongoid::Criteria do
             @ids << Mongo::ObjectID.new.to_s
             @documents << stub
           end
-          @collection = stub
-          Person.expects(:collection).returns(@collection)
+          @criteria = mock
+          Mongoid::Criteria.expects(:new).returns(@criteria)
         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
-
-        end
-
-        context "when documents are not found" do
-
-          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 "delegates to #id_criteria" do
+          @criteria.expects(:id_criteria).with(@ids).returns(@documents)
+          Mongoid::Criteria.translate(Person, @ids).should == @documents
         end
 
       end
@@ -721,7 +695,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns a criteria with a selector from the conditions" do
-          @criteria.selector.should == { :_type => { "$in" => ["Doctor", "Person"] }, :title => "Test" }
+          @criteria.selector.should == { :title => "Test" }
         end
 
         it "returns a criteria with klass Person" do
@@ -737,7 +711,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns a criteria with a selector from the conditions" do
-          @criteria.selector.should == { :_type => { "$in" => ["Doctor", "Person"] }, :title => "Test" }
+          @criteria.selector.should == { :title => "Test" }
         end
 
         it "returns a criteria with klass Person" do
@@ -753,7 +727,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns a criteria with a selector from the conditions" do
-          @criteria.selector.should == { :_type => { "$in" => ["Doctor", "Person"] }, :title => "Test" }
+          @criteria.selector.should == { :title => "Test" }
         end
 
         it "returns a criteria with klass Person" do
@@ -768,7 +742,7 @@ describe Mongoid::Criteria do
         end
 
         it "adds the criteria and the options" do
-          @criteria.selector.should == { :_type => { "$in" => ["Doctor", "Person"] }, :title => "Test" }
+          @criteria.selector.should == { :title => "Test" }
           @criteria.options.should == { :skip => 10 }
         end
 

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

@@ -12,10 +12,7 @@ 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 =>
@@ -32,10 +29,7 @@ describe Mongoid::Criterion::Exclusion do
       it "accepts id" do
         @criteria.excludes(:id => "1")
         @criteria.selector.should ==
-          { :_type =>
-              { "$in" =>
-                ["Doctor", "Person"]
-              },
+          {
             :_id => { "$ne" => "1" }
           }
       end
@@ -43,10 +37,7 @@ describe Mongoid::Criterion::Exclusion do
       it "accepts _id" do
         @criteria.excludes(:_id => "1")
         @criteria.selector.should ==
-          { :_type =>
-              { "$in" =>
-                ["Doctor", "Person"]
-              },
+          {
             :_id => { "$ne" => "1" }
           }
       end
@@ -60,7 +51,6 @@ 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,10 +61,8 @@ describe Mongoid::Criterion::Inclusion do
     it "adds the $in clause to the selector" do
       @criteria.in(:title => ["title1", "title2"], :text => ["test"])
       @criteria.selector.should ==
-        { :_type =>
-          { "$in" =>
-            ["Doctor", "Person"]
-          }, :title => { "$in" => ["title1", "title2"] }, :text => { "$in" => ["test"] }
+        {
+          :title => { "$in" => ["title1", "title2"] }, :text => { "$in" => ["test"] }
         }
     end
 
@@ -83,7 +81,7 @@ describe Mongoid::Criterion::Inclusion do
         it "adds the clause to the selector" do
           @criteria.where(:title => "Title", :text => "Text")
           @criteria.selector.should ==
-            { :_type => { "$in" => ["Doctor", "Person"] }, :title => "Title", :text => "Text" }
+            { :title => "Title", :text => "Text" }
         end
 
       end
@@ -95,7 +93,7 @@ describe Mongoid::Criterion::Inclusion do
           it "returns those matching an all clause" do
             @criteria.where(:title.all => ["Sir"])
             @criteria.selector.should ==
-              { :_type => { "$in" => ["Doctor", "Person"] }, :title => { "$all" => ["Sir"] } }
+              { :title => { "$all" => ["Sir"] } }
           end
 
         end
@@ -105,7 +103,7 @@ describe Mongoid::Criterion::Inclusion do
           it "returns those matching an exists clause" do
             @criteria.where(:title.exists => true)
             @criteria.selector.should ==
-              { :_type => { "$in" => ["Doctor", "Person"] }, :title => { "$exists" => true } }
+              { :title => { "$exists" => true } }
           end
 
         end
@@ -115,7 +113,7 @@ describe Mongoid::Criterion::Inclusion do
           it "returns those matching a gt clause" do
             @criteria.where(:age.gt => 30)
             @criteria.selector.should ==
-              { :_type => { "$in" => ["Doctor", "Person"] }, :age => { "$gt" => 30 } }
+              { :age => { "$gt" => 30 } }
           end
 
         end
@@ -125,7 +123,7 @@ describe Mongoid::Criterion::Inclusion do
           it "returns those matching a gte clause" do
             @criteria.where(:age.gte => 33)
             @criteria.selector.should ==
-              { :_type => { "$in" => ["Doctor", "Person"] }, :age => { "$gte" => 33 } }
+              { :age => { "$gte" => 33 } }
           end
 
         end
@@ -135,7 +133,7 @@ describe Mongoid::Criterion::Inclusion do
           it "returns those matching an in clause" do
             @criteria.where(:title.in => ["Sir", "Madam"])
             @criteria.selector.should ==
-              { :_type => { "$in" => ["Doctor", "Person"] }, :title => { "$in" => ["Sir", "Madam"] } }
+              { :title => { "$in" => ["Sir", "Madam"] } }
           end
 
         end
@@ -145,7 +143,7 @@ describe Mongoid::Criterion::Inclusion do
           it "returns those matching a lt clause" do
             @criteria.where(:age.lt => 34)
             @criteria.selector.should ==
-              { :_type => { "$in" => ["Doctor", "Person"] }, :age => { "$lt" => 34 } }
+              { :age => { "$lt" => 34 } }
           end
 
         end
@@ -155,7 +153,7 @@ describe Mongoid::Criterion::Inclusion do
           it "returns those matching a lte clause" do
             @criteria.where(:age.lte => 33)
             @criteria.selector.should ==
-              { :_type => { "$in" => ["Doctor", "Person"] }, :age => { "$lte" => 33 } }
+              { :age => { "$lte" => 33 } }
           end
 
         end
@@ -165,7 +163,7 @@ describe Mongoid::Criterion::Inclusion do
           it "returns those matching a ne clause" do
             @criteria.where(:age.ne => 50)
             @criteria.selector.should ==
-              { :_type => { "$in" => ["Doctor", "Person"] }, :age => { "$ne" => 50 } }
+              { :age => { "$ne" => 50 } }
           end
 
         end
@@ -175,7 +173,7 @@ describe Mongoid::Criterion::Inclusion do
           it "returns those matching a nin clause" do
             @criteria.where(:title.nin => ["Esquire", "Congressman"])
             @criteria.selector.should ==
-              { :_type => { "$in" => ["Doctor", "Person"] }, :title => { "$nin" => ["Esquire", "Congressman"] } }
+              { :title => { "$nin" => ["Esquire", "Congressman"] } }
           end
 
         end
@@ -185,7 +183,7 @@ describe Mongoid::Criterion::Inclusion do
           it "returns those matching a size clause" do
             @criteria.where(:aliases.size => 2)
             @criteria.selector.should ==
-              { :_type => { "$in" => ["Doctor", "Person"] }, :aliases => { "$size" => 2 } }
+              { :aliases => { "$size" => 2 } }
           end
 
         end
@@ -199,7 +197,7 @@ describe Mongoid::Criterion::Inclusion do
       it "adds the $where clause to the selector" do
         @criteria.where("this.date < new Date()")
         @criteria.selector.should ==
-          { :_type => { "$in" => ["Doctor", "Person"] }, "$where" => "this.date < new Date()" }
+          { "$where" => "this.date < new Date()" }
       end
 
     end

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

@@ -112,15 +112,32 @@ describe Mongoid::Criterion::Optional do
 
     context "when passing a single id" do
 
-      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 }
+      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
       end
 
-      it "returns self" do
-        id = Mongo::ObjectID.new.to_s
-        @criteria.id(id.to_s).should == @criteria
+      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
       end
 
     end
@@ -135,7 +152,7 @@ describe Mongoid::Criterion::Optional do
       it "adds the _id query to the selector" do
         @criteria.id(@ids)
         @criteria.selector.should ==
-          { :_type => { "$in" => ["Doctor", "Person"] }, :_id => { "$in" => @ids } }
+          { :_id => { "$in" => @ids } }
       end
 
     end