mongo_mapper 0.14.0 → 0.15.1

data/spec/functional/identity_map_spec.rb

@@ -14,12 +14,12 @@ describe "IdentityMap" do
   end
 
   def expect_no_queries
-    expect_any_instance_of(Mongo::Collection).to receive(:find_one).never
-    expect_any_instance_of(Mongo::Collection).to receive(:find).never
+    Mongo::Collection.any_instance.should_receive(:find_one).never
+    Mongo::Collection.any_instance.should_receive(:find).never
   end
 
   def expects_one_query
-    expect_any_instance_of(Mongo::Collection).to receive(:find_one).once.and_return({})
+    Mongo::Collection.any_instance.should_receive(:find).once.and_call_original
   end
 
   def clear_identity_map
@@ -185,11 +185,11 @@ describe "IdentityMap" do
           key :created_at, Time
         end
 
-        expect do
+        lambda do
           loaded = person_with_time_class.load({'_id' => @id, 'name' => 'Frank', 'created_at' => '2014-12-07T20:36:45.529-08:00'}, true)
           loaded.should be_present
           loaded.created_at.should be_an_instance_of(Time)
-        end.to_not raise_error
+        end.should_not raise_error
       end
     end
 
@@ -420,7 +420,7 @@ describe "IdentityMap" do
           belongs_to :parent, :class_name => 'Item'
           one :blog, :class_name => 'Blog', :foreign_key => 'parent_id'
         end
-        Item.collection.remove
+        Item.collection.drop
 
         class ::Blog < ::Item; end
 
@@ -461,7 +461,7 @@ describe "IdentityMap" do
 
         blog = Blog.create(:title => 'Jill', :parent => root)
         assert_in_map(blog)
-        root.should equal(blog.parent.target)
+        root.should equal(blog.parent)
       end
 
       it "should work correctly with one proxy" do
@@ -470,7 +470,7 @@ describe "IdentityMap" do
 
         root = Item.create(:title => 'Root', :blog => blog)
         assert_in_map(root)
-        blog.should equal(root.blog.target)
+        blog.should equal(root.blog)
       end
 
       it "should work correctly with one proxy create" do

data/spec/functional/indexes_spec.rb

@@ -13,22 +13,25 @@ describe "Indexing" do
 
   context "against a known collection" do
     before do
-      allow(@document).to receive(:collection).and_return(double(:name => :foo))
+      @document.stub(:collection).and_return(double(:name => :foo, :indexes => double()))
     end
-    [:create_index, :ensure_index].each do |method|
-      it "should delegate #{method} to collection" do
-        expect(@document.collection).to receive(method).with(:arg, {})
-        @document.send(method, :arg)
-      end
+
+    it "should delegate create_index to collection#create_one" do
+      @document.collection.indexes.should_receive(:create_one).with({:arg => 1}, {})
+      @document.create_index(:arg)
     end
 
+    it "should delegate ensure_index to collection#create_one" do
+      @document.collection.indexes.should_receive(:create_one).with({:arg => 1}, {})
+      @document.create_index(:arg)
+    end
     it "should delegate drop_index to collection" do
-      expect(@document.collection).to receive(:drop_index).with(:arg)
+      @document.collection.indexes.should_receive(:drop_one).with(:arg)
       @document.drop_index(:arg)
     end
 
     it "should delegate drop_indexes to collection" do
-      expect(@document.collection).to receive(:drop_indexes)
+      @document.collection.indexes.should_receive(:drop_all)
       @document.drop_indexes
     end
   end
@@ -48,6 +51,11 @@ describe "Indexing" do
     @document.should have_index('last_name_1')
   end
 
+  it "should allow specifying as a hash" do
+    @document.ensure_index({last_name: -1})
+    @document.should have_index('last_name_-1')
+  end
+
   it "should allow creating unique index for a key" do
     @document.ensure_index :first_name, :unique => true
     @document.should have_index('fn_1')
@@ -55,18 +63,11 @@ describe "Indexing" do
 
   it "should allow creating index on multiple keys" do
     @document.ensure_index [[:first_name, 1], [:last_name, -1]]
-
-    # order is different for different versions of ruby so instead of
-    # just checking have_index('first_name_1_last_name_-1') I'm checking
-    # the values of the indexes to make sure the index creation was successful
-    @document.collection.index_information.detect do |index|
-      keys = index[0]
-      keys.include?('fn_1') && keys.include?('last_name_-1')
-    end.should_not be_nil
+    @document.should have_index('fn_1_last_name_-1')
   end
 
   it "should work with :index shortcut when defining key" do
-    silence_stderr { @document.key :father, String, :index => true }
+    suppress_stderr { @document.key :father, String, :index => true }
     @document.should have_index('father_1')
   end
-end
+end

data/spec/functional/keys_spec.rb

@@ -34,28 +34,46 @@ describe "Keys" do
     instance.foo.should == 'baz'
   end
 
-  context "when persisting an typecasted array" do
-    TypecastedKeyModel = Doc do
-      key :people, Array, :typecast => "Person"
-    end
-
+  context "when persisting typecasts" do
     Person = Struct.new(:name) do
       def self.to_mongo(value)
         value.name
       end
 
       def self.from_mongo(value)
-        Person.new value
+        new(value)
       end
     end
 
-    it "should not mutate the model's state" do
-      person = Person.new "Bob"
-      doc = TypecastedKeyModel.new(:people => [person])
+    context "when persisting a typecast Array" do
+      typecast_key_model = Doc do
+        key :people, Array, :typecast => "Person"
+      end
+
+      it "should not mutate the model's state" do
+        person = Person.new "Bob"
+        doc = typecast_key_model.new(:people => [person])
 
-      doc.save
+        doc.save!
+
+        doc.people.should == [person]
+      end
+    end
 
-      doc.people.should == [person]
+    context "when persisting a typecast Set" do
+      typecast_key_model = Doc do
+        key :people, Set, :typecast => "Person"
+      end
+
+      it "should not mutate the model's state" do
+        person = Person.new "Bob"
+
+        doc = typecast_key_model.new(:people => Set.new([person]))
+
+        doc.save!
+
+        doc.people.should == Set.new([person])
+      end
     end
   end
 
@@ -70,7 +88,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 +102,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 +111,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 +127,7 @@ describe "Keys" do
     }
 
     before do
-      doc.collection.insert(:dynamic => "foo")
+      doc.collection.insert_one(:dynamic => "foo")
       doc.first
     end
 
@@ -129,7 +147,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 +155,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 +186,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 +213,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 +237,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 +264,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 +272,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 +309,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 +319,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",
@@ -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