mongo_mapper 0.14.0 → 0.15.0

data/spec/functional/keys_spec.rb

@@ -70,7 +70,7 @@ describe "Keys" do
       end
     end
 
-    expect { doc.new }.to_not raise_error
+    lambda { doc.new }.should_not raise_error
   end
 
   it "should not bomb if a key is read before Keys#initialize gets to get called" do
@@ -84,7 +84,7 @@ describe "Keys" do
       end
     end
 
-    expect { doc.new }.to_not raise_error
+    lambda { doc.new }.should_not raise_error
   end
 
   it "should permit for key overrides" do
@@ -93,7 +93,7 @@ describe "Keys" do
       key :class, String, :accessors => :skip
     end
 
-    doc.collection.insert('class' => 'String')
+    doc.collection.insert_one('class' => 'String')
     doc.all.first.tap do |d|
       d.class.should == doc
       d["class"].should == "String"
@@ -109,7 +109,7 @@ describe "Keys" do
     }
 
     before do
-      doc.collection.insert(:dynamic => "foo")
+      doc.collection.insert_one(:dynamic => "foo")
       doc.first
     end
 
@@ -129,7 +129,7 @@ describe "Keys" do
   describe "with invalid names" do
     it "should warn when key names start with an uppercase letter" do
       doc = Doc {}
-      expect(Kernel).to receive(:warn).once.with(/may not start with uppercase letters/)
+      Kernel.should_receive(:warn).once.with(/may not start with uppercase letters/)
       doc.class_eval do
         key :NotConstant
       end
@@ -137,30 +137,30 @@ describe "Keys" do
 
     it "should handle keys that start with uppercase letters by translating their first letter to lowercase" do
       doc = Doc {}
-      allow(Kernel).to receive(:warn)
+      Kernel.stub(:warn)
       doc.class_eval do
         key :NotConstant
       end
-      doc.collection.insert("NotConstant" => "Just data!")
+      doc.collection.insert_one("NotConstant" => "Just data!")
       doc.first.notConstant.should == "Just data!"
     end
 
     it "should not create accessors for bad keys" do
       doc = Doc {}
-      expect(doc).to_not receive(:create_accessors_for)
+      doc.should_not_receive(:create_accessors_for)
       doc.class_eval do
         key :"bad-name", :__dynamic => true
       end
-      expect { doc.new.method(:"bad-name") }.to raise_error(NameError)
+      lambda { doc.new.method(:"bad-name") }.should raise_error(NameError)
     end
 
     it "should not create accessors for reserved keys" do
       doc = Doc {}
-      expect(doc).to_not receive(:create_accessors_for)
+      doc.should_not_receive(:create_accessors_for)
       doc.class_eval do
         key :"class", :__dynamic => true
       end
-      expect(doc.new.class).to eq doc
+      doc.new.class.should == doc
     end
 
     it "should create accessors for good keys" do
@@ -168,13 +168,13 @@ describe "Keys" do
         key :good_name
       }
       doc.new.good_name.should be_nil
-      expect { doc.new.method("good_name") }.to_not raise_error
+      lambda { doc.new.method("good_name") }.should_not raise_error
     end
   end
 
   it "should handle loading dynamic fields from the database that have bad names" do
     doc = Doc {}
-    doc.collection.insert("foo-bar" => "baz-bin")
+    doc.collection.insert_one("foo-bar" => "baz-bin")
 
     doc.first["foo-bar"].should == "baz-bin"
   end
@@ -195,7 +195,7 @@ describe "Keys" do
       end
 
       it "should serialize with aliased keys" do
-        AliasedKeyModel.collection.find_one.keys.should =~ %w(_id f bar)
+        AliasedKeyModel.collection.find.first.keys.should =~ %w(_id f bar)
 
         AliasedKeyModel.first.tap do |d|
           d.foo.should == "whee!"
@@ -219,15 +219,15 @@ describe "Keys" do
       it "should permit dealiasing of atomic operations" do
         m = AliasedKeyModel.first
         m.set(:foo => 1)
-        AliasedKeyModel.collection.find_one["f"].should == 1
-        AliasedKeyModel.collection.find_one["foo"].should be_nil
+        AliasedKeyModel.collection.find.first["f"].should == 1
+        AliasedKeyModel.collection.find.first["foo"].should be_nil
       end
 
       it "should permit dealiasing of update operations" do
         m = AliasedKeyModel.first
         m.update_attributes(:foo => 1)
-        AliasedKeyModel.collection.find_one["f"].should == 1
-        AliasedKeyModel.collection.find_one["foo"].should be_nil
+        AliasedKeyModel.collection.find.first["f"].should == 1
+        AliasedKeyModel.collection.find.first["foo"].should be_nil
       end
 
       it "should not break when unaliasing non-keys" do
@@ -246,7 +246,7 @@ describe "Keys" do
       before { AliasedKeyModel.create(:with_underscores => "foobar") }
       it "should work" do
         AliasedKeyModel.first.with_underscores.should == "foobar"
-        AliasedKeyModel.collection.find_one["with-hyphens"].should == "foobar"
+        AliasedKeyModel.collection.find.first["with-hyphens"].should == "foobar"
       end
     end
 
@@ -254,7 +254,7 @@ describe "Keys" do
       before { AliasedKeyModel.create(:field_name => "foobar") }
       it "should work" do
         AliasedKeyModel.first.field_name.should == "foobar"
-        AliasedKeyModel.collection.find_one["alternate_field_name"].should == "foobar"
+        AliasedKeyModel.collection.find.first["alternate_field_name"].should == "foobar"
       end
     end
 
@@ -291,7 +291,7 @@ describe "Keys" do
         owner.reload
         owner.associated_documents.to_a.should =~ associated_documents.to_a
 
-        AssociatedKeyWithAlias.collection.find_one.keys.should =~ %w(_id n aid)
+        AssociatedKeyWithAlias.collection.find.first.keys.should =~ %w(_id n aid)
       end
 
       it "should work with embedded documents" do
@@ -301,7 +301,7 @@ describe "Keys" do
 
         owner.reload
         owner.other_documents[0].embedded_name.should == "Underling"
-        owner.collection.find_one["other_documents"][0]["en"].should == "Underling"
+        owner.collection.find.first["other_documents"][0]["en"].should == "Underling"
       end
     end
   end

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",
@@ -467,6 +508,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 +579,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 +595,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
@@ -292,12 +292,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 +320,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 +616,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 +789,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 +894,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 +911,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 +932,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