mongo 1.9.2 → 1.10.0.rc0

data/test/functional/ssl_test.rb

@@ -1,109 +1,29 @@
+# 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.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 require 'test_helper'
+require 'shared/ssl_shared'
 
-class SSLCertValidationTest < Test::Unit::TestCase
+class SSLTest < Test::Unit::TestCase
   include Mongo
+  include SSLTests
 
-  CERT_PATH   = "#{Dir.pwd}/test/fixtures/certificates/"
-  CLIENT_CERT = "#{CERT_PATH}client.pem"
-  CA_CERT     = "#{CERT_PATH}ca.pem"
-
-  # This test doesn't connect, no server config required
-  def test_ssl_configuration
-    # raises when ssl=false and ssl opts specified
-    assert_raise MongoArgumentError do
-      MongoClient.new('server', 27017, :connect  => false,
-                                       :ssl      => false,
-                                       :ssl_cert => CLIENT_CERT)
-    end
-
-    # raises when ssl=nil and ssl opts specified
-    assert_raise MongoArgumentError do
-      MongoClient.new('server', 27017, :connect => false,
-                                       :ssl_key => CLIENT_CERT)
-    end
-
-    # raises when verify=true and no ca_cert
-    assert_raise MongoArgumentError do
-      MongoClient.new('server', 27017, :connect    => false,
-                                       :ssl        => true,
-                                       :ssl_key    => CLIENT_CERT,
-                                       :ssl_cert   => CLIENT_CERT,
-                                       :ssl_verify => true)
-    end
-  end
-
-  # Requires MongoDB built with SSL and the follow options:
-  #
-  # mongod --dbpath /path/to/data/directory --sslOnNormalPorts \
-  # --sslPEMKeyFile /path/to/server.pem \
-  # --sslCAFile /path/to/ca.pem \
-  # --sslCRLFile /path/to/crl.pem \
-  # --sslWeakCertificateValidation
-  #
-  # Make sure you have 'server' as an alias for localhost in /etc/hosts
-  #
-  def test_ssl_basic
-    client = MongoClient.new('server', 27017, :connect => false,
-                                              :ssl     => true)
-    assert client.connect
-  end
-
-  # Requires MongoDB built with SSL and the follow options:
-  #
-  # mongod --dbpath /path/to/data/directory --sslOnNormalPorts \
-  # --sslPEMKeyFile /path/to/server.pem \
-  # --sslCAFile /path/to/ca.pem \
-  # --sslCRLFile /path/to/crl.pem
-  #
-  # Make sure you have 'server' as an alias for localhost in /etc/hosts
-  #
-  def test_ssl_with_cert
-    client = MongoClient.new('server', 27017, :connect  => false,
-                                              :ssl      => true,
-                                              :ssl_cert => CLIENT_CERT,
-                                              :ssl_key  => CLIENT_CERT)
-    assert client.connect
-  end
-
-  def test_ssl_with_peer_cert_validation
-    client = MongoClient.new('server', 27017, :connect     => false,
-                                              :ssl         => true,
-                                              :ssl_key     => CLIENT_CERT,
-                                              :ssl_cert    => CLIENT_CERT,
-                                              :ssl_verify  => true,
-                                              :ssl_ca_cert => CA_CERT)
-    assert client.connect
-  end
-
-  def test_ssl_peer_cert_validation_hostname_fail
-    client = MongoClient.new('localhost', 27017, :connect     => false,
-                                                 :ssl         => true,
-                                                 :ssl_key     => CLIENT_CERT,
-                                                 :ssl_cert    => CLIENT_CERT,
-                                                 :ssl_verify  => true,
-                                                 :ssl_ca_cert => CA_CERT)
-    assert_raise ConnectionFailure do
-      client.connect
-    end
-  end
-
-  # Requires mongod built with SSL and the follow options:
-  #
-  # mongod --dbpath /path/to/data/directory --sslOnNormalPorts \
-  # --sslPEMKeyFile /path/to/server.pem \
-  # --sslCAFile /path/to/ca.pem \
-  # --sslCRLFile /path/to/crl_client_revoked.pem
-  #
-  # Make sure you have 'server' as an alias for localhost in /etc/hosts
-  #
-  def test_ssl_with_invalid_cert
-    assert_raise ConnectionFailure do
-      MongoClient.new('server', 27017, :ssl         => true,
-                                       :ssl_key     => CLIENT_CERT,
-                                       :ssl_cert    => CLIENT_CERT,
-                                       :ssl_verify  => true,
-                                       :ssl_ca_cert => CA_CERT)
-    end
+  def setup
+    @client_class     = MongoClient
+    @uri_info         = 'server'
+    @connect_info     = ['server', 27017]
+    @bad_connect_info = ['localhost', 27017]
   end
 
 end

data/test/functional/support_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.

data/test/functional/timeout_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,7 +14,8 @@
 
 require 'test_helper'
 
-class TestTimeout < Test::Unit::TestCase
+class TimeoutTest < Test::Unit::TestCase
+
   def test_op_timeout
     connection = standard_connection(:op_timeout => 0.5)
 
@@ -32,9 +33,9 @@ class TestTimeout < Test::Unit::TestCase
   end
 
   def test_external_timeout_does_not_leave_socket_in_bad_state
-    client = Mongo::MongoClient.new
-    db = client[MONGO_TEST_DB]
-    coll = db['timeout-tests']
+    client = standard_connection
+    db     = client[TEST_DB]
+    coll   = db['timeout-tests']
 
     # prepare the database
     coll.drop
@@ -54,21 +55,4 @@ class TestTimeout < Test::Unit::TestCase
     end
   end
 
-=begin
-  def test_ssl_op_timeout
-    connection = standard_connection(:op_timeout => 1, :ssl => true)
-
-    coll = connection.db(MONGO_TEST_DB).collection("test")
-    coll.insert({:a => 1})
-    # Should not timeout
-    assert coll.find_one({"$where" => "sleep(100); return true;"})
-
-    # Should timeout
-    assert_raise Mongo::OperationTimeout do
-      coll.find_one({"$where" => "sleep(5 * 1000); return true;"})
-    end
-
-    coll.remove
-  end
-=end
 end

data/test/functional/uri_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.
@@ -31,6 +31,40 @@ class URITest < Test::Unit::TestCase
     assert_equal 27018, parser.nodes[0][1]
   end
 
+def test_ipv6_format
+  parser = Mongo::URIParser.new('mongodb://[::1]:27018')
+  assert_equal 1, parser.nodes.length
+  assert_equal '::1', parser.nodes[0][0]
+  assert_equal 27018, parser.nodes[0][1]
+
+  parser = Mongo::URIParser.new('mongodb://[::1]')
+  assert_equal 1, parser.nodes.length
+  assert_equal '::1', parser.nodes[0][0]
+end
+
+def test_ipv6_format_multi
+  parser = Mongo::URIParser.new('mongodb://[::1]:27017,[::1]:27018')
+  assert_equal 2, parser.nodes.length
+  assert_equal '::1', parser.nodes[0][0]
+  assert_equal 27017, parser.nodes[0][1]
+  assert_equal '::1', parser.nodes[1][0]
+  assert_equal 27018, parser.nodes[1][1]
+
+  parser = Mongo::URIParser.new('mongodb://[::1]:27017,localhost:27018')
+  assert_equal 2, parser.nodes.length
+  assert_equal '::1', parser.nodes[0][0]
+  assert_equal 27017, parser.nodes[0][1]
+  assert_equal 'localhost', parser.nodes[1][0]
+  assert_equal 27018, parser.nodes[1][1]
+
+  parser = Mongo::URIParser.new('mongodb://localhost:27017,[::1]:27018')
+  assert_equal 2, parser.nodes.length
+  assert_equal 'localhost', parser.nodes[0][0]
+  assert_equal 27017, parser.nodes[0][1]
+  assert_equal '::1', parser.nodes[1][0]
+  assert_equal 27018, parser.nodes[1][1]
+end
+
   def test_multiple_uris
     parser = Mongo::URIParser.new('mongodb://a.example.com:27018,b.example.com')
     assert_equal 2, parser.nodes.length
@@ -38,37 +72,72 @@ class URITest < Test::Unit::TestCase
     assert_equal ['b.example.com', 27017], parser.nodes[1]
   end
 
+  def test_username_without_password
+    parser = Mongo::URIParser.new('mongodb://bob:@localhost?authMechanism=GSSAPI')
+    assert_equal "bob", parser.auths.first[:username]
+    assert_equal nil, parser.auths.first[:password]
+
+    parser = Mongo::URIParser.new('mongodb://bob@localhost?authMechanism=GSSAPI')
+    assert_equal nil, parser.auths.first[:password]
+
+    assert_raise_error MongoArgumentError do
+      Mongo::URIParser.new('mongodb://bob:@localhost')
+    end
+
+    assert_raise_error MongoArgumentError do
+      Mongo::URIParser.new('mongodb://bob@localhost')
+    end
+  end
+
   def test_complex_passwords
     parser = Mongo::URIParser.new('mongodb://bob:secret.word@a.example.com:27018/test')
-    assert_equal "bob", parser.auths[0][:username]
-    assert_equal "secret.word", parser.auths[0][:password]
+    assert_equal "bob", parser.auths.first[:username]
+    assert_equal "secret.word", parser.auths.first[:password]
 
     parser = Mongo::URIParser.new('mongodb://bob:s-_3#%R.t@a.example.com:27018/test')
-    assert_equal "bob", parser.auths[0][:username]
-    assert_equal "s-_3#%R.t", parser.auths[0][:password]
+    assert_equal "bob", parser.auths.first[:username]
+    assert_equal "s-_3#%R.t", parser.auths.first[:password]
+
+    assert_raise_error MongoArgumentError do
+      Mongo::URIParser.new('mongodb://doctor:bad:wolf@gallifrey.com:27018/test')
+    end
+
+    assert_raise_error MongoArgumentError do
+      Mongo::URIParser.new('mongodb://doctor:bow@tie@gallifrey.com:27018/test')
+    end
   end
 
   def test_complex_usernames
-    parser = Mongo::URIParser.new('mongodb://b:ob:secret.word@a.example.com:27018/test')
-    assert_equal "b:ob", parser.auths[0][:username]
+    parser = Mongo::URIParser.new('mongodb://s-_3#%R.t:secret.word@a.example.com:27018/test')
+    assert_equal "s-_3#%R.t", parser.auths.first[:username]
+
+    assert_raise_error MongoArgumentError do
+      Mongo::URIParser.new('mongodb://doc:tor:badwolf@gallifrey.com:27018/test')
+    end
+
+    assert_raise_error MongoArgumentError do
+      Mongo::URIParser.new('mongodb://d@ctor:bowtie@gallifrey.com:27018/test')
+    end
   end
 
   def test_username_with_encoded_symbol
     parser = Mongo::URIParser.new('mongodb://f%40o:bar@localhost/admin')
     username = parser.auths.first[:username]
     assert_equal 'f@o', username
+
+    parser = Mongo::URIParser.new('mongodb://f%3Ao:bar@localhost/admin')
+    username = parser.auths.first[:username]
+    assert_equal 'f:o', username
   end
 
   def test_password_with_encoded_symbol
     parser = Mongo::URIParser.new('mongodb://foo:b%40r@localhost/admin')
     password = parser.auths.first[:password]
     assert_equal 'b@r', password
-  end
 
-  def test_passwords_contain_no_commas
-    assert_raise MongoArgumentError do
-      Mongo::URIParser.new('mongodb://bob:a,b@a.example.com:27018/test')
-    end
+    parser = Mongo::URIParser.new('mongodb://foo:b%3Ar@localhost/admin')
+    password = parser.auths.first[:password]
+    assert_equal 'b:r', password
   end
 
   def test_opts_with_semincolon_separator
@@ -209,4 +278,36 @@ class URITest < Test::Unit::TestCase
     assert_equal :nearest, client.read
     assert_true client.mongos?
   end
+
+  def test_auth_source
+    parser = Mongo::URIParser.new("mongodb://user:pass@localhost?authSource=foobar")
+    assert_equal 'foobar', parser.authsource
+  end
+
+  def test_auth_mechanism
+    parser = Mongo::URIParser.new("mongodb://user@localhost?authMechanism=MONGODB-X509")
+    assert_equal 'MONGODB-X509', parser.authmechanism
+
+    assert_raise_error MongoArgumentError  do
+      Mongo::URIParser.new("mongodb://user@localhost?authMechanism=INVALID")
+    end
+  end
+
+  def test_sasl_plain
+    parser = Mongo::URIParser.new("mongodb://user:pass@localhost?authMechanism=PLAIN")
+    assert_equal 'PLAIN', parser.auths.first[:mechanism]
+    assert_equal 'user', parser.auths.first[:username]
+    assert_equal 'pass', parser.auths.first[:password]
+    assert_equal 'admin', parser.auths.first[:source]
+
+    parser = Mongo::URIParser.new("mongodb://foo%2Fbar%40example.net:pass@localhost/some_db?authMechanism=PLAIN")
+    assert_equal 'PLAIN', parser.auths.first[:mechanism]
+    assert_equal 'foo/bar@example.net', parser.auths.first[:username]
+    assert_equal 'pass', parser.auths.first[:password]
+    assert_equal 'some_db', parser.auths.first[:source]
+
+    assert_raise_error MongoArgumentError  do
+      Mongo::URIParser.new("mongodb://user@localhost/some_db?authMechanism=PLAIN")
+    end
+  end
 end

data/test/functional/write_concern_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.
@@ -19,7 +19,7 @@ class WriteConcernTest < Test::Unit::TestCase
   context "Write concern propogation: " do
     setup do
       @con = standard_connection
-      @db  = @con[MONGO_TEST_DB]
+      @db  = @con[TEST_DB]
       @col = @db['test-safe']
       @col.create_index([[:a, 1]], :unique => true)
       @col.remove
@@ -59,7 +59,7 @@ class WriteConcernTest < Test::Unit::TestCase
   context "Write concern error objects" do
     setup do
       @con = standard_connection
-      @db  = @con[MONGO_TEST_DB]
+      @db  = @con[TEST_DB]
       @col = @db['test']
       @col.remove
       @col.insert({:a => 1})
@@ -71,8 +71,8 @@ class WriteConcernTest < Test::Unit::TestCase
       response = @col.update({:a => 1}, {"$set" => {:a => 2}},
                              :multi => true)
 
-      assert response['updatedExisting']
-      assert_equal 3, response['n']
+      assert(response['updatedExisting'] || @db.connection.wire_version_feature?(Mongo::MongoClient::BATCH_COMMANDS)) # TODO - review new write command return values
+      assert(response['n'] == 3 || @db.connection.wire_version_feature?(Mongo::MongoClient::BATCH_COMMANDS)) # TODO - update command top pending
     end
 
     should "return object on remove" do
@@ -83,7 +83,7 @@ class WriteConcernTest < Test::Unit::TestCase
 
   context "Write concern in gridfs" do
     setup do
-      @db = standard_connection.db(MONGO_TEST_DB)
+      @db = standard_connection.db(TEST_DB)
       @grid = Mongo::GridFileSystem.new(@db)
       @filename = 'sample'
     end

data/test/helpers/general.rb

@@ -0,0 +1,50 @@
+# 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.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Redirects output while yielding a given block of code.
+#
+# @return [Object] The result of the block.
+def silently
+  warn_level = $VERBOSE
+  $VERBOSE = nil
+  begin
+    result = yield
+  ensure
+    $VERBOSE = warn_level
+  end
+  result
+end
+
+class Hash
+  def stringify_keys
+    dup.stringify_keys!
+  end
+
+  def stringify_keys!
+    keys.each do |key|
+      self[key.to_s] = delete(key)
+    end
+    self
+  end
+
+  def except(*keys)
+    dup.except!(*keys)
+  end
+
+  # Replaces the hash without the given keys.
+  def except!(*keys)
+    keys.each { |key| delete(key) }
+    self
+  end
+end

data/test/helpers/test_unit.rb

@@ -0,0 +1,309 @@
+# 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.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+TEST_DB   = 'ruby_test' unless defined? TEST_DB
+TEST_HOST = ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost' unless defined? TEST_HOST
+TEST_DATA = File.join(File.dirname(__FILE__), 'fixtures/data')
+TEST_BASE = Test::Unit::TestCase
+
+unless defined? TEST_PORT
+  TEST_PORT = if ENV['MONGO_RUBY_DRIVER_PORT']
+    ENV['MONGO_RUBY_DRIVER_PORT'].to_i
+  else
+    Mongo::MongoClient::DEFAULT_PORT
+  end
+end
+
+class Test::Unit::TestCase
+  include Mongo
+  include BSON
+
+  # Handles creating a pre-defined MongoDB cluster for integration testing.
+  #
+  # @param  kind=nil [Symbol] Type of cluster (:rs or :sc).
+  # @param  opts={} [Hash] Options to be passed through to the cluster manager.
+  #
+  # @return [ClusterManager] The cluster manager instance being used.
+  def ensure_cluster(kind=nil, opts={})
+    cluster_instance = nil
+    class_vars = TEST_BASE.class_eval { class_variables }
+    if class_vars.include?("@@cluster_#{kind}") || class_vars.include?("@@cluster_#{kind}".to_sym)
+      cluster_instance = TEST_BASE.class_eval { class_variable_get("@@cluster_#{kind}") }
+    end
+
+    unless cluster_instance
+      if kind == :rs
+        cluster_opts = Config::DEFAULT_REPLICA_SET.dup
+      else
+        cluster_opts = Config::DEFAULT_SHARDED_SIMPLE.dup
+      end
+
+      cluster_opts.merge!(opts)
+      cluster_opts.merge!(:dbpath => ENV['MONGO_DBPATH'] || 'data')
+      config = Config.cluster(cluster_opts)
+
+      cluster_instance = Config::ClusterManager.new(config)
+      TEST_BASE.class_eval { class_variable_set("@@cluster_#{kind}", cluster_instance) }
+    end
+
+    cluster_instance.start
+    instance_variable_set("@#{kind}", cluster_instance)
+  end
+
+  # Generic helper to rescue and retry from a connection failure.
+  #
+  # @param max_retries=30 [Integer] The number of times to attempt a retry.
+  #
+  # @return [Object] The block result.
+  def rescue_connection_failure(max_retries=30)
+    retries = 0
+    begin
+      yield
+    rescue Mongo::ConnectionFailure => ex
+      retries += 1
+      raise ex if retries > max_retries
+      sleep(2)
+      retry
+    end
+  end
+
+  # Creates and connects a standard, pre-defined MongoClient instance.
+  #
+  # @param  options={} [Hash] Options to be passed to the client instance.
+  # @param  legacy=false [Boolean] When true, uses deprecated Mongo::Connection.
+  #
+  # @return [MongoClient] The client instance.
+  def self.standard_connection(options={}, legacy=false)
+    if legacy
+      Connection.new(TEST_HOST, TEST_PORT, options)
+    else
+      MongoClient.new(TEST_HOST, TEST_PORT, options)
+    end
+  end
+
+  # Creates and connects a standard, pre-defined MongoClient instance.
+  #
+  # @param  options={} [Hash] Options to be passed to the client instance.
+  # @param  legacy=false [Boolean] When true, uses deprecated Mongo::Connection.
+  #
+  # @return [MongoClient] The client instance.
+  def standard_connection(options={}, legacy=false)
+    self.class.standard_connection(options, legacy)
+  end
+
+  def self.host_port
+    "#{mongo_host}:#{mongo_port}"
+  end
+
+  def self.mongo_host
+    TEST_HOST
+  end
+
+  def self.mongo_port
+    TEST_PORT
+  end
+
+  def host_port
+    self.class.host_port
+  end
+
+  def mongo_host
+    self.class.mongo_host
+  end
+
+  def mongo_port
+    self.class.mongo_port
+  end
+
+  def method_name
+    caller[0]=~/`(.*?)'/
+    $1
+  end
+
+  def perform_step_down(member)
+    start   = Time.now
+    timeout = 20 # seconds
+    begin
+      step_down_command = BSON::OrderedHash.new
+      step_down_command[:replSetStepDown] = 30
+      member['admin'].command(step_down_command)
+    rescue Mongo::OperationFailure => e
+      retry unless (Time.now - start) > timeout
+      raise e
+    end
+  end
+
+  def new_mock_socket(host='localhost', port=27017)
+    socket = Object.new
+    socket.stubs(:setsockopt).with(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+    socket.stubs(:close)
+    socket.stubs(:closed?)
+    socket.stubs(:checkin)
+    socket.stubs(:pool)
+    socket
+  end
+
+  def new_mock_unix_socket(sockfile='/tmp/mongod.sock')
+    socket = Object.new
+    socket.stubs(:setsockopt).with(Socket::IPPROTO_TCP)
+    socket.stubs(:close)
+    socket.stubs(:closed?)
+    socket
+  end
+
+  def new_mock_db
+    Object.new
+  end
+
+  def assert_raise_error(klass, message=nil)
+    begin
+      yield
+    rescue => e
+      if klass.to_s != e.class.to_s
+        flunk "Expected exception class #{klass} but got #{e.class}.\n #{e.backtrace}"
+      end
+
+      if message && !e.message.include?(message)
+        p e.backtrace
+        flunk "#{e.message} does not include #{message}.\n#{e.backtrace}"
+      end
+    else
+      flunk "Expected assertion #{klass} but none was raised."
+    end
+  end
+
+  def match_document(key, expected, actual) # special cases for Regexp match, BSON::ObjectId, Range
+    if expected.is_a?(Hash) && actual.is_a?(Hash)
+      expected_keys = expected.keys.sort
+      actual_keys = actual.keys.sort
+      #currently allow extra fields in actual as the following check for equality of keys is commented out
+      #raise "field:#{key.inspect} - Hash keys expected:#{expected_keys.inspect} actual:#{actual_keys.inspect}" if expected_keys != actual_keys
+      expected_keys.each{|k| match_document(k, expected[k], actual[k])}
+    elsif expected.is_a?(Array) && actual.is_a?(Array)
+      raise "field:#{key.inspect} - Array size expected:#{expected.size} actual:#{actual.size}" if expected.size != actual.size
+      (0...expected.size).each{|i| match_document(i, expected[i], actual[i])}
+    elsif expected.is_a?(Regexp) && actual.is_a?(String)
+      raise "field:#{key.inspect} - Regexp expected:#{expected.inspect} actual:#{actual.inspect}" if expected !~ actual
+    elsif expected.is_a?(BSON::ObjectId) && actual.is_a?(BSON::ObjectId)
+      # match type but not value
+    elsif expected.is_a?(Range)
+      raise "field:#{key.inspect} - Range expected:#{expected.inspect} actual:#{actual.inspect}" if !expected.include?(actual)
+    elsif expected.is_a?(Set)
+      raise "field:#{key.inspect} - Set expected:#{expected.inspect} actual:#{actual.inspect}" if !expected.include?(actual)
+    else
+      raise "field:#{key.inspect} - expected:#{expected.inspect} actual:#{actual.inspect}" if expected != actual
+    end
+    true
+  end
+
+  def assert_match_document(expected, actual, message = '')
+    match = begin
+      match_document('', expected, actual)
+    rescue => ex
+      message = ex.message + ' - ' + message
+      false
+    end
+    assert(match, message)
+  end
+
+  def with_forced_timeout(client, &block)
+    cmd_line_args = client['admin'].command({ :getCmdLineOpts => 1 })['argv']
+    if cmd_line_args.include?('enableTestCommands=1') && client.server_version >= "2.5.3"
+      begin
+        #Force any query or command with valid non-zero max time to fail (SERVER-10650)
+        fail_point_cmd = OrderedHash.new
+        fail_point_cmd[:configureFailPoint] = 'maxTimeAlwaysTimeOut'
+        fail_point_cmd[:mode] = 'alwaysOn'
+        client['admin'].command(fail_point_cmd)
+        yield
+        fail_point_cmd[:mode] = 'off'
+        client['admin'].command(fail_point_cmd)
+      end
+    end
+  end
+
+  def with_default_journaling(client, &block)
+    cmd_line_args = client['admin'].command({ :getCmdLineOpts => 1 })['parsed']
+    unless client.server_version < "2.0" || cmd_line_args.include?('nojournal')
+      yield
+    end
+  end
+
+  def with_no_replication(client, &block)
+    if client.class == MongoClient
+      yield
+    end
+  end
+
+  def with_no_journaling(client, &block)
+    cmd_line_args = client['admin'].command({ :getCmdLineOpts => 1 })['parsed']
+    unless client.server_version < "2.0" || !cmd_line_args.include?('nojournal')
+      yield
+    end
+  end
+
+  def with_ipv6_enabled(client, &block)
+    cmd_line_args = client['admin'].command({ :getCmdLineOpts => 1 })['parsed']
+    if cmd_line_args.include?('ipv6')
+      yield
+    end
+  end
+
+  def with_write_commands(client, &block)
+    wire_version = Mongo::MongoClient::BATCH_COMMANDS
+    if client.primary_wire_version_feature?(wire_version)
+      yield wire_version
+    end
+  end
+
+  def with_preserved_env_uri(new_uri=nil, &block)
+    old_mongodb_uri = ENV['MONGODB_URI']
+    begin
+      ENV['MONGODB_URI'] = new_uri
+      yield
+    ensure
+      ENV['MONGODB_URI'] = old_mongodb_uri
+    end
+  end
+
+  def with_write_operations(client, &block)
+    wire_version = Mongo::MongoClient::RELEASE_2_4_AND_BEFORE
+    if client.primary_wire_version_feature?(wire_version)
+      client.class.class_eval(%Q{
+        alias :old_use_write_command? :use_write_command?
+        def use_write_command?(write_concern)
+          false
+        end
+      })
+      yield wire_version
+      client.class.class_eval(%Q{
+        alias :use_write_command? :old_use_write_command?
+      })
+    end
+  end
+
+  def with_write_commands_and_operations(client, &block)
+    with_write_commands(client, &block)
+    with_write_operations(client, &block)
+  end
+
+end
+
+# Before and after hooks for the entire test run
+# handles mop up after the cluster manager is done.
+Test::Unit.at_exit do
+  TEST_BASE.class_eval { class_variables }.select { |v| v =~ /@@cluster_/ }.each do |cluster|
+    TEST_BASE.class_eval { class_variable_get(cluster) }.stop
+  end
+end