mongo 1.9.2 → 1.10.0.rc0

data/test/functional/{connection_test.rb → client_test.rb}

@@ -1,4 +1,4 @@
-# Copyright (C) 2013 10gen Inc.
+# Copyright (C) 2009-2013 MongoDB, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -14,10 +14,8 @@
 
 require 'test_helper'
 require 'logger'
-require 'stringio'
-require 'thread'
 
-class TestConnection < Test::Unit::TestCase
+class ClientTest < Test::Unit::TestCase
 
   include Mongo
   include BSON
@@ -52,6 +50,30 @@ class TestConnection < Test::Unit::TestCase
     assert ping['ok']
   end
 
+  def test_ipv6
+    with_ipv6_enabled(@client) do
+      assert client = MongoClient.new('[::1]')
+    end
+  end
+
+  def test_ipv6_uri_no_opts
+    with_ipv6_enabled(@client) do
+      uri = 'mongodb://[::1]:27017'
+      with_preserved_env_uri(uri) do
+        assert MongoClient.new
+      end
+    end
+  end
+
+  def test_ipv6_uri_opts
+    with_ipv6_enabled(@client) do
+      uri = 'mongodb://[::1]:27017/?slaveOk=true'
+      with_preserved_env_uri(uri) do
+        assert MongoClient.new
+      end
+    end
+  end
+
   def test_connection_uri
     con = MongoClient.from_uri("mongodb://#{host_port}")
     assert_equal mongo_host, con.primary_pool.host
@@ -65,66 +87,49 @@ class TestConnection < Test::Unit::TestCase
   end
 
   def test_env_mongodb_uri
-    begin
-      old_mongodb_uri = ENV['MONGODB_URI']
-      ENV['MONGODB_URI'] = "mongodb://#{host_port}"
+    uri = "mongodb://#{host_port}"
+    with_preserved_env_uri(uri) do
       con = MongoClient.new
       assert_equal mongo_host, con.primary_pool.host
       assert_equal mongo_port, con.primary_pool.port
-    ensure
-      ENV['MONGODB_URI'] = old_mongodb_uri
     end
   end
 
   def test_from_uri_implicit_mongodb_uri
-    begin
-      old_mongodb_uri = ENV['MONGODB_URI']
-      ENV['MONGODB_URI'] = "mongodb://#{host_port}"
+    uri = "mongodb://#{host_port}"
+    with_preserved_env_uri(uri) do
       con = MongoClient.from_uri
       assert_equal mongo_host, con.primary_pool.host
       assert_equal mongo_port, con.primary_pool.port
-    ensure
-      ENV['MONGODB_URI'] = old_mongodb_uri
     end
   end
 
   def test_db_from_uri_exists_no_options
-    begin
-      db_name = "_database"
-
-      old_mongodb_uri = ENV['MONGODB_URI']
-      ENV['MONGODB_URI'] = "mongodb://#{host_port}/#{db_name}"
+    db_name = "_database"
+    uri = "mongodb://#{host_port}/#{db_name}"
+    with_preserved_env_uri(uri) do
       con = MongoClient.from_uri
       db = con.db
       assert_equal db.name, db_name
-    ensure
-      ENV['MONGODB_URI'] = old_mongodb_uri
     end
   end
 
   def test_db_from_uri_exists_options
-    begin
-      db_name = "_database"
-
-      old_mongodb_uri = ENV['MONGODB_URI']
-      ENV['MONGODB_URI'] = "mongodb://#{host_port}/#{db_name}?"
+    db_name = "_database"
+    uri = "mongodb://#{host_port}/#{db_name}?"
+    with_preserved_env_uri(uri) do
       con = MongoClient.from_uri
       db = con.db
       assert_equal db.name, db_name
-    ensure
-      ENV['MONGODB_URI'] = old_mongodb_uri
     end
   end
 
   def test_db_from_uri_exists_no_db_name
-    begin
-      old_mongodb_uri = ENV['MONGODB_URI']
-      ENV['MONGODB_URI'] = "mongodb://#{host_port}/"
+    uri = "mongodb://#{host_port}/"
+    with_preserved_env_uri(uri) do
       con = MongoClient.from_uri
       db = con.db
       assert_equal db.name, MongoClient::DEFAULT_DB_NAME
-    ensure
-      ENV['MONGODB_URI'] = old_mongodb_uri
     end
   end
 
@@ -163,59 +168,47 @@ class TestConnection < Test::Unit::TestCase
   end
 
   def test_database_info
-    @client.drop_database(MONGO_TEST_DB)
-    @client.db(MONGO_TEST_DB).collection('info-test').insert('a' => 1)
+    @client.drop_database(TEST_DB)
+    @client.db(TEST_DB).collection('info-test').insert('a' => 1)
 
     info = @client.database_info
     assert_not_nil info
     assert_kind_of Hash, info
-    assert_not_nil info[MONGO_TEST_DB]
-    assert info[MONGO_TEST_DB] > 0
+    assert_not_nil info[TEST_DB]
+    assert info[TEST_DB] > 0
 
-    @client.drop_database(MONGO_TEST_DB)
+    @client.drop_database(TEST_DB)
   end
 
   def test_copy_database
-    @client.db('old').collection('copy-test').insert('a' => 1)
-    @client.copy_database('old', 'new', host_port)
-    old_object = @client.db('old').collection('copy-test').find.next_document
-    new_object = @client.db('new').collection('copy-test').find.next_document
-    assert_equal old_object, new_object
-    @client.drop_database('old')
-    @client.drop_database('new')
-  end
-
-  def test_copy_database_with_auth
-    @client.db('old').collection('copy-test').insert('a' => 1)
-    @client.db('old').add_user('bob', 'secret')
-
-    assert_raise Mongo::OperationFailure do
-      @client.copy_database('old', 'new', host_port, 'bob', 'badpassword')
-    end
+    old_name = TEST_DB + '_old'
+    new_name = TEST_DB + '_new'
 
-    result = @client.copy_database('old', 'new', host_port, 'bob', 'secret')
-    assert Mongo::Support.ok?(result)
+    @client.drop_database(new_name)
+    @client.db(old_name).collection('copy-test').insert('a' => 1)
+    @client.copy_database(old_name, new_name, host_port)
 
-    @client.drop_database('old')
-    @client.drop_database('new')
+    old_object = @client.db(old_name).collection('copy-test').find.next_document
+    new_object = @client.db(new_name).collection('copy-test').find.next_document
+    assert_equal old_object, new_object
   end
 
   def test_database_names
-    @client.drop_database(MONGO_TEST_DB)
-    @client.db(MONGO_TEST_DB).collection('info-test').insert('a' => 1)
+    @client.drop_database(TEST_DB)
+    @client.db(TEST_DB).collection('info-test').insert('a' => 1)
 
     names = @client.database_names
     assert_not_nil names
     assert_kind_of Array, names
     assert names.length >= 1
-    assert names.include?(MONGO_TEST_DB)
+    assert names.include?(TEST_DB)
   end
 
   def test_logging
     output = StringIO.new
     logger = Logger.new(output)
     logger.level = Logger::DEBUG
-    standard_connection(:logger => logger).db(MONGO_TEST_DB)
+    standard_connection(:logger => logger).db(TEST_DB)
     assert output.string.include?("admin['$cmd'].find")
   end
 
@@ -223,7 +216,7 @@ class TestConnection < Test::Unit::TestCase
     output = StringIO.new
     logger = Logger.new(output)
     logger.level = Logger::DEBUG
-    standard_connection(:logger => logger).db(MONGO_TEST_DB)
+    standard_connection(:logger => logger).db(TEST_DB)
     assert_match(/\(\d+.\d{1}ms\)/, output.string)
     assert output.string.include?("admin['$cmd'].find")
   end
@@ -240,15 +233,15 @@ class TestConnection < Test::Unit::TestCase
   end
 
   def test_drop_database
-    db = @client.db('ruby-mongo-will-be-deleted')
+    db = @client.db(TEST_DB + '_drop_test')
     coll = db.collection('temp')
     coll.remove
     coll.insert(:name => 'temp')
     assert_equal 1, coll.count()
-    assert @client.database_names.include?('ruby-mongo-will-be-deleted')
+    assert @client.database_names.include?(TEST_DB + '_drop_test')
 
-    @client.drop_database('ruby-mongo-will-be-deleted')
-    assert !@client.database_names.include?('ruby-mongo-will-be-deleted')
+    @client.drop_database(TEST_DB + '_drop_test')
+    assert !@client.database_names.include?(TEST_DB + '_drop_test')
   end
 
   def test_nodes
@@ -337,6 +330,66 @@ class TestConnection < Test::Unit::TestCase
     assert_equal Mongo::DEFAULT_MAX_BSON_SIZE * Mongo::MESSAGE_SIZE_FACTOR, conn.max_message_size
   end
 
+  def test_max_wire_version_and_min_wire_version_values
+    conn = standard_connection(:connect => false)
+
+    admin_db = Object.new
+    admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1, 'maxWireVersion' => 1, 'minWireVersion' => 1})
+    conn.expects(:[]).with('admin').returns(admin_db)
+    conn.connect
+
+    assert_equal 1, conn.max_wire_version
+    assert_equal 1, conn.min_wire_version
+  end
+
+  def test_max_wire_version_and_min_wire_version_values_with_no_reported_values
+    conn = standard_connection(:connect => false)
+
+    admin_db = Object.new
+    admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1})
+    conn.expects(:[]).with('admin').returns(admin_db)
+    conn.connect
+
+    assert_equal 0, conn.max_wire_version
+    assert_equal 0, conn.min_wire_version
+  end
+
+  def test_wire_version_feature
+    conn = standard_connection(:connect => false)
+    conn.stubs(:min_wire_version).returns(0)
+    conn.stubs(:max_wire_version).returns(1)
+    assert_true conn.wire_version_feature?(0)
+    assert_true conn.wire_version_feature?(1)
+    assert_false conn.wire_version_feature?(2)
+    assert_false conn.wire_version_feature?(-1)
+  end
+
+  def test_wire_version_not_in_range
+    [
+      [Mongo::MongoClient::MAX_WIRE_VERSION+1, Mongo::MongoClient::MAX_WIRE_VERSION+1],
+      [Mongo::MongoClient::MIN_WIRE_VERSION-1, Mongo::MongoClient::MIN_WIRE_VERSION-1]
+    ].each do |min_wire_version, max_wire_version|
+      conn = standard_connection(:connect => false)
+      admin_db = Object.new
+      admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1, 'maxWireVersion' => max_wire_version, 'minWireVersion' => min_wire_version})
+      conn.expects(:[]).with('admin').returns(admin_db)
+      assert_raises Mongo::ConnectionFailure do
+        conn.connect
+      end
+    end
+  end
+
+  def test_use_write_command
+    with_write_commands(@client) do
+      assert_true @client.use_write_command?({:w => 1})
+      assert_false @client.use_write_command?({:w => 0})
+    end
+    with_write_operations(@client) do
+      assert_false @client.use_write_command?({:w => 1})
+      assert_false @client.use_write_command?({:w => 0})
+    end
+  end
+
   def test_connection_activity
     conn = standard_connection
     assert conn.active?
@@ -361,22 +414,42 @@ class TestConnection < Test::Unit::TestCase
   context "Saved authentications" do
     setup do
       @client = standard_connection
-      @auth = {:db_name => 'test', :username => 'bob', :password => 'secret', :source => nil}
-      @client.add_auth(@auth[:db_name], @auth[:username], @auth[:password], @auth[:source])
+
+      @auth = {
+        :db_name   => TEST_DB,
+        :username  => 'bob',
+        :password  => 'secret',
+        :source    => TEST_DB,
+        :mechanism => 'MONGODB-CR'
+      }
+
+      @client.auths << @auth
     end
 
     teardown do
       @client.clear_auths
     end
 
-    should "save the authentication" do
-      assert_equal @auth, @client.auths[0]
+    should "save and validate the authentication" do
+      assert_equal Authentication.validate_credentials(@auth), @client.auths.first
     end
 
     should "not allow multiple authentications for the same db" do
-      auth = {:db_name => 'test', :username => 'mickey', :password => 'm0u53', :source => nil}
+      auth = {
+        :db_name   => TEST_DB,
+        :username  => 'mickey',
+        :password  => 'm0u53',
+        :source    => nil,
+        :mechanism => nil
+      }
+
       assert_raise Mongo::MongoArgumentError do
-        @client.add_auth(auth[:db_name], auth[:username], auth[:password], auth[:source])
+        @client.add_auth(
+          auth[:db_name],
+          auth[:username],
+          auth[:password],
+          auth[:source],
+          auth[:mechanism])
       end
     end
 
@@ -384,7 +457,7 @@ class TestConnection < Test::Unit::TestCase
       @client.remove_auth('non-existent database')
       assert_equal 1, @client.auths.length
 
-      @client.remove_auth('test')
+      @client.remove_auth(TEST_DB)
       assert_equal 0, @client.auths.length
     end
 
@@ -398,11 +471,12 @@ class TestConnection < Test::Unit::TestCase
     context "checking out writers" do
       setup do
         @con = standard_connection(:pool_size => 10, :pool_timeout => 10)
-        @coll = @con[MONGO_TEST_DB]['test-connection-exceptions']
+        @coll = @con[TEST_DB]['test-connection-exceptions']
       end
 
       should "close the connection on send_message for major exceptions" do
-        @con.expects(:checkout_writer).raises(SystemStackError)
+        @con.stubs(:checkout_writer).raises(SystemStackError)
+        @con.stubs(:checkout_reader).raises(SystemStackError)
         @con.expects(:close)
         begin
           @coll.insert({:foo => "bar"})
@@ -411,7 +485,8 @@ class TestConnection < Test::Unit::TestCase
       end
 
       should "close the connection on send_message_with_gle for major exceptions" do
-        @con.expects(:checkout_writer).raises(SystemStackError)
+        @con.stubs(:checkout_writer).raises(SystemStackError)
+        @con.stubs(:checkout_reader).raises(SystemStackError)
         @con.expects(:close)
         begin
           @coll.insert({:foo => "bar"}, :w => 1)
@@ -433,7 +508,7 @@ class TestConnection < Test::Unit::TestCase
   context "Connection exceptions" do
     setup do
       @con = standard_connection(:pool_size => 10, :pool_timeout => 10)
-      @coll = @con[MONGO_TEST_DB]['test-connection-exceptions']
+      @coll = @con[TEST_DB]['test-connection-exceptions']
     end
 
     should "release connection if an exception is raised on send_message" do

data/test/functional/collection_test.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2013 10gen Inc.
+# Copyright (C) 2009-2013 MongoDB, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,16 +15,145 @@
 require 'rbconfig'
 require 'test_helper'
 
-class TestCollection < Test::Unit::TestCase
+class CollectionTest < Test::Unit::TestCase
   @@client       ||= standard_connection(:op_timeout => 10)
-  @@db           = @@client.db(MONGO_TEST_DB)
+  @@db           = @@client.db(TEST_DB)
   @@test         = @@db.collection("test")
   @@version      = @@client.server_version
 
+  LIMITED_MAX_BSON_SIZE = 1024
+  LIMITED_MAX_MESSAGE_SIZE = 3 * LIMITED_MAX_BSON_SIZE
+  LIMITED_TEST_HEADROOM = 50
+  LIMITED_VALID_VALUE_SIZE = LIMITED_MAX_BSON_SIZE - LIMITED_TEST_HEADROOM
+  LIMITED_INVALID_VALUE_SIZE = LIMITED_MAX_BSON_SIZE + Mongo::MongoClient::COMMAND_HEADROOM + 1
+
   def setup
     @@test.remove
   end
 
+  @@wv0 = Mongo::MongoClient::RELEASE_2_4_AND_BEFORE
+  @@wv2 = Mongo::MongoClient::BATCH_COMMANDS
+  @@a_h = Mongo::MongoClient::APPEND_HEADROOM
+  @@s_h = Mongo::MongoClient::SERIALIZE_HEADROOM
+
+  MAX_SIZE_EXCEPTION_TEST = [
+    #[@@wv0, @@client.max_bson_size, nil, /xyzzy/], # succeeds standalone, fails whole suite
+  ]
+  MAX_SIZE_EXCEPTION_CRUBY_TEST = [
+    [@@wv0, @@client.max_bson_size + 1,     BSON::InvalidDocument,   /Document.* too large/]
+  ]
+  MAX_SIZE_EXCEPTION_JRUBY_TEST = [
+    [@@wv0, @@client.max_bson_size + 1,     Mongo::OperationFailure, /object to insert too large/]
+  ]
+  MAX_SIZE_EXCEPTION_COMMANDS_TEST = [
+    #[@@wv2, @@client.max_bson_size,         nil,                     /xyzzy/], # succeeds standalone, fails whole suite
+    [@@wv2, @@client.max_bson_size + 1,     Mongo::OperationFailure, /object to insert too large/],
+    [@@wv2, @@client.max_bson_size + @@s_h, Mongo::OperationFailure, /object to insert too large/],
+    [@@wv2, @@client.max_bson_size + @@a_h, BSON::InvalidDocument,   /Document.* too large/]
+  ]
+
+  @@max_size_exception_test = MAX_SIZE_EXCEPTION_TEST
+  @@max_size_exception_test += MAX_SIZE_EXCEPTION_CRUBY_TEST unless RUBY_PLATFORM == 'java'
+  #@@max_size_exception_test += MAX_SIZE_EXCEPTION_JRUBY_TEST if RUBY_PLATFORM == 'java'
+  @@max_size_exception_test += MAX_SIZE_EXCEPTION_COMMANDS_TEST if @@version >= "2.5.2"
+
+  def generate_sized_doc(size)
+    doc = {"_id" => BSON::ObjectId.new, "x" => "y"}
+    serialize_doc = BSON::BSON_CODER.serialize(doc, false, false, size)
+    doc = {"_id" => BSON::ObjectId.new, "x" => "y" * (1 + size - serialize_doc.size)}
+    assert_equal size, BSON::BSON_CODER.serialize(doc, false, false, size).size
+    doc
+  end
+
+  def with_max_wire_version(client, wire_version) # does not support replica sets
+    if client.wire_version_feature?(wire_version)
+      client.class.class_eval(%Q{
+        alias :old_max_wire_version :max_wire_version
+        def max_wire_version
+          #{wire_version}
+        end
+      })
+      yield wire_version
+      client.class.class_eval(%Q{
+        alias :max_wire_version :old_max_wire_version
+      })
+    end
+  end
+
+  def test_insert_batch_max_sizes
+    @@max_size_exception_test.each do |wire_version, size, exc, regexp|
+      with_max_wire_version(@@client, wire_version) do
+        @@test.remove
+        doc = generate_sized_doc(size)
+        begin
+          @@test.insert([doc.dup])
+          assert_equal nil, exc
+        rescue => e
+          assert_equal exc, e.class, "wire_version:#{wire_version}, size:#{size}, exc:#{exc} e:#{e.message.inspect} @@version:#{@@version}"
+          assert_match regexp, e.message
+        end
+      end
+    end
+  end
+
+  if @@version >= '2.5.1'
+    def test_aggregation_cursor
+      [10, 1000].each do |size|
+        @@test.drop
+        size.times {|i| @@test.insert({ :_id => i }) }
+        expected_sum = size.times.reduce(:+)
+
+        cursor = @@test.aggregate(
+          [{ :$project => {:_id => '$_id'}} ],
+          :cursor => {}
+        )
+
+        assert_equal Mongo::Cursor, cursor.class
+
+        cursor_sum = cursor.reduce(0) do |sum, doc|
+          sum += doc['_id']
+        end
+
+        assert_equal expected_sum, cursor_sum
+      end
+      @@test.drop
+    end
+
+    def test_aggregation_cursor_invalid_ops
+      cursor = @@test.aggregate([], :cursor => {})
+      assert_raise(Mongo::InvalidOperation) { cursor.rewind! }
+      assert_raise(Mongo::InvalidOperation) { cursor.explain }
+      assert_raise(Mongo::InvalidOperation) { cursor.count }
+    end
+  end
+
+  def test_aggregation_invalid_read_pref
+    assert_raise Mongo::MongoArgumentError do
+      @@test.aggregate([], :read => :invalid_read_pref)
+    end
+  end
+
+  if @@version >= '2.5.3'
+    def test_aggregation_allow_disk_usage
+      @@db.expects(:command).with do |selector, opts|
+        opts[:allowDiskUsage] == true
+      end.returns({ 'ok' => 1 })
+      @@test.aggregate([], :allowDiskUsage => true)
+    end
+
+    def test_aggregation_supports_explain
+      @@db.expects(:command).with do |selector, opts|
+        opts[:explain] == true
+      end.returns({ 'ok' => 1 })
+      @@test.aggregate([], :explain => true)
+    end
+
+    def test_aggregation_explain_returns_raw_result
+      response = @@test.aggregate([], :explain => true)
+      assert response['stages']
+    end
+  end
+
   def test_capped_method
     @@db.create_collection('normal')
     assert !@@db['normal'].capped?
@@ -43,7 +172,7 @@ class TestCollection < Test::Unit::TestCase
 
     # Create a db with a pk_factory.
     @db = MongoClient.new(ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost',
-                         ENV['MONGO_RUBY_DRIVER_PORT'] || MongoClient::DEFAULT_PORT).db(MONGO_TEST_DB, :pk => Object.new)
+                         ENV['MONGO_RUBY_DRIVER_PORT'] || MongoClient::DEFAULT_PORT).db(TEST_DB, :pk => Object.new)
     @coll = @db.collection('coll-with-pk')
     assert @coll.pk_factory.is_a?(Object)
 
@@ -51,20 +180,19 @@ class TestCollection < Test::Unit::TestCase
     assert @coll.pk_factory.is_a?(Object)
   end
 
-  class TestPK
+  class PKTest
     def self.create_pk
     end
   end
 
   def test_pk_factory_on_collection
     silently do
-      @coll = Collection.new('foo', @@db, TestPK)
-      assert_equal TestPK, @coll.pk_factory
+      @coll = Collection.new('foo', @@db, PKTest)
+      assert_equal PKTest, @coll.pk_factory
     end
 
-
-    @coll2 = Collection.new('foo', @@db, :pk => TestPK)
-    assert_equal TestPK, @coll2.pk_factory
+    @coll2 = Collection.new('foo', @@db, :pk => PKTest)
+    assert_equal PKTest, @coll2.pk_factory
   end
 
   def test_valid_names
@@ -158,13 +286,17 @@ class TestCollection < Test::Unit::TestCase
 
   def test_safe_insert
     @@test.create_index("hello", :unique => true)
-    a = {"hello" => "world"}
-    @@test.insert(a)
-    @@test.insert(a, :w => 0)
-    assert(@@db.get_last_error['err'].include?("11000"))
-
-    assert_raise OperationFailure do
+    begin
+      a = {"hello" => "world"}
       @@test.insert(a)
+      @@test.insert(a, :w => 0)
+      assert(@@db.get_last_error['err'].include?("11000"))
+
+      assert_raise OperationFailure do
+        @@test.insert(a)
+      end
+    ensure
+      @@test.drop_indexes
     end
   end
 
@@ -182,29 +314,32 @@ class TestCollection < Test::Unit::TestCase
   def test_bulk_insert_with_continue_on_error
     if @@version >= "2.0"
       @@test.create_index([["foo", 1]], :unique => true)
-      docs = []
-      docs << {:foo => 1}
-      docs << {:foo => 1}
-      docs << {:foo => 2}
-      docs << {:foo => 3}
-      assert_raise OperationFailure do
-        @@test.insert(docs)
-      end
-      assert_equal 1, @@test.count
-      @@test.remove
+      begin
+        docs = []
+        docs << {:foo => 1}
+        docs << {:foo => 1}
+        docs << {:foo => 2}
+        docs << {:foo => 3}
+        assert_raise OperationFailure do
+          @@test.insert(docs)
+        end
+        assert_equal 1, @@test.count
+        @@test.remove
 
-      docs = []
-      docs << {:foo => 1}
-      docs << {:foo => 1}
-      docs << {:foo => 2}
-      docs << {:foo => 3}
-      assert_raise OperationFailure do
-        @@test.insert(docs, :continue_on_error => true)
-      end
-      assert_equal 3, @@test.count
+        docs = []
+        docs << {:foo => 1}
+        docs << {:foo => 1}
+        docs << {:foo => 2}
+        docs << {:foo => 3}
+        assert_raise OperationFailure do
+          @@test.insert(docs, :continue_on_error => true)
+        end
+        assert_equal 3, @@test.count
 
-      @@test.remove
-      @@test.drop_index("foo_1")
+        @@test.remove
+      ensure
+        @@test.drop_index("foo_1")
+      end
     end
   end
 
@@ -229,7 +364,7 @@ class TestCollection < Test::Unit::TestCase
     assert_raise BSON::InvalidKeyName do
       @@test.insert(docs, :collect_on_error => false)
     end
-    assert_equal 0, @@test.count
+    assert_equal 2, @@test.count
 
     doc_ids, error_docs = @@test.insert(docs, :collect_on_error => true)
     assert_equal 2, @@test.count
@@ -250,7 +385,7 @@ class TestCollection < Test::Unit::TestCase
     assert_raise BSON::InvalidStringEncoding do
       @@test.insert(docs, :collect_on_error => false)
     end
-    assert_equal 0, @@test.count
+    assert_equal 2, @@test.count
 
     doc_ids, error_docs = @@test.insert(docs, :collect_on_error => true)
     assert_equal 2, @@test.count
@@ -284,20 +419,20 @@ class TestCollection < Test::Unit::TestCase
     admin_db.expects(:command).returns({
       'ok' => 1,
       'ismaster' => 1,
-      'maxBsonObjectSize' => 1024,
-      'maxMessageSizeBytes' => 3 * 1024
+      'maxBsonObjectSize' => LIMITED_MAX_BSON_SIZE,
+      'maxMessageSizeBytes' => LIMITED_MAX_MESSAGE_SIZE
     })
     conn.expects(:[]).with('admin').returns(admin_db)
     conn.connect
-    return conn.db(MONGO_TEST_DB)["test"]
+    return conn.db(TEST_DB)["test"]
   end
 
   def test_non_operation_failure_halts_insertion_with_continue_on_error
     coll = limited_collection
-    coll.stubs(:send_insert_message).raises(OperationTimeout).times(1)
+    coll.db.connection.stubs(:send_message_with_gle).raises(OperationTimeout).times(1)
     docs = []
     10.times do
-      docs << {'foo' => 'a' * 950}
+      docs << {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE}
     end
     assert_raise OperationTimeout do
       coll.insert(docs, :continue_on_error => true)
@@ -307,7 +442,7 @@ class TestCollection < Test::Unit::TestCase
   def test_chunking_batch_insert
      docs = []
      10.times do
-       docs << {'foo' => 'a' * 950}
+       docs << {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE}
      end
      limited_collection.insert(docs)
      assert_equal 10, limited_collection.count
@@ -316,13 +451,13 @@ class TestCollection < Test::Unit::TestCase
   def test_chunking_batch_insert_without_collect_on_error
     docs = []
     4.times do
-      docs << {'foo' => 'a' * 950}
+      docs << {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE}
     end
     invalid_docs = []
     invalid_docs << {'$invalid-key' => 1} # non utf8 encoding
     docs += invalid_docs
     4.times do
-      docs << {'foo' => 'a' * 950}
+      docs << {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE}
     end
     assert_raise BSON::InvalidKeyName do
       limited_collection.insert(docs, :collect_on_error => false)
@@ -334,13 +469,13 @@ class TestCollection < Test::Unit::TestCase
    if RUBY_PLATFORM == 'java' then return end
     docs = []
     4.times do
-      docs << {'foo' => 'a' * 950}
+      docs << {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE}
     end
     invalid_docs = []
     invalid_docs << {'$invalid-key' => 1} # non utf8 encoding
     docs += invalid_docs
     4.times do
-      docs << {'foo' => 'a' * 950}
+      docs << {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE}
     end
     doc_ids, error_docs = limited_collection.insert(docs, :collect_on_error => true)
     assert_equal 8, doc_ids.count
@@ -351,28 +486,28 @@ class TestCollection < Test::Unit::TestCase
   def test_chunking_batch_insert_with_continue_on_error
     docs = []
     4.times do
-      docs << {'foo' => 'a' * 950}
+      docs << {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE}
     end
     docs << {'_id' => 'b', 'foo' => 'a'}
     docs << {'_id' => 'b', 'foo' => 'c'}
     4.times do
-      docs << {'foo' => 'a' * 950}
+      docs << {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE}
     end
     assert_raise OperationFailure do
       limited_collection.insert(docs, :continue_on_error => true)
     end
-    assert_equal 9, limited_collection.count
+    assert limited_collection.count >= 6, "write commands need headroom for doc wrapping overhead - count:#{limited_collection.count}"
   end
 
   def test_chunking_batch_insert_without_continue_on_error
     docs = []
     4.times do
-      docs << {'foo' => 'a' * 950}
+      docs << {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE}
     end
     docs << {'_id' => 'b', 'foo' => 'a'}
     docs << {'_id' => 'b', 'foo' => 'c'}
     4.times do
-      docs << {'foo' => 'a' * 950}
+      docs << {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE}
     end
     assert_raise OperationFailure do
       limited_collection.insert(docs, :continue_on_error => false)
@@ -383,74 +518,74 @@ class TestCollection < Test::Unit::TestCase
   def test_maximum_insert_size
     docs = []
     3.times do
-      docs << {'foo' => 'a' * 950}
+      docs << {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE}
     end
     assert_equal limited_collection.insert(docs).length, 3
   end
 
   def test_maximum_document_size
     assert_raise InvalidDocument do
-      limited_collection.insert({'foo' => 'a' * 1024})
+      limited_collection.insert({'foo' => 'a' * LIMITED_MAX_BSON_SIZE})
     end
   end
 
   def test_maximum_save_size
-    assert limited_collection.save({'foo' => 'a' * 950})
+    assert limited_collection.save({'foo' => 'a' * LIMITED_VALID_VALUE_SIZE})
     assert_raise InvalidDocument do
-      limited_collection.save({'foo' => 'a' * 1024})
+      limited_collection.save({'foo' => 'a' * LIMITED_MAX_BSON_SIZE})
     end
   end
 
   def test_maximum_remove_size
-    assert limited_collection.remove({'foo' => 'a' * 950})
+    assert limited_collection.remove({'foo' => 'a' * LIMITED_VALID_VALUE_SIZE})
     assert_raise InvalidDocument do
-      limited_collection.remove({'foo' => 'a' * 1024})
+      limited_collection.remove({'foo' => 'a' * LIMITED_MAX_BSON_SIZE})
     end
   end
 
   def test_maximum_update_size
     assert_raise InvalidDocument do
       limited_collection.update(
-        {'foo' => 'a' * 1024},
-        {'foo' => 'a' * 950}
+        {'foo' => 'a' * LIMITED_MAX_BSON_SIZE},
+        {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE}
       )
     end
 
     assert_raise InvalidDocument do
       limited_collection.update(
-        {'foo' => 'a' * 950},
-        {'foo' => 'a' * 1024}
+        {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE},
+        {'foo' => 'a' * LIMITED_MAX_BSON_SIZE}
       )
     end
 
     assert_raise InvalidDocument do
       limited_collection.update(
-        {'foo' => 'a' * 1024},
-        {'foo' => 'a' * 1024}
+        {'foo' => 'a' * LIMITED_MAX_BSON_SIZE},
+        {'foo' => 'a' * LIMITED_MAX_BSON_SIZE}
       )
     end
 
     assert limited_collection.update(
-      {'foo' => 'a' * 950},
-      {'foo' => 'a' * 950}
+      {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE},
+      {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE}
     )
   end
 
   def test_maximum_query_size
-    assert limited_collection.find({'foo' => 'a' * 950}).to_a
+    assert limited_collection.find({'foo' => 'a' * LIMITED_VALID_VALUE_SIZE}).to_a
     assert limited_collection.find(
-      {'foo' => 'a' * 950},
-      {:fields => {'foo' => 'a' * 950}}
+      {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE},
+      {:fields => {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE}}
     ).to_a
 
     assert_raise InvalidDocument do
-      limited_collection.find({'foo' => 'a' * 1024}).to_a
+      limited_collection.find({'foo' => 'a' * LIMITED_INVALID_VALUE_SIZE}).to_a
     end
 
     assert_raise InvalidDocument do
       limited_collection.find(
-        {'foo' => 'a' * 950},
-        {:fields => {'foo' => 'a' * 1024}}
+        {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE},
+        {:fields => {'foo' => 'a' * LIMITED_MAX_BSON_SIZE}}
       ).to_a
     end
   end
@@ -470,8 +605,8 @@ class TestCollection < Test::Unit::TestCase
   #  end
   #end
 
-  if @@version >= "2.0.0"
-    def test_safe_mode_with_journal_commit_option
+  def test_safe_mode_with_journal_commit_option
+    with_default_journaling(@@client) do
       @@test.insert({:foo => 1}, :j => true)
       @@test.update({:foo => 1}, {:foo => 2}, :j => true)
       @@test.remove({:foo => 2}, :j => true)
@@ -490,13 +625,15 @@ class TestCollection < Test::Unit::TestCase
     assert_equal 1, @@test.find_one(:_id => id2)["x"]
   end
 
-  def test_update_check_keys
-    @@test.save("x" => 1)
-    @@test.update({"x" => 1}, {"$set" => {"a.b" => 2}})
-    assert_equal 2, @@test.find_one("x" => 1)["a"]["b"]
+  if @@version < "2.5.3"
+    def test_update_check_keys
+      @@test.save("x" => 1)
+      @@test.update({"x" => 1}, {"$set" => {"a.b" => 2}})
+      assert_equal 2, @@test.find_one("x" => 1)["a"]["b"]
 
-    assert_raise_error BSON::InvalidKeyName do
-      @@test.update({"x" => 1}, {"a.b" => 3})
+      assert_raise_error BSON::InvalidKeyName do
+        @@test.update({"x" => 1}, {"a.b" => 3})
+      end
     end
   end
 
@@ -568,7 +705,7 @@ class TestCollection < Test::Unit::TestCase
 
   def test_mocked_safe_remove
     @client = standard_connection
-    @db   = @client[MONGO_TEST_DB]
+    @db   = @client[TEST_DB]
     @test = @db['test-safe-remove']
     @test.save({:a => 20})
     @client.stubs(:receive).returns([[{'ok' => 0, 'err' => 'failed'}], 1, 0])
@@ -581,7 +718,7 @@ class TestCollection < Test::Unit::TestCase
 
   def test_safe_remove
     @client = standard_connection
-    @db   = @client[MONGO_TEST_DB]
+    @db   = @client[TEST_DB]
     @test = @db['test-safe-remove']
     @test.remove
     @test.save({:a => 50})
@@ -593,6 +730,14 @@ class TestCollection < Test::Unit::TestCase
     assert_equal true, @@test.remove({}, :w => 0)
   end
 
+  def test_remove_with_limit
+    @@test.insert([{:n => 1},{:n => 2},{:n => 3}])
+    @@test.remove({}, :limit => 1)
+    assert_equal 2, @@test.count
+    @@test.remove({}, :limit => 0)
+    assert_equal 0, @@test.count
+  end
+
   def test_count
     @@test.drop
 
@@ -692,6 +837,22 @@ class TestCollection < Test::Unit::TestCase
     end
   end
 
+  def test_find_one_with_max_time_ms
+    with_forced_timeout(@@client) do
+      assert_raise ExecutionTimeout do
+        @@test.find_one({}, { :max_time_ms => 100 })
+      end
+    end
+  end
+
+  def test_find_one_with_compile_regex_option
+    regex = /.*/
+    @@test.insert('r' => /.*/)
+    assert_kind_of Regexp, @@test.find_one({})['r']
+    assert_kind_of Regexp, @@test.find_one({}, :compile_regex => true)['r']
+    assert_equal BSON::Regex, @@test.find_one({}, :compile_regex => false)['r'].class
+  end
+
   def test_insert_adds_id
     doc = {"hello" => "world"}
     @@test.insert(doc)
@@ -856,6 +1017,57 @@ class TestCollection < Test::Unit::TestCase
       results = @@test.aggregate([{"$unwind"=> "$tags"}])
       assert_equal desired_results, results
     end
+
+    def test_aggregate_with_compile_regex_option
+      # see SERVER-6470
+      return unless @@version >= '2.3.2'
+      @@test.insert({ 'r' => /.*/ })
+      result1 = @@test.aggregate([])
+      assert_kind_of Regexp, result1.first['r']
+
+      result2 = @@test.aggregate([], :compile_regex => false)
+      assert_kind_of BSON::Regex, result2.first['r']
+
+      return unless @@version >= '2.5.1'
+      result = @@test.aggregate([], :compile_regex => false, :cursor => {})
+      assert_kind_of BSON::Regex, result.first['r']
+    end
+  end
+
+  if @@version >= "2.5.2"
+    def test_out_aggregate
+      out_collection = 'test_out'
+      @@db.drop_collection(out_collection)
+      setup_aggregate_data
+      docs = @@test.find.to_a
+      pipeline = [{:$out => out_collection}]
+      @@test.aggregate(pipeline)
+      assert_equal docs, @@db.collection(out_collection).find.to_a
+    end
+
+    def test_out_aggregate_nonprimary_sym_warns
+      ReadPreference::expects(:warn).with(regexp_matches(/rerouted to primary/))
+      pipeline = [{:$out => 'test_out'}]
+      @@test.aggregate(pipeline, :read => :secondary)
+    end
+
+    def test_out_aggregate_nonprimary_string_warns
+      ReadPreference::expects(:warn).with(regexp_matches(/rerouted to primary/))
+      pipeline = [{'$out' => 'test_out'}]
+      @@test.aggregate(pipeline, :read => :secondary)
+    end
+
+    def test_out_aggregate_string_returns_raw_response
+      pipeline = [{'$out' => 'test_out'}]
+      response = @@test.aggregate(pipeline)
+      assert response.respond_to?(:keys)
+    end
+
+    def test_out_aggregate_sym_returns_raw_response
+      pipeline = [{:$out => 'test_out'}]
+      response = @@test.aggregate(pipeline)
+      assert response.respond_to?(:keys)
+    end
   end
 
   if @@version > "1.1.1"
@@ -865,7 +1077,7 @@ class TestCollection < Test::Unit::TestCase
 
       m = "function() { emit(this.user_id, 1); }"
       r = "function(k,vals) { return 1; }"
-      res = @@test.map_reduce(m, r, :out => 'foo');
+      res = @@test.map_reduce(m, r, :out => 'foo')
       assert res.find_one({"_id" => 1})
       assert res.find_one({"_id" => 2})
     end
@@ -876,7 +1088,7 @@ class TestCollection < Test::Unit::TestCase
 
       m = Code.new("function() { emit(this.user_id, 1); }")
       r = Code.new("function(k,vals) { return 1; }")
-      res = @@test.map_reduce(m, r, :out => 'foo');
+      res = @@test.map_reduce(m, r, :out => 'foo')
       assert res.find_one({"_id" => 1})
       assert res.find_one({"_id" => 2})
     end
@@ -889,7 +1101,7 @@ class TestCollection < Test::Unit::TestCase
 
       m = Code.new("function() { emit(this.user_id, 1); }")
       r = Code.new("function(k,vals) { return 1; }")
-      res = @@test.map_reduce(m, r, :query => {"user_id" => {"$gt" => 1}}, :out => 'foo');
+      res = @@test.map_reduce(m, r, :query => {"user_id" => {"$gt" => 1}}, :out => 'foo')
       assert_equal 2, res.count
       assert res.find_one({"_id" => 2})
       assert res.find_one({"_id" => 3})
@@ -914,6 +1126,13 @@ class TestCollection < Test::Unit::TestCase
       assert res["timeMillis"]
     end
 
+    def test_map_reduce_nonprimary_output_collection_reroutes
+      output_collection = "test-map-coll"
+      m = Code.new("function() { emit(this.user_id, 1); }")
+      r = Code.new("function(k,vals) { return 1; }")
+      Mongo::ReadPreference.expects(:warn).with(regexp_matches(/rerouted to primary/))
+      res = @@test.map_reduce(m, r, :raw => true, :out => output_collection, :read => :secondary)
+    end
 
     if @@version >= "1.8.0"
       def test_map_reduce_with_collection_merge
@@ -951,7 +1170,7 @@ class TestCollection < Test::Unit::TestCase
         r = Code.new("function(k,vals) { return 1; }")
         oh = BSON::OrderedHash.new
         oh[:replace] = 'foo'
-        oh[:db] = MONGO_TEST_DB
+        oh[:db] = TEST_DB
         res = @@test.map_reduce(m, r, :out => (oh))
         assert res["result"]
         assert res["counts"]
@@ -961,6 +1180,23 @@ class TestCollection < Test::Unit::TestCase
     end
   end
 
+  if @@version >= '2.5.5'
+    def test_parallel_scan
+      8000.times { |i| @@test.insert({ :_id => i }) }
+
+      n_docs = {}
+      threads = []
+      cursors = @@test.parallel_scan(3)
+      cursors.each_with_index do |cursor, i|
+        threads << Thread.new do
+          n_docs[i] = cursor.to_a.size
+        end
+      end
+      threads.each(&:join)
+      assert_equal @@test.count, n_docs.values.inject(0) { |sum, n| sum + n }
+    end
+  end
+
   if @@version > "1.3.0"
     def test_find_and_modify
       @@test << { :a => 1, :processed => false }
@@ -1005,7 +1241,8 @@ class TestCollection < Test::Unit::TestCase
       @@test << {:n => 1}
       @@test.create_index("n")
 
-      assert_equal "#{MONGO_TEST_DB}.test", @@test.stats['ns']
+      assert_equal "#{TEST_DB}.test", @@test.stats['ns']
+      @@test.drop
     end
   end
 
@@ -1184,6 +1421,7 @@ end
     @@test.ensure_index([['a', 1]])
     assert @@test.index_information.keys.include?("a_1")
     @@test.drop_index("a_1")
+    @@test.drop_indexes
   end
 
   def test_ensure_index_timeout
@@ -1201,6 +1439,7 @@ end
     sleep(1)
     # This won't be, so generate_indexes will be called twice
     coll.ensure_index([['a', 1]])
+    coll.drop
   end
 
   if @@version > '2.0.0'
@@ -1213,12 +1452,18 @@ end
     end
 
     def test_max_scan
-      1000.times do |n|
-        @@test.save({:a => n})
+      @@test.drop
+      n = 100
+      n.times do |i|
+        @@test.save({:_id => i, :x => i % 10})
       end
-      assert @@test.find({:a => 999}).next
-      assert !@@test.find({:a => 999}, :max_scan => 500).next
-      @@test.remove
+      assert_equal(n, @@test.find.to_a.size)
+      assert_equal(50, @@test.find({}, :max_scan => 50).to_a.size)
+      assert_equal(10, @@test.find({:x => 2}).to_a.size)
+      assert_equal(5, @@test.find({:x => 2}, :max_scan => 50).to_a.size)
+      @@test.ensure_index([[:x, 1]])
+      assert_equal(10, @@test.find({:x => 2}, :max_scan => n).to_a.size)
+      @@test.drop
     end
   end
 
@@ -1400,6 +1645,7 @@ end
     should "create a geoHaystack index" do
       @geo.save({ "_id" => 100, "pos" => { "long" => 126.9, "lat" => 35.2 }, "type" => "restaurant"})
       @geo.create_index([['pos', Mongo::GEOHAYSTACK], ['type', Mongo::ASCENDING]], :bucket_size => 1)
+      assert @geo.index_information['pos_geoHaystack_type_1']
     end
 
     should "create a geo 2dsphere index" do
@@ -1472,8 +1718,8 @@ end
     end
 
     should "generate indexes in the proper order" do
-      @collection.expects(:insert_documents) do |sel, coll, safe|
-        assert_equal 'b_1_a_1', sel[:name]
+      @collection.expects(:send_write) do |type, selector, documents, check_keys, opts, collection_name|
+        assert_equal 'b_1_a_1', selector[:name]
       end
       @collection.create_index([['b', 1], ['a', 1]])
     end
@@ -1501,7 +1747,7 @@ end
   context "Capped collections" do
     setup do
       @@db.drop_collection('log')
-      @capped = @@db.create_collection('log', :capped => true, :size => 1024)
+      @capped = @@db.create_collection('log', :capped => true, :size => LIMITED_MAX_BSON_SIZE)
 
       10.times { |n| @capped.insert({:n => n}) }
     end