mongo 1.5.2 → 1.6.0

data/test/replica_sets/complex_connect_test.rb

@@ -0,0 +1,44 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'logger'
+require './test/replica_sets/rs_test_helper'
+
+class ComplexConnectTest < Test::Unit::TestCase
+  
+  def setup
+    ensure_rs
+  end
+
+  def teardown
+    @rs.restart_killed_nodes
+    @conn.close if defined?(@conn) && @conn
+  end
+
+  def test_complex_connect
+    logger = Logger.new(STDOUT)
+    primary = Connection.new(@rs.host, @rs.ports[0])
+
+    @conn = ReplSetConnection.new([@rs.host, @rs.ports[2]], [@rs.host, @rs.ports[1]],
+      [@rs.host, @rs.ports[0]], :logger => logger)
+
+    @conn['test']['foo'].insert({:a => 1})
+    assert @conn['test']['foo'].find_one
+
+    config = primary['local']['system.replset'].find_one
+    config['version'] += 1
+    config['members'].delete_if do |member|
+      member['host'].include?(@rs.ports[2].to_s)
+    end
+
+    assert_raise ConnectionFailure do
+      primary['admin'].command({:replSetReconfig => config})
+    end
+    @rs.ensure_up
+    assert_raise ConnectionFailure do
+      primary['admin'].command({:replSetStepDown => 1})
+    end
+
+    rescue_connection_failure do
+      assert @conn['test']['foo'].find_one
+    end
+  end
+end

data/test/replica_sets/connect_test.rb

@@ -2,75 +2,73 @@ $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require './test/replica_sets/rs_test_helper'
 
 class ConnectTest < Test::Unit::TestCase
-  include ReplicaSetTest
+  def setup
+    ensure_rs
+  end
 
   def teardown
-    self.rs.restart_killed_nodes
+    @rs.restart_killed_nodes
     @conn.close if defined?(@conn) && @conn
   end
 
   # TODO: test connect timeout.
 
   def test_connect_with_deprecated_multi
-    @conn = Connection.multi([[self.rs.host, self.rs.ports[0]], [self.rs.host, self.rs.ports[1]]], :name => self.rs.name)
+    @conn = Connection.multi([[@rs.host, @rs.ports[0]], [@rs.host, @rs.ports[1]]], :name => @rs.name)
     assert @conn.is_a?(ReplSetConnection)
     assert @conn.connected?
   end
 
   def test_connect_bad_name
     assert_raise_error(ReplicaSetConnectionError, "-wrong") do
-      @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]], [self.rs.host, self.rs.ports[1]],
-        [self.rs.host, self.rs.ports[2]], :name => self.rs.name + "-wrong")
+      @conn = ReplSetConnection.new(build_seeds(3), :name => @rs.name + "-wrong")
     end
   end
 
   def test_connect_with_primary_node_killed
-    node = self.rs.kill_primary
+    node = @rs.kill_primary
 
     # Becuase we're killing the primary and trying to connect right away,
     # this is going to fail right away.
     assert_raise_error(ConnectionFailure, "Failed to connect to primary node") do
-      @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]], [self.rs.host, self.rs.ports[1]],
-        [self.rs.host, self.rs.ports[2]])
+      @conn = ReplSetConnection.new build_seeds(3)
     end
 
     # This allows the secondary to come up as a primary
     rescue_connection_failure do
-      @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]], [self.rs.host, self.rs.ports[1]],
-        [self.rs.host, self.rs.ports[2]])
+      @conn = ReplSetConnection.new build_seeds(3)
     end
   end
 
   def test_connect_with_secondary_node_killed
-    node = self.rs.kill_secondary
+    node = @rs.kill_secondary
 
     rescue_connection_failure do
-      @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]], [self.rs.host, self.rs.ports[1]],
-        [self.rs.host, self.rs.ports[2]])
+      @conn = ReplSetConnection.new build_seeds(3)
     end
     assert @conn.connected?
   end
 
   def test_connect_with_third_node_killed
-    self.rs.kill(self.rs.get_node_from_port(self.rs.ports[2]))
+    @rs.kill(@rs.get_node_from_port(@rs.ports[2]))
 
     rescue_connection_failure do
-      @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]], [self.rs.host, self.rs.ports[1]],
-        [self.rs.host, self.rs.ports[2]])
+      @conn = ReplSetConnection.new build_seeds(3)
     end
     assert @conn.connected?
   end
 
   def test_connect_with_primary_stepped_down
-    @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]], [self.rs.host, self.rs.ports[1]],
-      [self.rs.host, self.rs.ports[2]])
+    @conn = ReplSetConnection.new build_seeds(3)
     @conn[MONGO_TEST_DB]['bar'].save({:a => 1}, {:safe => {:w => 3}})
     assert @conn[MONGO_TEST_DB]['bar'].find_one
 
     primary = Mongo::Connection.new(@conn.primary_pool.host, @conn.primary_pool.port)
-    primary['admin'].command({:replSetStepDown => 60})
+    assert_raise Mongo::ConnectionFailure do
+      primary['admin'].command({:replSetStepDown => 60})
+    end
     assert @conn.connected?
-    assert_raise_error Mongo::ConnectionFailure, "not master" do
+    assert_raise Mongo::ConnectionFailure do
       @conn[MONGO_TEST_DB]['bar'].find_one
     end
     assert !@conn.connected?
@@ -80,14 +78,42 @@ class ConnectTest < Test::Unit::TestCase
     end
   end
 
+  def test_save_with_primary_stepped_down
+    @conn = ReplSetConnection.new build_seeds(3)
+
+    primary = Mongo::Connection.new(@conn.primary_pool.host, @conn.primary_pool.port)
+
+    # 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
+    assert_raise Mongo::ConnectionFailure do
+      primary['admin'].command(step_down_command)
+    end
+
+    rescue_connection_failure do
+      @conn[MONGO_TEST_DB]['bar'].save({:a => 1}, {:safe => {:w => 3}})
+    end
+  end
+
   def test_connect_with_connection_string
-    @conn = Connection.from_uri("mongodb://#{self.rs.host}:#{self.rs.ports[0]},#{self.rs.host}:#{self.rs.ports[1]}?replicaset=#{self.rs.name}")
+    @conn = Connection.from_uri("mongodb://#{@rs.host}:#{@rs.ports[0]},#{@rs.host}:#{@rs.ports[1]}?replicaset=#{@rs.name}")
     assert @conn.is_a?(ReplSetConnection)
     assert @conn.connected?
   end
+  
+  def test_connect_with_new_seed_format
+    @conn = ReplSetConnection.new build_seeds(3)
+    assert @conn.connected?
+  end
+  
+  def test_connect_with_old_seed_format
+    @conn = ReplSetConnection.new([@rs.host, @rs.ports[0]], [@rs.host, @rs.ports[1]], [@rs.host, @rs.ports[2]])
+    assert @conn.connected?
+  end
 
   def test_connect_with_full_connection_string
-    @conn = Connection.from_uri("mongodb://#{self.rs.host}:#{self.rs.ports[0]},#{self.rs.host}:#{self.rs.ports[1]}?replicaset=#{self.rs.name};safe=true;w=2;fsync=true;slaveok=true")
+    @conn = Connection.from_uri("mongodb://#{@rs.host}:#{@rs.ports[0]},#{@rs.host}:#{@rs.ports[1]}?replicaset=#{@rs.name};safe=true;w=2;fsync=true;slaveok=true")
     assert @conn.is_a?(ReplSetConnection)
     assert @conn.connected?
     assert_equal 2, @conn.safe[:w]

data/test/replica_sets/count_test.rb

@@ -2,12 +2,10 @@ $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require './test/replica_sets/rs_test_helper'
 
 class ReplicaSetCountTest < Test::Unit::TestCase
-  include ReplicaSetTest
 
   def setup
-    @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]],
-                                  [self.rs.host, self.rs.ports[1]], [self.rs.host, self.rs.ports[2]],
-                                  :read => :secondary)
+    ensure_rs
+    @conn = ReplSetConnection.new(build_seeds(3), :read => :secondary)
     assert @conn.primary_pool
     @primary = Connection.new(@conn.primary_pool.host, @conn.primary_pool.port)
     @db = @conn.db(MONGO_TEST_DB)
@@ -16,7 +14,7 @@ class ReplicaSetCountTest < Test::Unit::TestCase
   end
 
   def teardown
-    self.rs.restart_killed_nodes
+    @rs.restart_killed_nodes
     @conn.close if @conn
   end
 
@@ -25,7 +23,7 @@ class ReplicaSetCountTest < Test::Unit::TestCase
     assert_equal 1, @coll.count
 
     # Kill the current master node
-    @node = self.rs.kill_primary
+    @node = @rs.kill_primary
 
     rescue_connection_failure do
       @coll.insert({:a => 30}, :safe => true)

data/test/replica_sets/insert_test.rb

@@ -2,38 +2,37 @@ $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require './test/replica_sets/rs_test_helper'
 
 class ReplicaSetInsertTest < Test::Unit::TestCase
-  include ReplicaSetTest
 
   def setup
-    @conn = ReplSetConnection.new([TEST_HOST, self.rs.ports[0]],
-                                  [TEST_HOST, self.rs.ports[1]], [TEST_HOST, self.rs.ports[2]])
+    ensure_rs
+    @conn = ReplSetConnection.new build_seeds(3)
     @db = @conn.db(MONGO_TEST_DB)
     @db.drop_collection("test-sets")
     @coll = @db.collection("test-sets")
   end
 
   def teardown
-    self.rs.restart_killed_nodes
+    @rs.restart_killed_nodes
     @conn.close if @conn
   end
 
   def test_insert
-    @coll.save({:a => 20}, :safe => true)
+    @coll.save({:a => 20}, :safe => {:w => 2})
 
-    self.rs.kill_primary
+    @rs.kill_primary
 
     rescue_connection_failure do
-      @coll.save({:a => 30}, :safe => true)
+      @coll.save({:a => 30}, :safe => {:w => 2})
     end
 
-    @coll.save({:a => 40}, :safe => true)
-    @coll.save({:a => 50}, :safe => true)
-    @coll.save({:a => 60}, :safe => true)
-    @coll.save({:a => 70}, :safe => true)
+    @coll.save({:a => 40}, :safe => {:w => 2})
+    @coll.save({:a => 50}, :safe => {:w => 2})
+    @coll.save({:a => 60}, :safe => {:w => 2})
+    @coll.save({:a => 70}, :safe => {:w => 2})
 
     # Restart the old master and wait for sync
-    self.rs.restart_killed_nodes
-    sleep(1)
+    @rs.restart_killed_nodes
+    sleep(5)
     results = []
 
     rescue_connection_failure do
@@ -43,7 +42,7 @@ class ReplicaSetInsertTest < Test::Unit::TestCase
       end
     end
 
-    @coll.save({:a => 80}, :safe => true)
+    @coll.save({:a => 80}, :safe => {:w => 2})
     @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_sets/pooled_insert_test.rb

@@ -4,32 +4,31 @@ require './test/replica_sets/rs_test_helper'
 # NOTE: This test expects a replica set of three nodes to be running
 # on the local host.
 class ReplicaSetPooledInsertTest < Test::Unit::TestCase
-  include ReplicaSetTest
 
   def setup
-    @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]], [self.rs.host, self.rs.ports[1]],
-      [self.rs.host, self.rs.ports[2]], :pool_size => 5, :timeout => 5, :refresh_mode => false)
+    ensure_rs
+    @conn = ReplSetConnection.new(build_seeds(3), :pool_size => 5, :timeout => 5, :refresh_mode => false)
     @db = @conn.db(MONGO_TEST_DB)
     @db.drop_collection("test-sets")
     @coll = @db.collection("test-sets")
   end
 
   def teardown
-    self.rs.restart_killed_nodes
+    @rs.restart_killed_nodes
     @conn.close if @conn
   end
 
   def test_insert
     expected_results = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-    @coll.save({:a => -1}, :safe => true)
+    @coll.save({:a => -1}, :safe => {:w => 2})
 
-    self.rs.kill_primary
+    @rs.kill_primary
 
     threads = []
     10.times do |i|
       threads[i] = Thread.new do
         rescue_connection_failure do
-          @coll.save({:a => i}, :safe => true)
+          @coll.save({:a => i}, :safe => {:w => 2})
         end
       end
     end
@@ -37,8 +36,8 @@ class ReplicaSetPooledInsertTest < Test::Unit::TestCase
     threads.each {|t| t.join}
 
     # Restart the old master and wait for sync
-    self.rs.restart_killed_nodes
-    sleep(1)
+    @rs.restart_killed_nodes
+    sleep(5)
     results = []
 
     rescue_connection_failure do
@@ -48,7 +47,7 @@ class ReplicaSetPooledInsertTest < Test::Unit::TestCase
       end
     end
 
-    @coll.save({:a => 10}, :safe => true)
+    @coll.save({:a => 10}, :safe => {:w => 2})
     @coll.find.each {|r| results << r}
     (expected_results + [10]).each do |a|
       assert results.any? {|r| r['a'] == a}, "Could not find record for a => #{a} on second find"

data/test/replica_sets/query_test.rb

@@ -2,17 +2,17 @@ $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require './test/replica_sets/rs_test_helper'
 
 class ReplicaSetQueryTest < Test::Unit::TestCase
-  include ReplicaSetTest
 
   def setup
-    @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]])
+    ensure_rs
+    @conn = ReplSetConnection.new build_seeds(1)
     @db = @conn.db(MONGO_TEST_DB)
     @db.drop_collection("test-sets")
     @coll = @db.collection("test-sets")
   end
 
   def teardown
-    self.rs.restart_killed_nodes
+    @rs.restart_killed_nodes
     @conn.close if @conn
   end
 
@@ -28,7 +28,7 @@ class ReplicaSetQueryTest < Test::Unit::TestCase
 
     puts "Benchmark before failover: #{benchmark_queries}"
 
-    self.rs.kill_primary
+    @rs.kill_primary
 
     results = []
     rescue_connection_failure do

data/test/replica_sets/read_preference_test.rb

@@ -3,21 +3,25 @@ require './test/replica_sets/rs_test_helper'
 require 'logger'
 
 class ReadPreferenceTest < Test::Unit::TestCase
-  include ReplicaSetTest
 
   def setup
+    ensure_rs
     log = Logger.new("test.log")
-    @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]],
-                                 [self.rs.host, self.rs.ports[1]],
-          :read => :secondary, :pool_size => 50,
-          :refresh_mode => false, :refresh_interval => 5, :logger => log)
+    seeds = build_seeds(2)
+    args = {
+      :read => :secondary,
+      :pool_size => 50,
+      :refresh_mode => false,
+      :refresh_interval => 5,
+      :logger => log
+    }
+    @conn = ReplSetConnection.new(seeds, args)
     @db = @conn.db(MONGO_TEST_DB)
     @db.drop_collection("test-sets")
-    col = @db['mongo-test']
   end
 
   def teardown
-    self.rs.restart_killed_nodes
+    @rs.restart_killed_nodes
   end
 
   def test_read_primary
@@ -34,8 +38,38 @@ class ReadPreferenceTest < Test::Unit::TestCase
       "Primary port and read port at the same!"
   end
 
+  def test_read_secondary_only
+    @rs.add_arbiter
+    @rs.remove_secondary_node
+    
+    @conn = ReplSetConnection.new(build_seeds(2), :read => :secondary_only)
+
+    @db = @conn.db(MONGO_TEST_DB)
+    @coll = @db.collection("test-sets")
+    
+    @coll.save({:a => 20}, :safe => {:w => 2})
+
+    # Test that reads are going to secondary on ReplSetConnection
+    @secondary = Connection.new(@rs.host, @conn.read_pool.port, :slave_ok => true)
+    queries_before = @secondary['admin'].command({:serverStatus => 1})['opcounters']['query']
+    @coll.find_one
+    queries_after = @secondary['admin'].command({:serverStatus => 1})['opcounters']['query']
+    assert_equal 1, queries_after - queries_before
+
+    @rs.kill_secondary
+    @conn.refresh
+    
+    # Test that reads are only allowed from secondaries
+    assert_raise ConnectionFailure.new("Could not connect to a secondary for reading.") do
+      @coll.find_one
+    end
+        
+    @rs = ReplSetManager.new
+    @rs.start_set
+  end
+
   def test_query_secondaries
-    @secondary = Connection.new(self.rs.host, @conn.read_pool.port, :slave_ok => true)
+    @secondary = Connection.new(@rs.host, @conn.read_pool.port, :slave_ok => true)
     @coll = @db.collection("test-sets", :safe => {:w => 3, :wtimeout => 20000})
     @coll.save({:a => 20})
     @coll.save({:a => 30})
@@ -49,7 +83,7 @@ class ReadPreferenceTest < Test::Unit::TestCase
     assert results.include?(30)
     assert results.include?(40)
 
-    self.rs.kill_primary
+    @rs.kill_primary
 
     results = []
     rescue_connection_failure do
@@ -68,13 +102,13 @@ class ReadPreferenceTest < Test::Unit::TestCase
     assert_equal 2, @coll.find.to_a.length
 
     # Should still be able to read immediately after killing master node
-    self.rs.kill_primary
+    @rs.kill_primary
     assert_equal 2, @coll.find.to_a.length
     rescue_connection_failure do
       puts "@coll.save()"
       @coll.save({:a => 50}, :safe => {:w => 2, :wtimeout => 10000})
     end
-    self.rs.restart_killed_nodes
+    @rs.restart_killed_nodes
     @coll.save({:a => 50}, :safe => {:w => 2, :wtimeout => 10000})
     assert_equal 4, @coll.find.to_a.length
   end
@@ -85,8 +119,8 @@ class ReadPreferenceTest < Test::Unit::TestCase
     @coll.save({:a => 30})
     assert_equal 2, @coll.find.to_a.length
 
-    read_node = self.rs.get_node_from_port(@conn.read_pool.port)
-    self.rs.kill(read_node)
+    read_node = @rs.get_node_from_port(@conn.read_pool.port)
+    @rs.kill(read_node)
 
     # Should fail immediately on next read
     old_read_pool_port = @conn.read_pool.port
@@ -141,7 +175,7 @@ class ReadPreferenceTest < Test::Unit::TestCase
   # end
 
   #def teardown
-  #  self.rs.restart_killed_nodes
+  #  @rs.restart_killed_nodes
   #end
 
 end