mongo_mapper 0.13.0 → 0.15.1

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
@@ -14,7 +14,7 @@ describe "Logger" do
 
     it "should be able to log messages" do
       MongoMapper.logger.debug 'testing'
-      @output.string.include?('testing').should be_true
+      @output.string.include?('testing').should be_truthy
     end
   end
 end

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")
 
-            Mongo::Collection.any_instance.should_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")
 
-            Mongo::Collection.any_instance.should_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

@@ -0,0 +1,577 @@
+require 'spec_helper'
+
+describe "Partial Updates" do
+  before do
+    @klass = Doc("PartialUpdates") do
+      key :string_field, String
+      key :array_field, Array
+      key :hash_field, Hash
+      key :integer_field, Integer
+      key :boolean_field, Boolean
+
+      timestamps!
+    end
+
+    @dealiased_keys_class = Doc("DealiasedKeys") do
+      key :foo, :abbr => "f"
+    end
+
+    @pet_klass = EDoc('Pet') do
+      key :name, String
+      key :flag, Boolean
+    end
+
+    @person_class = Doc('Person') do
+      key :name, String
+    end
+    @person_class.many :pets, :class => @pet_klass
+
+    @author_class = Doc("Author")
+
+    @post_class = Doc("Post") do
+      key :title, String
+    end
+    @post_class.one :author, :as => :authorable, :class => @author_class, :dependent => :nullify
+
+    @comments_class = Doc("Comment") do
+      key :text, String
+      key :owner_id, ObjectId
+    end
+
+    @klass.partial_updates = true
+    @dealiased_keys_class.partial_updates = true
+    @person_class.partial_updates = true
+    @post_class.partial_updates = true
+    @author_class.partial_updates = true
+    @comments_class.partial_updates = true
+
+    @obj = @klass.new
+  end
+
+  after do
+    @klass.destroy_all
+    @dealiased_keys_class.destroy_all
+    @person_class.destroy_all
+    @author_class.destroy_all
+    @post_class.destroy_all
+    @comments_class.destroy_all
+  end
+
+  it "should be able to turn on and off partial updates for the klass" do
+    @klass.partial_updates = false
+    @klass.partial_updates.should be_falsey
+
+    @klass.partial_updates = true
+    @klass.partial_updates.should be_truthy
+  end
+
+  it "should have partial updates off by default" do
+    Doc {}.partial_updates.should be_falsey
+  end
+
+  it "should update fields" do
+    @obj.string_field = "foo"
+    @obj.string_field.should == "foo"
+    @obj.save!
+
+    @obj.string_field = "bar"
+    @obj.string_field.should == "bar"
+    @obj.save!
+  end
+
+  describe "with partial updates on" do
+    it "should only update fields that have changed on save" do
+      @obj.string_field = "foo"
+      @obj.save!
+
+      mock_collection = double 'collection'
+      @obj.stub(:collection).and_return mock_collection
+
+      @obj.collection.should_receive(:update_one).with({:_id => @obj.id}, {
+        '$set' => {
+          "string_field" => "bar",
+          "updated_at" => kind_of(Time),
+        }
+      }, {})
+
+      @obj.string_field = "bar"
+      @obj.save!
+    end
+
+    it "should properly nullify associations" do
+      @post = @post_class.create
+      @author = @author_class.new
+      @post.author = @author
+      @author.reload
+      @author.authorable_id.should == @post.id
+
+      @post.author = @author_class.new
+
+      @author.reload
+      @author.authorable_id.should be_nil
+    end
+  end
+
+  describe "when partial updates are off" do
+    before do
+      @klass.partial_updates = false
+      @obj = @klass.new
+
+      @post_class.partial_updates = false
+      @author_class.partial_updates = false
+    end
+
+    it "should update all attributes" do
+      @obj.string_field = "foo"
+      @obj.save!
+
+      mock_collection = double 'collection'
+      @obj.stub(:collection).and_return mock_collection
+
+      @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!
+    end
+
+    it "should raise if fields_for_partial_update is called" do
+      lambda {
+        @obj.fields_for_partial_update
+      }.should raise_error(MongoMapper::Plugins::PartialUpdates::PartialUpdatesDisabledError)
+    end
+
+    it "should properly nullify associations" do
+      @post = @post_class.create
+      @author = @author_class.new
+      @post.author = @author
+      @author.reload
+      @author.authorable_id.should == @post.id
+
+      @post.author = @author_class.new
+
+      @author.reload
+      @author.authorable_id.should be_nil
+    end
+  end
+
+  describe "detecting attribute changes" do
+    it "should be able to find the fields_for_partial_update" do
+      @obj.string_field = "foo"
+
+      fields_for_partial_updates = @obj.fields_for_partial_update
+      fields_for_partial_updates.keys.should =~ [:set_fields, :unset_fields]
+      fields_for_partial_updates[:set_fields].should =~ ["_id", "string_field"]
+      fields_for_partial_updates[:unset_fields] == []
+    end
+
+    it "should not find any if no fields have changed" do
+      @obj.save!
+      @obj.fields_for_partial_update.should == {
+        :set_fields => [],
+        :unset_fields => []
+      }
+    end
+
+    it "should be cleared after save" do
+      @obj.string_field = "foo"
+      @obj.fields_for_partial_update[:set_fields].should =~ ["_id", "string_field"]
+
+      @obj.save!
+
+      @obj.fields_for_partial_update.should == {
+        :set_fields => [],
+        :unset_fields => []
+      }
+    end
+
+    it "should detect in place updates with a string" do
+      @obj.string_field = "foo"
+      @obj.save!
+
+      @obj.string_field.gsub!(/foo/, "bar")
+      @obj.string_field.should == "bar"
+      @obj.fields_for_partial_update[:set_fields].should == ["string_field"]
+    end
+
+    it "should detect in place updates with an array" do
+      @obj.array_field = [1]
+      @obj.save!
+
+      @obj.array_field << 2
+      @obj.array_field.should == [1,2]
+      @obj.fields_for_partial_update[:set_fields].should == ["array_field"]
+    end
+
+    it "should detect non-key based values" do
+      @obj.attributes = { :non_keyed_field => "foo" }
+      @obj.fields_for_partial_update[:set_fields].should =~ ["_id", "non_keyed_field"]
+    end
+
+    it "should allow fields that have numbers to be changed" do
+      @obj.integer_field = 1
+      @obj.save!
+
+      @obj.integer_field = 2
+      @obj.fields_for_partial_update[:set_fields].should == ["integer_field"]
+    end
+
+    it "should update fields with dealiased keys" do
+      @obj = @dealiased_keys_class.new(:foo => "one")
+      @obj.fields_for_partial_update[:set_fields].should =~ ["_id", "f"]
+    end
+
+    it "should update fields that have been deleted" do
+      @obj.attributes = { :foo => "bar" }
+      @obj.save!
+
+      attrs = @obj.attributes.dup
+      attrs.delete("foo")
+
+      @obj.stub(:attributes).and_return(attrs)
+
+      @obj.fields_for_partial_update.should == {
+        :set_fields => [],
+        :unset_fields => ["foo"]
+      }
+    end
+
+    it "should have an empty list of fields_for_partial_update[:set_fields] after reload" do
+      @obj.integer_field = 10
+      @obj.save!
+
+      @obj.reload
+      @obj.fields_for_partial_update.should == {
+        :set_fields => [],
+        :unset_fields => []
+      }
+    end
+
+    it "should return [] when re-found with find()" do
+      @obj.save!
+      obj_refound = @klass.find(@obj.id)
+      obj_refound.fields_for_partial_update.should == {
+        :set_fields => [],
+        :unset_fields => []
+      }
+    end
+
+    it "should return a field when re-found with find() and changed" do
+      @obj.save!
+      obj_refound = @klass.find(@obj.id)
+      obj_refound.string_field = "foo"
+      obj_refound.fields_for_partial_update[:set_fields].should == ["string_field"]
+    end
+
+    it "should return a field when it is a new object and it's been initialized with new" do
+      @obj = @klass.new({
+        :string_field => "foo"
+      })
+      @obj.fields_for_partial_update[:set_fields].should =~ ["_id", "string_field"]
+    end
+
+    it "should be able to detect any change in an array (deep copy)" do |variable|
+      @obj = @klass.create!({ :array_field => [["array", "of"], ["arrays"]] })
+      @obj.array_field.last.unshift "many"
+      @obj.save!
+      @obj.reload
+      @obj.array_field.last.should == ["many", "arrays"]
+    end
+
+    it "should be able to detect any change in an array (super deep copy)" do |variable|
+      @obj = @klass.create!({ :array_field => [["array", "of"], ["arrays"]] })
+      @obj.array_field.last << "foo"
+      @obj.fields_for_partial_update[:set_fields].should == ["array_field"]
+    end
+
+    it "should be able to detect a deep change in a hash" do
+      @obj = @klass.new({
+        :hash_field => {
+          :a => {
+            :really => {
+              :deep => :hash
+            }
+          }
+        }
+      })
+      @obj.save!
+
+      @obj.fields_for_partial_update[:set_fields].should == []
+
+      @obj.hash_field[:a][:really] = {
+        :really => {
+          :really => {
+            :really => {
+              :deep => :hash
+            }
+          }
+        }
+      }
+
+      @obj.fields_for_partial_update[:set_fields].should == ["hash_field"]
+    end
+  end
+
+  it "should set timestamps" do
+    @obj.string_field = "foo"
+    @obj.save!
+
+    @obj.created_at.should_not be_nil
+    @obj.updated_at.should_not be_nil
+
+    @obj.reload
+    @obj.created_at.should_not be_nil
+    @obj.updated_at.should_not be_nil
+  end
+
+  it "should be able to reload set values" do
+    @obj.string_field = "foo"
+    @obj.integer_field = 1
+    @obj.save!
+
+    @obj.reload
+    @obj.string_field.should == "foo"
+    @obj.integer_field.should == 1
+  end
+
+  it "should be able to reload documents created from create" do
+    @obj = @klass.create({
+      :string_field => "foo",
+      :integer_field => 1
+    })
+
+    @obj.reload
+    @obj.string_field.should == "foo"
+    @obj.integer_field.should == 1
+  end
+
+  describe "with embedded documents" do
+    before do
+      @person = @person_class.new
+      @person.pets.build
+      @person.save!
+      @person.reload
+      @pet = @person.pets.first
+    end
+
+    it "should have the child as an update key when the child changes" do
+      @pet.name = "monkey"
+      @person.fields_for_partial_update[:set_fields].should == ["pets"]
+    end
+  end
+
+  describe "with a has many" do
+    before do
+      @post_class.partial_updates = true
+      @comments_class.partial_updates = true
+
+      @post_class.many :comments, :class => @comments_class, :foreign_key => :owner_id
+    end
+
+    after do
+      @post_class.destroy_all
+      @comments_class.destroy_all
+    end
+
+    it "should save the children assigned through a hash in new (when assigned through new)" do
+      @post = @post_class.new({
+        :title => "foobar",
+        "comments" => [
+          { "text" => "one" }
+        ],
+      })
+
+      @post.save!
+      @post.reload
+
+      @post.title.should == "foobar"
+      @post.comments.length == 1
+      @post.comments.first.text.should == 'one'
+    end
+
+    it "should save the children assigned through a hash in new (when assigned through new) even when the children are refernced before save" do
+      @post = @post_class.new({
+        :title => "foobar",
+        "comments" => [
+          { "text" => "one" }
+        ],
+      })
+
+      # this line is important - it causes the proxy to load
+      @post.comments.length == 1
+
+      @post.comments.first.should be_persisted
+      @post.comments.first.fields_for_partial_update[:set_fields].should == []
+
+      @post.save!
+      @post.reload
+
+      @post.title.should == "foobar"
+      @post.comments.length.should == 1
+      @post.comments.first.text.should == 'one'
+    end
+
+    it "should update the children after a save if fields have changed" do
+      @post = @post_class.new({
+        :title => "foobar",
+        "comments" => [
+          { "text" => "one" }
+        ],
+      })
+
+      @post.comments.length == 1
+
+      @post.save!
+      @post.reload
+
+      comment = @post.comments.first
+      comment.text = "two"
+      comment.save!
+      comment.reload
+      comment.text.should == "two"
+    end
+
+    it "should save the built document when saving parent" do
+      post = @post_class.create(:title => "foobar")
+      comment = post.comments.build(:text => 'Foo')
+
+      post.save!
+
+      post.should_not be_new
+      comment.should_not be_new
+    end
+
+    it "should clear objects between test runs" do
+      @post_class.count.should == 0
+      @comments_class.count.should == 0
+    end
+
+    it "should only save one object with create" do
+      @post_class.count.should == 0
+      @comments_class.count.should == 0
+
+      @post_class.create(:title => "foobar")
+      @comments_class.create()
+
+      @post_class.count.should == 1
+      @comments_class.count.should == 1
+    end
+
+    it "should save an association with create with the correct attributes" do
+      post = @post_class.create(:title => "foobar")
+      @comments_class.create("text" => 'foo')
+
+      @comments_class.count.should == 1
+      @comments_class.first.text.should == "foo"
+    end
+
+    it "should be able to find objects through the association proxy" do
+      post = @post_class.create!(:title => "foobar")
+      comment = @comments_class.create!("text" => 'foo')
+
+      @comments_class.count.should == 1
+      @comments_class.first.text.should == "foo"
+
+      post.comments << comment
+
+      post.comments.count.should == 1
+      post.comments.first.text.should == "foo"
+      post.comments.all("text" => "foo").length.should == 1
+    end
+
+    it "should work with destroy all and conditions" do
+      @post_class.partial_updates = true
+      @comments_class.partial_updates = true
+
+      post = @post_class.create(:title => "foobar")
+      post.comments << @comments_class.create(:text => '1')
+      post.comments << @comments_class.create(:text => '2')
+      post.comments << @comments_class.create(:text => '3')
+
+      post.comments.count.should == 3
+      post.comments.destroy_all(:text => '1')
+      post.comments.count.should == 2
+
+      post.comments.destroy_all
+      post.comments.count.should == 0
+    end
+
+    it "should work with dealiased keys" do
+      @obj = @dealiased_keys_class.new(:foo => "foo")
+      @obj.save!
+      @obj.reload
+      @obj.foo.should == "foo"
+
+      @obj.foo = "bar"
+      @obj.save!
+      @obj.reload
+      @obj.foo.should == "bar"
+    end
+
+    it "should be able to nullify one associations through re-assignment" do
+      @post = @post_class.create
+      @author = @author_class.new
+      @post.author = @author
+
+      @author.reload
+      @author.authorable_id.should == @post.id
+
+      @post.author = @author_class.new
+
+      @author.reload
+      @author.authorable_id.should be_nil
+    end
+
+    it "should update values set in before_create" do
+      @klass.before_create do
+        self.string_field = "Scott"
+      end
+
+      obj = @klass.new
+      obj.save!
+
+      obj.string_field.should == "Scott"
+      obj.reload
+      obj.string_field.should == "Scott"
+    end
+
+    it "should update values set in before_update" do
+      @klass.before_update do
+        self.string_field = "Scott"
+      end
+
+      obj = @klass.new
+      obj.save!
+
+      obj.save!
+      obj.string_field.should == "Scott"
+      obj.reload
+      obj.string_field.should == "Scott"
+    end
+
+    it "should respect typecasting" do
+      obj = @klass.create(:boolean_field => 'true')
+      obj.boolean_field.should eq(true)
+
+      obj.boolean_field = "true"
+      obj.boolean_field.should eq(true)
+      updates = obj.fields_for_partial_update
+      updates[:set_fields].should == []
+      updates[:unset_fields].should == []
+
+      mock_collection = double('collection')
+      obj.stub(:collection).and_return(mock_collection)
+
+      update_query_expectation = hash_including("$set"=> hash_including("boolean_field"))
+
+      obj.collection.should_not_receive(:update_one).with(anything, update_query_expectation, anything)
+      obj.save!
+    end
+  end
+end