mongo_mapper 0.12.0 → 0.13.0.beta1

data/spec/functional/indexes_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe "Indexing" do
+  before do
+    @document = Doc do
+      key :first_name, String
+      key :last_name, String
+      key :age, Integer
+      key :date, Date
+    end
+  end
+  after { drop_indexes(@document) }
+
+  [:create_index, :ensure_index, :drop_index, :drop_indexes].each do |method|
+    it "should delegate #{method} to collection" do
+      @document.stub(:collection).and_return(double(:name => :foo))
+      @document.collection.should_receive(method).with(:arg)
+      @document.send(method, :arg)
+    end
+  end
+
+  it "should allow creating index for a key" do
+    @document.ensure_index :first_name
+    @document.should have_index('first_name_1')
+  end
+
+  it "should allow creating unique index for a key" do
+    @document.ensure_index :first_name, :unique => true
+    @document.should have_index('first_name_1')
+  end
+
+  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?('first_name_1') && keys.include?('last_name_-1')
+    end.should_not be_nil
+  end
+
+  it "should work with :index shortcut when defining key" do
+    silence_stderr { @document.key :father, String, :index => true }
+    @document.should have_index('father_1')
+  end
+end

data/spec/functional/keys_spec.rb

@@ -0,0 +1,224 @@
+require 'spec_helper'
+
+describe "Keys" do
+  it "should not have a disparity between the ivar and accessor" do
+    doc = Doc do
+      key :foo, String
+
+      def modify_foo
+        @foo = :baz
+      end
+
+      def get_foo
+        @foo
+      end
+    end
+
+    instance = doc.new(:foo => "bar")
+    instance.get_foo.should == instance.foo
+
+    instance.foo = :bing
+    instance.get_foo.should == instance.foo
+
+    instance.modify_foo
+    instance.get_foo.should == instance.foo
+  end
+
+  it "should not bomb if a key is written before Keys#initialize gets to get called" do
+    doc = Class.new do
+      include MongoMapper::Document
+
+      def initialize
+        self.class.key :something, String
+        self.something = :other_thing
+        super
+      end
+    end
+
+    expect { doc.new }.to_not raise_error
+  end
+
+  it "should not bomb if a key is read before Keys#initialize gets to get called" do
+    doc = Class.new do
+      include MongoMapper::Document
+
+      def initialize
+        self.class.key :something, String
+        self.something
+        super
+      end
+    end
+
+    expect { doc.new }.to_not raise_error
+  end
+
+
+  context "key segmenting" do
+    let(:doc) {
+      Doc {
+        key :defined
+      }
+    }
+
+    before do
+      doc.collection.insert(:dynamic => "foo")
+      doc.first
+    end
+
+    describe "#dynamic_keys" do
+      it "should find dynamic keys" do
+        doc.dynamic_keys.keys.should == ["dynamic"]
+      end
+    end
+
+    describe "#defined_keys" do
+      it "should find defined keys" do
+        doc.defined_keys.keys.should =~ ["_id", "defined"]
+      end
+    end
+  end
+
+  describe "with invalid names" do
+    it "should warn when key names start with an uppercase letter" do
+      doc = Doc {}
+      Kernel.should_receive(:warn).once.with(/may not start with uppercase letters/)
+      doc.class_eval do
+        key :NotConstant
+      end
+    end
+
+    it "should handle keys that start with uppercase letters by translating their first letter to lowercase" do
+      doc = Doc {}
+      Kernel.stub(:warn)
+      doc.class_eval do
+        key :NotConstant
+      end
+      doc.collection.insert("NotConstant" => "Just data!")
+      doc.first.notConstant.should == "Just data!"
+    end
+
+    it "should not create accessors for bad keys" do
+      doc = Doc {}
+      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)
+    end
+
+    it "should create accessors for good keys" do
+      doc = Doc {
+        key :good_name
+      }
+      doc.new.good_name.should be_nil
+      expect { doc.new.method("good_name") }.to_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.first["foo-bar"].should == "baz-bin"
+  end
+
+  describe "with aliases" do
+    AliasedKeyModel = Doc do
+      key :foo, :abbr => :f
+      key :with_underscores, :alias => "with-hyphens"
+      key :field_name, :field_name => "alternate_field_name"
+      key :bar
+    end
+
+    before { AliasedKeyModel.collection.drop }
+
+    context "standard key operations" do
+      before do
+        AliasedKeyModel.create(:foo => "whee!", :bar => "whoo!")
+      end
+
+      it "should serialize with aliased keys" do
+        AliasedKeyModel.collection.find_one.keys.should =~ %w(_id f bar)
+
+        AliasedKeyModel.first.tap do |d|
+          d.foo.should == "whee!"
+          d.bar.should == "whoo!"
+        end
+      end
+
+      it "should permit querying via aliases" do
+        AliasedKeyModel.where(AliasedKeyModel.abbr(:f) => "whee!").first.foo.should == "whee!"
+      end
+
+      it "should serialize to JSON with full keys" do
+        AliasedKeyModel.first.as_json.tap do |json|
+          json.should have_key "foo"
+          json.should_not have_key "f"
+        end
+      end
+    end
+
+    context "given field which are not valid Ruby method names" 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"
+      end
+    end
+
+    context "given a field aliased with :field_name" 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"
+      end
+    end
+
+    context "associations" do
+      AssociatedKeyWithAlias = Doc do
+        set_collection_name "associated_documents"
+        key :name, String, :abbr => :n
+        key :association_id, ObjectId, :abbr => :aid
+      end
+
+      OwnerDocWithKeyAliases = Doc do
+        set_collection_name "owner_documents"
+        key :name, String, :abbr => :n
+        many :associated_documents, :class_name => "AssociatedKeyWithAlias", :foreign_key => AssociatedKeyWithAlias.abbr(:association_id)
+        many :other_documents, :class_name => "EmbeddedDocWithAliases"
+      end
+
+      EmbeddedDocWithAliases = EDoc do
+        key :embedded_name, String, :abbr => :en
+      end
+
+      before do
+        AssociatedKeyWithAlias.collection.drop
+        OwnerDocWithKeyAliases.collection.drop
+      end
+
+      it "should work" do
+        owner = OwnerDocWithKeyAliases.create(:name => "Big Boss")
+
+        associated_documents = 3.times.map {|i| AssociatedKeyWithAlias.new(:name => "Associated Record #{i}") }
+        owner.associated_documents = associated_documents
+        owner.save
+
+        owner.reload
+        owner.associated_documents.to_a.should =~ associated_documents.to_a
+
+        AssociatedKeyWithAlias.collection.find_one.keys.should =~ %w(_id n aid)
+      end
+
+      it "should work with embedded documents" do
+        owner = OwnerDocWithKeyAliases.create(:name => "Big Boss")
+        owner.other_documents << EmbeddedDocWithAliases.new(:embedded_name => "Underling")
+        owner.save
+
+        owner.reload
+        owner.other_documents[0].embedded_name.should == "Underling"
+        owner.collection.find_one["other_documents"][0]["en"].should == "Underling"
+      end
+    end
+  end
+end

data/{test/functional/test_logger.rb → spec/functional/logger_spec.rb}

@@ -1,18 +1,18 @@
-require 'test_helper'
+require 'spec_helper'
 
-class LoggerTest < Test::Unit::TestCase
+describe "Logger" do
   context "with connection that has logger" do
-    setup do
+    before do
       @output = StringIO.new
       @logger = Logger.new(@output)
-      MongoMapper.connection = Mongo::Connection.new('127.0.0.1', 27017, :logger => @logger)
+      MongoMapper.connection = Mongo::MongoClient.new('127.0.0.1', 27017, :logger => @logger)
     end
 
-    should "be able to get access to that logger" do
+    it "should be able to get access to that logger" do
       MongoMapper.logger.should == @logger
     end
 
-    should "be able to log messages" do
+    it "should be able to log messages" do
       MongoMapper.logger.debug 'testing'
       @output.string.include?('testing').should be_true
     end

data/spec/functional/modifiers_spec.rb

@@ -0,0 +1,550 @@
+require 'spec_helper'
+
+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 :title,       String
+        key :day_count,   Integer, :default => 0
+        key :week_count,  Integer, :default => 0
+        key :month_count, Integer, :default => 0
+        key :tags,        Array
+      end
+    }
+
+    let(:page_class_with_standard_key) {
+      Doc do
+        key :title,       String
+        key :day_count,   Integer, :default => 0
+        key :week_count,  Integer, :default => 0
+        key :month_count, Integer, :default => 0
+        key :tags,        Array
+      end
+    }
+
+    def assert_page_counts(page, day_count, week_count, month_count)
+      doc = page.collection.find_one({:_id => page.id})
+      doc.should be_present, "Could not find document"
+      doc.fetch('day_count').should == day_count
+      doc.fetch('week_count').should == week_count
+      doc.fetch('month_count').should == month_count
+    end
+
+    def assert_keys_removed(page, *keys)
+      page.class.collection.find_one({:_id => page.id}).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
+    end
+
+    context "ClassMethods" do
+      let!(:page_class) { page_class_with_standard_key }
+      let!(:page)  { page_class.create(:title => 'Home') }
+      let!(:page2) { page_class.create(:title => 'Home') }
+
+      context "unset" do
+        let!(:page)  { page_class.create(:title => 'Home', :tags => %w(foo bar)) }
+
+        it "should work with criteria and keys" do
+          page_class.unset({:title => 'Home'}, :title, :tags)
+          assert_keys_removed page, :title, :tags
+          assert_keys_removed page2, :title, :tags
+        end
+
+        it "should work with ids and keys" do
+          page_class.unset(page.id, page2.id, :title, :tags)
+          assert_keys_removed page, :title, :tags
+          assert_keys_removed page2, :title, :tags
+        end
+
+        context "additional options (upsert & safe)" do
+          it "should be able to pass upsert option" do
+            new_key_value = DateTime.now.to_s
+            page_class.unset({:title => new_key_value, :tags => %w(foo bar)}, :tags, {:upsert => true})
+            page_class.count(:title => new_key_value).should == 1
+            page_class.first(:title => new_key_value).tags.should == []
+          end
+
+          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(
+              {:title => "Better Be Safe than Sorry"},
+              {'$unset' => {:tags => 1}},
+              {:w => 1, :multi => true}
+            )
+            page_class.unset({:title => "Better Be Safe than Sorry"}, :tags, {:w => 1})
+          end
+
+          it "should be able to pass both safe and upsert options" do
+            new_key_value = DateTime.now.to_s
+            page_class.unset({:title => new_key_value, :tags => %w(foo bar)}, :tags, {:upsert => true, :safe => true})
+            page_class.count(:title => new_key_value).should == 1
+            page_class.first(:title => new_key_value).tags.should == []
+          end
+        end
+      end
+
+      context "increment" do
+        it "should work with criteria and modifier hashes" do
+          page_class.increment({:title => 'Home'}, :day_count => 1, :week_count => 2, :month_count => 3)
+
+          assert_page_counts page, 1, 2, 3
+          assert_page_counts page2, 1, 2, 3
+        end
+
+        it "should work with ids and modifier hash" do
+          page_class.increment(page.id, page2.id, :day_count => 1, :week_count => 2, :month_count => 3)
+
+          assert_page_counts page, 1, 2, 3
+          assert_page_counts page2, 1, 2, 3
+        end
+
+        it "should work with ids given as strings" do
+          page_class.increment(page.id.to_s, page2.id.to_s, :day_count => 1, :week_count => 2, :month_count => 3)
+
+          assert_page_counts page, 1, 2, 3
+          assert_page_counts page2, 1, 2, 3
+        end
+      end
+
+      context "decrement" do
+        let!(:page)  { page_class.create(:title => 'Home', :day_count => 1, :week_count => 2, :month_count => 3) }
+        let!(:page2) { page_class.create(:title => 'Home', :day_count => 1, :week_count => 2, :month_count => 3) }
+
+        it "should work with criteria and modifier hashes" do
+          page_class.decrement({:title => 'Home'}, :day_count => 1, :week_count => 2, :month_count => 3)
+
+          assert_page_counts page, 0, 0, 0
+          assert_page_counts page2, 0, 0, 0
+        end
+
+        it "should work with ids and modifier hash" do
+          page_class.decrement(page.id, page2.id, :day_count => 1, :week_count => 2, :month_count => 3)
+
+          assert_page_counts page, 0, 0, 0
+          assert_page_counts page2, 0, 0, 0
+        end
+
+        it "should decrement with positive or negative numbers" do
+          page_class.decrement(page.id, page2.id, :day_count => -1, :week_count => 2, :month_count => -3)
+
+          assert_page_counts page, 0, 0, 0
+          assert_page_counts page2, 0, 0, 0
+        end
+
+        it "should work with ids given as strings" do
+          page_class.decrement(page.id.to_s, page2.id.to_s, :day_count => -1, :week_count => 2, :month_count => -3)
+
+          assert_page_counts page, 0, 0, 0
+          assert_page_counts page2, 0, 0, 0
+        end
+      end
+
+      context "set" do
+        it "should work with criteria and modifier hashes" do
+          page_class.set({:title => 'Home'}, :title => 'Home Revised')
+
+          page.reload
+          page.title.should == 'Home Revised'
+
+          page2.reload
+          page2.title.should == 'Home Revised'
+        end
+
+        it "should work with ids and modifier hash" do
+          page_class.set(page.id, page2.id, :title => 'Home Revised')
+
+          page.reload
+          page.title.should == 'Home Revised'
+
+          page2.reload
+          page2.title.should == 'Home Revised'
+        end
+
+        it "should typecast values before querying" do
+          page_class.key :tags, Set
+
+          expect {
+            page_class.set(page.id, :tags => ['foo', 'bar'].to_set)
+            page.reload
+            page.tags.should == Set.new(['foo', 'bar'])
+          }.to_not raise_error
+        end
+
+        it "should not typecast keys that are not defined in document" do
+          expect {
+            page_class.set(page.id, :colors => ['red', 'green'].to_set)
+          }.to raise_error(BSON::InvalidDocument)
+        end
+
+        it "should set keys that are not defined in document" do
+          page_class.set(page.id, :colors => %w[red green])
+          page.reload
+          page[:colors].should == %w[red green]
+        end
+
+        context "additional options (upsert & safe)" do
+          it "should be able to pass upsert option" do
+            new_key_value = DateTime.now.to_s
+            page_class.set({:title => new_key_value}, {:day_count => 1}, {:upsert => true})
+            page_class.count(:title => new_key_value).should == 1
+            page_class.first(:title => new_key_value).day_count.should == 1
+          end
+
+          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(
+              {:title => "Better Be Safe than Sorry"},
+              {'$set' => {:title => "I like safety."}},
+              {:w => 1, :multi => true}
+            )
+            page_class.set({:title => "Better Be Safe than Sorry"}, {:title => "I like safety."}, {:safe => true})
+          end
+
+          it "should be able to pass both safe and upsert options" do
+            new_key_value = DateTime.now.to_s
+            page_class.set({:title => new_key_value}, {:day_count => 1}, {:upsert => true, :safe => true})
+            page_class.count(:title => new_key_value).should == 1
+            page_class.first(:title => new_key_value).day_count.should == 1
+          end
+        end
+      end
+
+      context "push" do
+        it "should work with criteria and modifier hashes" do
+          page_class.push({:title => 'Home'}, :tags => 'foo')
+
+          page.reload
+          page.tags.should == %w(foo)
+
+          page2.reload
+          page2.tags.should == %w(foo)
+        end
+
+        it "should work with ids and modifier hash" do
+          page_class.push(page.id, page2.id, :tags => 'foo')
+
+          page.reload
+          page.tags.should == %w(foo)
+
+          page2.reload
+          page2.tags.should == %w(foo)
+        end
+      end
+
+      context "push_all" do
+        let(:tags) { %w(foo bar) }
+
+        it "should work with criteria and modifier hashes" do
+          page_class.push_all({:title => 'Home'}, :tags => tags)
+
+          page.reload
+          page.tags.should == tags
+
+          page2.reload
+          page2.tags.should == tags
+        end
+
+        it "should work with ids and modifier hash" do
+          page_class.push_all(page.id, page2.id, :tags => tags)
+
+          page.reload
+          page.tags.should == tags
+
+          page2.reload
+          page2.tags.should == tags
+        end
+      end
+
+      context "pull" do
+        let(:page)  { page_class.create(:title => 'Home', :tags => %w(foo bar)) }
+        let(:page2) { page_class.create(:title => 'Home', :tags => %w(foo bar)) }
+
+        it "should work with criteria and modifier hashes" do
+          page_class.pull({:title => 'Home'}, :tags => 'foo')
+
+          page.reload
+          page.tags.should == %w(bar)
+
+          page2.reload
+          page2.tags.should == %w(bar)
+        end
+
+        it "should be able to pull with ids and modifier hash" do
+          page_class.pull(page.id, page2.id, :tags => 'foo')
+
+          page.reload
+          page.tags.should == %w(bar)
+
+          page2.reload
+          page2.tags.should == %w(bar)
+        end
+      end
+
+      context "pull_all" do
+        let(:page)  { page_class.create(:title => 'Home', :tags => %w(foo bar baz)) }
+        let(:page2) { page_class.create(:title => 'Home', :tags => %w(foo bar baz)) }
+
+        it "should work with criteria and modifier hashes" do
+          page_class.pull_all({:title => 'Home'}, :tags => %w(foo bar))
+
+          page.reload
+          page.tags.should == %w(baz)
+
+          page2.reload
+          page2.tags.should == %w(baz)
+        end
+
+        it "should work with ids and modifier hash" do
+          page_class.pull_all(page.id, page2.id, :tags => %w(foo bar))
+
+          page.reload
+          page.tags.should == %w(baz)
+
+          page2.reload
+          page2.tags.should == %w(baz)
+        end
+      end
+
+      context "add_to_set" do
+        let(:page) { page_class.create(:title => 'Home', :tags => 'foo') }
+
+        it "should be able to add to set with criteria and modifier hash" do
+          page_class.add_to_set({:title => 'Home'}, :tags => 'foo')
+
+          page.reload
+          page.tags.should == %w(foo)
+
+          page2.reload
+          page2.tags.should == %w(foo)
+        end
+
+        it "should be able to add to set with ids and modifier hash" do
+          page_class.add_to_set(page.id, page2.id, :tags => 'foo')
+
+          page.reload
+          page.tags.should == %w(foo)
+
+          page2.reload
+          page2.tags.should == %w(foo)
+        end
+      end
+
+      context "push_uniq" do
+        let(:page) { page_class.create(:title => 'Home', :tags => 'foo') }
+
+        it "should be able to push uniq with criteria and modifier hash" do
+          page_class.push_uniq({:title => 'Home'}, :tags => 'foo')
+
+          page.reload
+          page.tags.should == %w(foo)
+
+          page2.reload
+          page2.tags.should == %w(foo)
+        end
+
+        it "should be able to push uniq with ids and modifier hash" do
+          page_class.push_uniq(page.id, page2.id, :tags => 'foo')
+
+          page.reload
+          page.tags.should == %w(foo)
+
+          page2.reload
+          page2.tags.should == %w(foo)
+        end
+      end
+
+      context "pop" do
+        let(:page) { page_class.create(:title => 'Home', :tags => %w(foo bar)) }
+
+        it "should be able to remove the last element the array" do
+          page_class.pop(page.id, :tags => 1)
+          page.reload
+          page.tags.should == %w(foo)
+        end
+
+        it "should be able to remove the first element of the array" do
+          page_class.pop(page.id, :tags => -1)
+          page.reload
+          page.tags.should == %w(bar)
+        end
+      end
+
+      context "additional options (upsert & safe)" do
+        it "should be able to pass upsert option" do
+          new_key_value = DateTime.now.to_s
+          page_class.increment({:title => new_key_value}, {:day_count => 1}, {:upsert => true})
+          page_class.count(:title => new_key_value).should == 1
+          page_class.first(:title => new_key_value).day_count.should == 1
+        end
+
+        it "should be able to pass safe option" do
+          page_class.create(:title => "Better Be Safe than Sorry")
+
+          # We are trying to increment a key of type string here which should fail
+          expect {
+            page_class.increment({:title => "Better Be Safe than Sorry"}, {:title => 1}, {:safe => true})
+          }.to raise_error(Mongo::OperationFailure)
+        end
+
+        it "should be able to pass both safe and upsert options" do
+          new_key_value = DateTime.now.to_s
+          page_class.increment({:title => new_key_value}, {:day_count => 1}, {:upsert => true, :safe => true})
+          page_class.count(:title => new_key_value).should == 1
+          page_class.first(:title => new_key_value).day_count.should == 1
+        end
+      end
+    end
+
+    context "compound keys" do
+      it "should create a document" do
+        expect {
+          page_class_with_compound_key.create(:title => 'Foo', :tags => %w(foo))
+        }.to 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
+      {
+        :page_class_with_standard_key => "with standard key",
+        :page_class_with_compound_key => "with compound key",
+      }.each do |klass, description|
+        context description do
+          let!(:page_class) { send(klass) }
+
+          it "should be able to unset with keys" do
+            page = page_class.create(:title => 'Foo', :tags => %w(foo))
+            page.unset(:title, :tags)
+            assert_keys_removed page, :title, :tags
+          end
+
+          it "should be able to increment with modifier hashes" do
+            page = page_class.create
+            page.increment(:day_count => 1, :week_count => 2, :month_count => 3)
+
+            assert_page_counts page, 1, 2, 3
+          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)
+
+            assert_page_counts page, 0, 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)
+            assert_page_counts page, 0, 0, 0
+          end
+
+          it "should be able to set with modifier hashes" do
+            page  = page_class.create(:title => 'Home')
+            page.set(:title => 'Home Revised')
+
+            page.reload
+            page.title.should == 'Home Revised'
+          end
+
+          it "should be able to push with modifier hashes" do
+            page = page_class.create
+            page.push(:tags => 'foo')
+
+            page.reload
+            page.tags.should == %w(foo)
+          end
+
+          it "should be able to push_all with modifier hashes" do
+            page = page_class.create
+            page.push_all(:tags => %w(foo bar))
+
+            page.reload
+            page.tags.should == %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')
+
+            page.reload
+            page.tags.should == %w(bar)
+          end
+
+          it "should be able to pull_all with criteria and modifier hashes" do
+            page = page_class.create(:tags => %w(foo bar baz))
+            page.pull_all(:tags => %w(foo bar))
+
+            page.reload
+            page.tags.should == %w(baz)
+          end
+
+          it "should be able to add_to_set with criteria and modifier hash" do
+            page  = page_class.create(:tags => 'foo')
+            page2 = page_class.create
+
+            page.add_to_set(:tags => 'foo')
+            page2.add_to_set(:tags => 'foo')
+
+            page.reload
+            page.tags.should == %w(foo)
+
+            page2.reload
+            page2.tags.should == %w(foo)
+          end
+
+          it "should be able to push uniq with criteria and modifier hash" do
+            page  = page_class.create(:tags => 'foo')
+            page2 = page_class.create
+
+            page.push_uniq(:tags => 'foo')
+            page2.push_uniq(:tags => 'foo')
+
+            page.reload
+            page.tags.should == %w(foo)
+
+            page2.reload
+            page2.tags.should == %w(foo)
+          end
+
+          it "should be able to pop with modifier hashes" do
+            page = page_class.create(:tags => %w(foo bar))
+            page.pop(:tags => 1)
+
+            page.reload
+            page.tags.should == %w(foo)
+          end
+
+          it "should be able to pass upsert option" do
+            page = page_class.create(:title => "Upsert Page")
+            page.increment({:new_count => 1}, {:upsert => true})
+
+            page.reload
+            page.new_count.should == 1
+          end
+
+          it "should be able to pass safe option" do
+            page = page_class.create(:title => "Safe Page")
+
+            # We are trying to increment a key of type string here which should fail
+            expect {
+              page.increment({:title => 1}, {:safe => true})
+            }.to raise_error(Mongo::OperationFailure)
+          end
+
+          it "should be able to pass upsert and safe options" do
+            page = page_class.create(:title => "Upsert and Safe Page")
+            page.increment({:another_count => 1}, {:upsert => true, :safe => true})
+
+            page.reload
+            page.another_count.should == 1
+          end
+        end
+      end
+    end
+  end
+end