mongo 1.8.0 → 1.8.2

data/test/replica_set/count_test.rb

@@ -16,11 +16,6 @@ class ReplicaSetCountTest < Test::Unit::TestCase
     @client.close if @conn
   end
 
-  def self.shutdown
-    @@cluster.stop
-    @@cluster.clobber
-  end
-
   def test_correct_count_after_insertion_reconnect
     @coll.insert({:a => 20}, :w => 2, :wtimeout => 10000)
     assert_equal 1, @coll.count
@@ -43,4 +38,13 @@ class ReplicaSetCountTest < Test::Unit::TestCase
     count_after = @primary['admin'].command({:serverStatus => 1})['opcounters']['command']
     assert_equal 2, count_after - count_before
   end
+
+  def test_count_with_read
+    @coll.insert({:a => 20}, :w => 2, :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()
+    count_after = @primary['admin'].command({:serverStatus => 1})['opcounters']['command']
+    assert_equal 1, count_after - count_before
+  end
 end

data/test/replica_set/cursor_test.rb

@@ -6,37 +6,29 @@ class ReplicaSetCursorTest < Test::Unit::TestCase
     ensure_cluster(:rs)
   end
 
-  def self.shutdown
-    @@cluster.stop
-    @@cluster.clobber
-  end
-
   def test_cursors_get_closed
     setup_client
     assert_cursor_count
   end
 
-  #def test_cursors_get_closed_secondary
-  #  setup_client(:secondary)
-  #  assert_cursor_count
-  #end
+  def test_cursors_get_closed_secondary
+    setup_client(:secondary)
+    assert_cursor_count
+  end
 
   private
 
   def setup_client(read=:primary)
     # Setup ReplicaSet Connection
-    @client = MongoReplicaSetClient.new(
-        @rs.repl_set_seeds,
-      :read => read
-    )
+    @client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :read => read)
 
     @db = @client.db(MONGO_TEST_DB)
     @db.drop_collection("cursor_tests")
     @coll = @db.collection("cursor_tests")
 
-    @coll.insert({:a => 1}, :w => 3)
-    @coll.insert({:b => 2}, :w => 3)
-    @coll.insert({:c => 3}, :w => 3)
+    @coll.insert({:a => 1}, :w => 2)
+    @coll.insert({:b => 2}, :w => 2)
+    @coll.insert({:c => 3}, :w => 2)
 
     # Pin reader
     @coll.find_one
@@ -55,21 +47,19 @@ class ReplicaSetCursorTest < Test::Unit::TestCase
   end
 
   def assert_cursor_count
-    before_primary = cursor_count(@primary)
-    before_read = cursor_count(@read)
-    before_query = query_count(@read)
+    before_primary_cursor = cursor_count(@primary)
+    before_read_cursor = cursor_count(@read)
+    before_read_query = query_count(@read)
 
     @coll.find.limit(2).to_a
-    sleep(1)
 
-    after_primary = cursor_count(@primary)
-    after_read = cursor_count(@read)
-    after_query = query_count(@read)
+    after_primary_cursor = cursor_count(@primary)
+    after_read_cursor = cursor_count(@read)
+    after_read_query = query_count(@read)
 
-    assert_equal before_primary, after_primary
-    assert_equal before_read, after_read
-    assert_equal 1, after_query - before_query
+    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
   end
 
 end
-

data/test/replica_set/insert_test.rb

@@ -14,24 +14,19 @@ class ReplicaSetInsertTest < Test::Unit::TestCase
     @client.close if @conn
   end
 
-  def self.shutdown
-    @@cluster.stop
-    @@cluster.clobber
-  end
-
   def test_insert
     @coll.save({:a => 20}, :w => 2)
 
     @rs.primary.stop
 
     rescue_connection_failure do
-      @coll.save({:a => 30}, :w => 2)
+      @coll.save({:a => 30}, :w => 1)
     end
 
-    @coll.save({:a => 40}, :w => 2)
-    @coll.save({:a => 50}, :w => 2)
-    @coll.save({:a => 60}, :w => 2)
-    @coll.save({:a => 70}, :w => 2)
+    @coll.save({:a => 40}, :w => 1)
+    @coll.save({:a => 50}, :w => 1)
+    @coll.save({:a => 60}, :w => 1)
+    @coll.save({:a => 70}, :w => 1)
 
     # Restart the old master and wait for sync
     @rs.start

data/test/replica_set/query_test.rb

@@ -14,15 +14,10 @@ class ReplicaSetQueryTest < Test::Unit::TestCase
     @client.close if @conn
   end
 
-  def self.shutdown
-    @@cluster.stop
-    @@cluster.clobber
-  end
-
   def test_query
-    @coll.save({:a => 20}, :w => 3)
-    @coll.save({:a => 30}, :w => 3)
-    @coll.save({:a => 40}, :w => 3)
+    @coll.save({:a => 20}, :w => 2)
+    @coll.save({:a => 30}, :w => 2)
+    @coll.save({:a => 40}, :w => 2)
     results = []
     @coll.find.each {|r| results << r}
     [20, 30, 40].each do |a|
@@ -48,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 => 3)
+  #     @coll.save({:a => i}, :w => 2)
   #   end
   #   as = []
   #   # Set an explicit batch size, in case the default ever changes.

data/test/replica_set/read_preference_test.rb

@@ -0,0 +1,200 @@
+require 'test_helper'
+
+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)
+    db = conn.db(MONGO_TEST_DB)
+    coll = db.collection("test-sets")
+    coll.save({:a => 20}, {:w => 2})
+  end
+
+  def test_read_primary
+    conn = make_connection
+    rescue_connection_failure do
+      assert conn.read_primary?
+      assert conn.primary?
+    end
+
+    conn = make_connection(:primary_preferred)
+    rescue_connection_failure do
+      assert conn.read_primary?
+      assert conn.primary?
+    end
+
+    conn = make_connection(:secondary)
+    rescue_connection_failure do
+      assert !conn.read_primary?
+      assert !conn.primary?
+    end
+
+    conn = make_connection(:secondary_preferred)
+    rescue_connection_failure do
+      assert !conn.read_primary?
+      assert !conn.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,
+      "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,
+      "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,
+      "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,
+      "Primary port and read port are the same!"
+  end
+
+  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)
+  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)
+
+    # Kill the primary so only a single secondary exists
+    @rs.primary.kill
+
+    # Test that reads are going to the right members
+    assert_raise_error ConnectionFailure do
+      @primary[MONGO_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)
+
+    # 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)
+  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[MONGO_TEST_DB]['test-sets'].find_one
+    end
+    assert_query_route(@secondary_preferred, @primary_direct)
+
+    # 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)
+  end
+
+  def test_write_lots_of_data
+    @conn = make_connection(:secondary_preferred)
+    @db = @conn[MONGO_TEST_DB]
+    @coll = @db.collection("test-sets", {:w => 2})
+
+    6000.times do |n|
+      @coll.save({:a => n})
+    end
+
+    cursor = @coll.find()
+    cursor.next
+    cursor.close
+  end
+
+  private
+
+  def prepare_routing_test
+    # Setup replica set connections
+    @primary = make_connection(:primary)
+    @primary_preferred = make_connection(:primary_preferred)
+    @secondary = make_connection(:secondary)
+    @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)
+    @secondary_direct = Connection.new(@rs.config['host'], @secondary.read_pool.port, :slave_ok => true)
+  end
+
+  def make_connection(mode = :primary, opts = {})
+    opts.merge!({:read => mode})
+    MongoReplicaSetClient.new(@rs.repl_set_seeds, opts)
+  end
+
+  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}"
+    queries_before = query_count(expected_target)
+    assert_nothing_raised do
+      test_connection['MONGO_TEST_DB']['test-sets'].find_one
+    end
+    queries_after = query_count(expected_target)
+    assert_equal 1, queries_after - queries_before
+  end
+end

data/test/replica_set/refresh_test.rb

@@ -7,147 +7,136 @@ class ReplicaSetRefreshTest < Test::Unit::TestCase
     ensure_cluster(:rs)
   end
 
-  def self.shutdown
-    @@cluster.stop
-    @@cluster.clobber
-  end
-
   def test_connect_and_manual_refresh_with_secondaries_down
     @rs.secondaries.each{|s| s.stop}
+    client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :refresh_mode => false)
 
-    rescue_connection_failure do
-      @client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :refresh_mode => false)
-    end
-
-    assert_equal [], @client.secondaries
-    assert @client.connected?
-    assert_equal @client.read_pool, @client.primary_pool
+    assert_equal Set.new, client.secondaries
+    assert client.connected?
+    assert_equal client.read_pool, client.primary_pool
 
     # Refresh with no change to set
-    @client.refresh
-    assert_equal [], @client.secondaries
-    assert @client.connected?
-    assert_equal @client.read_pool, @client.primary_pool
+    client.refresh
+    assert_equal Set.new, client.secondaries
+    assert client.connected?
+    assert_equal client.read_pool, client.primary_pool
 
     # Test no changes after restart until manual refresh
     @rs.restart
-    assert_equal [], @client.secondaries
-    assert @client.connected?
-    assert_equal @client.read_pool, @client.primary_pool
+    assert_equal Set.new, client.secondaries
+    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 2, @client.secondaries.length
+    client.refresh
+    assert_equal client.read_pool, client.primary_pool
+    assert_equal 1, client.secondaries.length
   end
 
   def test_automated_refresh_with_secondaries_down
     @rs.secondaries.each{|s| s.stop}
-    
-    rescue_connection_failure do
-      @client = MongoReplicaSetClient.new(@rs.repl_set_seeds,
-        :refresh_interval => 1, :refresh_mode => :sync, :read => :secondary_preferred)
-    end
+    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 [], @client.secondaries
-    assert @client.connected?
-    assert_equal @client.manager.read, @client.manager.primary
-    old_refresh_version = @client.refresh_version
+    assert_equal Set.new, client.secondaries
+    assert client.connected?
+    assert client.manager.pools.member?(client.manager.read_pool)
+    old_refresh_version = client.refresh_version
 
     # Restart nodes and ensure refresh interval has passed
     @rs.restart
     sleep(2)
 
-    assert @client.refresh_version == old_refresh_version,
+    assert client.refresh_version == old_refresh_version,
       "Refresh version has changed."
 
     # Trigger synchronous refresh
-    @client['foo']['bar'].find_one
+    client['foo']['bar'].find_one
 
-    assert @client.refresh_version > old_refresh_version,
+    assert client.refresh_version > old_refresh_version,
       "Refresh version hasn't changed."
-    assert @client.secondaries.length == 2,
+    assert client.secondaries.length == 1,
       "No secondaries have been added."
-    assert @client.manager.read != @client.manager.primary,
+    assert client.manager.read_pool != client.manager.primary,
       "Read pool and primary pool are identical."
   end
   
   def test_automated_refresh_when_secondary_goes_down
-    @client = MongoReplicaSetClient.new(@rs.repl_set_seeds,
+    client = MongoReplicaSetClient.new(@rs.repl_set_seeds,
       :refresh_interval => 1, :refresh_mode => :sync)
 
-    num_secondaries = @client.secondary_pools.length
-    old_refresh_version = @client.refresh_version
+    num_secondaries = client.secondary_pools.length
+    old_refresh_version = client.refresh_version
 
-    @rs.secondaries.first.kill
-    sleep(2)
+    @rs.kill_secondary
+    sleep(1)
 
-    assert @client.refresh_version == old_refresh_version,
+    assert client.refresh_version == old_refresh_version,
       "Refresh version has changed."
 
-    @client['foo']['bar'].find_one
+    client['foo']['bar'].find_one
 
-    assert @client.refresh_version > old_refresh_version,
+    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.length
+    assert_equal num_secondaries - 1, client.secondary_pools.length
 
     @rs.start
     sleep(2)
 
-    @client['foo']['bar'].find_one
+    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.length
+    assert_equal num_secondaries, client.secondary_pools.length
   end
 =begin
   def test_automated_refresh_with_removed_node
-    @client = MongoReplicaSetClient.new(@rs.repl_set_seeds,
+    client = MongoReplicaSetClient.new(@rs.repl_set_seeds,
       :refresh_interval => 1, :refresh_mode => :sync)
 
-    num_secondaries = @client.secondary_pools.length
-    old_refresh_version = @client.refresh_version
+    num_secondaries = client.secondary_pools.length
+    old_refresh_version = client.refresh_version
 
     n = @rs.repl_set_remove_node(2)
     sleep(2)
 
     rescue_connection_failure do
-      @client['foo']['bar'].find_one
+      client['foo']['bar'].find_one
     end
 
-    assert @client.refresh_version > old_refresh_version,
+    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.length
+    assert_equal num_secondaries - 1, client.secondary_pools.length
 
     #@rs.add_node(n)
   end
 
   def test_adding_and_removing_nodes
-    @client = MongoReplicaSetClient.new(build_seeds(3),
+    client = MongoReplicaSetClient.new(build_seeds(3),
       :refresh_interval => 2, :refresh_mode => :sync)
 
     @rs.add_node
     sleep(4)
-    @client['foo']['bar'].find_one
+    client['foo']['bar'].find_one
 
     @conn2 = MongoReplicaSetClient.new(build_seeds(3),
       :refresh_interval => 2, :refresh_mode => :sync)
 
-    assert @conn2.secondaries.sort == @client.secondaries.sort,
+    assert @conn2.secondaries.sort == client.secondaries.sort,
       "Second connection secondaries not equal to first."
-    assert_equal 3, @client.secondary_pools.length
-    assert_equal 3, @client.secondaries.length
+    assert_equal 3, client.secondary_pools.length
+    assert_equal 3, client.secondaries.length
 
-    config = @client['admin'].command({:ismaster => 1})
+    config = client['admin'].command({:ismaster => 1})
 
     @rs.remove_secondary_node
     sleep(4)
-    config = @client['admin'].command({:ismaster => 1})
+    config = client['admin'].command({:ismaster => 1})
 
-    assert_equal 2, @client.secondary_pools.length
-    assert_equal 2, @client.secondaries.length
+    assert_equal 2, client.secondary_pools.length
+    assert_equal 2, client.secondaries.length
   end
 =end
 end