mongo_mapper 0.14.0.rc1 → 0.15.3

data/spec/functional/logger_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
 describe "Logger" do
-  context "with connection that has logger" do
+  context "with connection that has logger", without_connection: true do
     before do
       @output = StringIO.new
       @logger = Logger.new(@output)
-      MongoMapper.connection = Mongo::MongoClient.new('127.0.0.1', 27017, :logger => @logger)
+      MongoMapper.connection = Mongo::Client.new(['127.0.0.1:27017'], :logger => @logger)
     end
 
     it "should be able to get access to that logger" do

data/spec/functional/modifiers_spec.rb

@@ -4,7 +4,7 @@ module Modifiers
   describe "Modifiers" do
     let(:page_class_with_compound_key) {
       Doc do
-        key :_id,         BSON::OrderedHash, :default => lambda { BSON::OrderedHash['n', 42, 'i', BSON::ObjectId.new] }
+        key :_id,         Hash, :default => lambda { Hash['n', 42, 'i', BSON::ObjectId.new] }
         key :title,       String
         key :day_count,   Integer, :default => 0
         key :week_count,  Integer, :default => 0
@@ -24,7 +24,7 @@ module Modifiers
     }
 
     def assert_page_counts(page, day_count, week_count, month_count)
-      doc = page.collection.find_one({:_id => page.id})
+      doc = page.collection.find({:_id => page.id}).first
       doc.should be_present, "Could not find document"
       doc.fetch('day_count').should == day_count
       doc.fetch('week_count').should == week_count
@@ -32,7 +32,7 @@ module Modifiers
     end
 
     def assert_keys_removed(page, *keys)
-      page.class.collection.find_one({:_id => page.id}).tap do |doc|
+      page.class.collection.find({:_id => page.id}).first.tap do |doc|
         doc.should be_present, "Could not find document"
         (doc.keys & keys).should be_empty, "Expected to not have keys #{keys.inspect}, got #{(keys & doc.keys).inspect}"
       end
@@ -69,10 +69,10 @@ module Modifiers
           it "should be able to pass safe option" do
             page_class.create(:title => "Better Be Safe than Sorry")
 
-            expect_any_instance_of(Mongo::Collection).to receive(:update).with(
+            Mongo::Collection.any_instance.should_receive(:update_many).with(
               {:title => "Better Be Safe than Sorry"},
               {'$unset' => {:tags => 1}},
-              {:w => 1, :multi => true}
+              {:w => 1}
             )
             page_class.unset({:title => "Better Be Safe than Sorry"}, :tags, {:w => 1})
           end
@@ -166,17 +166,17 @@ module Modifiers
         it "should typecast values before querying" do
           page_class.key :tags, Set
 
-          expect {
+          lambda {
             page_class.set(page.id, :tags => ['foo', 'bar'].to_set)
             page.reload
             page.tags.should == Set.new(['foo', 'bar'])
-          }.to_not raise_error
+          }.should_not raise_error
         end
 
-        it "should not typecast keys that are not defined in document" do
-          expect {
+        it "should not typecast keys that are not defined in document and have no default typecasing" do
+          lambda {
             page_class.set(page.id, :colors => ['red', 'green'].to_set)
-          }.to raise_error(BSON::InvalidDocument)
+          }.should raise_error(BSON::Error::UnserializableClass, /does not define its BSON serialized type/)
         end
 
         it "should set keys that are not defined in document" do
@@ -196,10 +196,10 @@ module Modifiers
           it "should be able to pass safe option" do
             page_class.create(:title => "Better Be Safe than Sorry")
 
-            expect_any_instance_of(Mongo::Collection).to receive(:update).with(
+            Mongo::Collection.any_instance.should_receive(:update_many).with(
               {:title => "Better Be Safe than Sorry"},
               {'$set' => {:title => "I like safety."}},
-              {:w => 1, :multi => true}
+              {:w => 1}
             )
             page_class.set({:title => "Better Be Safe than Sorry"}, {:title => "I like safety."}, {:safe => true})
           end
@@ -238,6 +238,15 @@ module Modifiers
       context "push_all" do
         let(:tags) { %w(foo bar) }
 
+        before do
+          Kernel.stub(:warn)
+        end
+
+        it "should issue a warning" do
+          Kernel.should_receive(:warn).with("push_all no longer supported. use $push with $each")
+          page_class.push_all({:title => 'Home'}, :tags => tags)
+        end
+
         it "should work with criteria and modifier hashes" do
           page_class.push_all({:title => 'Home'}, :tags => tags)
 
@@ -385,9 +394,9 @@ module Modifiers
           page_class.create(:title => "Better Be Safe than Sorry")
 
           # We are trying to increment a key of type string here which should fail
-          expect {
+          lambda {
             page_class.increment({:title => "Better Be Safe than Sorry"}, {:title => 1}, {:safe => true})
-          }.to raise_error(Mongo::OperationFailure)
+          }.should raise_error(Mongo::Error::OperationFailure)
         end
 
         it "should be able to pass both safe and upsert options" do
@@ -397,19 +406,51 @@ module Modifiers
           page_class.first(:title => new_key_value).day_count.should == 1
         end
       end
+
+      context "upsert" do
+        it "should insert document if not present" do
+          lambda {
+            page_class.upsert({:title => 'A new story'}, {:title => 'A new story', :day_count => 1})
+          }.should change {page_class.count}
+          page_class.first(title: 'A new story').day_count.should == 1
+        end
+
+        it "should update documents if present" do
+          lambda {
+            page_class.upsert({:_id => page2.id}, {tags: %w(foo bar)})
+          }.should_not change {page_class.count}
+          page2.reload.tags.should == %w(foo bar)
+        end
+      end
+
+      context "find_and_modify" do
+        it "should retrieve the document without the changes" do
+          page_class.find_and_modify(query: {_id: page2.id}, update: {title: 'A new title'})['title'].should == 'Home'
+          page2.reload.title.should == 'A new title'
+        end
+
+        it "should allow find_and_modify options" do
+          page_class.find_and_modify(query: {_id: page2.id}, update: {title: 'A new title'}, return_document: :after)['title'].should == 'A new title'
+        end
+      end
+
     end
 
     context "compound keys" do
       it "should create a document" do
-        expect {
+        lambda {
           page_class_with_compound_key.create(:title => 'Foo', :tags => %w(foo))
-        }.to change { page_class_with_compound_key.count }.by(1)
+        }.should change { page_class_with_compound_key.count }.by(1)
         doc = page_class_with_compound_key.first
         page_class_with_compound_key.find(doc._id).should == doc
       end
     end
 
     context "instance methods" do
+      before do
+        Kernel.stub(:warn)
+      end
+
       {
         :page_class_with_standard_key => "with standard key",
         :page_class_with_compound_key => "with compound key",
@@ -430,6 +471,13 @@ module Modifiers
             assert_page_counts page, 1, 2, 3
           end
 
+          it "should be able to increment with just the field name" do
+            page = page_class.create
+            page.increment :day_count
+
+            assert_page_counts page, 1, 0, 0
+          end
+
           it "should be able to decrement with modifier hashes" do
             page = page_class.create(:day_count => 1, :week_count => 2, :month_count => 3)
             page.decrement(:day_count => 1, :week_count => 2, :month_count => 3)
@@ -437,6 +485,13 @@ module Modifiers
             assert_page_counts page, 0, 0, 0
           end
 
+          it "should be able to decrement with just the field name" do
+            page = page_class.create
+            page.decrement :day_count
+
+            assert_page_counts page, -1, 0, 0
+          end
+
           it "should always decrement when decrement is called whether number is positive or negative" do
             page = page_class.create(:day_count => 1, :week_count => 2, :month_count => 3)
             page.decrement(:day_count => -1, :week_count => 2, :month_count => -3)
@@ -467,6 +522,13 @@ module Modifiers
             page.tags.should == %w(foo bar)
           end
 
+          it "should issue a warning with push_all" do
+            Kernel.should_receive(:warn).with("push_all no longer supported. use $push with $each")
+
+            page = page_class.create
+            page.push_all(:tags => %w(foo bar))
+          end
+
           it "should be able to pull with criteria and modifier hashes" do
             page = page_class.create(:tags => %w(foo bar))
             page.pull(:tags => 'foo')
@@ -531,9 +593,9 @@ module Modifiers
             page = page_class.create(:title => "Safe Page")
 
             # We are trying to increment a key of type string here which should fail
-            expect {
+            lambda {
               page.increment({:title => 1}, {:safe => true})
-            }.to raise_error(Mongo::OperationFailure)
+            }.should raise_error(Mongo::Error::OperationFailure)
           end
 
           it "should be able to pass upsert and safe options" do
@@ -547,4 +609,4 @@ module Modifiers
       end
     end
   end
-end
+end

data/spec/functional/partial_updates_spec.rb

@@ -85,9 +85,9 @@ describe "Partial Updates" do
       @obj.save!
 
       mock_collection = double 'collection'
-      allow(@obj).to receive(:collection).and_return mock_collection
+      @obj.stub(:collection).and_return mock_collection
 
-      expect(@obj.collection).to receive(:update).with({:_id => @obj.id}, {
+      @obj.collection.should_receive(:update_one).with({:_id => @obj.id}, {
         '$set' => {
           "string_field" => "bar",
           "updated_at" => kind_of(Time),
@@ -126,16 +126,16 @@ describe "Partial Updates" do
       @obj.save!
 
       mock_collection = double 'collection'
-      allow(@obj).to receive(:collection).and_return mock_collection
+      @obj.stub(:collection).and_return mock_collection
 
-      expect(@obj.collection).to receive(:save).with({
+      @obj.collection.should_receive(:update_one).with({:_id => @obj.id}, {
         "_id" => @obj.id,
         "string_field" => "bar",
         "array_field" => [],
         "hash_field" => {},
         "created_at" => kind_of(Time),
         "updated_at" => kind_of(Time),
-      }, {})
+      }, {upsert: true})
 
       @obj.string_field = "bar"
       @obj.save!
@@ -234,7 +234,7 @@ describe "Partial Updates" do
       attrs = @obj.attributes.dup
       attrs.delete("foo")
 
-      allow(@obj).to receive(:attributes).and_return(attrs)
+      @obj.stub(:attributes).and_return(attrs)
 
       @obj.fields_for_partial_update.should == {
         :set_fields => [],
@@ -566,11 +566,11 @@ describe "Partial Updates" do
       updates[:unset_fields].should == []
 
       mock_collection = double('collection')
-      allow(obj).to receive(:collection).and_return(mock_collection)
+      obj.stub(:collection).and_return(mock_collection)
 
       update_query_expectation = hash_including("$set"=> hash_including("boolean_field"))
 
-      obj.collection.should_not receive(:update).with(anything, update_query_expectation, anything)
+      obj.collection.should_not_receive(:update_one).with(anything, update_query_expectation, anything)
       obj.save!
     end
   end

data/spec/functional/protected_spec.rb

@@ -115,7 +115,7 @@ describe "Single collection inherited protected attributes" do
       key :site_id, ObjectId
       attr_protected :site_id
     end
-    GrandParent.collection.remove
+    GrandParent.collection.drop
 
     class ::Child < ::GrandParent
       key :position, Integer

data/spec/functional/querying_spec.rb

@@ -164,7 +164,7 @@ describe "Querying" do
     end
 
     it "should raise document not found if nothing provided for find!" do
-      expect { document.find! }.to raise_error(MongoMapper::DocumentNotFound)
+      lambda { document.find! }.should raise_error(MongoMapper::DocumentNotFound)
     end
 
     context "(with a single id)" do
@@ -177,7 +177,7 @@ describe "Querying" do
       end
 
       it "should raise error if document not found with find!" do
-        expect { document.find!(123) }.to raise_error(MongoMapper::DocumentNotFound)
+        lambda { document.find!(123) }.should raise_error(MongoMapper::DocumentNotFound)
       end
     end
 
@@ -203,15 +203,15 @@ describe "Querying" do
       end
 
       it "should raise error if not all found when using find!" do
-        expect {
+        lambda {
           document.find!(@doc1._id, BSON::ObjectId.new.to_s)
-        }.to raise_error(MongoMapper::DocumentNotFound)
+        }.should raise_error(MongoMapper::DocumentNotFound)
       end
 
       it "should raise error if not all found when using find!" do
-        expect {
+        lambda {
           document.find!([@doc1._id, BSON::ObjectId.new.to_s])
-        }.to raise_error(MongoMapper::DocumentNotFound)
+        }.should raise_error(MongoMapper::DocumentNotFound)
       end
 
       it "should return array if array with one element" do
@@ -219,6 +219,16 @@ describe "Querying" do
       end
     end
 
+    context "(with array of single id)" do
+      it "should return an array" do
+        document.find([@doc1._id]).should == [@doc1]
+      end
+
+      it "should return an array for find!" do
+        document.find!([@doc1._id]).should == [@doc1]
+      end
+    end
+
     it "should be able to find using condition auto-detection" do
       document.first(:first_name => 'John').should == @doc1
       document.all(:last_name => 'Nunemaker', :order => 'age desc').should == [@doc1, @doc3]
@@ -255,6 +265,18 @@ describe "Querying" do
         document.find_each(:last_name => 'Nunemaker', :order => 'age desc') {|doc| yield_documents << doc }
         yield_documents.should == [@doc1, @doc3]
       end
+
+      it "should return an enumerator when no block is given" do
+        yield_documents = []
+        enum = document.find_each(:order => "first_name")
+        enum.with_index {|doc, idx| yield_documents << [doc, idx] }
+        yield_documents.should == [[@doc1, 0], [@doc3, 1], [@doc2, 2]]
+
+        yield_documents = []
+        enum = document.find_each(:last_name => 'Nunemaker', :order => 'age desc')
+        enum.with_index {|doc, idx| yield_documents << [doc, idx] }
+        yield_documents.should == [[@doc1, 0], [@doc3, 1]]
+      end
     end
   end # finding documents
 
@@ -292,12 +314,12 @@ describe "Querying" do
     end
 
     it "should disregard non-keys when creating, but use them in the query" do
-      expect {
+      lambda {
         document.create(:first_name => 'John', :age => 9)
         lambda {
           document.first_or_create(:first_name => 'John', :age.gt => 10).first_name.should == 'John'
         }.should change { document.count }.by(1)
-      }.to_not raise_error
+      }.should_not raise_error
     end
   end
 
@@ -320,10 +342,10 @@ describe "Querying" do
     end
 
     it "should disregard non-keys when initializing, but use them in the query" do
-      expect {
+      lambda {
         document.create(:first_name => 'John', :age => 9)
         document.first_or_new(:first_name => 'John', :age.gt => 10).first_name.should == 'John'
-      }.to_not raise_error
+      }.should_not raise_error
     end
   end
 
@@ -616,6 +638,32 @@ describe "Querying" do
     it "should be chainable" do
       @query.sort(:age).all.map(&:age).should == [26, 27, 28]
     end
+
+    it "supports hash" do
+      @query = document.fields({:age => 0})
+      docs = @query.all
+      docs.should include(@doc1)
+      docs.should include(@doc3)
+      docs.should include(@doc2)
+      docs.each do |doc|
+        doc.age.should              be_nil # key was not loaded
+        doc.first_name.should_not   be_nil
+        doc.last_name.should_not    be_nil # key was not loaded
+      end
+    end
+
+    it "supports array" do
+      @query = document.fields([:age,:first_name])
+      docs = @query.all
+      docs.should include(@doc1)
+      docs.should include(@doc3)
+      docs.should include(@doc2)
+      docs.each do |doc|
+        doc.age.should_not          be_nil
+        doc.first_name.should_not   be_nil
+        doc.last_name.should        be_nil # key was not loaded
+      end
+    end
   end
 
   context ".limit" do
@@ -763,7 +811,7 @@ describe "Querying" do
     it "should update the attribute without invoking validations" do
       document.key :name, String, :required => true
 
-      expect(@doc).to receive(:valid?).never
+      @doc.should_receive(:valid?).never
       @doc.update_attribute('name', '').should be_truthy
 
       @doc.reload.name.should == ''
@@ -868,7 +916,7 @@ describe "Querying" do
 
     it "should insert invalid document" do
       doc = document.new
-      expect(doc).to receive(:valid?).never
+      doc.should_receive(:valid?).never
       doc.save(:validate => false)
       document.count.should == 1
     end
@@ -885,15 +933,15 @@ describe "Querying" do
 
     it "should allow passing safe" do
       @document.create(:name => 'John')
-      expect {
+      lambda {
         @document.new(:name => 'John').save(:safe => true)
-      }.to raise_error(Mongo::OperationFailure)
+      }.should raise_error(Mongo::Error::OperationFailure)
     end
 
     it "should raise argument error if options has unsupported key" do
-      expect {
+      lambda {
         @document.new.save(:foo => true)
-      }.to raise_error(ArgumentError)
+      }.should raise_error(ArgumentError)
     end
   end
 
@@ -906,21 +954,21 @@ describe "Querying" do
 
     it "should allow passing safe" do
       @document.create(:name => 'John')
-      expect {
+      lambda {
         @document.new(:name => 'John').save!(:safe => true)
-      }.to raise_error(Mongo::OperationFailure)
+      }.should raise_error(Mongo::Error::OperationFailure)
     end
 
     it "should raise argument error if options has unsupported key" do
-      expect {
+      lambda {
         @document.new.save!(:foo => true)
-      }.to raise_error(ArgumentError)
+      }.should raise_error(ArgumentError)
     end
 
     it "should raise argument error if using validate as that would be pointless with save!" do
-      expect {
+      lambda {
         @document.new.save!(:validate => false)
-      }.to raise_error(ArgumentError)
+      }.should raise_error(ArgumentError)
     end
   end