mongoid-pre 2.0.0.beta1 → 2.0.0.pre

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

@@ -5,9 +5,9 @@ describe Mongoid::Contexts::Mongo do
   describe "#aggregate" do
 
     before do
-      @criteria = Mongoid::Criteria.new(Person)
-      @criteria.only(:field1)
-      @context = Mongoid::Contexts::Mongo.new(@criteria)
+      @selector = {}
+      @options = { :fields => [:field1] }
+      @context = Mongoid::Contexts::Mongo.new(@selector, @options, Person)
     end
 
     context "when klass not provided" do
@@ -19,78 +19,20 @@ 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']}}, {:count => 0}, @reduce, true)
+        @collection.expects(:group).with([:field1], {}, {:count => 0}, @reduce, true)
         @context.aggregate
       end
-    end
-  end
-
-  describe "#avg" do
-
-    before do
-      @reduce = Mongoid::Javascript.sum.gsub("[field]", "age")
-      @collection = mock
-      Person.expects(:collection).twice.returns(@collection)
-      @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']}},
-        {:sum => "start"},
-        @reduce
-      ).returns([{"sum" => 100.0}])
-      @cursor = mock(:count => 10)
-      @collection.expects(:find).returns(@cursor)
-      @context.avg(:age).should == 10
-    end
-  end
-
-  describe "blank?" do
-
-    before do
-      @criteria = Mongoid::Criteria.new(Game)
-      @criteria.where(:test => 'Testing')
-      @context = Mongoid::Contexts::Mongo.new(@criteria)
-    end
-
-    context "when a document exists" do
-
-      before do
-        @doc = mock
-        @collection = mock
-        Game.expects(:collection).returns(@collection)
-        @collection.expects(:find_one).with({ :test => "Testing" }, { :fields => [ :_id ] }).returns(@doc)
-      end
 
-      it "returns false" do
-        @context.blank?.should be_false
-      end
     end
 
-    context "when a document does not exist" do
-
-      before do
-        @doc = mock
-        @collection = mock
-        Game.expects(:collection).returns(@collection)
-        @collection.expects(:find_one).with({ :test => "Testing" }, { :fields => [ :_id ] }).returns(nil)
-      end
-
-      it "returns true" do
-        @context.blank?.should be_true
-      end
-    end
   end
 
   describe "#count" do
 
     before do
-      @criteria = Mongoid::Criteria.new(Person)
-      @criteria.where(:test => 'Testing')
-      @context = Mongoid::Contexts::Mongo.new(@criteria)
+      @selector = { :_type => { "$in" => ["Doctor", "Person"] }, :test => "Testing" }
+      @options = {}
+      @context = Mongoid::Contexts::Mongo.new(@selector, @options, Person)
     end
 
     context "when criteria has not been executed" do
@@ -114,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(@criteria.selector, {}).returns(@cursor)
+        @collection.expects(:find).with(@selector, {}).returns(@cursor)
         @cursor.expects(:count).returns(10)
         @context.count.should == 10
       end
@@ -123,22 +65,6 @@ describe Mongoid::Contexts::Mongo do
 
   end
 
-  describe "#distinct" do
-
-    before do
-      @criteria = Mongoid::Criteria.new(Person)
-      @criteria.where(:test => 'Testing')
-      @context = Mongoid::Contexts::Mongo.new(@criteria)
-      @collection = mock
-      Person.expects(:collection).returns(@collection)
-    end
-
-    it "returns delegates to distinct on the collection" do
-      @collection.expects(:distinct).with(:title, @criteria.selector).returns(["Sir"])
-      @context.distinct(:title).should == ["Sir"]
-    end
-  end
-
   describe "#execute" do
 
     let(:selector) { { :field => "value"  } }
@@ -147,16 +73,8 @@ describe Mongoid::Contexts::Mongo do
     before do
       @cursor = stub(:count => 500)
       @collection = mock
-      @klass = stub(
-        :collection => @collection,
-        :hereditary => false,
-        :instantiate => @person,
-        :enslaved? => false,
-        :cached? => false
-      )
-      @criteria = Mongoid::Criteria.new(@klass)
-      @criteria.where(selector).skip(20)
-      @context = Mongoid::Contexts::Mongo.new(@criteria)
+      @klass = stub(:collection => @collection, :hereditary => false, :instantiate => @person)
+      @context = Mongoid::Contexts::Mongo.new(selector, options, @klass)
     end
 
     it "calls find on the collection" do
@@ -179,7 +97,7 @@ describe Mongoid::Contexts::Mongo do
       context "when _type not in the field list" do
 
         before do
-          @criteria.only(:title)
+          options[:fields] = [ :title ]
           @expected_options = { :skip => 20, :fields => [ :title, :_type ] }
         end
 
@@ -197,10 +115,10 @@ describe Mongoid::Contexts::Mongo do
   describe "#group" do
 
     before do
-      @criteria = Mongoid::Criteria.new(Person)
-      @criteria.only(:field1)
+      @selector = { :_type => { "$in" => ["Doctor", "Person"] } }
+      @options = { :fields => [ :field1 ] }
       @grouping = [{ "title" => "Sir", "group" => [{ "title" => "Sir", "age" => 30, "_type" => "Person" }] }]
-      @context = Mongoid::Contexts::Mongo.new(@criteria)
+      @context = Mongoid::Contexts::Mongo.new(@selector, @options, Person)
     end
 
     context "when klass provided" do
@@ -212,12 +130,7 @@ 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
-        ).returns(@grouping)
+        @collection.expects(:group).with([:field1], {:_type => { "$in" => ["Doctor", "Person"] }}, {:group => []}, @reduce, true).returns(@grouping)
         @context.group
       end
 
@@ -230,118 +143,21 @@ describe Mongoid::Contexts::Mongo do
     let(:selector) { { :field => "value"  } }
     let(:options) { { :skip => 20 } }
     let(:klass) { Person }
-    let(:criteria) { Mongoid::Criteria.new(klass) }
-    let(:context) { Mongoid::Contexts::Mongo.new(criteria) }
 
     before do
-      criteria.where(selector).skip(20)
+      @context = Mongoid::Contexts::Mongo.new(selector, options, klass)
     end
 
     it "sets the selector" do
-      context.selector.should == criteria.selector
+      @context.selector.should == selector
     end
 
     it "sets the options" do
-      context.options.should == options
+      @context.options.should == options
     end
 
     it "sets the klass" do
-      context.klass.should == klass
-    end
-
-    context "when persisting type" do
-
-      it "set the selector to query across the _type when it is hereditary" do
-        context.selector[:_type].should == {'$in' => Person._types}
-      end
-
-    end
-
-    context "when not persisting type" do
-
-      before do
-        Mongoid.persist_types = false
-      end
-
-      after do
-        Mongoid.persist_types = true
-      end
-
-      it "does not add the type to the selector" do
-        context.selector[:_type].should be_nil
-      end
-
-    end
-
-    context "enslaved and cached classes" do
-
-      let(:klass) { Game }
-
-      it "enslaves the criteria" do
-        context.criteria.should be_enslaved
-      end
-
-      it "caches the criteria" do
-        context.criteria.should be_cached
-      end
-    end
-  end
-
-  describe "#iterate" do
-    before do
-      @criteria = Mongoid::Criteria.new(Person)
-      @context = Mongoid::Contexts::Mongo.new(@criteria)
-      @person = Person.new(:title => "Sir")
-      @cursor = stub('cursor')
-      @cursor.stubs(:each).yields(@person)
-    end
-
-    context "when not caching" do
-
-      it "executes the criteria" do
-        @context.expects(:execute).returns(@cursor)
-        @context.iterate do |person|
-          person.should == @person
-        end
-
-      end
-
-    end
-
-    context "when caching" do
-      before do
-        @criteria.cache
-      end
-
-      it "executes the criteria" do
-        @context.expects(:execute).returns(@cursor)
-        @context.iterate do |person|
-          person.should == @person
-        end
-      end
-
-      it "executes only once and it caches the result" do
-        @context.expects(:execute).once.returns(@cursor)
-        @context.iterate do |person|
-          person.should == @person
-        end
-        @context.iterate do |person|
-          person.should == @person
-        end
-      end
-
-      it "executes even if there is no block" do
-        @context.expects(:execute).once.returns(@cursor)
-        @context.iterate
-      end
-
-      it "caches even if there is no block" do
-        @context.expects(:execute).once.returns(@cursor)
-        @context.iterate
-        @context.iterate do |person|
-          person.should == @person
-        end
-      end
+      @context.klass.should == klass
     end
 
   end
@@ -356,13 +172,10 @@ describe Mongoid::Contexts::Mongo do
     context "when documents exist" do
 
       before do
-        @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(
+        @selector = {}
+        @options = { :sort => [[:title, :asc]] }
+        @context = Mongoid::Contexts::Mongo.new(@selector, @options, Person)
+        @collection.expects(:find_one).with(@selector, { :sort => [[:title, :desc]] }).returns(
           { "title" => "Sir", "_type" => "Person" }
         )
       end
@@ -376,13 +189,10 @@ describe Mongoid::Contexts::Mongo do
     context "when no documents exist" do
 
       before do
-        @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)
+        @selector = {}
+        @options = { :sort => [[:_id, :asc]] }
+        @context = Mongoid::Contexts::Mongo.new(@selector, @options, Person)
+        @collection.expects(:find_one).with(@selector, { :sort => [[:_id, :desc]] }).returns(nil)
       end
 
       it "returns nil" do
@@ -394,13 +204,10 @@ describe Mongoid::Contexts::Mongo do
     context "when no sorting options provided" do
 
       before do
-        @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(
+        @selector = {}
+        @options = { :sort => [[:_id, :asc]] }
+        @context = Mongoid::Contexts::Mongo.new(@selector, @options, Person)
+        @collection.expects(:find_one).with(@selector, { :sort => [[:_id, :desc]] }).returns(
           { "title" => "Sir", "_type" => "Person" }
         )
       end
@@ -416,19 +223,19 @@ describe Mongoid::Contexts::Mongo do
   describe "#max" do
 
     before do
-      @reduce = Mongoid::Javascript.max.gsub("[field]", "age")
+      @reduce = Mongoid::Contexts::Mongo::MAX_REDUCE.gsub("[field]", "age")
       @collection = mock
       Person.expects(:collection).returns(@collection)
-      @criteria = Mongoid::Criteria.new(Person)
-      @context = Mongoid::Contexts::Mongo.new(@criteria)
+      @context = Mongoid::Contexts::Mongo.new({}, {}, Person)
     end
 
     it "calls group on the collection with the aggregate js" do
       @collection.expects(:group).with(
         nil,
-        {:_type => {'$in' => ['Doctor', 'Person']}},
+        {},
         {:max => "start"},
-        @reduce
+        @reduce,
+        true
       ).returns([{"max" => 200.0}])
       @context.max(:age).should == 200.0
     end
@@ -438,19 +245,19 @@ describe Mongoid::Contexts::Mongo do
   describe "#min" do
 
     before do
-      @reduce = Mongoid::Javascript.min.gsub("[field]", "age")
+      @reduce = Mongoid::Contexts::Mongo::MIN_REDUCE.gsub("[field]", "age")
       @collection = mock
       Person.expects(:collection).returns(@collection)
-      @criteria = Mongoid::Criteria.new(Person)
-      @context = Mongoid::Contexts::Mongo.new(@criteria)
+      @context = Mongoid::Contexts::Mongo.new({}, {}, Person)
     end
 
     it "calls group on the collection with the aggregate js" do
       @collection.expects(:group).with(
         nil,
-        {:_type => {'$in' => ['Doctor', 'Person']}},
+        {},
         {:min => "start"},
-        @reduce
+        @reduce,
+        true
       ).returns([{"min" => 4.0}])
       @context.min(:age).should == 4.0
     end
@@ -462,10 +269,10 @@ describe Mongoid::Contexts::Mongo do
     context "when documents exist" do
 
       before do
+        @collection = mock
         Person.expects(:collection).returns(@collection)
-        @criteria = Mongoid::Criteria.new(Person)
-        @context = Mongoid::Contexts::Mongo.new(@criteria)
-        @collection.expects(:find_one).with({:_type => {'$in' => ['Doctor', 'Person']}}, {}).returns(
+        @context = Mongoid::Contexts::Mongo.new({}, {}, Person)
+        @collection.expects(:find_one).with({}, {}).returns(
           { "title"=> "Sir", "_type" => "Person" }
         )
       end
@@ -481,9 +288,8 @@ describe Mongoid::Contexts::Mongo do
       before do
         @collection = mock
         Person.expects(:collection).returns(@collection)
-        @criteria = Mongoid::Criteria.new(Person)
-        @context = Mongoid::Contexts::Mongo.new(@criteria)
-        @collection.expects(:find_one).with({:_type => {'$in' => ['Doctor', 'Person']}}, {}).returns(nil)
+        @context = Mongoid::Contexts::Mongo.new({}, {}, Person)
+        @collection.expects(:find_one).with({}, {}).returns(nil)
       end
 
       it "returns nil" do
@@ -500,7 +306,7 @@ describe Mongoid::Contexts::Mongo do
 
       before do
         @criteria = Mongoid::Criteria.new(Person).extras({ :page => 5 })
-        @context = Mongoid::Contexts::Mongo.new(@criteria)
+        @context = Mongoid::Contexts::Mongo.new({}, @criteria.options, Person)
       end
 
       it "returns the page option" do
@@ -513,7 +319,7 @@ describe Mongoid::Contexts::Mongo do
 
       before do
         @criteria = Mongoid::Criteria.new(Person)
-        @context = Mongoid::Contexts::Mongo.new(@criteria)
+        @context = Mongoid::Contexts::Mongo.new({}, @criteria.options, Person)
       end
 
       it "returns 1" do
@@ -530,7 +336,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)
+      @context = Mongoid::Contexts::Mongo.new(@criteria.selector, @criteria.options, Person)
       @collection.expects(:find).with(
         {:_type => { "$in" => ["Doctor", "Person"] }, :_id => "1"}, :skip => 60, :limit => 20
       ).returns([])
@@ -549,19 +355,19 @@ describe Mongoid::Contexts::Mongo do
     context "when klass not provided" do
 
       before do
-        @reduce = Mongoid::Javascript.sum.gsub("[field]", "age")
+        @reduce = Mongoid::Contexts::Mongo::SUM_REDUCE.gsub("[field]", "age")
         @collection = mock
-        @criteria = Mongoid::Criteria.new(Person)
-        @context = Mongoid::Contexts::Mongo.new(@criteria)
+        @context = Mongoid::Contexts::Mongo.new({}, {}, Person)
         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
+          @reduce,
+          true
         ).returns([{"sum" => 50.0}])
         @context.sum(:age).should == 50.0
       end
@@ -570,113 +376,4 @@ 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