mongo 1.8.0 → 1.8.2

data/test/functional/connection_test.rb

@@ -415,10 +415,7 @@ class TestConnection < Test::Unit::TestCase
     end
 
     should "show a proper exception message if an IOError is raised while closing a socket" do
-      fake_socket = mock('fake_socket')
-      fake_socket.stubs(:close).raises(IOError.new)
-      fake_socket.stub_everything
-      TCPSocket.stubs(:new).returns(fake_socket)
+      TCPSocket.any_instance.stubs(:close).raises(IOError.new)
 
       @con.primary_pool.checkout_new_socket
       @con.primary_pool.expects(:warn)

data/test/functional/db_api_test.rb

@@ -330,7 +330,7 @@ class DBAPITest < Test::Unit::TestCase
     @@db.create_collection('foobar')
 
     coll = @@db.create_collection('foobar')
-    assert_equal true, coll.safe
+    assert_equal true, Mongo::WriteConcern.gle?(coll.write_concern)
   end
 
 
@@ -404,8 +404,9 @@ class DBAPITest < Test::Unit::TestCase
 
     test.insert("hello" => "world")
     test.insert("hello" => "mike")
-    test.insert("hello" => "world")
-    assert @@db.error?
+    assert_raise OperationFailure do
+      test.insert("hello" => "world")
+    end
   end
 
   def test_index_on_subfield
@@ -423,8 +424,9 @@ class DBAPITest < Test::Unit::TestCase
 
     test.insert("hello" => {"a" => 4, "b" => 5})
     test.insert("hello" => {"a" => 7, "b" => 2})
-    test.insert("hello" => {"a" => 4, "b" => 10})
-    assert @@db.error?
+    assert_raise OperationFailure do
+      test.insert("hello" => {"a" => 4, "b" => 10} )
+    end
   end
 
   def test_array
@@ -766,24 +768,26 @@ HERE
 
   def test_encodings
     if RUBY_VERSION >= '1.9'
-      ascii = "hello world"
+      default = "hello world"
       utf8 = "hello world".encode("UTF-8")
       iso8859 = "hello world".encode("ISO-8859-1")
 
       if RUBY_PLATFORM =~ /jruby/
-        assert_equal "ASCII-8BIT", ascii.encoding.name
+        assert_equal "ASCII-8BIT", default.encoding.name
+      elsif RUBY_VERSION >= '2.0'
+        assert_equal "UTF-8", default.encoding.name
       else
-        assert_equal "US-ASCII", ascii.encoding.name
+        assert_equal "US-ASCII", default.encoding.name
       end
 
       assert_equal "UTF-8", utf8.encoding.name
       assert_equal "ISO-8859-1", iso8859.encoding.name
 
       @@coll.remove
-      @@coll.save("ascii" => ascii, "utf8" => utf8, "iso8859" => iso8859)
+      @@coll.save("default" => default, "utf8" => utf8, "iso8859" => iso8859)
       doc = @@coll.find_one()
 
-      assert_equal "UTF-8", doc["ascii"].encoding.name
+      assert_equal "UTF-8", doc["default"].encoding.name
       assert_equal "UTF-8", doc["utf8"].encoding.name
       assert_equal "UTF-8", doc["iso8859"].encoding.name
     end

data/test/functional/pool_test.rb

@@ -5,51 +5,43 @@ class PoolTest < Test::Unit::TestCase
   include Mongo
 
   def setup
-    @connection = standard_connection
+    @client    ||= standard_connection({:pool_size => 500, :pool_timeout => 5})
+    @db         = @client.db(MONGO_TEST_DB)
+    @collection = @db.collection("pool_test")
   end
 
   def test_pool_affinity
-    @pool = Pool.new(@connection, TEST_HOST, TEST_PORT, :size => 5)
-
-    @threads    = []
+    pool = Pool.new(@client, TEST_HOST, TEST_PORT, :size => 5)
 
+    threads = []
     10.times do
-      @threads << Thread.new do
-        original_socket = @pool.checkout
-        @pool.checkin(original_socket)
+      threads << Thread.new do
+        original_socket = pool.checkout
+        pool.checkin(original_socket)
         5000.times do
-          socket = @pool.checkout
+          socket = pool.checkout
           assert_equal original_socket, socket
-          @pool.checkin(socket)
+          pool.checkin(socket)
         end
       end
     end
 
-    @threads.each { |t| t.join }
+    threads.each { |t| t.join }
   end
 
-  def test_pool_thread_pruning
-    @pool = Pool.new(@connection, TEST_HOST, TEST_PORT, :size => 5)
-
-    @threads = []
-
-    10.times do
-      @threads << Thread.new do
-        50.times do
-          socket = @pool.checkout
-          @pool.checkin(socket)
-        end
-      end
+  def test_pool_affinity_max_size
+    8000.times {|x| @collection.insert({:value => x})}
+    threads = []
+    threads << Thread.new do
+      @collection.find({"value" => {"$lt" => 100}}).each {|e| e}
+      Thread.pass
+      sleep(5)
+      @collection.find({"value" => {"$gt" => 100}}).each {|e| e}
     end
-
-    @threads.each { |t| t.join }
-    assert_equal 10, @pool.instance_variable_get(:@threads_to_sockets).size
-
-    # Thread-socket pool
-    10000.times do
-      @pool.checkin(@pool.checkout)
+    sleep(1)
+    threads << Thread.new do
+      @collection.find({'$where' => "function() {for(i=0;i<8000;i++) {this.value};}"}).each {|e| e}
     end
-
-    assert_equal 1, @pool.instance_variable_get(:@threads_to_sockets).size
+    threads.each(&:join)
   end
 end

data/test/functional/timeout_test.rb

@@ -2,18 +2,16 @@ require 'test_helper'
 
 class TestTimeout < Test::Unit::TestCase
   def test_op_timeout
-    connection = standard_connection(:op_timeout => 2)
+    connection = standard_connection(:op_timeout => 1)
     
     admin = connection.db('admin')
 
-    command = BSON::OrderedHash.new
-    command[:sleep] = 1
-    command[:secs] = 1
+    command = {:eval => "sleep(500)"}
     # Should not timeout
     assert admin.command(command)
    
     # Should timeout
-    command[:secs] = 3
+    command = {:eval => "sleep(1500)"}
     assert_raise Mongo::OperationTimeout do
       admin.command(command) 
     end

data/test/functional/uri_test.rb

@@ -20,8 +20,8 @@ class URITest < Test::Unit::TestCase
   def test_multiple_uris
     parser = Mongo::URIParser.new('mongodb://a.example.com:27018,b.example.com')
     assert_equal 2, parser.nodes.length
-    assert_equal 'a.example.com:27018', parser.nodes[0]
-    assert_equal 'b.example.com:27017', parser.nodes[1]
+    assert_equal ['a.example.com', 27018], parser.nodes[0]
+    assert_equal ['b.example.com', 27017], parser.nodes[1]
   end
 
   def test_complex_passwords
@@ -48,8 +48,8 @@ class URITest < Test::Unit::TestCase
   def test_multiple_uris_with_auths
     parser = Mongo::URIParser.new('mongodb://bob:secret@a.example.com:27018,b.example.com/test')
     assert_equal 2, parser.nodes.length
-    assert_equal 'a.example.com:27018', parser.nodes[0]
-    assert_equal 'b.example.com:27017', parser.nodes[1]
+    assert_equal ['a.example.com', 27018], parser.nodes[0]
+    assert_equal ['b.example.com', 27017], parser.nodes[1]
     assert_equal 2, parser.auths.length
     assert_equal "bob", parser.auths[0]["username"]
     assert_equal "secret", parser.auths[0]["password"]
@@ -97,7 +97,12 @@ class URITest < Test::Unit::TestCase
     assert parser.journal
     assert_equal 200, parser.wtimeoutms
   end
-  
+
+  def test_opts_ssl
+    parser = Mongo::URIParser.new('mongodb://localhost:27018?ssl=true;w=2;journal=true;fsync=true;wtimeoutMS=200')
+    assert parser.ssl
+  end
+
   def test_opts_nonsafe_timeout
     parser = Mongo::URIParser.new('mongodb://localhost:27018?connectTimeoutMS=5500&socketTimeoutMS=500')
     assert_equal 5.5, parser.connecttimeoutms

data/test/replica_set/basic_test.rb

@@ -6,11 +6,6 @@ class BasicTest < Test::Unit::TestCase
     ensure_cluster(:rs)
   end
 
-  def self.shutdown
-    @@cluster.stop
-    @@cluster.clobber
-  end
-
   def test_connect
     client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :name => @rs.repl_set_name)
     assert client.connected?
@@ -70,9 +65,9 @@ class BasicTest < Test::Unit::TestCase
     assert_equal @rs.primary_name, [client.host, client.port].join(':')
     assert_equal client.host, client.primary_pool.host
     assert_equal client.port, client.primary_pool.port
-    assert_equal 2, client.secondaries.length
-    assert_equal 2, client.arbiters.length
-    assert_equal 2, client.secondary_pools.length
+    assert_equal 1, client.secondaries.length
+    assert_equal 1, client.arbiters.length
+    assert_equal 1, client.secondary_pools.length
     assert_equal @rs.repl_set_name, client.replica_set_name
     assert client.secondary_pools.include?(client.read_pool(:secondary))
     assert_equal 90, client.refresh_interval

data/test/replica_set/client_test.rb

@@ -11,34 +11,12 @@ class ClientTest < Test::Unit::TestCase
     @client.close if @client
   end
 
-  def self.shutdown
-    @@cluster.stop
-    @@cluster.clobber
-  end
-
-  # To reset after (test) failure
-  #     rake test:cleanup
-
-  def step_down_command
-    # Adding force=true to avoid 'no secondaries within 10 seconds of my optime' errors
-    step_down_command = BSON::OrderedHash.new
-    step_down_command[:replSetStepDown] = 60
-    step_down_command[:force]           = true
-    step_down_command
-  end
-
   # TODO: test connect timeout.
 
   def test_connect_with_deprecated_multi
-    #replica_host_ports = @rs.replicas.collect{|replica| [replica.host, replica.port]}
-    host = @rs.replicas.first.host
     silently do
-      @client = MongoClient.multi([
-        # guaranteed to have one data-holding member
-        [host, @rs.replicas[0].port],
-        [host, @rs.replicas[1].port],
-        [host, @rs.replicas[2].port],
-      ], :name => @rs.repl_set_name)
+      # guaranteed to have one data-holding member
+      @client = MongoClient.multi(@rs.repl_set_seeds_old, :name => @rs.repl_set_name)
     end
     assert !@client.nil?
     assert @client.connected?
@@ -50,6 +28,28 @@ class ClientTest < Test::Unit::TestCase
     end
   end
 
+  def test_reconnect_method_override
+    rescue_connection_failure do
+      @client = MongoReplicaSetClient.new(@rs.repl_set_seeds)
+    end
+
+    MongoReplicaSetClient.any_instance.expects(:connect)
+    MongoClient.any_instance.expects(:connect).never
+    assert_nothing_raised Mongo::ConnectionFailure do
+      @client.reconnect
+    end
+  end
+
+  def test_primary_method_override
+    rescue_connection_failure do
+      @client = MongoReplicaSetClient.new(@rs.repl_set_seeds)
+    end
+
+    MongoReplicaSetClient.any_instance.expects(:read_primary?)
+    MongoClient.any_instance.expects(:read_primary?).never
+    @client.primary?
+  end
+
   def test_connect_with_first_secondary_node_terminated
     @rs.secondaries.first.stop
 
@@ -70,10 +70,10 @@ class ClientTest < Test::Unit::TestCase
 
   def test_connect_with_primary_stepped_down
     @client = MongoReplicaSetClient.new @rs.repl_set_seeds
-    @client[MONGO_TEST_DB]['bar'].save({:a => 1}, {:w => 3})
+    @client[MONGO_TEST_DB]['bar'].save({:a => 1}, {:w => 2})
     assert @client[MONGO_TEST_DB]['bar'].find_one
 
-    primary = Mongo::MongoClient.new(@client.primary_pool.host, @client.primary_pool.port)
+    primary = Mongo::MongoClient.new(*@client.primary)
     assert_raise Mongo::ConnectionFailure do
       primary['admin'].command(step_down_command)
     end
@@ -82,38 +82,43 @@ class ClientTest < Test::Unit::TestCase
     rescue_connection_failure do
       @client[MONGO_TEST_DB]['bar'].find_one
     end
+    @client[MONGO_TEST_DB]['bar'].find_one
   end
 
   def test_connect_with_primary_killed
     @client = MongoReplicaSetClient.new @rs.repl_set_seeds
     assert @client.connected?
-    @client[MONGO_TEST_DB]['bar'].save({:a => 1}, {:w => 3})
+    @client[MONGO_TEST_DB]['bar'].save({:a => 1}, {:w => 2})
     assert @client[MONGO_TEST_DB]['bar'].find_one
 
     @rs.primary.kill(Signal.list['KILL'])
 
+    sleep(3)
+
     rescue_connection_failure do
       @client[MONGO_TEST_DB]['bar'].find_one
     end
+    @client[MONGO_TEST_DB]['bar'].find_one
   end
 
   def test_save_with_primary_stepped_down
     @client = MongoReplicaSetClient.new @rs.repl_set_seeds
     assert @client.connected?
 
-    primary = Mongo::MongoClient.new(@client.primary_pool.host, @client.primary_pool.port)
+    primary = Mongo::MongoClient.new(*@client.primary)
     assert_raise Mongo::ConnectionFailure do
       primary['admin'].command(step_down_command)
     end
 
     rescue_connection_failure do
-      @client[MONGO_TEST_DB]['bar'].save({:a => 1}, {:w => 3})
+      @client[MONGO_TEST_DB]['bar'].save({:a => 1}, {:w => 2})
     end
+    @client[MONGO_TEST_DB]['bar'].find_one
   end
 
   #def test_connect_with_first_node_removed
   #  @client = MongoReplicaSetClient.new @rs.repl_set_seeds
-  #  @client[MONGO_TEST_DB]['bar'].save({:a => 1}, {:w => 3})
+  #  @client[MONGO_TEST_DB]['bar'].save({:a => 1}, {:w => 2})
   #
   #  old_primary = [@client.primary_pool.host, @client.primary_pool.port]
   #  old_primary_conn = Mongo::MongoClient.new(*old_primary)
@@ -220,7 +225,7 @@ class ClientTest < Test::Unit::TestCase
 
   def test_connect_with_old_seed_format
     silently do
-      @client = MongoReplicaSetClient.new(@rs.replicas[0].host_port_a, @rs.replicas[1].host_port_a)
+      @client = MongoReplicaSetClient.new(@rs.repl_set_seeds_old)
     end
     assert @client.connected?
   end
@@ -252,4 +257,15 @@ class ClientTest < Test::Unit::TestCase
     assert_equal 0, @client.write_concern[:w]
   end
 
+  def test_find_and_modify_with_secondary_read_preference
+    @client = MongoReplicaSetClient.new
+    collection = @client[MONGO_TEST_DB].collection('test', :read => :secondary)
+    collection << { :a => 1, :processed => false}
+
+    collection.find_and_modify(
+      :query => {},
+      :update => {"$set" => {:processed => true}}
+    )
+    assert_equal collection.find_one({}, :fields => {:_id => 0}, :read => :primary), {'a' => 1, 'processed' => true}
+  end
 end

data/test/replica_set/complex_connect_test.rb

@@ -6,11 +6,6 @@ class ComplexConnectTest < Test::Unit::TestCase
     ensure_cluster(:rs)
   end
 
-  def self.shutdown
-    @@cluster.stop
-    @@cluster.clobber
-  end
-
   def teardown
     @client.close if defined?(@conn) && @conn
   end
@@ -31,8 +26,12 @@ class ComplexConnectTest < Test::Unit::TestCase
     assert @client['test']['foo'].find_one
 
     config = primary['local']['system.replset'].find_one
+    old_config = config.dup
     config['version'] += 1
-    port_to_delete = @rs.servers.collect(&:port).find{|port| port != primary.port}.to_s # eliminate exception: can't find self in new replset config
+
+    # 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
@@ -42,15 +41,13 @@ class ComplexConnectTest < Test::Unit::TestCase
     end
     @rs.start
 
-    force_stepdown = BSON::OrderedHash.new
-    force_stepdown[:replSetStepDown] = 1
-    force_stepdown[:force] = true
 
     assert_raise ConnectionFailure do
-      primary['admin'].command(force_stepdown)
+      primary['admin'].command(step_down_command)
     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']['foo'].find_one
@@ -58,5 +55,10 @@ class ComplexConnectTest < Test::Unit::TestCase
 
       assert @client['test']['foo'].find_one
     end
+
+    primary = MongoClient.new(host, @rs.primary.port)
+    assert_raise ConnectionFailure do
+      primary['admin'].command({:replSetReconfig => old_config})
+    end
   end
 end

data/test/replica_set/connection_test.rb

@@ -4,41 +4,11 @@ class ConnectionTest < Test::Unit::TestCase
 
   def setup
     ensure_cluster(:rs)
-    @connection = nil
   end
 
-  def teardown
-    @connection.close if @connection
-  end
-
-  def self.shutdown
-    @@cluster.stop
-    @@cluster.clobber
-  end
-
-  # To reset after (test) failure
-  #     rake test:cleanup
-
-  def step_down_command
-    # Adding force=true to avoid 'no secondaries within 10 seconds of my optime' errors
-    step_down_command = BSON::OrderedHash.new
-    step_down_command[:replSetStepDown] = 60
-    step_down_command[:force]           = true
-    step_down_command
-  end
-
-  # TODO: test connect timeout.
-
   def test_connect_with_deprecated_multi
-    #replica_host_ports = @rs.replicas.collect{|replica| [replica.host, replica.port]}
-    host = @rs.replicas.first.host
     silently do
-      @connection = Connection.multi([
-        # guaranteed to have one data-holding member
-        [host, @rs.replicas[0].port],
-        [host, @rs.replicas[1].port],
-        [host, @rs.replicas[2].port],
-      ], :name => @rs.repl_set_name)
+      @connection = Connection.multi(@rs.repl_set_seeds_old, :name => @rs.repl_set_name)
     end
     assert !@connection.nil?
     assert @connection.connected?
@@ -68,127 +38,14 @@ class ConnectionTest < Test::Unit::TestCase
     assert @connection.connected?
   end
 
-  def test_connect_with_primary_stepped_down
-    @connection = ReplSetConnection.new @rs.repl_set_seeds
-    @connection[MONGO_TEST_DB]['bar'].save({:a => 1}, {:safe => {:w => 3}})
-    assert @connection[MONGO_TEST_DB]['bar'].find_one
-
-    primary = Mongo::Connection.new(@connection.primary_pool.host, @connection.primary_pool.port)
-    assert_raise Mongo::ConnectionFailure do
-      primary['admin'].command(step_down_command)
-    end
-    assert @connection.connected?
-
-    rescue_connection_failure do
-      @connection[MONGO_TEST_DB]['bar'].find_one
-    end
-  end
-
-  def test_connect_with_primary_killed
-    @connection = ReplSetConnection.new @rs.repl_set_seeds
-    assert @connection.connected?
-    @connection[MONGO_TEST_DB]['bar'].save({:a => 1}, {:safe => {:w => 3}})
-    assert @connection[MONGO_TEST_DB]['bar'].find_one
-
-    @rs.primary.kill(Signal.list['KILL'])
-
-    rescue_connection_failure do
-      @connection[MONGO_TEST_DB]['bar'].find_one
-    end
-  end
-
-  def test_save_with_primary_stepped_down
-    @connection = ReplSetConnection.new @rs.repl_set_seeds
-    assert @connection.connected?
-
-    primary = Mongo::Connection.new(@connection.primary_pool.host, @connection.primary_pool.port)
-    assert_raise Mongo::ConnectionFailure do
-      primary['admin'].command(step_down_command)
-    end
-
-    rescue_connection_failure do
-      @connection[MONGO_TEST_DB]['bar'].save({:a => 1}, {:safe => {:w => 3}})
-    end
-  end
-
-  #def test_connect_with_first_node_removed
-  #  @connection = ReplSetConnection.new @rs.repl_set_seeds
-  #  @connection[MONGO_TEST_DB]['bar'].save({:a => 1}, {:safe => {:w => 3}})
-  #
-  #  old_primary = [@connection.primary_pool.host, @connection.primary_pool.port]
-  #  old_primary_conn = Mongo::Connection.new(*old_primary)
-  #  assert_raise Mongo::ConnectionFailure do
-  #    old_primary_conn['admin'].command(step_down_command)
-  #  end
-  #
-  #  # Wait for new primary
-  #  rescue_connection_failure do
-  #    sleep 1 until @rs.get_node_with_state(1)
-  #  end
-  #
-  #  new_primary = @rs.get_all_host_pairs_with_state(1).first
-  #  new_primary_conn = Mongo::Connection.new(*new_primary)
-  #
-  #  config = nil
-  #
-  #  # Remove old primary from replset
-  #  rescue_connection_failure do
-  #    config = @connection['local']['system.replset'].find_one
-  #  end
-  #
-  #  old_member = config['members'].select {|m| m['host'] == old_primary.join(':')}.first
-  #  config['members'].reject! {|m| m['host'] == old_primary.join(':')}
-  #  config['version'] += 1
-  #
-  #  begin
-  #    new_primary_conn['admin'].command({'replSetReconfig' => config})
-  #  rescue Mongo::ConnectionFailure
-  #  end
-  #
-  #  # Wait for the dust to settle
-  #  rescue_connection_failure do
-  #    assert @connection[MONGO_TEST_DB]['bar'].find_one
-  #  end
-  #
-  #  # Make sure a new connection skips the old primary
-  #  @new_conn = ReplSetConnection.new @rs.repl_set_seeds
-  #  @new_conn.connect
-  #  new_nodes = [@new_conn.primary] + @new_conn.secondaries
-  #  assert !(new_nodes).include?(old_primary)
-  #
-  #  # Add the old primary back
-  #  config['members'] << old_member
-  #  config['version'] += 1
-  #
-  #  begin
-  #    new_primary_conn['admin'].command({'replSetReconfig' => config})
-  #  rescue Mongo::ConnectionFailure
-  #  end
-  #end
-
-  #def test_connect_with_hung_first_node
-  #  hung_node = nil
-  #  begin
-  #    hung_node = IO.popen('nc -lk 127.0.0.1 29999 >/dev/null 2>&1')
-  #
-  #    @connection = ReplSetConnection.new(['localhost:29999'] + @rs.repl_set_seeds,
-  #                                  :connect_timeout => 2)
-  #    @connection.connect
-  #    assert ['localhost:29999'] != @connection.primary
-  #    assert !@connection.secondaries.include?('localhost:29999')
-  #  ensure
-  #    Process.kill("KILL", hung_node.pid) if hung_node
-  #  end
-  #end
-
   def test_connect_with_connection_string
-    @connection = Connection.from_uri("mongodb://#{@rs.replicas[0].host_port},#{@rs.replicas[1].host_port}?replicaset=#{@rs.repl_set_name}")
+    @connection = Connection.from_uri("mongodb://#{@rs.repl_set_seeds_uri}?replicaset=#{@rs.repl_set_name}")
     assert !@connection.nil?
     assert @connection.connected?
   end
 
   def test_connect_with_connection_string_in_env_var
-    ENV['MONGODB_URI'] = "mongodb://#{@rs.replicas[0].host_port},#{@rs.replicas[1].host_port}?replicaset=#{@rs.repl_set_name}"
+    ENV['MONGODB_URI'] = "mongodb://#{@rs.repl_set_seeds_uri}?replicaset=#{@rs.repl_set_name}"
     @connection = ReplSetConnection.new
     assert !@connection.nil?
     assert_equal 2, @connection.seeds.length
@@ -201,7 +58,7 @@ class ConnectionTest < Test::Unit::TestCase
   end
 
   def test_connect_with_connection_string_in_implicit_mongodb_uri
-    ENV['MONGODB_URI'] = "mongodb://#{@rs.replicas[0].host_port},#{@rs.replicas[1].host_port}?replicaset=#{@rs.repl_set_name}"
+    ENV['MONGODB_URI'] = "mongodb://#{@rs.repl_set_seeds_uri}?replicaset=#{@rs.repl_set_name}"
     @connection = Connection.from_uri
     assert !@connection.nil?
     assert_equal 2, @connection.seeds.length
@@ -220,13 +77,13 @@ class ConnectionTest < Test::Unit::TestCase
 
   def test_connect_with_old_seed_format
     silently do
-      @connection = ReplSetConnection.new(@rs.replicas[0].host_port_a, @rs.replicas[1].host_port_a)
+      @connection = ReplSetConnection.new(@rs.repl_set_seeds_old)
     end
     assert @connection.connected?
   end
 
   def test_connect_with_full_connection_string
-    @connection = Connection.from_uri("mongodb://#{@rs.replicas[0].host_port},#{@rs.replicas[1].host_port}?replicaset=#{@rs.repl_set_name};safe=true;w=2;fsync=true;slaveok=true")
+    @connection = Connection.from_uri("mongodb://#{@rs.repl_set_seeds_uri}?replicaset=#{@rs.repl_set_name};safe=true;w=2;fsync=true;slaveok=true")
     assert !@connection.nil?
     assert @connection.connected?
     assert_equal 2, @connection.write_concern[:w]
@@ -235,7 +92,7 @@ class ConnectionTest < Test::Unit::TestCase
   end
 
   def test_connect_with_full_connection_string_in_env_var
-    ENV['MONGODB_URI'] = "mongodb://#{@rs.replicas[0].host_port},#{@rs.replicas[1].host_port}?replicaset=#{@rs.repl_set_name};safe=true;w=2;fsync=true;slaveok=true"
+    ENV['MONGODB_URI'] = "mongodb://#{@rs.repl_set_seeds_uri}?replicaset=#{@rs.repl_set_name};safe=true;w=2;fsync=true;slaveok=true"
     @connection = ReplSetConnection.new
     assert !@connection.nil?
     assert @connection.connected?
@@ -245,7 +102,7 @@ class ConnectionTest < Test::Unit::TestCase
   end
 
   def test_connect_options_override_env_var
-    ENV['MONGODB_URI'] = "mongodb://#{@rs.replicas[0].host_port},#{@rs.replicas[1].host_port}?replicaset=#{@rs.repl_set_name};safe=true;w=2;fsync=true;slaveok=true"
+    ENV['MONGODB_URI'] = "mongodb://#{@rs.repl_set_seeds_uri}?replicaset=#{@rs.repl_set_name};safe=true;w=2;fsync=true;slaveok=true"
     @connection = ReplSetConnection.new({:safe => {:w => 1}})
     assert !@connection.nil?
     assert @connection.connected?