mongo 1.11.1 → 1.12.0.rc0

data/lib/mongo/functional/uri_parser.rb

@@ -22,7 +22,8 @@ module Mongo
 
     HOST_REGEX = /([-.\w]+)|(\[[^\]]+\])/
     PORT_REGEX = /(?::(\w+))?/
-    NODE_REGEX = /((#{HOST_REGEX}#{PORT_REGEX},?)+)/
+    UNIX_SOCK_REGEX = /([\S]+.sock)/
+    NODE_REGEX = /((#{HOST_REGEX}#{PORT_REGEX},?)+|#{UNIX_SOCK_REGEX}{1})/
 
     PATH_REGEX = /(?:\/([-\w]+))?/
 
@@ -41,15 +42,15 @@ module Mongo
 
     OPT_ATTRS  = [
       :authmechanism,
+      :authmechanismproperties,
       :authsource,
-      :canonicalizehostname,
       :connect,
       :connecttimeoutms,
       :fsync,
-      :gssapiservicename,
       :journal,
       :pool_size,
       :readpreference,
+      :readpreferencetags,
       :replicaset,
       :safe,
       :slaveok,
@@ -61,89 +62,96 @@ module Mongo
     ]
 
     OPT_VALID = {
-      :authmechanism        => lambda { |arg| Mongo::Authentication.validate_mechanism(arg) },
-      :authsource           => lambda { |arg| arg.length > 0 },
-      :canonicalizehostname => lambda { |arg| ['true', 'false'].include?(arg) },
-      :connect              => lambda { |arg| [ 'direct', 'replicaset', 'true', 'false', true, false ].include?(arg) },
-      :connecttimeoutms     => lambda { |arg| arg =~ /^\d+$/ },
-      :fsync                => lambda { |arg| ['true', 'false'].include?(arg) },
-      :gssapiservicename    => lambda { |arg| arg.length > 0 },
-      :journal              => lambda { |arg| ['true', 'false'].include?(arg) },
-      :pool_size            => lambda { |arg| arg.to_i > 0 },
-      :readpreference       => lambda { |arg| READ_PREFERENCES.keys.include?(arg) },
-      :replicaset           => lambda { |arg| arg.length > 0 },
-      :safe                 => lambda { |arg| ['true', 'false'].include?(arg) },
-      :slaveok              => lambda { |arg| ['true', 'false'].include?(arg) },
-      :sockettimeoutms      => lambda { |arg| arg =~ /^\d+$/ },
-      :ssl                  => lambda { |arg| ['true', 'false'].include?(arg) },
-      :w                    => lambda { |arg| arg =~ /^\w+$/ },
-      :wtimeout             => lambda { |arg| arg =~ /^\d+$/ },
-      :wtimeoutms           => lambda { |arg| arg =~ /^\d+$/ }
+      :authmechanism           => lambda { |arg| Mongo::Authentication.validate_mechanism(arg) },
+      :authmechanismproperties => lambda { |arg| arg.length > 0 },
+      :authsource              => lambda { |arg| arg.length > 0 },
+      :connect                 => lambda { |arg| [ 'direct', 'replicaset', 'true', 'false', true, false ].include?(arg) },
+      :connecttimeoutms        => lambda { |arg| arg =~ /^\d+$/ },
+      :fsync                   => lambda { |arg| ['true', 'false'].include?(arg) },
+      :journal                 => lambda { |arg| ['true', 'false'].include?(arg) },
+      :pool_size               => lambda { |arg| arg.to_i > 0 },
+      :readpreference          => lambda { |arg| READ_PREFERENCES.keys.include?(arg) },
+      :readpreferencetags      => lambda { |arg| arg.none? { |tags| tags.scan(/(\w+:\w+),?/).empty? } },
+      :replicaset              => lambda { |arg| arg.length > 0 },
+      :safe                    => lambda { |arg| ['true', 'false'].include?(arg) },
+      :slaveok                 => lambda { |arg| ['true', 'false'].include?(arg) },
+      :sockettimeoutms         => lambda { |arg| arg =~ /^\d+$/ },
+      :ssl                     => lambda { |arg| ['true', 'false'].include?(arg) },
+      :w                       => lambda { |arg| arg =~ /^\w+$/ },
+      :wtimeout                => lambda { |arg| arg =~ /^\d+$/ },
+      :wtimeoutms              => lambda { |arg| arg =~ /^\d+$/ }
      }
 
     OPT_ERR = {
-      :authmechanism        => "must be one of #{Mongo::Authentication::MECHANISMS.join(', ')}",
-      :authsource           => "must be a string containing the name of the database being used for authentication",
-      :canonicalizehostname => "must be 'true' or 'false'",
-      :connect              => "must be 'direct', 'replicaset', 'true', or 'false'",
-      :connecttimeoutms     => "must be an integer specifying milliseconds",
-      :fsync                => "must be 'true' or 'false'",
-      :gssapiservicename    => "must be a string containing the name of the GSSAPI service",
-      :journal              => "must be 'true' or 'false'",
-      :pool_size            => "must be an integer greater than zero",
-      :readpreference       => "must be on of #{READ_PREFERENCES.keys.map(&:inspect).join(",")}",
-      :replicaset           => "must be a string containing the name of the replica set to connect to",
-      :safe                 => "must be 'true' or 'false'",
-      :slaveok              => "must be 'true' or 'false'",
-      :settimeoutms         => "must be an integer specifying milliseconds",
-      :ssl                  => "must be 'true' or 'false'",
-      :w                    => "must be an integer indicating number of nodes to replicate to or a string " +
-                               "specifying that replication is required to the majority or nodes with a " +
-                               "particilar getLastErrorMode.",
-      :wtimeout             => "must be an integer specifying milliseconds",
-      :wtimeoutms           => "must be an integer specifying milliseconds"
+      :authmechanism           => Mongo::Authentication::MECHANISM_ERROR,
+      :authmechanismproperties => "must meet the format requirements of the authentication mechanism's properties",
+      :authsource              => "must be a string containing the name of the database being used for authentication",
+      :connect                 => "must be 'direct', 'replicaset', 'true', or 'false'",
+      :connecttimeoutms        => "must be an integer specifying milliseconds",
+      :fsync                   => "must be 'true' or 'false'",
+      :journal                 => "must be 'true' or 'false'",
+      :pool_size               => "must be an integer greater than zero",
+      :readpreference          => "must be one of #{READ_PREFERENCES.keys.map(&:inspect).join(",")}",
+      :readpreferencetags      => "must be a comma-separated list of one or more key:value pairs",
+      :replicaset              => "must be a string containing the name of the replica set to connect to",
+      :safe                    => "must be 'true' or 'false'",
+      :slaveok                 => "must be 'true' or 'false'",
+      :settimeoutms            => "must be an integer specifying milliseconds",
+      :ssl                     => "must be 'true' or 'false'",
+      :w                       => "must be an integer indicating number of nodes to replicate to or a string " +
+                                  "specifying that replication is required to the majority or nodes with a " +
+                                  "particilar getLastErrorMode.",
+      :wtimeout                => "must be an integer specifying milliseconds",
+      :wtimeoutms              => "must be an integer specifying milliseconds"
     }
 
     OPT_CONV = {
-      :authmechanism        => lambda { |arg| arg.upcase },
-      :authsource           => lambda { |arg| arg },
-      :canonicalizehostname => lambda { |arg| arg == 'true' ? true : false },
-      :connect              => lambda { |arg| arg == 'false' ? false : arg }, # convert 'false' to FalseClass
-      :connecttimeoutms     => lambda { |arg| arg.to_f / 1000 }, # stored as seconds
-      :fsync                => lambda { |arg| arg == 'true' ? true : false },
-      :gssapiservicename    => lambda { |arg| arg },
-      :journal              => lambda { |arg| arg == 'true' ? true : false },
-      :pool_size            => lambda { |arg| arg.to_i },
-      :readpreference       => lambda { |arg| READ_PREFERENCES[arg] },
-      :replicaset           => lambda { |arg| arg },
-      :safe                 => lambda { |arg| arg == 'true' ? true : false },
-      :slaveok              => lambda { |arg| arg == 'true' ? true : false },
-      :sockettimeoutms      => lambda { |arg| arg.to_f / 1000 }, # stored as seconds
-      :ssl                  => lambda { |arg| arg == 'true' ? true : false },
-      :w                    => lambda { |arg| Mongo::Support.is_i?(arg) ? arg.to_i : arg.to_sym },
-      :wtimeout             => lambda { |arg| arg.to_i },
-      :wtimeoutms           => lambda { |arg| arg.to_i }
+      :authmechanism           => lambda { |arg| arg.upcase },
+      :authmechanismproperties => lambda { |arg| arg },
+      :authsource              => lambda { |arg| arg },
+      :connect                 => lambda { |arg| arg == 'false' ? false : arg }, # convert 'false' to FalseClass
+      :connecttimeoutms        => lambda { |arg| arg.to_f / 1000 }, # stored as seconds
+      :fsync                   => lambda { |arg| arg == 'true' ? true : false },
+      :journal                 => lambda { |arg| arg == 'true' ? true : false },
+      :pool_size               => lambda { |arg| arg.to_i },
+      :readpreference          => lambda { |arg| READ_PREFERENCES[arg] },
+      :readpreferencetags      => lambda { |arg| arg.map do |tags|
+                                                   tags.scan(/(\w+:\w+),?/).reduce({}) do |tags, pair|
+                                                     key, value = pair.first.split(":")
+                                                     tags.merge!(key => value)
+                                                   end
+                                                 end },
+      :replicaset              => lambda { |arg| arg },
+      :safe                    => lambda { |arg| arg == 'true' ? true : false },
+      :slaveok                 => lambda { |arg| arg == 'true' ? true : false },
+      :sockettimeoutms         => lambda { |arg| arg.to_f / 1000 }, # stored as seconds
+      :ssl                     => lambda { |arg| arg == 'true' ? true : false },
+      :w                       => lambda { |arg| Mongo::Support.is_i?(arg) ? arg.to_i : arg.to_sym },
+      :wtimeout                => lambda { |arg| arg.to_i },
+      :wtimeoutms              => lambda { |arg| arg.to_i }
     }
 
     OPT_CASE_SENSITIVE = [ :authsource,
-                           :gssapiservicename,
+                           :authmechanismproperties,
                            :replicaset,
                            :w
                          ]
 
+    OPT_NOT_STRING = [ :readpreferencetags ]
+
     attr_reader :auths,
                 :authmechanism,
+                :authmechanismproperties,
                 :authsource,
-                :canonicalizehostname,
                 :connect,
                 :connecttimeoutms,
                 :db_name,
                 :fsync,
-                :gssapiservicename,
                 :journal,
                 :nodes,
                 :pool_size,
                 :readpreference,
+                :readpreferencetags,
                 :replicaset,
                 :safe,
                 :slaveok,
@@ -249,6 +257,7 @@ module Mongo
       opts[:op_timeout]      = @sockettimeoutms if @sockettimeoutms
       opts[:pool_size]       = @pool_size if @pool_size
       opts[:read]            = @readpreference if @readpreference
+      opts[:tag_sets]        = @readpreferencetags if @readpreferencetags
 
       if @slaveok && !@readpreference
         unless replicaset?
@@ -287,20 +296,24 @@ module Mongo
 
       user_info = matches[2].split(':') if matches[2]
       host_info = matches[3].split(',')
-      @db_name  = matches[8]
+      @db_name  = matches[9]
 
-      host_info.each do |host|
-        if host[0,1] == '['
-          host, port = host.split(']:') << MongoClient::DEFAULT_PORT
-          host = host.end_with?(']') ? host[1...-1] : host[1..-1]
-        else
-          host, port = host.split(':') << MongoClient::DEFAULT_PORT
-        end
-        unless port.to_s =~ /^\d+$/
-          raise MongoArgumentError,
-            "Invalid port #{port}; port must be specified as digits."
+      if host_info.first.end_with?('.sock')
+        @nodes << [ host_info.first ]
+      else
+        host_info.each do |host|
+          if host[0,1] == '['
+            host, port = host.split(']:') << MongoClient::DEFAULT_PORT
+            host = host.end_with?(']') ? host[1...-1] : host[1..-1]
+          else
+            host, port = host.split(':') << MongoClient::DEFAULT_PORT
+          end
+          unless port.to_s =~ /^\d+$/
+            raise MongoArgumentError,
+              "Invalid port #{port}; port must be specified as digits."
+          end
+          @nodes << [host, port.to_i]
         end
-        @nodes << [host, port.to_i]
       end
 
       if @nodes.empty?
@@ -330,10 +343,10 @@ module Mongo
           :username  => URI.unescape(username),
           :password  => password ? URI.unescape(password) : nil,
           :source    => @authsource,
-          :mechanism => @authmechanism
+          :mechanism => @authmechanism,
+          :extra     => @authmechanismproperties || {}
         })
-        auth[:extra] = @canonicalizehostname ? { :canonicalize_host_name => @canonicalizehostname } : {}
-        auth[:extra].merge!(:gssapi_service_name => @gssapiservicename) if @gssapiservicename
+
         @auths << auth
       end
     end
@@ -353,9 +366,13 @@ module Mongo
       end
 
       opts = CGI.parse(string_opts).inject({}) do |memo, (key, value)|
-        value = value.first
         key_sym = key.downcase.to_sym
-        memo[key_sym] = OPT_CASE_SENSITIVE.include?(key_sym) ? value.strip : value.strip.downcase
+        if OPT_NOT_STRING.include?(key_sym)
+          memo[key_sym] = value
+        else
+          value = value.first
+          memo[key_sym] = OPT_CASE_SENSITIVE.include?(key_sym) ? value.strip : value.strip.downcase
+        end
         memo
       end
 
@@ -369,6 +386,17 @@ module Mongo
           raise MongoArgumentError, "Invalid value #{value.inspect} for #{key}: #{OPT_ERR[key]}"
         end
       end
+
+      if @authmechanismproperties
+        @authmechanismproperties = @authmechanismproperties.split(',').reduce({}) do |prop, pair|
+          key, value = pair.split(':')
+          if ["true", "false"].include?(value.downcase)
+            value = value.downcase == "true"
+          end
+          prop[key.downcase.to_sym] = value
+          prop
+        end
+      end
     end
 
     def validate_connect

data/lib/mongo/mongo_client.rb

@@ -25,7 +25,8 @@ module Mongo
     RELEASE_2_4_AND_BEFORE = 0 # Everything before we started tracking.
     AGG_RETURNS_CURSORS    = 1 # The aggregation command may now be requested to return cursors.
     BATCH_COMMANDS         = 2 # insert, update, and delete batch command
-    MAX_WIRE_VERSION       = BATCH_COMMANDS # supported by this client implementation
+    MONGODB_2_8            = 3 # listCollections and listIndexes commands, SCRAM-SHA-1 auth mechanism
+    MAX_WIRE_VERSION       = MONGODB_2_8 # supported by this client implementation
     MIN_WIRE_VERSION       = RELEASE_2_4_AND_BEFORE # supported by this client implementation
 
     # Server command headroom
@@ -41,6 +42,7 @@ module Mongo
     DEFAULT_HOST         = 'localhost'
     DEFAULT_PORT         = 27017
     DEFAULT_DB_NAME      = 'test'
+    DEFAULT_OP_TIMEOUT   = 20
     GENERIC_OPTS         = [:auths, :logger, :connect, :db_name]
     TIMEOUT_OPTS         = [:timeout, :op_timeout, :connect_timeout]
     SSL_OPTS             = [:ssl, :ssl_key, :ssl_cert, :ssl_verify, :ssl_ca_cert, :ssl_key_pass_phrase]
@@ -125,8 +127,8 @@ module Mongo
     #  @option opts [Float] :pool_timeout (5.0) When all of the self.connections a pool are checked out,
     #    this is the number of seconds to wait for a new connection to be released before throwing an exception.
     #    Note: this setting is relevant only for multi-threaded applications.
-    #  @option opts [Float] :op_timeout (nil) The number of seconds to wait for a read operation to time out.
-    #    Disabled by default.
+    #  @option opts [Float] :op_timeout (DEFAULT_OP_TIMEOUT) The number of seconds to wait for a read operation to time out.
+    #    Set to DEFAULT_OP_TIMEOUT (20) by default. A value of nil may be specified explicitly.
     #  @option opts [Float] :connect_timeout (nil) The number of seconds to wait before timing out a
     #    connection attempt.
     #
@@ -332,26 +334,19 @@ module Mongo
     # @param password [String] password (applies to 'from' db)
     #
     # @note This command only supports the MONGODB-CR authentication mechanism.
-    def copy_database(from, to, from_host=DEFAULT_HOST, username=nil, password=nil)
-      oh = BSON::OrderedHash.new
-      oh[:copydb]   = 1
-      oh[:fromhost] = from_host
-      oh[:fromdb]   = from
-      oh[:todb]     = to
-      if username || password
-        unless username && password
-          raise MongoArgumentError,
-            'Both username and password must be supplied for authentication.'
-        end
-        nonce_cmd = BSON::OrderedHash.new
-        nonce_cmd[:copydbgetnonce] = 1
-        nonce_cmd[:fromhost] = from_host
-        result = self['admin'].command(nonce_cmd)
-        oh[:nonce] = result['nonce']
-        oh[:username] = username
-        oh[:key] = Mongo::Authentication.auth_key(username, password, oh[:nonce])
+    def copy_database(
+      from,
+      to,
+      from_host = DEFAULT_HOST,
+      username = nil,
+      password = nil,
+      mechanism = 'SCRAM-SHA-1'
+    )
+      if wire_version_feature?(MONGODB_2_8) && mechanism == 'SCRAM-SHA-1'
+        copy_db_scram(username, password, from_host, from, to)
+      else
+        copy_db_mongodb_cr(username, password, from_host, from, to)
       end
-      self['admin'].command(oh)
     end
 
     # Checks if a server is alive. This command will return immediately
@@ -446,7 +441,7 @@ module Mongo
       ping
       true
 
-      rescue ConnectionFailure
+      rescue ConnectionFailure, OperationTimeout
       false
     end
 
@@ -634,7 +629,7 @@ module Mongo
       @pool_timeout = opts.delete(:pool_timeout) || opts.delete(:timeout) || 5.0
 
       # Timeout on socket read operation.
-      @op_timeout = opts.delete(:op_timeout)
+      @op_timeout = opts.key?(:op_timeout) ? opts.delete(:op_timeout) : DEFAULT_OP_TIMEOUT
 
       # Timeout on socket connect.
       @connect_timeout = opts.delete(:connect_timeout) || 30

data/lib/mongo/mongo_replica_set_client.rb

@@ -85,7 +85,8 @@ module Mongo
     #   @option opts [Float] :pool_timeout (5.0) When all of the connections a pool are checked out,
     #     this is the number of seconds to wait for a new connection to be released before throwing an exception.
     #     Note: this setting is relevant only for multi-threaded applications.
-    #   @option opts [Float] :op_timeout (nil) The number of seconds to wait for a read operation to time out.
+    #   @option opts [Float] :op_timeout (DEFAULT_OP_TIMEOUT) The number of seconds to wait for a read operation to time out.
+    #    Set to DEFAULT_OP_TIMEOUT (20) by default. A value of nil may be specified explicitly.
     #   @option opts [Float] :connect_timeout (30) The number of seconds to wait before timing out a
     #     connection attempt.
     #   @option opts [Boolean] :ssl (false) If true, create the connection to the server using SSL.

data/test/functional/authentication_test.rb

@@ -17,6 +17,7 @@ require 'shared/authentication/basic_auth_shared'
 require 'shared/authentication/sasl_plain_shared'
 require 'shared/authentication/bulk_api_auth_shared'
 require 'shared/authentication/gssapi_shared'
+require 'shared/authentication/scram_shared'
 
 
 class AuthenticationTest < Test::Unit::TestCase
@@ -25,9 +26,11 @@ class AuthenticationTest < Test::Unit::TestCase
   include SASLPlainTests
   include BulkAPIAuthTests
   include GSSAPITests
+  include SCRAMTests
 
   def setup
     @client    = standard_connection
+    omit("auth not enabled on mongod") unless auth_enabled?(@client)
     @admin     = @client['admin']
     @version   = @client.server_version
     @db        = @client['ruby-test']

data/test/functional/client_test.rb

@@ -74,6 +74,27 @@ class ClientTest < Test::Unit::TestCase
     end
   end
 
+  def test_unix_sock
+    # There's an issue with unix sockets on JRuby with 32-bit libc
+    # https://jira.codehaus.org/browse/JRUBY-7183
+    return if RUBY_PLATFORM =~ /java/
+    begin
+      assert MongoClient.new("/tmp/mongodb-#{TEST_PORT}.sock")
+    rescue Errno::EAFNOSUPPORT
+      # System doesn't support UNIX sockets
+    end
+  end
+
+  def test_initialize_with_auths
+    auth = { :username  => TEST_USER,
+             :password  => TEST_USER_PWD,
+             :db_name   => TEST_DB,
+             :source    => TEST_DB}
+
+    client = MongoClient.new(:auths => Set.new([auth]))
+    assert client['test']['test'].find.to_a
+  end
+
   def test_connection_uri
     con = MongoClient.from_uri("mongodb://#{host_port}")
     assert_equal mongo_host, con.primary_pool.host
@@ -430,6 +451,18 @@ class ClientTest < Test::Unit::TestCase
     assert !conn.active?
   end
 
+  def test_operation_timeout_with_active
+    conn = standard_connection
+    assert conn.active?
+    assert_equal Mongo::MongoClient::DEFAULT_OP_TIMEOUT, conn.op_timeout
+
+    pool = conn.primary_pool
+    socket = pool.instance_variable_get(:@thread_ids_to_sockets)[Thread.current.object_id]
+
+    socket.stubs(:read).raises(Mongo::OperationTimeout)
+    assert_equal false, conn.active?
+  end
+
   context "Saved authentications" do
     setup do
       @client = Mongo::MongoClient.new

data/test/functional/collection_test.rb

@@ -18,6 +18,7 @@ require 'test_helper'
 class CollectionTest < Test::Unit::TestCase
 
   LIMITED_MAX_BSON_SIZE = 1024
+  LIMITED_BSON_SIZE_WITH_HEADROOM = LIMITED_MAX_BSON_SIZE + MongoClient::APPEND_HEADROOM
   LIMITED_MAX_MESSAGE_SIZE = 3 * LIMITED_MAX_BSON_SIZE
   LIMITED_TEST_HEADROOM = 50
   LIMITED_VALID_VALUE_SIZE = LIMITED_MAX_BSON_SIZE - LIMITED_TEST_HEADROOM
@@ -29,6 +30,7 @@ class CollectionTest < Test::Unit::TestCase
     @test         = @db.collection("test")
     @version      = @client.server_version
     @test.remove
+    @ismaster     = @client['admin'].command(:isMaster => 1)
   end
 
   @@wv0 = Mongo::MongoClient::RELEASE_2_4_AND_BEFORE
@@ -669,21 +671,22 @@ class CollectionTest < Test::Unit::TestCase
 
   def limited_collection
     conn = standard_connection(:connect => false)
+    is_master = @ismaster.merge('maxBsonObjectSize' => LIMITED_MAX_BSON_SIZE,
+                                'maxMessageSizeBytes' => LIMITED_MAX_BSON_SIZE)
     admin_db = Object.new
-    admin_db.expects(:command).returns({
-                                           'ok' => 1,
-                                           'ismaster' => 1,
-                                           'maxBsonObjectSize' => LIMITED_MAX_BSON_SIZE,
-                                           'maxMessageSizeBytes' => LIMITED_MAX_MESSAGE_SIZE
-                                       })
-    conn.expects(:[]).with('admin').returns(admin_db)
+    admin_db.expects(:command).returns(is_master)
+    conn.expects(:[]).with(TEST_DB).returns(admin_db)
     conn.connect
     return conn.db(TEST_DB)["test"]
   end
 
   def test_non_operation_failure_halts_insertion_with_continue_on_error
     coll = limited_collection
-    coll.db.connection.stubs(:send_message_with_gle).raises(OperationTimeout).times(1)
+    if @client.wire_version_feature?(MongoClient::BATCH_COMMANDS)
+      coll.db.stubs(:command).raises(OperationTimeout).times(1)
+    else
+      coll.db.connection.stubs(:send_message_with_gle).raises(OperationTimeout).times(1)
+    end
     docs = []
     10.times do
       docs << {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE}
@@ -738,6 +741,7 @@ class CollectionTest < Test::Unit::TestCase
   end
 
   def test_chunking_batch_insert_with_continue_on_error
+    coll = limited_collection
     docs = []
     4.times do
       docs << {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE}
@@ -748,9 +752,9 @@ class CollectionTest < Test::Unit::TestCase
       docs << {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE}
     end
     assert_raise OperationFailure do
-      limited_collection.insert(docs, :continue_on_error => true)
+      coll.insert(docs, :continue_on_error => true)
     end
-    assert limited_collection.count >= 6, "write commands need headroom for doc wrapping overhead - count:#{limited_collection.count}"
+    assert coll.count >= 6, "write commands need headroom for doc wrapping overhead - count:#{coll.count}"
   end
 
   def test_chunking_batch_insert_without_continue_on_error
@@ -779,49 +783,49 @@ class CollectionTest < Test::Unit::TestCase
 
   def test_maximum_document_size
     assert_raise InvalidDocument do
-      limited_collection.insert({'foo' => 'a' * LIMITED_MAX_BSON_SIZE})
+      limited_collection.insert({'foo' => 'a' * LIMITED_BSON_SIZE_WITH_HEADROOM})
     end
   end
 
   def test_maximum_save_size
     assert limited_collection.save({'foo' => 'a' * LIMITED_VALID_VALUE_SIZE})
     assert_raise InvalidDocument do
-      limited_collection.save({'foo' => 'a' * LIMITED_MAX_BSON_SIZE})
+      limited_collection.save({'foo' => 'a' * LIMITED_BSON_SIZE_WITH_HEADROOM})
     end
   end
 
   def test_maximum_remove_size
     assert limited_collection.remove({'foo' => 'a' * LIMITED_VALID_VALUE_SIZE})
     assert_raise InvalidDocument do
-      limited_collection.remove({'foo' => 'a' * LIMITED_MAX_BSON_SIZE})
+      limited_collection.remove({'foo' => 'a' * LIMITED_BSON_SIZE_WITH_HEADROOM})
     end
   end
 
   def test_maximum_update_size
     assert_raise InvalidDocument do
       limited_collection.update(
-        {'foo' => 'a' * LIMITED_MAX_BSON_SIZE},
+        {'foo' => 'a' * LIMITED_BSON_SIZE_WITH_HEADROOM},
         {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE}
       )
     end
 
     assert_raise InvalidDocument do
       limited_collection.update(
-        {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE},
+        {'foo' => 'a' * LIMITED_BSON_SIZE_WITH_HEADROOM},
         {'foo' => 'a' * LIMITED_MAX_BSON_SIZE}
       )
     end
 
     assert_raise InvalidDocument do
       limited_collection.update(
-        {'foo' => 'a' * LIMITED_MAX_BSON_SIZE},
-        {'foo' => 'a' * LIMITED_MAX_BSON_SIZE}
+        {'foo' => 'a' * LIMITED_BSON_SIZE_WITH_HEADROOM},
+        {'foo' => 'a' * LIMITED_BSON_SIZE_WITH_HEADROOM}
       )
     end
 
     assert limited_collection.update(
-             {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE},
-             {'foo' => 'a' * LIMITED_VALID_VALUE_SIZE}
+             {'foo' => 'a' * (LIMITED_VALID_VALUE_SIZE/2)},
+             {'foo' => 'a' * (LIMITED_VALID_VALUE_SIZE/2)}
            )
   end
 
@@ -1323,6 +1327,12 @@ class CollectionTest < Test::Unit::TestCase
     assert_equal desired_results, results
   end
 
+  def test_aggregate_command_using_sym
+    return unless @version > '2.1.1'
+    cmd = BSON::OrderedHash[:aggregate, @test.name, :pipeline, [{'$match' => {:_id => true}}]]
+    assert @db.command(cmd)
+  end
+
   def test_aggregate_pipeline_multiple_operators
     return unless @version > '2.1.1'
     setup_aggregate_data