mongo 1.8.3.rc0 → 1.8.3.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dec398480b1b7ced8276797d36e9257fecbc1707
+  data.tar.gz: 735c75e4d0877dc57cfede2016201a121737af4b
+SHA512:
+  metadata.gz: fe1e61dcef314f5ea551c7e1f96ccbeae3aa7969d714c2774dd17a694912267b14f86a3f9c73ccea0d0a3f2b4e3ad72c319c46ab2c9a28001f7a005f7d1de87f
+  data.tar.gz: 37d440db17fd4820dabfecf12b4da396ec8912593ef15256fc86e8839a1e3e1952f12bb484165069e5a63dffd4cdcd3eff031393881867b3ce3fea73cb99cea3

data/README.md

@@ -2,7 +2,7 @@
 
 [travis-img]: https://secure.travis-ci.org/mongodb/mongo-ruby-driver.png
 [travis-url]: http://travis-ci.org/mongodb/mongo-ruby-driver
-[codeclimate-img]: https://codeclimate.com/badge.png
+[codeclimate-img]: https://codeclimate.com/github/mongodb/mongo-ruby-driver.png
 [codeclimate-url]: https://codeclimate.com/github/mongodb/mongo-ruby-driver
 [jenkins-img]: https://jenkins.10gen.com/job/mongo-ruby-driver/badge/icon
 [jenkins-url]: https://jenkins.10gen.com/job/mongo-ruby-driver/

data/VERSION

@@ -1 +1 @@
-1.8.3.rc0
+1.8.3.rc1

data/lib/mongo/cursor.rb

@@ -324,16 +324,11 @@ module Mongo
         message.put_int(1)
         message.put_long(@cursor_id)
         log(:debug, "Cursor#close #{@cursor_id}")
-        begin
-          socket = @pool.checkout
-          @connection.send_message(
-            Mongo::Constants::OP_KILL_CURSORS,
-            message,
-            :socket => socket
-          )
-        ensure
-          socket.checkin
-        end
+        @connection.send_message(
+          Mongo::Constants::OP_KILL_CURSORS,
+          message,
+          :pool => @pool
+        )
       end
       @cursor_id = 0
       @closed    = true
@@ -516,7 +511,7 @@ module Mongo
       message.put_long(@cursor_id)
       log(:debug, "cursor.refresh() for cursor #{@cursor_id}") if @logger
 
-      socket = checkout_socket_from_connection
+      socket = @pool.checkout
 
       begin
         results, @n_received, @cursor_id = @connection.receive_message(
@@ -532,7 +527,9 @@ module Mongo
 
     def checkout_socket_from_connection
       begin
-        if @command && !Mongo::Support::secondary_ok?(@selector)
+        if @pool
+          socket = @pool.checkout
+        elsif @command && !Mongo::Support::secondary_ok?(@selector)
           socket = @connection.checkout_reader(:primary)
         else
           socket = @connection.checkout_reader(@read, @tag_sets, @acceptable_latency)
@@ -542,6 +539,7 @@ module Mongo
         raise ex
       end
       @pool = socket.pool
+      #puts "checkout_socket_from_connection caller:#{caller[0][/:in `([^']+)'/,1]} self:#{self.object_id} @pool.port:#{@pool.port}"
       socket
     end
 

data/lib/mongo/networking.rb

@@ -26,10 +26,12 @@ module Mongo
       add_message_headers(message, operation)
       packed_message = message.to_s
 
-      sock = opts.fetch(:socket, nil)
+      sock = nil
+      pool = opts.fetch(:pool, nil)
       begin
-        if operation == Mongo::Constants::OP_KILL_CURSORS && @read != :primary
-          sock ||= checkout_reader
+        if pool
+          #puts "send_message pool.port:#{pool.port}"
+          sock = pool.checkout
         else
           sock ||= checkout_writer
         end

data/test/bson/bson_test.rb

@@ -58,6 +58,68 @@ class BSONTest < Test::Unit::TestCase
     assert_equal doc, @encoder.deserialize(bson)
   end
 
+  def test_interface
+    doc = { 'a' => 1 }
+    bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
+  end
+
+  def test_read_bson_document
+    bson_file_data_h_star = ["21000000075f6964005115883c3d75c94d3aa18b63016100000000000000f03f00"]
+    strio = StringIO.new(bson_file_data_h_star.pack('H*'))
+    bson = BSON.read_bson_document(strio)
+    doc = {"_id"=>BSON::ObjectId('5115883c3d75c94d3aa18b63'), "a"=>1.0}
+    assert_equal doc, bson
+  end
+
+  def test_bson_ruby_interface
+    doc = { 'a' => 1 }
+    buf = BSON_RUBY.serialize(doc)
+    bson = BSON::BSON_RUBY.new
+    bson.instance_variable_set(:@buf, buf)
+    assert_equal [12, 0, 0, 0, 16, 97, 0, 1, 0, 0, 0, 0], bson.to_a
+    assert_equal "\f\x00\x00\x00\x10a\x00\x01\x00\x00\x00\x00", bson.to_s
+    assert_equal [12, 0, 0, 0, 16, 97, 0, 1, 0, 0, 0, 0], bson.unpack
+  end
+
+  def test_bson_ruby_hex_dump
+    doc = { 'a' => 1 }
+    buf = BSON_RUBY.serialize(doc)
+    bson = BSON_RUBY.new
+    bson.instance_variable_set(:@buf, buf)
+    doc_hex_dump = "   0:  0C 00 00 00 10 61 00 01\n   8:  00 00 00 00"
+    assert_equal doc_hex_dump, bson.hex_dump
+  end
+
+  def test_bson_ruby_dbref_not_used
+    buf = BSON::ByteBuffer.new
+    val = ns = 'namespace'
+
+    # Make a hole for the length
+    len_pos = buf.position
+    buf.put_int(0)
+
+    # Save the string
+    start_pos = buf.position
+    BSON::BSON_RUBY.serialize_cstr(buf, val)
+    end_pos = buf.position
+
+    # Put the string size in front
+    buf.put_int(end_pos - start_pos, len_pos)
+
+    # Go back to where we were
+    buf.position = end_pos
+
+    oid = ObjectId.new
+    buf.put_array(oid.to_a)
+    buf.rewind
+
+    bson = BSON::BSON_RUBY.new
+    bson.instance_variable_set(:@buf, buf)
+
+    assert_equal DBRef.new(ns, oid).to_s, bson.deserialize_dbref_data(buf).to_s
+  end
+
   def test_require_hash
     assert_raise_error InvalidDocument, "takes a Hash" do
       BSON.serialize('foo')
@@ -191,8 +253,14 @@ class BSONTest < Test::Unit::TestCase
   end
 
   def test_code
-    doc = {'$where' => Code.new('this.a.b < this.b')}
+    code = Code.new('this.a.b < this.b')
+    assert_equal 17, code.length
+    assert_match /<BSON::Code:.*@data="this.a.b < this.b".*>/, code.inspect
+    doc = {'$where' => code}
     assert_doc_pass(doc)
+    code = 'this.c.d < this.e'.to_bson_code # core_ext.rb
+    assert_equal BSON::Code, code.class
+    assert_equal code, code.to_bson_code
   end
 
   def test_code_with_symbol
@@ -343,8 +411,11 @@ class BSONTest < Test::Unit::TestCase
 
   def test_dbref
     oid = ObjectId.new
+    ns = 'namespace'
     doc = {}
-    doc['dbref'] = DBRef.new('namespace', oid)
+    dbref = DBRef.new(ns, oid)
+    assert_equal({"$id"=>oid, "$ns"=>ns}, dbref.to_hash)
+    doc['dbref'] = dbref
     bson = @encoder.serialize(doc)
     doc2 = @encoder.deserialize(bson)
 

data/test/bson/byte_buffer_test.rb

@@ -15,6 +15,16 @@ class ByteBufferTest < Test::Unit::TestCase
     assert_equal 0, @buf.length
   end
 
+  def test_initialize_with_string_and_clear
+    @buf = ByteBuffer.new("a")
+    assert_equal 1, @buf.size
+    assert_equal 1, @buf.position
+    @buf.clear
+    assert_equal 0, @buf.position
+    assert_equal "", @buf.to_s
+    assert_equal 0, @buf.size
+  end
+
   def test_nil_get_returns_one_byte
     @buf.put_array([1, 2, 3, 4])
     @buf.rewind
@@ -202,5 +212,4 @@ class ByteBufferTest < Test::Unit::TestCase
     assert_not_equal @buf, 123
     assert_not_equal @buf, nil
   end
-
 end

data/test/bson/timestamp_test.rb

@@ -2,6 +2,11 @@ require 'test_helper'
 
 class TimestampTest < Test::Unit::TestCase
 
+  def test_timestamp_to_s
+    t1 = Timestamp.new(5000, 200)
+    assert_equal "seconds: 5000, increment: 200", t1.to_s
+  end
+
   def test_timestamp_equality
     t1 = Timestamp.new(5000, 200)
     t2 = Timestamp.new(5000, 200)

data/test/functional/collection_test.rb

@@ -840,7 +840,7 @@ class TestCollection < Test::Unit::TestCase
         r = Code.new("function(k,vals) { return 1; }")
         oh = BSON::OrderedHash.new
         oh[:replace] = 'foo'
-        oh[:db] = 'somedb'
+        oh[:db] = MONGO_TEST_DB
         res = @@test.map_reduce(m, r, :out => (oh))
         assert res["result"]
         assert res["counts"]

data/test/functional/timeout_test.rb

@@ -3,24 +3,24 @@ require 'test_helper'
 class TestTimeout < Test::Unit::TestCase
   def test_op_timeout
     connection = standard_connection(:op_timeout => 1)
-    
+
     admin = connection.db('admin')
 
     command = {:eval => "sleep(500)"}
     # Should not timeout
     assert admin.command(command)
-   
+
     # Should timeout
     command = {:eval => "sleep(1500)"}
     assert_raise Mongo::OperationTimeout do
-      admin.command(command) 
+      admin.command(command)
     end
   end
 
   def test_external_timeout_does_not_leave_socket_in_bad_state
     client = Mongo::MongoClient.new
-    db = client['testdb']
-    coll = db['testcoll']
+    db = client[MONGO_TEST_DB]
+    coll = db['timeout-tests']
 
     # prepare the database
     coll.drop
@@ -43,14 +43,13 @@ class TestTimeout < Test::Unit::TestCase
 =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 
+    # Should timeout
     assert_raise Mongo::OperationTimeout do
       coll.find_one({"$where" => "sleep(5 * 1000); return true;"})
     end

data/test/replica_set/basic_test.rb

@@ -65,9 +65,8 @@ 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 1, client.secondaries.length
-    assert_equal 1, client.arbiters.length
-    assert_equal 1, client.secondary_pools.length
+    assert_equal 2, client.secondaries.length
+    assert_equal 2, 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

@@ -48,7 +48,7 @@ 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 => 2})
+    @client[MONGO_TEST_DB]['bar'].save({:a => 1}, {:w => 3})
     assert @client[MONGO_TEST_DB]['bar'].find_one
 
     primary = Mongo::MongoClient.new(*@client.primary)
@@ -66,7 +66,7 @@ class ClientTest < Test::Unit::TestCase
   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 => 2})
+    @client[MONGO_TEST_DB]['bar'].save({:a => 1}, {:w => 3})
     assert @client[MONGO_TEST_DB]['bar'].find_one
 
     @rs.primary.kill(Signal.list['KILL'])
@@ -96,7 +96,7 @@ class ClientTest < Test::Unit::TestCase
 
   #def test_connect_with_first_node_removed
   #  @client = MongoReplicaSetClient.new @rs.repl_set_seeds
-  #  @client[MONGO_TEST_DB]['bar'].save({:a => 1}, {:w => 2})
+  #  @client[MONGO_TEST_DB]['bar'].save({:a => 1}, {:w => 3})
   #
   #  old_primary = [@client.primary_pool.host, @client.primary_pool.port]
   #  old_primary_conn = Mongo::MongoClient.new(*old_primary)

data/test/replica_set/connection_test.rb

@@ -48,11 +48,13 @@ class ConnectionTest < Test::Unit::TestCase
     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
+    assert_equal 3, @connection.seeds.length
     assert_equal @rs.replicas[0].host, @connection.seeds[0][0]
     assert_equal @rs.replicas[1].host, @connection.seeds[1][0]
+    assert_equal @rs.replicas[2].host, @connection.seeds[2][0]
     assert_equal @rs.replicas[0].port, @connection.seeds[0][1]
     assert_equal @rs.replicas[1].port, @connection.seeds[1][1]
+    assert_equal @rs.replicas[2].port, @connection.seeds[2][1]
     assert_equal @rs.repl_set_name, @connection.replica_set_name
     assert @connection.connected?
   end
@@ -61,11 +63,13 @@ class ConnectionTest < Test::Unit::TestCase
     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
+    assert_equal 3, @connection.seeds.length
     assert_equal @rs.replicas[0].host, @connection.seeds[0][0]
     assert_equal @rs.replicas[1].host, @connection.seeds[1][0]
+    assert_equal @rs.replicas[2].host, @connection.seeds[2][0]
     assert_equal @rs.replicas[0].port, @connection.seeds[0][1]
     assert_equal @rs.replicas[1].port, @connection.seeds[1][1]
+    assert_equal @rs.replicas[2].port, @connection.seeds[2][1]
     assert_equal @rs.repl_set_name, @connection.replica_set_name
     assert @connection.connected?
   end

data/test/replica_set/count_test.rb

@@ -17,7 +17,7 @@ class ReplicaSetCountTest < Test::Unit::TestCase
   end
 
   def test_correct_count_after_insertion_reconnect
-    @coll.insert({:a => 20}, :w => 2, :wtimeout => 10000)
+    @coll.insert({:a => 20}, :w => 3, :wtimeout => 10000)
     assert_equal 1, @coll.count
 
     # Kill the current master node
@@ -32,7 +32,7 @@ class ReplicaSetCountTest < Test::Unit::TestCase
   end
 
   def test_count_command_sent_to_primary
-    @coll.insert({:a => 20}, :w => 2, :wtimeout => 10000)
+    @coll.insert({:a => 20}, :w => 3, :wtimeout => 10000)
     count_before = @primary['admin'].command({:serverStatus => 1})['opcounters']['command']
     assert_equal 1, @coll.count
     count_after = @primary['admin'].command({:serverStatus => 1})['opcounters']['command']
@@ -40,7 +40,7 @@ class ReplicaSetCountTest < Test::Unit::TestCase
   end
 
   def test_count_with_read
-    @coll.insert({:a => 20}, :w => 2, :wtimeout => 10000)
+    @coll.insert({:a => 20}, :w => 3, :wtimeout => 10000)
     count_before = @primary['admin'].command({:serverStatus => 1})['opcounters']['command']
     assert_equal 1, @coll.count(:read => :secondary)
     assert_equal 1, @coll.find({}, :read => :secondary).count()

data/test/replica_set/cursor_test.rb

@@ -6,24 +6,44 @@ class ReplicaSetCursorTest < Test::Unit::TestCase
     ensure_cluster(:rs)
   end
 
+  def test_get_more_primary
+    setup_client(:primary)
+    cursor_get_more_test(:primary)
+  end
+
+  def test_get_more_secondary
+    setup_client(:secondary)
+    cursor_get_more_test(:secondary)
+  end
+
+  def test_close_primary
+    setup_client(:primary)
+    kill_cursor_test(:primary)
+  end
+
+  def test_close_secondary
+    setup_client(:secondary)
+    kill_cursor_test(:secondary)
+  end
+
   def test_cursors_get_closed
     setup_client
-    assert_cursor_count
+    assert_cursors_on_members
   end
 
   def test_cursors_get_closed_secondary
     setup_client(:secondary)
-    assert_cursor_count(:secondary)
+    assert_cursors_on_members(:secondary)
   end
 
-  def test_cusors_get_closed_secondary_query
-    setup_client(:primary, :secondary)
-    assert_cursor_count(:secondary)
+  def test_cursors_get_closed_secondary_query
+    setup_client(:primary)
+    assert_cursors_on_members(:secondary)
   end
 
   private
 
-  def setup_client(read=:primary, route_read=nil)
+  def setup_client(read=:primary)
     route_read ||= read
     # Setup ReplicaSet Connection
     @client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :read => read)
@@ -31,41 +51,122 @@ class ReplicaSetCursorTest < Test::Unit::TestCase
     @db = @client.db(MONGO_TEST_DB)
     @db.drop_collection("cursor_tests")
     @coll = @db.collection("cursor_tests")
-
-    @coll.insert({:a => 1}, :w => 2)
-    @coll.insert({:b => 2}, :w => 2)
-    @coll.insert({:c => 3}, :w => 2)
-
-    # Pin reader
-    @coll.find_one
+    insert_docs
 
     # Setup Direct Connections
     @primary = Mongo::MongoClient.new(*@client.manager.primary)
-    @read = Mongo::MongoClient.new(*@client.manager.read_pool(route_read).host_port)
   end
 
-  def cursor_count(client)
-    client['cursor_tests'].command({:cursorInfo => 1})['totalOpen']
+  def insert_docs
+    @n_docs = 102 # batch size is 101
+    @n_docs.times do |i|
+      @coll.insert({ "x" => i }, :w => 3)
+    end
   end
 
-  def query_count(client)
-    client['admin'].command({:serverStatus => 1})['opcounters']['query']
+  def set_read_client_and_tag(read)
+    read_opts = {:read => read}
+    @tag = (0...3).map{|i|i.to_s}.detect do |tag|
+      begin
+        read_opts[:tag_sets] = [{:node => tag}] unless read == :primary
+        cursor = @coll.find({}, read_opts)
+        cursor.next
+        pool = cursor.instance_variable_get(:@pool)
+        cursor.close
+        @read = Mongo::MongoClient.new(pool.host, pool.port, :slave_ok => true)
+        tag
+      rescue Mongo::ConnectionFailure
+        false
+      end
+    end
   end
 
-  def assert_cursor_count(read=:primary)
-    before_primary_cursor = cursor_count(@primary)
-    before_read_cursor = cursor_count(@read)
-    before_read_query = query_count(@read)
-
-    @coll.find({}, :read => read).limit(2).to_a
+  def route_query(read)
+    read_opts = {:read => read}
+    read_opts[:tag_sets] = [{:node => @tag}] unless read == :primary
+    object_id = BSON::ObjectId.new
+    read_opts[:comment] = object_id
+
+    # set profiling level to 2 on client and member to which the query will be routed
+    @client.db(MONGO_TEST_DB).profiling_level = :all
+    @client.secondaries.each do |node|
+      node = Mongo::MongoClient.new(node[0], node[1], :slave_ok => true)
+      node.db(MONGO_TEST_DB).profiling_level = :all
+    end
+
+    @cursor = @coll.find({}, read_opts)
+    @cursor.next
+
+    # on client and other members set profiling level to 0
+    @client.db(MONGO_TEST_DB).profiling_level = :off
+    @client.secondaries.each do |node|
+      node = Mongo::MongoClient.new(node[0], node[1], :slave_ok => true)
+      node.db(MONGO_TEST_DB).profiling_level = :off
+    end
+    # do a query on system.profile of the reader to see if it was used for the query
+    profiled_queries = @read.db(MONGO_TEST_DB).collection('system.profile').find({
+      'ns' => "#{MONGO_TEST_DB}.cursor_tests", "query.$comment" => object_id })
+
+    assert_equal 1, profiled_queries.count
+  end
 
-    after_primary_cursor = cursor_count(@primary)
-    after_read_cursor = cursor_count(@read)
-    after_read_query = query_count(@read)
+  # batch from send_initial_query is 101 documents
+  # check that you get n_docs back from the query, with the same port
+  def cursor_get_more_test(read=:primary)
+    set_read_client_and_tag(read)
+    10.times do
+      # assert that the query went to the correct member
+      route_query(read)
+      docs_count = 1
+      port = @cursor.instance_variable_get(:@pool).port
+      assert @cursor.alive?
+      while @cursor.has_next?
+        docs_count += 1
+        @cursor.next
+        assert_equal port, @cursor.instance_variable_get(:@pool).port
+      end
+      assert !@cursor.alive?
+      assert_equal @n_docs, docs_count
+      @cursor.close #cursor is already closed
+    end
+  end
 
-    assert_equal before_primary_cursor, after_primary_cursor
-    assert_equal before_read_cursor, after_read_cursor
-    assert_equal 1, after_read_query - before_read_query
+  # batch from get_more can be huge, so close after send_initial_query
+  def kill_cursor_test(read=:primary)
+    set_read_client_and_tag(read)
+    10.times do
+      # assert that the query went to the correct member
+      route_query(read)
+      cursor_id = @cursor.cursor_id
+      cursor_clone = @cursor.clone
+      assert_equal cursor_id, cursor_clone.cursor_id
+      assert @cursor.instance_variable_get(:@pool)
+      # .next was called once already and leave one for get more
+      (@n_docs-2).times { @cursor.next }
+      @cursor.close
+      # an exception confirms the cursor has indeed been closed
+      assert_raise Mongo::OperationFailure do
+        cursor_clone.next
+      end
+    end
   end
 
-end
+  def assert_cursors_on_members(read=:primary)
+    set_read_client_and_tag(read)
+    # assert that the query went to the correct member
+    route_query(read)
+    cursor_id = @cursor.cursor_id
+    cursor_clone = @cursor.clone
+    assert_equal cursor_id, cursor_clone.cursor_id
+    assert @cursor.instance_variable_get(:@pool)
+    port = @cursor.instance_variable_get(:@pool).port
+    while @cursor.has_next?
+      @cursor.next
+      assert_equal port, @cursor.instance_variable_get(:@pool).port
+    end
+    # an exception confirms the cursor has indeed been closed after query
+    assert_raise Mongo::OperationFailure do
+      cursor_clone.next
+    end
+  end
+end

data/test/replica_set/insert_test.rb

@@ -15,7 +15,7 @@ class ReplicaSetInsertTest < Test::Unit::TestCase
   end
 
   def test_insert
-    @coll.save({:a => 20}, :w => 2)
+    @coll.save({:a => 20}, :w => 3)
 
     @rs.primary.stop
 
@@ -40,7 +40,7 @@ class ReplicaSetInsertTest < Test::Unit::TestCase
       end
     end
 
-    @coll.save({:a => 80}, :w => 2)
+    @coll.save({:a => 80}, :w => 3)
     @coll.find.each {|r| results << r}
     [20, 30, 40, 50, 60, 70, 80].each do |a|
       assert results.any? {|r| r['a'] == a}, "Could not find record for a => #{a} on second find"

data/test/replica_set/query_test.rb

@@ -15,9 +15,9 @@ class ReplicaSetQueryTest < Test::Unit::TestCase
   end
 
   def test_query
-    @coll.save({:a => 20}, :w => 2)
-    @coll.save({:a => 30}, :w => 2)
-    @coll.save({:a => 40}, :w => 2)
+    @coll.save({:a => 20}, :w => 3)
+    @coll.save({:a => 30}, :w => 3)
+    @coll.save({:a => 40}, :w => 3)
     results = []
     @coll.find.each {|r| results << r}
     [20, 30, 40].each do |a|
@@ -43,7 +43,7 @@ class ReplicaSetQueryTest < Test::Unit::TestCase
   # primary, where it does not exist.
   # def test_secondary_getmore
   #   200.times do |i|
-  #     @coll.save({:a => i}, :w => 2)
+  #     @coll.save({:a => i}, :w => 3)
   #   end
   #   as = []
   #   # Set an explicit batch size, in case the default ever changes.

data/test/replica_set/refresh_test.rb

@@ -8,40 +8,51 @@ class ReplicaSetRefreshTest < Test::Unit::TestCase
   end
 
   def test_connect_and_manual_refresh_with_secondaries_down
-    @rs.secondaries.each{|s| s.stop}
+    num_secondaries = @rs.secondaries.size
     client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :refresh_mode => false)
 
-    assert_equal Set.new, client.secondaries
+    assert_equal num_secondaries, client.secondaries.size
     assert client.connected?
     assert_equal client.read_pool, client.primary_pool
 
-    # Refresh with no change to set
+    @rs.secondaries.each {|s| s.stop}
+
     client.refresh
-    assert_equal Set.new, client.secondaries
+    assert client.secondaries.empty?
     assert client.connected?
     assert_equal client.read_pool, client.primary_pool
 
     # Test no changes after restart until manual refresh
     @rs.restart
-    assert_equal Set.new, client.secondaries
+    assert client.secondaries.empty?
     assert client.connected?
     assert_equal client.read_pool, client.primary_pool
 
     # Refresh and ensure state
     client.refresh
     assert_equal client.read_pool, client.primary_pool
-    assert_equal 1, client.secondaries.length
+    assert_equal num_secondaries, client.secondaries.size
   end
 
   def test_automated_refresh_with_secondaries_down
-    @rs.secondaries.each{|s| s.stop}
+    num_secondaries = @rs.secondaries.size
     client = MongoReplicaSetClient.new(@rs.repl_set_seeds,
       :refresh_interval => 1, :refresh_mode => :sync, :read => :secondary_preferred)
 
     # Ensure secondaries not available and read from primary
-    assert_equal Set.new, client.secondaries
+    assert_equal num_secondaries, client.secondaries.size
     assert client.connected?
-    assert client.manager.pools.member?(client.manager.read_pool)
+    assert client.secondary_pools.include?(client.read_pool)
+
+    @rs.secondaries.each{|s| s.stop}
+    sleep(2)
+
+    client['foo']['bar'].find_one
+
+    assert client.secondaries.empty?
+    assert client.connected?
+    assert_equal client.read_pool, client.primary_pool
+
     old_refresh_version = client.refresh_version
 
     # Restart nodes and ensure refresh interval has passed
@@ -56,7 +67,7 @@ class ReplicaSetRefreshTest < Test::Unit::TestCase
 
     assert client.refresh_version > old_refresh_version,
       "Refresh version hasn't changed."
-    assert client.secondaries.length == 1,
+    assert_equal num_secondaries, client.secondaries.size
       "No secondaries have been added."
     assert client.manager.read_pool != client.manager.primary,
       "Read pool and primary pool are identical."
@@ -66,11 +77,11 @@ class ReplicaSetRefreshTest < Test::Unit::TestCase
     client = MongoReplicaSetClient.new(@rs.repl_set_seeds,
       :refresh_interval => 1, :refresh_mode => :sync)
 
-    num_secondaries = client.secondary_pools.length
+    num_secondaries = client.secondary_pools.size
     old_refresh_version = client.refresh_version
 
-    @rs.kill_secondary
-    sleep(1)
+    @rs.stop_secondary
+    sleep(2)
 
     assert client.refresh_version == old_refresh_version,
       "Refresh version has changed."
@@ -79,16 +90,16 @@ class ReplicaSetRefreshTest < Test::Unit::TestCase
 
     assert client.refresh_version > old_refresh_version,
       "Refresh version hasn't changed."
-    assert_equal num_secondaries - 1, client.secondaries.length
-    assert_equal num_secondaries - 1, client.secondary_pools.length
+    assert_equal num_secondaries - 1, client.secondaries.size
+    assert_equal num_secondaries - 1, client.secondary_pools.size
 
-    @rs.start
+    @rs.restart
     sleep(2)
 
     client['foo']['bar'].find_one
 
-    assert_equal num_secondaries, client.secondaries.length
-    assert_equal num_secondaries, client.secondary_pools.length
+    assert_equal num_secondaries, client.secondaries.size
+    assert_equal num_secondaries, client.secondary_pools.size
   end
 =begin
   def test_automated_refresh_with_removed_node

data/test/replica_set/replication_ack_test.rb

@@ -23,13 +23,13 @@ class ReplicaSetAckTest < Test::Unit::TestCase
 
   def test_safe_mode_with_w_failure
     assert_raise_error OperationFailure, "timeout" do
-      @col.insert({:foo => 1}, :w => 3, :wtimeout => 1, :fsync => true)
+      @col.insert({:foo => 1}, :w => 4, :wtimeout => 1, :fsync => true)
     end
     assert_raise_error OperationFailure, "timeout" do
-      @col.update({:foo => 1}, {:foo => 2}, :w => 3, :wtimeout => 1, :fsync => true)
+      @col.update({:foo => 1}, {:foo => 2}, :w => 4, :wtimeout => 1, :fsync => true)
     end
     assert_raise_error OperationFailure, "timeout" do
-      @col.remove({:foo => 2}, :w => 3, :wtimeout => 1, :fsync => true)
+      @col.remove({:foo => 2}, :w => 4, :wtimeout => 1, :fsync => true)
     end
     assert_raise_error OperationFailure do
       @col.insert({:foo => 3}, :w => "test-tag")
@@ -37,35 +37,35 @@ class ReplicaSetAckTest < Test::Unit::TestCase
   end
 
   def test_safe_mode_replication_ack
-    @col.insert({:baz => "bar"}, :w => 2, :wtimeout => 5000)
+    @col.insert({:baz => "bar"}, :w => 3, :wtimeout => 5000)
 
-    assert @col.insert({:foo => "0" * 5000}, :w => 2, :wtimeout => 5000)
+    assert @col.insert({:foo => "0" * 5000}, :w => 3, :wtimeout => 5000)
     assert_equal 2, @slave1[MONGO_TEST_DB]["test-sets"].count
 
-    assert @col.update({:baz => "bar"}, {:baz => "foo"}, :w => 2, :wtimeout => 5000)
+    assert @col.update({:baz => "bar"}, {:baz => "foo"}, :w => 3, :wtimeout => 5000)
     assert @slave1[MONGO_TEST_DB]["test-sets"].find_one({:baz => "foo"})
 
     assert @col.insert({:foo => "bar"}, :w => "majority")
 
     assert @col.insert({:bar => "baz"}, :w => :majority)
 
-    assert @col.remove({}, :w => 2, :wtimeout => 5000)
+    assert @col.remove({}, :w => 3, :wtimeout => 5000)
     assert_equal 0, @slave1[MONGO_TEST_DB]["test-sets"].count
   end
 
   def test_last_error_responses
     20.times { @col.insert({:baz => "bar"}) }
-    response = @db.get_last_error(:w => 2, :wtimeout => 5000)
+    response = @db.get_last_error(:w => 3, :wtimeout => 5000)
     assert response['ok'] == 1
     assert response['lastOp']
 
     @col.update({}, {:baz => "foo"})
-    response = @db.get_last_error(:w => 2, :wtimeout => 5000)
+    response = @db.get_last_error(:w => 3, :wtimeout => 5000)
     assert response['ok'] == 1
     assert response['lastOp']
 
     @col.remove({})
-    response =  @db.get_last_error(:w => 2, :wtimeout => 5000)
+    response =  @db.get_last_error(:w => 3, :wtimeout => 5000)
     assert response['ok'] == 1
     assert response['n'] == 20
     assert response['lastOp']

data/test/test_helper.rb

@@ -7,6 +7,8 @@ if RUBY_VERSION >= '1.9.0' && RUBY_ENGINE == 'ruby'
       add_group "Mongo", 'lib/mongo'
       add_group "BSON", 'lib/bson'
       add_filter "/test/"
+      merge_timeout 3600
+      command_name ENV['SIMPLECOV_COMMAND_NAME'] if ENV.has_key?('SIMPLECOV_COMMAND_NAME')
     end
   end
 end

data/test/tools/mongo_config.rb

@@ -25,7 +25,7 @@ end
 module Mongo
   class Config
     DEFAULT_BASE_OPTS = { :host => 'localhost', :dbpath => 'data', :logpath => 'data/log'}
-    DEFAULT_REPLICA_SET = DEFAULT_BASE_OPTS.merge( :replicas => 2, :arbiters => 1 )
+    DEFAULT_REPLICA_SET = DEFAULT_BASE_OPTS.merge( :replicas => 3, :arbiters => 0 )
     DEFAULT_SHARDED_SIMPLE = DEFAULT_BASE_OPTS.merge( :shards => 2, :configs => 1, :routers => 4 )
     DEFAULT_SHARDED_REPLICA = DEFAULT_SHARDED_SIMPLE.merge( :replicas => 3, :arbiters => 0)
 
@@ -354,7 +354,7 @@ module Mongo
 
       def repl_set_config
         members = []
-        @config[:replicas].each{|s| members << { :_id => s[:_id], :host => "#{s[:host]}:#{s[:port]}" } }
+        @config[:replicas].each{|s| members << { :_id => s[:_id], :host => "#{s[:host]}:#{s[:port]}", :tags => { :node => s[:_id].to_s } } }
         @config[:arbiters].each{|s| members << { :_id => s[:_id], :host => "#{s[:host]}:#{s[:port]}", :arbiterOnly => true } }
         {
           :_id => @config[:replicas].first[:replSet],
@@ -442,12 +442,12 @@ module Mongo
         members_by_name(secondary_names)
       end
 
-      def kill_primary
-        primary.kill
+      def stop_primary
+        primary.stop
       end
 
-      def kill_secondary
-        secondaries[rand(secondaries.length)].kill
+      def stop_secondary
+        secondaries[rand(secondaries.length)].stop
       end
 
       def replicas

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongo
 version: !ruby/object:Gem::Version
-  version: 1.8.3.rc0
-  prerelease: 6
+  version: 1.8.3.rc1
 platform: ruby
 authors:
 - Tyler Brock
@@ -13,52 +12,43 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain:
-- !binary |-
-  LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSURPRENDQWlDZ0F3SUJB
-  Z0lCQURBTkJna3Foa2lHOXcwQkFRVUZBREJDTVJRd0VnWURWUVFEREF0a2Nt
-  bDIKWlhJdGNuVmllVEVWTUJNR0NnbVNKb21UOGl4a0FSa1dCVEV3WjJWdU1S
-  TXdFUVlLQ1pJbWlaUHlMR1FCR1JZRApZMjl0TUI0WERURXpNREl3TVRFME1U
-  RXpOMW9YRFRFME1ESXdNVEUwTVRFek4xb3dRakVVTUJJR0ExVUVBd3dMClpI
-  SnBkbVZ5TFhKMVlua3hGVEFUQmdvSmtpYUprL0lzWkFFWkZnVXhNR2RsYmpF
-  VE1CRUdDZ21TSm9tVDhpeGsKQVJrV0EyTnZiVENDQVNJd0RRWUpLb1pJaHZj
-  TkFRRUJCUUFEZ2dFUEFEQ0NBUW9DZ2dFQkFORmRTQWE4ZlJtMQpiQU05emE2
-  WjBmQUg0ZzAyYnFNMU5Hbnc4ekpRckUvUEZyRmZZNklGQ1QyQXNMZk93cjFt
-  YVZtN2lVMStrZFZJCklRK2lJLzkrRStBckorcmJHVjNkRFBRK1NMbDNtTFQr
-  dlhqZmpjeE1xSTJJVzZVdVZ0dDJVM1J4ZDRRVTBrZFQKSnhtY1BZczVmRE42
-  QmdZYzZYWGdVankzbStLd2hhMnBHY3RkY2lVT3dFZk9aNFJtTlJsRVpLQ01M
-  UkhkRlA4ago0V1RuSlNHZlhEaXVvWElDSmI1eU9QT1pQdWFhcFBTTlhwOTNR
-  a1Vkc3FkS0MzMkkrS01wS0tZR0JRNnlpc2ZBCjVNeVZQUEN6TFIxbFA1cVhW
-  R0pQbk9xVUFrdkVVZkNhaGc3RVA5dEkyMHF4aVhyUjZUU0VyYVloSUZYTDBF
-  R1kKdThLQWNQSG01S2tDQXdFQUFhTTVNRGN3Q1FZRFZSMFRCQUl3QURBZEJn
-  TlZIUTRFRmdRVVczZFpzWDcwbWxTTQpDaVByWnhBR0ExdndmTmN3Q3dZRFZS
-  MFBCQVFEQWdTd01BMEdDU3FHU0liM0RRRUJCUVVBQTRJQkFRQ0lhL1k2CnhT
-  N1lXQnhrbjlXUDBFTW5KM3BZOXZlZjlEVG1MU2kvMmp6OFB6d2xLUTg5ek5U
-  cnFTVUQ4TG9RWm1CcUNKQnQKZEtTUS9SVW5hSEp1eGg4SFd2V3ViUDhFQllU
-  dWYrSTFERm5SdjY0OElGM01SMXRDUXVtVkwwWGNZTXZaY3hCagphL3ArOERv
-  bVdUUXFVZE5iTm9HeXd3anRWQldmRGR3RlY4UG8xWGNOL0F0cElMT0pRZDlK
-  NzdJTklHR0NIeFpvCjZTT0hIYU5rbmxFOUgwdzZxMFNWeFpLWkk4LysyYzQ0
-  N1YwTnJISXcxUWhlMHRBR0o5VjF1M2t5OGd5eGUwU00KOHY3ekxGMlhsaVli
-  ZnVyWUl3a2NYczh5UG44Z2dBcEJJeTliWDZWSnhScy9sMitVdnF6YUhJRmFG
-  eS9GOC9HUApSTlR1WHNWRzVOREFDbzdRCi0tLS0tRU5EIENFUlRJRklDQVRF
-  LS0tLS0K
-date: 2013-02-14 00:00:00.000000000 Z
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDODCCAiCgAwIBAgIBADANBgkqhkiG9w0BAQUFADBCMRQwEgYDVQQDDAtkcml2
+  ZXItcnVieTEVMBMGCgmSJomT8ixkARkWBTEwZ2VuMRMwEQYKCZImiZPyLGQBGRYD
+  Y29tMB4XDTEzMDIwMTE0MTEzN1oXDTE0MDIwMTE0MTEzN1owQjEUMBIGA1UEAwwL
+  ZHJpdmVyLXJ1YnkxFTATBgoJkiaJk/IsZAEZFgUxMGdlbjETMBEGCgmSJomT8ixk
+  ARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANFdSAa8fRm1
+  bAM9za6Z0fAH4g02bqM1NGnw8zJQrE/PFrFfY6IFCT2AsLfOwr1maVm7iU1+kdVI
+  IQ+iI/9+E+ArJ+rbGV3dDPQ+SLl3mLT+vXjfjcxMqI2IW6UuVtt2U3Rxd4QU0kdT
+  JxmcPYs5fDN6BgYc6XXgUjy3m+Kwha2pGctdciUOwEfOZ4RmNRlEZKCMLRHdFP8j
+  4WTnJSGfXDiuoXICJb5yOPOZPuaapPSNXp93QkUdsqdKC32I+KMpKKYGBQ6yisfA
+  5MyVPPCzLR1lP5qXVGJPnOqUAkvEUfCahg7EP9tI20qxiXrR6TSEraYhIFXL0EGY
+  u8KAcPHm5KkCAwEAAaM5MDcwCQYDVR0TBAIwADAdBgNVHQ4EFgQUW3dZsX70mlSM
+  CiPrZxAGA1vwfNcwCwYDVR0PBAQDAgSwMA0GCSqGSIb3DQEBBQUAA4IBAQCIa/Y6
+  xS7YWBxkn9WP0EMnJ3pY9vef9DTmLSi/2jz8PzwlKQ89zNTrqSUD8LoQZmBqCJBt
+  dKSQ/RUnaHJuxh8HWvWubP8EBYTuf+I1DFnRv648IF3MR1tCQumVL0XcYMvZcxBj
+  a/p+8DomWTQqUdNbNoGywwjtVBWfDdwFV8Po1XcN/AtpILOJQd9J77INIGGCHxZo
+  6SOHHaNknlE9H0w6q0SVxZKZI8/+2c447V0NrHIw1Qhe0tAGJ9V1u3ky8gyxe0SM
+  8v7zLF2XliYbfurYIwkcXs8yPn8ggApBIy9bX6VJxRs/l2+UvqzaHIFaFy/F8/GP
+  RNTuXsVG5NDACo7Q
+  -----END CERTIFICATE-----
+date: 2013-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bson
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.8.3.rc0
+        version: 1.8.3.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.8.3.rc0
+        version: 1.8.3.rc1
 description: A Ruby driver for MongoDB. For more information about Mongo, see http://www.mongodb.org.
 email: mongodb-dev@googlegroups.com
 executables:
@@ -149,7 +139,6 @@ files:
 - test/replica_set/read_preference_test.rb
 - test/replica_set/refresh_test.rb
 - test/replica_set/replication_ack_test.rb
-- test/replica_set/z_cluster_shutdown.rb
 - test/sharded_cluster/basic_test.rb
 - test/test_helper.rb
 - test/threading/basic_test.rb
@@ -172,27 +161,26 @@ files:
 - test/unit/write_concern_test.rb
 homepage: http://www.mongodb.org
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>'
+  - - '>'
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
 rubyforge_project: mongo
-rubygems_version: 1.8.23
+rubygems_version: 2.0.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Ruby driver for MongoDB
 test_files:
 - test/auxillary/1.4_feature_test.rb
@@ -241,7 +229,6 @@ test_files:
 - test/replica_set/read_preference_test.rb
 - test/replica_set/refresh_test.rb
 - test/replica_set/replication_ack_test.rb
-- test/replica_set/z_cluster_shutdown.rb
 - test/sharded_cluster/basic_test.rb
 - test/test_helper.rb
 - test/threading/basic_test.rb

data/test/replica_set/z_cluster_shutdown.rb

@@ -1,13 +0,0 @@
-require 'test_helper'
-
-# mock test case to shutdown cluster for rake test:replica_set, must be last by file name sort order
-class ZClusterShutdownTest < Test::Unit::TestCase
-  def setup
-    ensure_cluster(:rs)
-  end
-
-  def test_cluster_shutdown
-    @@force_shutdown = true
-  end
-end
-