diff --git a/tasks/testing.rake b/tasks/testing.rake
index 5187ee6697..9558af0ba5 100644
--- a/tasks/testing.rake
+++ b/tasks/testing.rake
@@ -24,10 +24,7 @@ TEST_SUITES = {
   :threading => { :pattern => 'test/threading/**/*_test.rb' },
   :replica_set => {
     :pattern => 'test/replica_set/**/*_test.rb',
-    :exclude => ['test/replica_set/complex_connect_test.rb',
-                 'test/replica_set/count_test.rb',
-                 'test/replica_set/read_preference_test.rb',
-                 'test/replica_set/ssl_test.rb']
+    :exclude => ['test/replica_set/ssl_test.rb']
   },
   :sharded_cluster => { :pattern => 'test/sharded_cluster/**/*_test.rb' },
   :tools => {
diff --git a/test/functional/client_test.rb b/test/functional/client_test.rb
index d20e9b31ea..ea05c15df5 100644
--- a/test/functional/client_test.rb
+++ b/test/functional/client_test.rb
@@ -452,7 +452,8 @@ def test_connection_activity
   end
 
   def test_operation_timeout_with_active
-    conn = standard_connection
+    conn = MongoClient.new
+    authenticate_client(conn)
     assert conn.active?
     assert_equal Mongo::MongoClient::DEFAULT_OP_TIMEOUT, conn.op_timeout
 
diff --git a/test/helpers/test_unit.rb b/test/helpers/test_unit.rb
index f0c78b63f0..b10265e4d2 100644
--- a/test/helpers/test_unit.rb
+++ b/test/helpers/test_unit.rb
@@ -12,9 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-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
+TEST_HOST       = ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost' unless defined? TEST_HOST
+TEST_DATA       = File.join(File.dirname(__FILE__), 'fixtures/data')
+TEST_OP_TIMEOUT = 40
+TEST_BASE       = Test::Unit::TestCase
 
 unless defined? TEST_PORT
   TEST_PORT = if ENV['MONGO_RUBY_DRIVER_PORT']
@@ -89,16 +90,17 @@ def rescue_connection_failure(max_retries=30)
   #
   # @return [MongoClient] The client instance.
   def self.standard_connection(options={}, legacy=false)
+    opts = options[:op_timeout] ? options : options.merge(:op_timeout => TEST_OP_TIMEOUT)
     if legacy
       silently do
         # We have to create the Connection object directly here instead of using TEST_URI
         # because Connection#from_uri ends up creating a MongoClient object.
-        conn = Connection.new(TEST_HOST, TEST_PORT, options)
+        conn = Connection.new(TEST_HOST, TEST_PORT, opts)
         conn[TEST_DB].authenticate(TEST_USER, TEST_USER_PWD)
         conn
       end
     else
-      MongoClient.from_uri(TEST_URI, options)
+      MongoClient.from_uri(TEST_URI, opts)
     end
   end
 
@@ -420,7 +422,7 @@ def self.cleanup_users_and_dbs
     not_cluster = TEST_BASE.class_eval { class_variables }.none? { |v| v =~ /@@cluster_/ }
 
     if @@connected_single_mongod && not_cluster
-      client = Mongo::MongoClient.from_uri(TEST_URI)
+      client = Mongo::MongoClient.from_uri(TEST_URI, :op_timeout => TEST_OP_TIMEOUT)
       db = client[TEST_DB]
       begin
         begin
diff --git a/test/replica_set/authentication_test.rb b/test/replica_set/authentication_test.rb
index 3659d22ed6..996407f113 100644
--- a/test/replica_set/authentication_test.rb
+++ b/test/replica_set/authentication_test.rb
@@ -28,7 +28,7 @@ class ReplicaSetAuthenticationTest < Test::Unit::TestCase
 
   def setup
     ensure_cluster(:rs)
-    @client    = MongoReplicaSetClient.from_uri(@uri)
+    @client    = MongoReplicaSetClient.from_uri(@uri, :op_timeout => TEST_OP_TIMEOUT)
     @admin     = @client['admin']
     @version   = @client.server_version
     @db        = @client['ruby-test']
diff --git a/test/replica_set/basic_test.rb b/test/replica_set/basic_test.rb
index af102153dc..b988de3d9c 100644
--- a/test/replica_set/basic_test.rb
+++ b/test/replica_set/basic_test.rb
@@ -21,7 +21,7 @@ def setup
   end
 
   def test_connect
-    client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :name => @rs.repl_set_name)
+    client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :name => @rs.repl_set_name, :op_timeout => TEST_OP_TIMEOUT)
     assert client.connected?
     assert_equal @rs.primary_name, client.primary.join(':')
     assert_equal @rs.secondary_names.sort, client.secondaries.collect{|s| s.join(':')}.sort
diff --git a/test/replica_set/client_test.rb b/test/replica_set/client_test.rb
index 74f42041bd..99db67ebf2 100644
--- a/test/replica_set/client_test.rb
+++ b/test/replica_set/client_test.rb
@@ -26,7 +26,7 @@ def teardown
   end
 
   def test_reconnection
-    @client = MongoReplicaSetClient.from_uri(@uri)
+    @client = MongoReplicaSetClient.from_uri(@uri, :op_timeout => TEST_OP_TIMEOUT)
     assert @client.connected?
 
     manager = @client.local_manager
diff --git a/test/replica_set/complex_connect_test.rb b/test/replica_set/complex_connect_test.rb
deleted file mode 100644
index 3eb362847e..0000000000
--- a/test/replica_set/complex_connect_test.rb
+++ /dev/null
@@ -1,80 +0,0 @@
-# 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'
-
-class ComplexConnectTest < Test::Unit::TestCase
-
-  def setup
-    ensure_cluster(:rs)
-  end
-
-  def teardown
-    @client.close if defined?(@conn) && @conn
-  end
-
-  def test_complex_connect
-    host = @rs.servers.first.host
-    primary = MongoClient.new(host, @rs.primary.port)
-    authenticate_client(primary)
-
-    @client = MongoReplicaSetClient.new([
-      @rs.servers[2].host_port,
-      @rs.servers[1].host_port,
-      @rs.servers[0].host_port
-    ])
-
-    authenticate_client(@client)
-    version = @client.server_version
-
-    @client[TEST_DB]['complext-connect-test'].insert({:a => 1})
-    assert @client[TEST_DB]['complext-connect-test'].find_one
-
-    config = primary['local']['system.replset'].find_one
-    old_config = config.dup
-    config['version'] += 1
-
-    # eliminate exception: can't find self in new replset config
-    port_to_delete = @rs.servers.collect(&:port).find{|port| port != primary.port}.to_s
-
-    config['members'].delete_if do |member|
-      member['host'].include?(port_to_delete)
-    end
-
-    assert_raise ConnectionFailure do
-      primary['admin'].command({:replSetReconfig => config})
-    end
-    @rs.start
-
-    assert_raise ConnectionFailure do
-      perform_step_down(primary)
-    end
-
-    # isMaster is currently broken in 2.1+ when called on removed nodes
-    puts version
-    if version < "2.1"
-      rescue_connection_failure do
-        assert @client[TEST_DB]['complext-connect-test'].find_one
-      end
-
-      assert @client[TEST_DB]['complext-connect-test'].find_one
-    end
-
-    primary = MongoClient.new(host, @rs.primary.port)
-    authenticate_client(primary)
-    assert_raise ConnectionFailure do
-      primary['admin'].command({:replSetReconfig => old_config})
-    end
-  end
-end
diff --git a/test/replica_set/count_test.rb b/test/replica_set/count_test.rb
index b06a088a16..c2d2ff3916 100644
--- a/test/replica_set/count_test.rb
+++ b/test/replica_set/count_test.rb
@@ -18,7 +18,7 @@ class ReplicaSetCountTest < Test::Unit::TestCase
 
   def setup
     ensure_cluster(:rs)
-    @client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :read => :primary_preferred)
+    @client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :read => :primary_preferred, :op_timeout => TEST_OP_TIMEOUT)
     authenticate_client(@client)
     assert @client.primary_pool
     @primary = MongoClient.new(@client.primary_pool.host, @client.primary_pool.port)
diff --git a/test/replica_set/cursor_test.rb b/test/replica_set/cursor_test.rb
index 8c678ea63d..3e03f75fde 100644
--- a/test/replica_set/cursor_test.rb
+++ b/test/replica_set/cursor_test.rb
@@ -65,7 +65,7 @@ def test_intervening_query_secondary
   def setup_client(read=:primary)
     route_read ||= read
     # Setup ReplicaSet Connection
-    @client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :read => read)
+    @client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :read => read, :op_timeout => TEST_OP_TIMEOUT)
     authenticate_client(@client)
 
     @db = @client.db(TEST_DB)
diff --git a/test/replica_set/insert_test.rb b/test/replica_set/insert_test.rb
index 2538034fed..c0a34676f2 100644
--- a/test/replica_set/insert_test.rb
+++ b/test/replica_set/insert_test.rb
@@ -18,7 +18,7 @@ class ReplicaSetInsertTest < Test::Unit::TestCase
 
   def setup
     ensure_cluster(:rs)
-    @client = MongoReplicaSetClient.from_uri(@uri)
+    @client = MongoReplicaSetClient.from_uri(@uri, :op_timeout => TEST_OP_TIMEOUT)
     @version = @client.server_version
     @db = @client.db(TEST_DB)
     @db.drop_collection("test-sets")
diff --git a/test/replica_set/max_values_test.rb b/test/replica_set/max_values_test.rb
index f363c104d3..31e3c145dd 100644
--- a/test/replica_set/max_values_test.rb
+++ b/test/replica_set/max_values_test.rb
@@ -20,7 +20,7 @@ class MaxValuesTest < Test::Unit::TestCase
 
   def setup
     ensure_cluster(:rs)
-    @client = MongoReplicaSetClient.from_uri(@uri)
+    @client = MongoReplicaSetClient.from_uri(@uri, :op_timeout => TEST_OP_TIMEOUT)
     @db = new_mock_db
     @client.stubs(:[]).returns(@db)
     @ismaster = {
diff --git a/test/replica_set/pinning_test.rb b/test/replica_set/pinning_test.rb
index da59756fe1..033c8a579b 100644
--- a/test/replica_set/pinning_test.rb
+++ b/test/replica_set/pinning_test.rb
@@ -17,7 +17,7 @@
 class ReplicaSetPinningTest < Test::Unit::TestCase
   def setup
     ensure_cluster(:rs)
-    @client = MongoReplicaSetClient.from_uri(@uri)
+    @client = MongoReplicaSetClient.from_uri(@uri, :op_timeout => TEST_OP_TIMEOUT)
     @db = @client.db(TEST_DB)
     @coll = @db.collection("test-sets")
     @coll.insert({:a => 1})
diff --git a/test/replica_set/query_test.rb b/test/replica_set/query_test.rb
index 6accc125d4..99c68f5007 100644
--- a/test/replica_set/query_test.rb
+++ b/test/replica_set/query_test.rb
@@ -18,7 +18,7 @@ class ReplicaSetQueryTest < Test::Unit::TestCase
 
   def setup
     ensure_cluster(:rs)
-    @client = MongoReplicaSetClient.from_uri(@uri)
+    @client = MongoReplicaSetClient.from_uri(@uri, :op_timeout => TEST_OP_TIMEOUT)
     @db = @client.db(TEST_DB)
     @db.drop_collection("test-sets")
     @coll = @db.collection("test-sets")
diff --git a/test/replica_set/read_preference_test.rb b/test/replica_set/read_preference_test.rb
index 50c906baf8..7e6a30e918 100644
--- a/test/replica_set/read_preference_test.rb
+++ b/test/replica_set/read_preference_test.rb
@@ -17,66 +17,63 @@
 class ReadPreferenceTest < Test::Unit::TestCase
 
   def setup
-    ensure_cluster(:rs, :replicas => 2, :arbiters => 0)
-
-    # Insert data
-    primary = @rs.primary
-    conn = Connection.new(primary.host, primary.port)
-    authenticate_client(conn)
-    db = conn.db(TEST_DB)
-    coll = db.collection("test-sets")
+    ensure_cluster(:rs)
+    client = make_connection
+    db = client.db(TEST_DB)
+    coll = db.collection('test-sets')
     coll.save({:a => 20}, {:w => 2})
   end
 
   def test_read_primary
-    conn = make_connection
+    client = make_connection
     rescue_connection_failure do
-      assert conn.read_primary?
-      assert conn.primary?
+      assert client.read_primary?
+      assert client.primary?
     end
 
-    conn = make_connection(:primary_preferred)
+    client = make_connection(:primary_preferred)
     rescue_connection_failure do
-      assert conn.read_primary?
-      assert conn.primary?
+      assert client.read_primary?
+      assert client.primary?
     end
 
-    conn = make_connection(:secondary)
+    client = make_connection(:secondary)
     rescue_connection_failure do
-      assert !conn.read_primary?
-      assert !conn.primary?
+      assert !client.read_primary?
+      assert !client.primary?
     end
 
-    conn = make_connection(:secondary_preferred)
+    client = make_connection(:secondary_preferred)
     rescue_connection_failure do
-      assert !conn.read_primary?
-      assert !conn.primary?
+      assert !client.read_primary?
+      assert !client.primary?
     end
   end
 
   def test_connection_pools
-    conn = make_connection
-    assert conn.primary_pool, "No primary pool!"
-    assert conn.read_pool, "No read pool!"
-    assert conn.primary_pool.port == conn.read_pool.port,
+    client = make_connection
+    assert client.primary_pool, "No primary pool!"
+    assert client.read_pool, "No read pool!"
+    assert client.primary_pool.port == client.read_pool.port,
       "Primary port and read port are not the same!"
 
-    conn = make_connection(:primary_preferred)
-    assert conn.primary_pool, "No primary pool!"
-    assert conn.read_pool, "No read pool!"
-    assert conn.primary_pool.port == conn.read_pool.port,
+
+    client = make_connection(:primary_preferred)
+    assert client.primary_pool, "No primary pool!"
+    assert client.read_pool, "No read pool!"
+    assert client.primary_pool.port == client.read_pool.port,
       "Primary port and read port are not the same!"
 
-    conn = make_connection(:secondary)
-    assert conn.primary_pool, "No primary pool!"
-    assert conn.read_pool, "No read pool!"
-    assert conn.primary_pool.port != conn.read_pool.port,
+    client = make_connection(:secondary)
+    assert client.primary_pool, "No primary pool!"
+    assert client.read_pool, "No read pool!"
+    assert client.primary_pool.port != client.read_pool.port,
       "Primary port and read port are the same!"
 
-    conn = make_connection(:secondary_preferred)
-    assert conn.primary_pool, "No primary pool!"
-    assert conn.read_pool, "No read pool!"
-    assert conn.primary_pool.port != conn.read_pool.port,
+    client = make_connection(:secondary_preferred)
+    assert client.primary_pool, "No primary pool!"
+    assert client.read_pool, "No read pool!"
+    assert client.primary_pool.port != client.read_pool.port,
       "Primary port and read port are the same!"
   end
 
@@ -84,97 +81,97 @@ def test_read_routing
     prepare_routing_test
 
     # Test that reads are going to the right members
-    assert_query_route(@primary, @primary_direct)
-    assert_query_route(@primary_preferred, @primary_direct)
-    assert_query_route(@secondary, @secondary_direct)
-    assert_query_route(@secondary_preferred, @secondary_direct)
+    assert_query_route(@primary, :primary)
+    assert_query_route(@primary_preferred, :primary)
+    assert_query_route(@secondary, :secondary)
+    assert_query_route(@secondary_preferred, :secondary)
   end
 
   def test_read_routing_with_primary_down
     prepare_routing_test
 
     # Test that reads are going to the right members
-    assert_query_route(@primary, @primary_direct)
-    assert_query_route(@primary_preferred, @primary_direct)
-    assert_query_route(@secondary, @secondary_direct)
-    assert_query_route(@secondary_preferred, @secondary_direct)
+    assert_query_route(@primary, :primary)
+    assert_query_route(@primary_preferred, :primary)
+    assert_query_route(@secondary, :secondary)
+    assert_query_route(@secondary_preferred, :secondary)
 
-    # Kill the primary so only a single secondary exists
+    # Kill the primary so the remaining two members are secondaries
     @rs.primary.kill
-
+    sleep(2)
     # Test that reads are going to the right members
     assert_raise_error ConnectionFailure do
       @primary[TEST_DB]['test-sets'].find_one
     end
-    assert_query_route(@primary_preferred, @secondary_direct)
-    assert_query_route(@secondary, @secondary_direct)
-    assert_query_route(@secondary_preferred, @secondary_direct)
+    assert_query_route(@primary_preferred, :secondary)
+    assert_query_route(@secondary, :secondary)
+    assert_query_route(@secondary_preferred, :secondary)
 
     # Restore set
     @rs.restart
     sleep(1)
     @repl_cons.each { |con| con.refresh }
     sleep(1)
-    @primary_direct = Connection.new(
-      @rs.config['host'],
-      @primary.read_pool.port
-    )
 
     # Test that reads are going to the right members
-    assert_query_route(@primary, @primary_direct)
-    assert_query_route(@primary_preferred, @primary_direct)
-    assert_query_route(@secondary, @secondary_direct)
-    assert_query_route(@secondary_preferred, @secondary_direct)
+    assert_query_route(@primary, :primary)
+    assert_query_route(@primary_preferred, :primary)
+    assert_query_route(@secondary, :secondary)
+    assert_query_route(@secondary_preferred, :secondary)
   end
 
   def test_read_routing_with_secondary_down
     prepare_routing_test
 
     # Test that reads are going to the right members
-    assert_query_route(@primary, @primary_direct)
-    assert_query_route(@primary_preferred, @primary_direct)
-    assert_query_route(@secondary, @secondary_direct)
-    assert_query_route(@secondary_preferred, @secondary_direct)
-
-    # Kill the secondary so that only primary exists
-    @rs.secondaries.first.kill
-
-    # Test that reads are going to the right members
-    assert_query_route(@primary, @primary_direct)
-    assert_query_route(@primary_preferred, @primary_direct)
-    assert_raise_error ConnectionFailure do
-      @secondary[TEST_DB]['test-sets'].find_one
+    assert_query_route(@primary, :primary)
+    assert_query_route(@primary_preferred, :primary)
+    assert_query_route(@secondary, :secondary)
+    assert_query_route(@secondary_preferred, :secondary)
+
+    secondaries = @rs.secondaries
+    secondaries[0].kill
+    assert_query_route(@secondary_preferred, :secondary)
+
+    secondaries[1].kill
+    sleep(2)
+
+    recovered = false
+    until recovered
+      begin
+        @secondary[TEST_DB]['test-sets'].find_one
+        recovered = true
+      rescue ConnectionFailure
+      end
     end
-    assert_query_route(@secondary_preferred, @primary_direct)
+
+    assert_query_route(@secondary_preferred, :secondary)
+    assert_query_route(@secondary, :secondary)
+    assert_query_route(@primary_preferred, :secondary)
 
     # Restore set
     @rs.restart
     sleep(1)
     @repl_cons.each { |con| con.refresh }
     sleep(1)
-    @secondary_direct = Connection.new(
-      @rs.config['host'],
-      @secondary.read_pool.port,
-      :slave_ok => true
-    )
 
     # Test that reads are going to the right members
-    assert_query_route(@primary, @primary_direct)
-    assert_query_route(@primary_preferred, @primary_direct)
-    assert_query_route(@secondary, @secondary_direct)
-    assert_query_route(@secondary_preferred, @secondary_direct)
+    assert_query_route(@primary, :primary)
+    assert_query_route(@primary_preferred, :primary)
+    assert_query_route(@secondary, :secondary)
+    assert_query_route(@secondary_preferred, :secondary)
   end
 
   def test_write_lots_of_data
-    @conn = make_connection(:secondary_preferred)
-    @db = @conn[TEST_DB]
-    @coll = @db.collection("test-sets", {:w => 2})
+    client = make_connection(:secondary_preferred)
+    db = client[TEST_DB]
+    coll = db.collection("test-sets", {:w => 2})
 
     6000.times do |n|
-      @coll.save({:a => n})
+      coll.save({:a => n})
     end
 
-    cursor = @coll.find()
+    cursor = coll.find()
     cursor.next
     cursor.close
   end
@@ -189,15 +186,14 @@ def prepare_routing_test
     @secondary_preferred = make_connection(:secondary_preferred)
     @repl_cons = [@primary, @primary_preferred, @secondary, @secondary_preferred]
 
-    # Setup direct connections
-    @primary_direct = Connection.new(@rs.config['host'], @primary.read_pool.port)
-    authenticate_client(@primary_direct)
-    @secondary_direct = Connection.new(@rs.config['host'], @secondary.read_pool.port, :slave_ok => true)
-    authenticate_client(@secondary_direct)
+    @repl_cons.each do |client|
+      client.stubs(:pinned_pool).returns(nil)
+    end
   end
 
   def make_connection(mode = :primary, opts = {})
-    opts.merge!({:read => mode})
+    opts.merge!(:read => mode)
+    opts.merge!(:op_timeout => nil)
     client = MongoReplicaSetClient.new(@rs.repl_set_seeds, opts)
     authenticate_client(client)
   end
@@ -206,15 +202,18 @@ def query_count(connection)
     connection['admin'].command({:serverStatus => 1})['opcounters']['query']
   end
 
-  def assert_query_route(test_connection, expected_target)
-    #puts "#{test_connection.read_pool.port} #{expected_target.read_pool.port}"
+  def assert_query_route(test_connection, type)
+    secondary = type == :secondary
     authenticate_client(test_connection)
-    authenticate_client(expected_target)
-    queries_before = query_count(expected_target)
+    cursor = test_connection[TEST_DB]['test-sets'].find
     assert_nothing_raised do
-      test_connection[TEST_DB]['test-sets'].find_one
+      cursor.next
     end
-    queries_after = query_count(expected_target)
-    assert_equal 1, queries_after - queries_before
+    pool = cursor.instance_variable_get("@pool")
+    assert_equal secondary, secondary?(MongoClient.new(pool.host, pool.port))
+  end
+
+  def secondary?(client)
+    client['admin'].command(:isMaster => 1)['secondary']
   end
 end
\ No newline at end of file
diff --git a/test/replica_set/refresh_test.rb b/test/replica_set/refresh_test.rb
index 82dc0775a6..49fd608fbf 100644
--- a/test/replica_set/refresh_test.rb
+++ b/test/replica_set/refresh_test.rb
@@ -22,7 +22,8 @@ def setup
 
   def test_connect_and_manual_refresh_with_secondary_down
     num_secondaries = @rs.secondaries.size
-    client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :refresh_mode => false)
+    client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :refresh_mode => false,
+                                       :op_timeout => TEST_OP_TIMEOUT)
     authenticate_client(client)
 
     assert_equal num_secondaries, client.secondaries.size
@@ -57,7 +58,8 @@ def test_connect_and_manual_refresh_with_secondary_down
   def test_automated_refresh_with_secondary_down
     num_secondaries = @rs.secondaries.size
     client = MongoReplicaSetClient.new(@rs.repl_set_seeds,
-      :refresh_interval => 1, :refresh_mode => :sync, :read => :secondary_preferred)
+      :refresh_interval => 1, :refresh_mode => :sync, :read => :secondary_preferred,
+      :op_timeout => TEST_OP_TIMEOUT)
     authenticate_client(client)
 
     # Ensure secondaries are all recognized by client and client is connected
@@ -99,7 +101,8 @@ def test_concurrent_refreshes
     factor = 5
     nthreads = factor * 10
     threads = []
-    client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :refresh_mode => :sync, :refresh_interval => 1)
+    client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :refresh_mode => :sync,
+                                       :refresh_interval => 1, :op_timeout => TEST_OP_TIMEOUT)
     authenticate_client(client)
 
     nthreads.times do |i|
diff --git a/test/replica_set/replication_ack_test.rb b/test/replica_set/replication_ack_test.rb
index d3606f3c99..d1129a90a5 100644
--- a/test/replica_set/replication_ack_test.rb
+++ b/test/replica_set/replication_ack_test.rb
@@ -18,7 +18,7 @@ class ReplicaSetAckTest < Test::Unit::TestCase
 
   def setup
     ensure_cluster(:rs)
-    @client = MongoReplicaSetClient.from_uri(@uri)
+    @client = MongoReplicaSetClient.from_uri(@uri, :op_timeout => TEST_OP_TIMEOUT)
 
     @slave1 = MongoClient.new(
       @client.secondary_pools.first.host,
@@ -33,7 +33,7 @@ def setup
   end
 
   def teardown
-    @client.close if @conn
+    @client.close if @client
   end
 
   def test_safe_mode_with_w_failure
diff --git a/test/tools/mongo_config.rb b/test/tools/mongo_config.rb
index c2d32ba77c..953120aee6 100755
--- a/test/tools/mongo_config.rb
+++ b/test/tools/mongo_config.rb
@@ -672,6 +672,7 @@ def delete_users
         cmd_servers = replica_set? ? [ primary ] : routers
 
         cmd_servers.each do |cmd_server|
+          next unless cmd_server
           begin
             client = Mongo::MongoClient.new(cmd_server.config[:host],
                                             cmd_server.config[:port])
@@ -690,6 +691,7 @@ def delete_users
       end
 
       def stop
+        start
         delete_users
         servers.each{|server| server.stop}
         self