mongoid 1.1.3 → 1.1.4

data/spec/unit/mongoid/associations/has_one_spec.rb

@@ -63,6 +63,31 @@ describe Mongoid::Associations::HasOne do
 
   end
 
+  describe "#initialize" do
+
+    before do
+      @parent = Person.new(:title => "Dr")
+      @name = Name.new(:first_name => "Richard", :last_name => "Dawkins")
+      @parent.name = @name
+      @block = Proc.new {
+        def extension
+          "Testing"
+        end
+      }
+      @options = Mongoid::Associations::Options.new(:name => :name, :extend => @block)
+      @association = Mongoid::Associations::HasOne.new(@parent, {}, @options)
+    end
+
+    context "when the options have an extension" do
+
+      it "adds the extension module" do
+        @association.extension.should == "Testing"
+      end
+
+    end
+
+  end
+
   describe ".instantiate" do
 
     context "when the attributes are nil" do
@@ -178,7 +203,7 @@ describe Mongoid::Associations::HasOne do
       before do
         @name = Name.new(:first_name => "Donald")
         @person = Person.new(:title => "Sir")
-        Mongoid::Associations::HasOne.update(
+        @association = Mongoid::Associations::HasOne.update(
           @name,
           @person,
           Mongoid::Associations::Options.new(:name => :name)
@@ -194,6 +219,10 @@ describe Mongoid::Associations::HasOne do
           { "_id" => "donald", "first_name" => "Donald", "_type" => "Name" }
       end
 
+      it "returns the proxy" do
+        @association.target.should == @name
+      end
+
     end
 
     context "when setting the object to nil" do
@@ -216,6 +245,22 @@ describe Mongoid::Associations::HasOne do
 
   end
 
+  describe "#to_a" do
+
+    before do
+      @association = Mongoid::Associations::HasOne.new(
+        @document,
+        @attributes["mixed_drink"],
+        Mongoid::Associations::Options.new(:name => :mixed_drink)
+      )
+    end
+
+    it "returns the target in a new array" do
+      @association.to_a.first.should be_a_kind_of(MixedDrink)
+    end
+
+  end
+
   describe "#valid?" do
 
     context "when the document is not nil" do

data/spec/unit/mongoid/associations/options_spec.rb

@@ -15,6 +15,64 @@ describe Mongoid::Associations::Options do
 
   end
 
+  describe "#extend" do
+
+    context "when extension exists" do
+
+      before do
+        @attributes = { :extend => lambda { "Test" } }
+        @options = Mongoid::Associations::Options.new(@attributes)
+      end
+
+      it "returns the proc" do
+        @options.extension.should == @attributes[:extend]
+      end
+
+    end
+
+    context "when extension doesnt exist" do
+
+      before do
+        @options = Mongoid::Associations::Options.new({})
+      end
+
+      it "returns nil" do
+        @options.extension.should be_nil
+      end
+
+    end
+
+  end
+
+  describe "extension?" do
+
+    context "when extension exists" do
+
+      before do
+        @attributes = { :extend => lambda { "Test" } }
+        @options = Mongoid::Associations::Options.new(@attributes)
+      end
+
+      it "returns true" do
+        @options.extension?.should be_true
+      end
+
+    end
+
+    context "when extension doesnt exist" do
+
+      before do
+        @options = Mongoid::Associations::Options.new({})
+      end
+
+      it "returns false" do
+        @options.extension?.should be_false
+      end
+
+    end
+
+  end
+
   describe "#foreign_key" do
 
     before do

data/spec/unit/mongoid/associations_spec.rb

@@ -113,6 +113,20 @@ describe Mongoid::Associations do
       code.phone_number.should == phone_number
     end
 
+    context "when adding an anonymous extension" do
+
+      before do
+        @person = Person.new(:title => "Dr")
+        @address = Address.new(:street => "Clarkenwell Road")
+        @person.addresses << @address
+      end
+
+      it "defines the method on the association" do
+        @address.addressable.extension.should == "Testing"
+      end
+
+    end
+
     context "when inverse_of not supplied" do
 
       it "raises an error" do
@@ -254,6 +268,15 @@ describe Mongoid::Associations do
       person.should respond_to(:addresses=)
     end
 
+    context "when adding an anonymous extension" do
+
+      it "defines the method on the association" do
+        person = Person.new
+        person.addresses.extension.should == "Testing"
+      end
+
+    end
+
     context "when setting the association directly" do
 
       before do
@@ -330,6 +353,15 @@ describe Mongoid::Associations do
       @person.should respond_to(:create_name)
     end
 
+    context "when adding an anonymous extension" do
+
+      it "defines the method on the association" do
+        @person.name = Name.new(:first_name => "Richard")
+        @person.name.extension.should == "Testing"
+      end
+
+    end
+
     context "when setting the association directly" do
 
       before do
@@ -391,6 +423,8 @@ describe Mongoid::Associations do
 
     before do
       @person = Person.new
+      @game = Game.new
+      @person.game = @game
     end
 
     it "creates a getter for the relationship" do
@@ -401,15 +435,38 @@ describe Mongoid::Associations do
       @person.should respond_to(:game=)
     end
 
+    context "when adding an anonymous extension" do
+
+      it "defines the method on the association" do
+        @person.game.extension.should == "Testing"
+      end
+
+    end
+
   end
 
   describe ".has_many_related" do
 
-    it "creates a getter and setter for the relationship" do
+    it "creates a getter for the association" do
       Person.new.should respond_to(:posts)
+    end
+
+    it "creates a setter for the association" do
       Person.new.should respond_to(:posts=)
     end
 
+    context "when adding an anonymous extension" do
+
+      before do
+        @person = Person.new
+      end
+
+      it "defines the method on the association" do
+        @person.posts.extension.should == "Testing"
+      end
+
+    end
+
   end
 
   describe "#update_associations" do

data/spec/unit/mongoid/criteria_spec.rb

@@ -138,58 +138,14 @@ describe Mongoid::Criteria do
 
   describe "#aggregate" do
 
-    context "when klass not provided" do
-
-      before do
-        @reduce = "function(obj, prev) { prev.count++; }"
-        @collection = mock
-        Person.expects(:collection).returns(@collection)
-      end
-
-      it "calls group on the collection with the aggregate js" do
-        @collection.expects(:group).with([:field1], {:_type => { "$in" => ["Doctor", "Person"] }}, {:count => 0}, @reduce, true)
-        @criteria.only(:field1).aggregate
-      end
-
-    end
-
-  end
-
-  describe "#all" 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
-
-    it "returns self" do
-      @criteria.all(:title => [ "title1" ]).should == @criteria
-    end
-
-  end
-
-  describe "#and" do
-
-    context "when provided a hash" 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" }
-      end
-
-    end
-
-    context "when provided a string" 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
-
+    before do
+      @context = stub.quacks_like(Mongoid::Contexts::Mongo.allocate)
+      @criteria.instance_variable_set(:@context, @context)
     end
 
-    it "returns self" do
-      @criteria.and.should == @criteria
+    it "delegates to the context" do
+      @context.expects(:aggregate)
+      @criteria.aggregate
     end
 
   end
@@ -298,23 +254,14 @@ describe Mongoid::Criteria do
 
   describe "#count" do
 
-    context "when criteria has been executed" do
-
-      before do
-        @criteria = Mongoid::Criteria.new(Person)
-        @selector = { :_type => { "$in" => ["Doctor", "Person"] }, :test => "Testing" }
-        @criteria.where(@selector)
-        @collection = mock
-        @cursor = mock
-        Person.expects(:collection).returns(@collection)
-      end
-
-      it "returns the count from the cursor without creating the documents" do
-        @collection.expects(:find).with(@selector, {}).returns(@cursor)
-        @cursor.expects(:count).returns(10)
-        @criteria.count.should == 10
-      end
+    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(:count).returns(10)
+      @criteria.count.should == 10
     end
 
   end
@@ -371,112 +318,14 @@ describe Mongoid::Criteria do
 
   describe "#first" do
 
-    context "when documents exist" do
-
-      before do
-        @collection = mock
-        Person.expects(:collection).returns(@collection)
-        @collection.expects(:find_one).with(@criteria.selector, @criteria.options).returns(
-          { "title" => "Sir", "_type" => "Person" }
-        )
-      end
-
-      it "calls find on the collection with the selector and options" do
-        criteria = Mongoid::Criteria.new(Person)
-        criteria.first.should be_a_kind_of(Person)
-      end
-
-    end
-
-    context "when no documents exist" do
-
-      before do
-        @collection = mock
-        Person.expects(:collection).returns(@collection)
-        @collection.expects(:find_one).with(@criteria.selector, @criteria.options).returns(nil)
-      end
-
-      it "returns nil" do
-        criteria = Mongoid::Criteria.new(Person)
-        criteria.first.should be_nil
-      end
-
-    end
-
-    context "when document is a subclass of the class queried from" do
-
-      before do
-        @collection = mock
-        Canvas.expects(:collection).returns(@collection)
-        @collection.expects(:find_one).with(@canvas_criteria.selector, @canvas_criteria.options).returns(
-          { "name" => "Firefox", "_type" => "Firefox" }
-        )
-      end
-
-      it "instantiates the subclass" do
-        criteria = Mongoid::Criteria.new(Canvas)
-        criteria.first.should be_a_kind_of(Firefox)
-      end
-
-    end
-
-  end
-
-  describe "#excludes" 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 => { "$ne" => "Bad Text" } }
-    end
-
-    it "returns self" do
-      @criteria.excludes(:title => "Bad").should == @criteria
-    end
-
-  end
-
-  describe "#extras" do
-
-    context "filtering" do
-
-      context "when page is provided" do
-
-        it "sets the limit and skip options" do
-          @criteria.extras({ :page => "2" })
-          @criteria.page.should == 2
-          @criteria.options.should == { :skip => 20, :limit => 20 }
-        end
-
-      end
-
-      context "when per_page is provided" do
-
-        it "sets the limit and skip options" do
-          @criteria.extras({ :per_page => 45 })
-          @criteria.options.should == { :skip => 0, :limit => 45 }
-        end
-
-      end
-
-      context "when page and per_page both provided" do
-
-        it "sets the limit and skip options" do
-          @criteria.extras({ :per_page => 30, :page => "4" })
-          @criteria.options.should == { :skip => 90, :limit => 30 }
-          @criteria.page.should == 4
-        end
-
-      end
-
-    end
-
-    it "adds the extras to the options" do
-      @criteria.extras({ :skip => 10 })
-      @criteria.options.should == { :skip => 10 }
+    before do
+      @context = stub.quacks_like(Mongoid::Contexts::Mongo.allocate)
+      @criteria.instance_variable_set(:@context, @context)
     end
 
-    it "returns self" do
-      @criteria.extras({}).should == @criteria
+    it "delegates to the context" do
+      @context.expects(:first).returns([])
+      @criteria.first.should == []
     end
 
   end
@@ -484,99 +333,13 @@ describe Mongoid::Criteria do
   describe "#group" do
 
     before do
-      @grouping = [{ "title" => "Sir", "group" => [{ "title" => "Sir", "age" => 30, "_type" => "Person" }] }]
-    end
-
-    context "when klass provided" do
-
-      before do
-        @reduce = "function(obj, prev) { prev.group.push(obj); }"
-        @criteria = Mongoid::Criteria.new(Person)
-        @collection = mock
-        Person.expects(:collection).returns(@collection)
-      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)
-        @criteria.only(:field1).group
-      end
-
+      @context = stub.quacks_like(Mongoid::Contexts::Mongo.allocate)
+      @criteria.instance_variable_set(:@context, @context)
     end
 
-    context "when klass not provided" do
-
-      before do
-        @reduce = "function(obj, prev) { prev.group.push(obj); }"
-        @collection = mock
-        Person.expects(:collection).returns(@collection)
-      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)
-        @criteria.only(:field1).group
-      end
-
-    end
-
-  end
-
-  describe "#id" 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 }
-      end
-
-      it "returns self" do
-        id = Mongo::ObjectID.new.to_s
-        @criteria.id(id.to_s).should == @criteria
-      end
-
-    end
-
-    context "when passing in an array of ids" do
-
-      before do
-        @ids = []
-        3.times { @ids << Mongo::ObjectID.new.to_s }
-      end
-
-      it "adds the _id query to the selector" do
-        @criteria.id(@ids)
-        @criteria.selector.should ==
-          { :_type => { "$in" => ["Doctor", "Person"] }, :_id => { "$in" => @ids } }
-      end
-
-    end
-
-  end
-
-  describe "#in" 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"] }
-        }
-    end
-
-    it "returns self" do
-      @criteria.in(:title => ["title1"]).should == @criteria
+    it "delegates to the context" do
+      @context.expects(:group).returns({})
+      @criteria.group.should == {}
     end
 
   end
@@ -605,80 +368,14 @@ describe Mongoid::Criteria do
 
   describe "#last" do
 
-    context "when documents exist" do
-
-      before do
-        @collection = mock
-        Person.expects(:collection).returns(@collection)
-        @collection.expects(:find_one).with(@criteria.selector, { :sort => [[:title, :desc]] }).returns(
-          { "title" => "Sir", "_type" => "Person" }
-        )
-      end
-
-      it "calls find on the collection with the selector and sort options reversed" do
-        criteria = Mongoid::Criteria.new(Person)
-        criteria.order_by([[:title, :asc]])
-        criteria.last.should be_a_kind_of(Person)
-      end
-
-    end
-
-    context "when no documents exist" do
-
-      before do
-        @collection = mock
-        Person.expects(:collection).returns(@collection)
-        @collection.expects(:find_one).with(@criteria.selector, { :sort => [[:_id, :desc]] }).returns(nil)
-      end
-
-      it "returns nil" do
-        criteria = Mongoid::Criteria.new(Person)
-        criteria.last.should be_nil
-      end
-
-    end
-
-    context "when no sorting options provided" do
-
-      before do
-        @collection = mock
-        Person.expects(:collection).returns(@collection)
-        @collection.expects(:find_one).with(@criteria.selector, { :sort => [[:_id, :desc]] }).returns(
-          { "title" => "Sir", "_type" => "Person" }
-        )
-      end
-
-      it "defaults to sort by id" do
-        criteria = Mongoid::Criteria.new(Person)
-        criteria.last
-      end
-
-    end
-
-  end
-
-  describe "#limit" do
-
-    context "when value provided" do
-
-      it "adds the limit to the options" do
-        @criteria.limit(100)
-        @criteria.options.should == { :limit => 100 }
-      end
-
-    end
-
-    context "when value not provided" do
-
-      it "defaults to 20" do
-        @criteria.limit
-        @criteria.options.should == { :limit => 20 }
-      end
-
+    before do
+      @context = stub.quacks_like(Mongoid::Contexts::Mongo.allocate)
+      @criteria.instance_variable_set(:@context, @context)
     end
 
-    it "returns self" do
-      @criteria.limit.should == @criteria
+    it "delegates to the context" do
+      @context.expects(:last).returns([])
+      @criteria.last.should == []
     end
 
   end
@@ -686,20 +383,13 @@ describe Mongoid::Criteria do
   describe "#max" do
 
     before do
-      @reduce = Mongoid::Contexts::Mongo::MAX_REDUCE.gsub("[field]", "age")
-      @collection = mock
-      Person.expects(:collection).returns(@collection)
+      @context = stub.quacks_like(Mongoid::Contexts::Mongo.allocate)
+      @criteria.instance_variable_set(:@context, @context)
     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
-      ).returns([{"max" => 200.0}])
-      @criteria.max(:age).should == 200.0
+    it "delegates to the context" do
+      @context.expects(:max).with(:field).returns(100)
+      @criteria.max(:field).should == 100
     end
 
   end
@@ -822,176 +512,41 @@ describe Mongoid::Criteria do
   describe "#min" do
 
     before do
-      @reduce = Mongoid::Contexts::Mongo::MIN_REDUCE.gsub("[field]", "age")
-      @collection = mock
-      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"] } },
-        {:min => "start"},
-        @reduce,
-        true
-      ).returns([{"min" => 4.0}])
-      @criteria.min(:age).should == 4.0
-    end
-
-  end
-
-  describe "#not_in" 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"] }
-      }
-    end
-
-    it "returns self" do
-      @criteria.not_in(:title => ["title1"]).should == @criteria
-    end
-
-  end
-
-  describe "#offset" do
-
-    context "when the per_page option exists" do
-
-      before do
-        @criteria = Mongoid::Criteria.new(Person).extras({ :per_page => 20, :page => 3 })
-      end
-
-      it "returns the per_page option" do
-        @criteria.offset.should == 40
-      end
-
+      @context = stub.quacks_like(Mongoid::Contexts::Mongo.allocate)
+      @criteria.instance_variable_set(:@context, @context)
     end
 
-    context "when the skip option exists" do
-
-      before do
-        @criteria = Mongoid::Criteria.new(Person).extras({ :skip => 20 })
-      end
-
-      it "returns the skip option" do
-        @criteria.offset.should == 20
-      end
-
-    end
-
-    context "when no option exists" do
-
-      context "when page option exists" do
-
-        before do
-          @criteria = Mongoid::Criteria.new(Person).extras({ :page => 2 })
-        end
-
-        it "adds the skip option to the options and returns it" do
-          @criteria.offset.should == 20
-          @criteria.options[:skip].should == 20
-        end
-
-      end
-
-      context "when page option does not exist" do
-
-        before do
-          @criteria = Mongoid::Criteria.new(Person)
-        end
-
-        it "returns nil" do
-          @criteria.offset.should be_nil
-          @criteria.options[:skip].should be_nil
-        end
-
-      end
-
+    it "delegates to the context" do
+      @context.expects(:min).with(:field).returns(100)
+      @criteria.min(:field).should == 100
     end
 
   end
 
   describe "#one" do
 
-    context "when documents exist" do
-
-      before do
-        @collection = mock
-        Person.expects(:collection).returns(@collection)
-        @collection.expects(:find_one).with(@criteria.selector, @criteria.options).returns(
-          { "title"=> "Sir", "_type" => "Person" }
-        )
-      end
-
-      it "calls find on the collection with the selector and options" do
-        criteria = Mongoid::Criteria.new(Person)
-        criteria.one.should be_a_kind_of(Person)
-      end
-
-    end
-
-    context "when no documents exist" do
-
-      before do
-        @collection = mock
-        Person.expects(:collection).returns(@collection)
-        @collection.expects(:find_one).with(@criteria.selector, @criteria.options).returns(nil)
-      end
-
-      it "returns nil" do
-        criteria = Mongoid::Criteria.new(Person)
-        criteria.one.should be_nil
-      end
-
-    end
-
-  end
-
-  describe "#order_by" do
-
-    context "when field names and direction specified" do
-
-      it "adds the sort to the options" do
-        @criteria.order_by([[:title, :asc], [:text, :desc]])
-        @criteria.options.should == { :sort => [[:title, :asc], [:text, :desc]] }
-      end
-
+    before do
+      @context = stub.quacks_like(Mongoid::Contexts::Mongo.allocate)
+      @criteria.instance_variable_set(:@context, @context)
     end
 
-    it "returns self" do
-      @criteria.order_by.should == @criteria
+    it "delegates to the context" do
+      @context.expects(:one)
+      @criteria.one
     end
 
   end
 
   describe "#page" do
 
-    context "when the page option exists" do
-
-      before do
-        @criteria = Mongoid::Criteria.new(Person).extras({ :page => 5 })
-      end
-
-      it "returns the page option" do
-        @criteria.page.should == 5
-      end
-
+    before do
+      @context = stub.quacks_like(Mongoid::Contexts::Mongo.allocate)
+      @criteria.instance_variable_set(:@context, @context)
     end
 
-    context "when the page option does not exist" do
-
-      before do
-        @criteria = Mongoid::Criteria.new(Person)
-      end
-
-      it "returns 1" do
-        @criteria.page.should == 1
-      end
-
+    it "delegates to the context" do
+      @context.expects(:page).returns(1)
+      @criteria.page.should == 1
     end
 
   end
@@ -999,74 +554,27 @@ describe Mongoid::Criteria do
   describe "#paginate" do
 
     before do
-      @collection = mock
-      Person.expects(:collection).returns(@collection)
-      @criteria = Person.where(:_id => "1").skip(60).limit(20)
-      @collection.expects(:find).with(
-        { :_type =>
-          { "$in" => ["Doctor", "Person"] },
-            :_id => "1"
-        }, :skip => 60, :limit => 20).returns([])
-      @results = @criteria.paginate
+      @context = stub.quacks_like(Mongoid::Contexts::Mongo.allocate)
+      @criteria.instance_variable_set(:@context, @context)
     end
 
-    it "executes and paginates the results" do
-      @results.current_page.should == 4
-      @results.per_page.should == 20
+    it "delegates to the context" do
+      @context.expects(:paginate).returns([])
+      @criteria.paginate.should == []
     end
 
   end
 
   describe "#per_page" do
 
-    context "when the per_page option exists" do
-
-      before do
-        @criteria = Mongoid::Criteria.new(Person).extras({ :per_page => 10 })
-      end
-
-      it "returns the per_page option" do
-        @criteria.per_page.should == 10
-      end
-
-    end
-
-    context "when the per_page option does not exist" do
-
-      before do
-        @criteria = Mongoid::Criteria.new(Person)
-      end
-
-      it "returns 1" do
-        @criteria.per_page.should == 20
-      end
-
-    end
-
-  end
-
-  describe "#only" do
-
-    context "when args are provided" do
-
-      it "adds the options for limiting by fields" do
-        @criteria.only(:title, :text)
-        @criteria.options.should == { :fields => [ :title, :text ] }
-      end
-
-      it "returns self" do
-        @criteria.only.should == @criteria
-      end
-
+    before do
+      @context = stub.quacks_like(Mongoid::Contexts::Mongo.allocate)
+      @criteria.instance_variable_set(:@context, @context)
     end
 
-    context "when no args provided" do
-
-      it "does not add the field option" do
-        @criteria.only
-        @criteria.options[:fields].should be_nil
-      end
-
+    it "delegates to the context" do
+      @context.expects(:per_page).returns(20)
+      @criteria.per_page.should == 20
     end
 
   end
@@ -1084,53 +592,16 @@ describe Mongoid::Criteria do
 
   end
 
-  describe "#skip" do
-
-    context "when value provided" do
-
-      it "adds the skip value to the options" do
-        @criteria.skip(20)
-        @criteria.options.should == { :skip => 20 }
-      end
-
-    end
-
-    context "when value not provided" do
-
-      it "defaults to zero" do
-        @criteria.skip
-        @criteria.options.should == { :skip => 0 }
-      end
-
-    end
-
-    it "returns self" do
-      @criteria.skip.should == @criteria
-    end
-
-  end
-
   describe "#sum" do
 
-    context "when klass not provided" do
-
-      before do
-        @reduce = Mongoid::Contexts::Mongo::SUM_REDUCE.gsub("[field]", "age")
-        @collection = mock
-        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
-        ).returns([{"sum" => 50.0}])
-        @criteria.sum(:age).should == 50.0
-      end
+    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(:sum).with(:field).returns(20)
+      @criteria.sum(:field).should == 20
     end
 
   end
@@ -1277,142 +748,6 @@ describe Mongoid::Criteria do
 
   end
 
-  describe "#where" do
-
-    context "when provided a hash" do
-
-      context "with simple hash keys" 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" }
-        end
-
-      end
-
-      context "with complex criterion" do
-
-        context "#all" do
-
-          it "returns those matching an all clause" do
-            @criteria.where(:title.all => ["Sir"])
-            @criteria.selector.should ==
-              { :_type => { "$in" => ["Doctor", "Person"] }, :title => { "$all" => ["Sir"] } }
-          end
-
-        end
-
-        context "#exists" do
-
-          it "returns those matching an exists clause" do
-            @criteria.where(:title.exists => true)
-            @criteria.selector.should ==
-              { :_type => { "$in" => ["Doctor", "Person"] }, :title => { "$exists" => true } }
-          end
-
-        end
-
-        context "#gt" do
-
-          it "returns those matching a gt clause" do
-            @criteria.where(:age.gt => 30)
-            @criteria.selector.should ==
-              { :_type => { "$in" => ["Doctor", "Person"] }, :age => { "$gt" => 30 } }
-          end
-
-        end
-
-        context "#gte" do
-
-          it "returns those matching a gte clause" do
-            @criteria.where(:age.gte => 33)
-            @criteria.selector.should ==
-              { :_type => { "$in" => ["Doctor", "Person"] }, :age => { "$gte" => 33 } }
-          end
-
-        end
-
-        context "#in" 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"] } }
-          end
-
-        end
-
-        context "#lt" do
-
-          it "returns those matching a lt clause" do
-            @criteria.where(:age.lt => 34)
-            @criteria.selector.should ==
-              { :_type => { "$in" => ["Doctor", "Person"] }, :age => { "$lt" => 34 } }
-          end
-
-        end
-
-        context "#lte" do
-
-          it "returns those matching a lte clause" do
-            @criteria.where(:age.lte => 33)
-            @criteria.selector.should ==
-              { :_type => { "$in" => ["Doctor", "Person"] }, :age => { "$lte" => 33 } }
-          end
-
-        end
-
-        context "#ne" do
-
-          it "returns those matching a ne clause" do
-            @criteria.where(:age.ne => 50)
-            @criteria.selector.should ==
-              { :_type => { "$in" => ["Doctor", "Person"] }, :age => { "$ne" => 50 } }
-          end
-
-        end
-
-        context "#nin" 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"] } }
-          end
-
-        end
-
-        context "#size" do
-
-          it "returns those matching a size clause" do
-            @criteria.where(:aliases.size => 2)
-            @criteria.selector.should ==
-              { :_type => { "$in" => ["Doctor", "Person"] }, :aliases => { "$size" => 2 } }
-          end
-
-        end
-
-      end
-
-    end
-
-    context "when provided a string" 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()" }
-      end
-
-    end
-
-    it "returns self" do
-      @criteria.where.should == @criteria
-    end
-
-  end
-
   context "#fuse" do
 
     it ":where => {:title => 'Test'} returns a criteria with the correct selector" do
@@ -1426,4 +761,5 @@ describe Mongoid::Criteria do
       @result.options.should == { :skip => 10 }
     end
   end
+
 end