mongoid 1.0.6 → 1.1.0

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

@@ -4,7 +4,7 @@ describe Mongoid::Associations::HasMany do
 
   before do
     @attributes = { :addresses => [
-      { :_id => "street-1", :street => "Street 1" },
+      { :_id => "street-1", :street => "Street 1", :state => "CA" },
       { :_id => "street-2", :street => "Street 2" } ] }
     @document = stub(:attributes => @attributes, :add_observer => true, :update => true)
   end
@@ -322,6 +322,45 @@ describe Mongoid::Associations::HasMany do
 
   end
 
+  describe "#method_missing" do
+
+    context "when the association class has a criteria class method" do
+
+      before do
+        @association = Mongoid::Associations::HasMany.new(
+          @document,
+          Mongoid::Associations::Options.new(:name => :addresses)
+        )
+      end
+
+      it "returns the criteria" do
+        @association.california.should be_a_kind_of(Mongoid::Criteria)
+      end
+
+      it "sets the documents on the criteria" do
+        criteria = @association.california
+        criteria.documents.should == @association.entries
+      end
+
+      it "returns the scoped documents" do
+        addresses = @association.california
+        addresses.size.should == 1
+        addresses.first.should be_a_kind_of(Address)
+        addresses.first.state.should == "CA"
+      end
+
+    end
+
+    context "when no class method exists" do
+
+      it "delegates to the array" do
+
+      end
+
+    end
+
+  end
+
   describe "#push" do
 
     before do

data/spec/unit/mongoid/attributes_spec.rb

@@ -223,7 +223,7 @@ describe Mongoid::Attributes do
         attrs[:age].should == 30
         attrs[:terms].should == true
         attrs[:_id].should == "1"
-        attrs[:score].should == ""
+        attrs[:score].should be_nil
       end
 
     end

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

@@ -9,19 +9,19 @@ describe Mongoid::Commands::Create do
     end
 
     it "executes a save command" do
-      Mongoid::Commands::Save.expects(:execute).with(@document, true).returns(@document)
+      Mongoid::Commands::Save.expects(:execute).with(@document, true, false).returns(@document)
       Mongoid::Commands::Create.execute(@document)
     end
 
     it "runs the before and after create callbacks" do
       @document.expects(:run_callbacks).with(:before_create)
-      Mongoid::Commands::Save.expects(:execute).with(@document, true).returns(@document)
+      Mongoid::Commands::Save.expects(:execute).with(@document, true, false).returns(@document)
       @document.expects(:run_callbacks).with(:after_create)
       Mongoid::Commands::Create.execute(@document)
     end
 
     it "returns the document" do
-      Mongoid::Commands::Save.expects(:execute).with(@document, true).returns(@document)
+      Mongoid::Commands::Save.expects(:execute).with(@document, true, false).returns(@document)
       Mongoid::Commands::Create.execute(@document).should == @document
     end
 

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

@@ -33,7 +33,7 @@ describe Mongoid::Commands::DeleteAll do
 
       it "drops the collection" do
         @klass.expects(:collection).returns(@collection)
-        @collection.expects(:drop)
+        @collection.expects(:remove).with(:_type => "Person")
         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(:drop)
+        @collection.expects(:remove).with(:_type => "Person")
         Mongoid::Commands::DeleteAll.execute(@klass, {})
       end
 

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

@@ -39,7 +39,7 @@ describe Mongoid::Commands::Save do
       context "when the document has a parent" do
 
         it "executes a save on the parent" do
-          @parent_collection.expects(:save).with(@parent.attributes)
+          @parent_collection.expects(:save).with(@parent.attributes, :safe => false)
           Mongoid::Commands::Save.execute(@document)
         end
 
@@ -52,7 +52,7 @@ describe Mongoid::Commands::Save do
         end
 
         it "calls save on the document collection" do
-          @doc_collection.expects(:save).with(@document.attributes)
+          @doc_collection.expects(:save).with(@document.attributes, :safe => false)
           Mongoid::Commands::Save.execute(@document)
         end
 

data/spec/unit/mongoid/commands_spec.rb

@@ -27,7 +27,7 @@ describe Mongoid::Commands do
   describe "#save" do
 
     it "delegates to the Save command" do
-      Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(true)
+      Mongoid::Commands::Save.expects(:execute).with(@person, true, false).returns(true)
       @person.save
     end
 
@@ -38,13 +38,13 @@ describe Mongoid::Commands do
       end
 
       it "delegates to the save command" do
-        Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(true)
+        Mongoid::Commands::Save.expects(:execute).with(@person, true, false).returns(true)
         @person.save
       end
 
       it "runs the before and after create callbacks" do
         @person.expects(:run_callbacks).with(:before_create)
-        Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(true)
+        Mongoid::Commands::Save.expects(:execute).with(@person, true, false).returns(true)
         @person.expects(:run_callbacks).with(:after_create)
         @person.save
       end
@@ -58,7 +58,7 @@ describe Mongoid::Commands do
       end
 
       it "passes the validate param to the command" do
-        Mongoid::Commands::Save.expects(:execute).with(@person, false).returns(true)
+        Mongoid::Commands::Save.expects(:execute).with(@person, false, false).returns(true)
         @person.save(false)
       end
 
@@ -71,7 +71,7 @@ describe Mongoid::Commands do
     context "when validation passes" do
 
       it "it returns the person" do
-        Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(true)
+        Mongoid::Commands::Save.expects(:execute).with(@person, true, true).returns(true)
         @person.save!
       end
 
@@ -80,7 +80,7 @@ describe Mongoid::Commands do
     context "when validation fails" do
 
       it "it raises an error" do
-        Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(false)
+        Mongoid::Commands::Save.expects(:execute).with(@person, true, true).returns(false)
         lambda { @person.save! }.should raise_error
       end
 
@@ -93,14 +93,14 @@ describe Mongoid::Commands do
       end
 
       it "delegates to the save command" do
-        Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(true)
+        Mongoid::Commands::Save.expects(:execute).with(@person, true, true).returns(true)
         @person.save!
       end
 
       context "when validation fails" do
 
         it "it raises an error " do
-          Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(false)
+          Mongoid::Commands::Save.expects(:execute).with(@person, true, true).returns(false)
           lambda { @person.save! }.should raise_error
         end
 
@@ -108,7 +108,7 @@ describe Mongoid::Commands do
 
       it "runs the before and after create callbacks" do
         @person.expects(:run_callbacks).with(:before_create)
-        Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(true)
+        Mongoid::Commands::Save.expects(:execute).with(@person, true, true).returns(true)
         @person.expects(:run_callbacks).with(:after_create)
         @person.save!
       end
@@ -120,7 +120,7 @@ describe Mongoid::Commands do
   describe "#update_attributes" do
 
     it "delegates to the Save command" do
-      Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(true)
+      Mongoid::Commands::Save.expects(:execute).with(@person, true, false).returns(true)
       @person.update_attributes({})
     end
 
@@ -131,7 +131,7 @@ describe Mongoid::Commands do
     context "when validation passes" do
 
       it "it returns the person" do
-        Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(true)
+        Mongoid::Commands::Save.expects(:execute).with(@person, true, false).returns(true)
         @person.update_attributes({}).should be_true
       end
 
@@ -140,7 +140,7 @@ describe Mongoid::Commands do
     context "when validation fails" do
 
       it "it raises an error" do
-        Mongoid::Commands::Save.expects(:execute).with(@person, true).returns(false)
+        Mongoid::Commands::Save.expects(:execute).with(@person, true, true).returns(false)
         lambda { @person.update_attributes!({}) }.should raise_error
       end
 

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

@@ -0,0 +1,208 @@
+require "spec_helper"
+
+describe Mongoid::Contexts::Enumerable do
+
+  before do
+    @london = Address.new(:number => 1, :street => "Bond Street")
+    @shanghai = Address.new(:number => 10, :street => "Nan Jing Dong Lu")
+    @melbourne = Address.new(:number => 20, :street => "Bourke Street")
+    @new_york = Address.new(:number => 20, :street => "Broadway")
+    @docs = [ @london, @shanghai, @melbourne, @new_york ]
+    @selector = { :street => "Bond Street" }
+    @options = { :fields => [ :number ] }
+    @context = Mongoid::Contexts::Enumerable.new(@selector, @options, @docs)
+  end
+
+  describe "#aggregate" do
+
+    before do
+      @counts = @context.aggregate
+    end
+
+    it "groups by the fields provided in the options" do
+      @counts.size.should == 3
+    end
+
+    it "stores the counts in proper groups" do
+      @counts[1].should == 1
+      @counts[10].should == 1
+      @counts[20].should == 2
+    end
+  end
+
+  describe "#count" do
+
+    it "returns the size of the enumerable" do
+      @context.count.should == 4
+    end
+
+  end
+
+  describe "#execute" do
+
+    it "returns the matching documents from the array" do
+      @context.execute.should == [ @london ]
+    end
+
+  end
+
+  describe "#first" do
+
+    it "returns the first in the enumerable" do
+      @context.first.should == @london
+    end
+
+  end
+
+  describe "#group" do
+
+    before do
+      @group = @context.group
+    end
+
+    it "groups by the fields provided in the options" do
+      @group.size.should == 3
+    end
+
+    it "stores the documents in proper groups" do
+      @group[1].should == [ @london ]
+      @group[10].should == [ @shanghai ]
+      @group[20].should == [ @melbourne, @new_york ]
+    end
+
+  end
+
+  describe ".initialize" do
+
+    let(:selector) { { :field => "value"  } }
+    let(:options) { { :skip => 20 } }
+    let(:documents) { [stub] }
+
+    before do
+      @context = Mongoid::Contexts::Enumerable.new(selector, options, documents)
+    end
+
+    it "sets the selector" do
+      @context.selector.should == selector
+    end
+
+    it "sets the options" do
+      @context.options.should == options
+    end
+
+    it "sets the documents" do
+      @context.documents.should == documents
+    end
+
+  end
+
+  describe "#last" do
+
+    it "returns the last in the enumerable" do
+      @context.last.should == @new_york
+    end
+
+  end
+
+  describe "#max" do
+
+    it "returns the max value for the supplied field" do
+      @context.max(:number).should == 20
+    end
+
+  end
+
+  describe "#min" do
+
+    it "returns the min value for the supplied field" do
+      @context.min(:number).should == 1
+    end
+
+  end
+
+  describe "#one" do
+
+    it "returns the first in the enumerable" do
+      @context.one.should == @london
+    end
+
+  end
+
+  describe "#page" do
+
+    context "when the page option exists" do
+
+      before do
+        @criteria = Mongoid::Criteria.new(Person).extras({ :page => 5 })
+        @context = Mongoid::Contexts::Enumerable.new({}, @criteria.options, [])
+      end
+
+      it "returns the page option" do
+        @context.page.should == 5
+      end
+
+    end
+
+    context "when the page option does not exist" do
+
+      before do
+        @criteria = Mongoid::Criteria.new(Person)
+        @context = Mongoid::Contexts::Enumerable.new({}, @criteria.options, [])
+      end
+
+      it "returns 1" do
+        @context.page.should == 1
+      end
+
+    end
+
+  end
+
+  describe "#paginate" do
+
+    before do
+      @criteria = Person.where(:_id => "1").skip(60).limit(20)
+      @context = Mongoid::Contexts::Enumerable.new(@criteria.selector, @criteria.options, [])
+      @results = @context.paginate
+    end
+
+    it "executes and paginates the results" do
+      @results.current_page.should == 4
+      @results.per_page.should == 20
+    end
+
+  end
+
+  describe "#per_page" do
+
+    context "when a limit option exists" do
+
+      it "returns 20" do
+        @context.per_page.should == 20
+      end
+
+    end
+
+    context "when a limit option does not exist" do
+
+      before do
+        @context = Mongoid::Contexts::Enumerable.new({}, { :limit => 50 }, [])
+      end
+
+      it "returns the limit" do
+        @context.per_page.should == 50
+      end
+
+    end
+
+  end
+
+  describe "#sum" do
+
+    it "returns the sum of all the field values" do
+      @context.sum(:number).should == 51
+    end
+
+  end
+
+end

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

@@ -0,0 +1,370 @@
+require "spec_helper"
+
+describe Mongoid::Contexts::Mongo do
+
+  describe "#aggregate" do
+
+    before do
+      @selector = {}
+      @options = { :fields => [:field1] }
+      @context = Mongoid::Contexts::Mongo.new(@selector, @options, Person)
+    end
+
+    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], {}, {:count => 0}, @reduce, true)
+        @context.aggregate
+      end
+
+    end
+
+  end
+
+  describe "#count" do
+
+    before do
+      @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
+
+      before do
+        @context.instance_variable_set(:@count, 34)
+      end
+
+      it "returns a count from the cursor" do
+        @context.count.should == 34
+      end
+
+    end
+
+    context "when criteria has been executed" do
+
+      before do
+        @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)
+        @context.count.should == 10
+      end
+
+    end
+
+  end
+
+  describe "#group" do
+
+    before do
+      @selector = { :_type => { "$in" => ["Doctor", "Person"] } }
+      @options = { :fields => [ :field1 ] }
+      @grouping = [{ "title" => "Sir", "group" => [{ "title" => "Sir", "age" => 30, "_type" => "Person" }] }]
+      @context = Mongoid::Contexts::Mongo.new(@selector, @options, Person)
+    end
+
+    context "when klass 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)
+        @context.group
+      end
+
+    end
+
+  end
+
+  describe "#execute" do
+
+    let(:selector) { { :field => "value"  } }
+    let(:options) { { :skip => 20 } }
+
+    before do
+      @cursor = stub(:count => 500)
+      @collection = mock
+      @person = mock
+      @klass = stub(:collection => @collection, :hereditary => false, :instantiate => @person)
+      @context = Mongoid::Contexts::Mongo.new(selector, options, @klass)
+    end
+
+    it "calls find on the collection" do
+      @collection.expects(:find).with(selector, options).returns(@cursor)
+      @cursor.expects(:collect).yields({ :title => "Sir" }).returns([@person])
+      @context.execute.should == [@person]
+    end
+
+    context "when field options are supplied" do
+
+      context "when _type not in the field list" do
+
+        before do
+          options[:fields] = [ :title ]
+          @expected_options = { :skip => 20, :fields => [ :title, :_type ] }
+        end
+
+        it "adds _type to the fields" do
+          @collection.expects(:find).with(selector, @expected_options).returns(@cursor)
+          @cursor.expects(:collect).yields({ :title => "Sir" }).returns([@person])
+          @context.execute.should == [@person]
+        end
+
+      end
+
+    end
+
+  end
+
+  describe ".initialize" do
+
+    let(:selector) { { :field => "value"  } }
+    let(:options) { { :skip => 20 } }
+    let(:klass) { Person }
+
+    before do
+      @context = Mongoid::Contexts::Mongo.new(selector, options, klass)
+    end
+
+    it "sets the selector" do
+      @context.selector.should == selector
+    end
+
+    it "sets the options" do
+      @context.options.should == options
+    end
+
+    it "sets the klass" do
+      @context.klass.should == klass
+    end
+
+  end
+
+  describe "#last" do
+
+    before do
+      @collection = mock
+      Person.expects(:collection).returns(@collection)
+    end
+
+    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(
+          { "title" => "Sir", "_type" => "Person" }
+        )
+      end
+
+      it "calls find on the collection with the selector and sort options reversed" do
+        @context.last.should be_a_kind_of(Person)
+      end
+
+    end
+
+    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)
+      end
+
+      it "returns nil" do
+        @context.last.should be_nil
+      end
+
+    end
+
+    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(
+          { "title" => "Sir", "_type" => "Person" }
+        )
+      end
+
+      it "defaults to sort by id" do
+        @context.last
+      end
+
+    end
+
+  end
+
+  describe "#max" do
+
+    before do
+      @reduce = Mongoid::Contexts::Mongo::MAX_REDUCE.gsub("[field]", "age")
+      @collection = mock
+      Person.expects(:collection).returns(@collection)
+      @context = Mongoid::Contexts::Mongo.new({}, {}, Person)
+    end
+
+    it "calls group on the collection with the aggregate js" do
+      @collection.expects(:group).with(
+        nil,
+        {},
+        {:max => "start"},
+        @reduce,
+        true
+      ).returns([{"max" => 200.0}])
+      @context.max(:age).should == 200.0
+    end
+
+  end
+
+  describe "#min" do
+
+    before do
+      @reduce = Mongoid::Contexts::Mongo::MIN_REDUCE.gsub("[field]", "age")
+      @collection = mock
+      Person.expects(:collection).returns(@collection)
+      @context = Mongoid::Contexts::Mongo.new({}, {}, Person)
+    end
+
+    it "calls group on the collection with the aggregate js" do
+      @collection.expects(:group).with(
+        nil,
+        {},
+        {:min => "start"},
+        @reduce,
+        true
+      ).returns([{"min" => 4.0}])
+      @context.min(:age).should == 4.0
+    end
+
+  end
+
+  describe "#one" 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(
+          { "title"=> "Sir", "_type" => "Person" }
+        )
+      end
+
+      it "calls find on the collection with the selector and options" do
+        @context.one.should be_a_kind_of(Person)
+      end
+
+    end
+
+    context "when no documents exist" do
+
+      before do
+        @collection = mock
+        Person.expects(:collection).returns(@collection)
+        @context = Mongoid::Contexts::Mongo.new({}, {}, Person)
+        @collection.expects(:find_one).with({}, {}).returns(nil)
+      end
+
+      it "returns nil" do
+        @context.one.should be_nil
+      end
+
+    end
+
+  end
+
+  describe "#page" do
+
+    context "when the page option exists" do
+
+      before do
+        @criteria = Mongoid::Criteria.new(Person).extras({ :page => 5 })
+        @context = Mongoid::Contexts::Mongo.new({}, @criteria.options, Person)
+      end
+
+      it "returns the page option" do
+        @context.page.should == 5
+      end
+
+    end
+
+    context "when the page option does not exist" do
+
+      before do
+        @criteria = Mongoid::Criteria.new(Person)
+        @context = Mongoid::Contexts::Mongo.new({}, @criteria.options, Person)
+      end
+
+      it "returns 1" do
+        @context.page.should == 1
+      end
+
+    end
+
+  end
+
+  describe "#paginate" do
+
+    before 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)
+      @collection.expects(:find).with({:_type => { "$in" => ["Doctor", "Person"] }, :_id => "1"}, :skip => 60, :limit => 20).returns([])
+      @results = @context.paginate
+    end
+
+    it "executes and paginates the results" do
+      @results.current_page.should == 4
+      @results.per_page.should == 20
+    end
+
+  end
+
+  describe "#sum" do
+
+    context "when klass not provided" do
+
+      before do
+        @reduce = Mongoid::Contexts::Mongo::SUM_REDUCE.gsub("[field]", "age")
+        @collection = mock
+        @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,
+          {},
+          {:sum => "start"},
+          @reduce,
+          true
+        ).returns([{"sum" => 50.0}])
+        @context.sum(:age).should == 50.0
+      end
+
+    end
+
+  end
+
+end