mongo 1.7.1 → 1.8.0

data/test/{replica_sets → replica_set}/insert_test.rb

@@ -1,37 +1,40 @@
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require './test/replica_sets/rs_test_helper'
+require 'test_helper'
 
 class ReplicaSetInsertTest < Test::Unit::TestCase
 
   def setup
-    ensure_rs
-    @conn = ReplSetConnection.new build_seeds(3)
-    @db = @conn.db(MONGO_TEST_DB)
+    ensure_cluster(:rs)
+    @client = MongoReplicaSetClient.new @rs.repl_set_seeds
+    @db = @client.db(MONGO_TEST_DB)
     @db.drop_collection("test-sets")
     @coll = @db.collection("test-sets")
   end
 
   def teardown
-    @rs.restart_killed_nodes
-    @conn.close if @conn
+    @client.close if @conn
+  end
+
+  def self.shutdown
+    @@cluster.stop
+    @@cluster.clobber
   end
 
   def test_insert
-    @coll.save({:a => 20}, :safe => {:w => 2})
+    @coll.save({:a => 20}, :w => 2)
 
-    @rs.kill_primary
+    @rs.primary.stop
 
     rescue_connection_failure do
-      @coll.save({:a => 30}, :safe => {:w => 2})
+      @coll.save({:a => 30}, :w => 2)
     end
 
-    @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})
+    @coll.save({:a => 40}, :w => 2)
+    @coll.save({:a => 50}, :w => 2)
+    @coll.save({:a => 60}, :w => 2)
+    @coll.save({:a => 70}, :w => 2)
 
     # Restart the old master and wait for sync
-    @rs.restart_killed_nodes
+    @rs.start
     sleep(5)
     results = []
 
@@ -42,7 +45,7 @@ class ReplicaSetInsertTest < Test::Unit::TestCase
       end
     end
 
-    @coll.save({:a => 80}, :safe => {:w => 2})
+    @coll.save({:a => 80}, :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_set/query_test.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+class ReplicaSetQueryTest < Test::Unit::TestCase
+
+  def setup
+    ensure_cluster(:rs)
+    @client = MongoReplicaSetClient.new @rs.repl_set_seeds
+    @db = @client.db(MONGO_TEST_DB)
+    @db.drop_collection("test-sets")
+    @coll = @db.collection("test-sets")
+  end
+
+  def teardown
+    @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)
+    results = []
+    @coll.find.each {|r| results << r}
+    [20, 30, 40].each do |a|
+      assert results.any? {|r| r['a'] == a}, "Could not find record for a => #{a}"
+    end
+
+    @rs.primary.stop
+
+    results = []
+    rescue_connection_failure do
+      @coll.find.each {|r| results << r}
+      [20, 30, 40].each do |a|
+        assert results.any? {|r| r['a'] == a}, "Could not find record for a => #{a}"
+      end
+    end
+  end
+
+  # Create a large collection and do a secondary query that returns
+  # enough records to require sending a GETMORE. In between opening
+  # the cursor and sending the GETMORE, do a :primary query. Confirm
+  # that the cursor reading from the secondary continues to talk to
+  # the secondary, rather than trying to read the cursor from the
+  # primary, where it does not exist.
+  # def test_secondary_getmore
+  #   200.times do |i|
+  #     @coll.save({:a => i}, :w => 3)
+  #   end
+  #   as = []
+  #   # Set an explicit batch size, in case the default ever changes.
+  #   @coll.find({}, { :batch_size => 100, :read => :secondary }) do |c|
+  #     c.each do |result|
+  #       as << result['a']
+  #       @coll.find({:a => result['a']}, :read => :primary).map
+  #     end
+  #   end
+  #   assert_equal(as.sort, 0.upto(199).to_a)
+  # end
+
+end

data/test/replica_set/refresh_test.rb

@@ -0,0 +1,153 @@
+require 'test_helper'
+require 'benchmark'
+
+class ReplicaSetRefreshTest < Test::Unit::TestCase
+
+  def setup
+    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}
+
+    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
+
+    # Refresh with no change to set
+    @client.refresh
+    assert_equal [], @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
+
+    # Refresh and ensure state
+    @client.refresh
+    assert_equal @client.read_pool, @client.primary_pool
+    #assert_equal 2, @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
+
+    # 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
+
+    # Restart nodes and ensure refresh interval has passed
+    @rs.restart
+    sleep(2)
+
+    assert @client.refresh_version == old_refresh_version,
+      "Refresh version has changed."
+
+    # Trigger synchronous refresh
+    @client['foo']['bar'].find_one
+
+    assert @client.refresh_version > old_refresh_version,
+      "Refresh version hasn't changed."
+    assert @client.secondaries.length == 2,
+      "No secondaries have been added."
+    assert @client.manager.read != @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,
+      :refresh_interval => 1, :refresh_mode => :sync)
+
+    num_secondaries = @client.secondary_pools.length
+    old_refresh_version = @client.refresh_version
+
+    @rs.secondaries.first.kill
+    sleep(2)
+
+    assert @client.refresh_version == old_refresh_version,
+      "Refresh version has changed."
+
+    @client['foo']['bar'].find_one
+
+    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
+
+    @rs.start
+    sleep(2)
+
+    @client['foo']['bar'].find_one
+
+    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,
+      :refresh_interval => 1, :refresh_mode => :sync)
+
+    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
+    end
+
+    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
+
+    #@rs.add_node(n)
+  end
+
+  def test_adding_and_removing_nodes
+    @client = MongoReplicaSetClient.new(build_seeds(3),
+      :refresh_interval => 2, :refresh_mode => :sync)
+
+    @rs.add_node
+    sleep(4)
+    @client['foo']['bar'].find_one
+
+    @conn2 = MongoReplicaSetClient.new(build_seeds(3),
+      :refresh_interval => 2, :refresh_mode => :sync)
+
+    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
+
+    config = @client['admin'].command({:ismaster => 1})
+
+    @rs.remove_secondary_node
+    sleep(4)
+    config = @client['admin'].command({:ismaster => 1})
+
+    assert_equal 2, @client.secondary_pools.length
+    assert_equal 2, @client.secondaries.length
+  end
+=end
+end

data/test/{replica_sets → replica_set}/replication_ack_test.rb

@@ -1,49 +1,53 @@
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require './test/replica_sets/rs_test_helper'
+require 'test_helper'
 
 class ReplicaSetAckTest < Test::Unit::TestCase
 
   def setup
-    ensure_rs
-    @conn = ReplSetConnection.new(build_seeds(1))
+    ensure_cluster(:rs)
+    @client = MongoReplicaSetClient.new(@rs.repl_set_seeds)
 
-    @slave1 = Connection.new(@conn.secondary_pools[0].host,
-      @conn.secondary_pools[0].port, :slave_ok => true)
+    @slave1 = MongoClient.new(
+      @client.secondary_pools[0].host,
+      @client.secondary_pools[0].port, :slave_ok => true)
 
     assert !@slave1.read_primary?
 
-    @db = @conn.db(MONGO_TEST_DB)
+    @db = @client.db(MONGO_TEST_DB)
     @db.drop_collection("test-sets")
     @col = @db.collection("test-sets")
   end
 
   def teardown
-    @rs.restart_killed_nodes
-    @conn.close if @conn
+    @client.close if @conn
+  end
+
+  def self.shutdown
+    @@cluster.stop
+    @@cluster.clobber
   end
 
   def test_safe_mode_with_w_failure
     assert_raise_error OperationFailure, "timeout" do
-      @col.insert({:foo => 1}, :safe => {:w => 4, :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}, :safe => {:w => 4, :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}, :safe => {:w => 4, :wtimeout => 1, :fsync => true})
+      @col.remove({:foo => 2}, :w => 4, :wtimeout => 1, :fsync => true)
     end
   end
 
   def test_safe_mode_replication_ack
-    @col.insert({:baz => "bar"}, :safe => {:w => 3, :wtimeout => 5000})
+    @col.insert({:baz => "bar"}, :w => 3, :wtimeout => 5000)
 
-    assert @col.insert({:foo => "0" * 5000}, :safe => {:w => 3, :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"}, :safe => {:w => 3, :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.remove({}, :safe => {:w => 3, :wtimeout => 5000})
+    assert @col.remove({}, :w => 3, :wtimeout => 5000)
     assert_equal 0, @slave1[MONGO_TEST_DB]["test-sets"].count
   end
 
@@ -53,7 +57,7 @@ class ReplicaSetAckTest < Test::Unit::TestCase
     assert response['ok'] == 1
     assert response['lastOp']
 
-    @col.update({}, {:baz => "foo"}, :multi => true)
+    @col.update({}, {:baz => "foo"})
     response = @db.get_last_error(:w => 2, :wtimeout => 5000)
     assert response['ok'] == 1
     assert response['lastOp']

data/test/sharded_cluster/basic_test.rb

@@ -1,112 +1,93 @@
-$:.unshift(File.expand_path('../..', File.dirname(__FILE__)))
-require 'test/sharded_cluster/sc_test_helper'
-require 'test/tools/mongo_config'
+require 'test_helper'
+include Mongo
 
 class BasicTest < Test::Unit::TestCase
-
-  def self.suite
-    s = super
-    def s.setup
-
-    end
-    def s.teardown
-      @@sc.stop
-      @@sc.clobber
-    end
-    def s.run(*args)
-      setup
-      super
-      teardown
-    end
-    s
-  end
-
+  
   def setup
-    ensure_sc
+    ensure_cluster(:sc)
   end
 
-  def teardown
-
+  def self.shutdown
+    @@cluster.stop
+    @@cluster.clobber
   end
 
   # TODO member.primary? ==> true
   def test_connect
     seeds = @sc.mongos_seeds
-    @con = Mongo::ShardedConnection.new(seeds)
-    assert @con.connected?
-    assert_equal(seeds.size, @con.seeds.size)
+    @client = MongoShardedClient.new(seeds)
+    assert @client.connected?
+    assert_equal(seeds.size, @client.seeds.size)
     probe(seeds.size)
-    @con.close
+    @client.close
   end
 
   def test_hard_refresh
     seeds = @sc.mongos_seeds
-    @con = Mongo::ShardedConnection.new(seeds)
-    assert @con.connected?
-    @con.hard_refresh!
-    assert @con.connected?
-    @con.close
+    @client = MongoShardedClient.new(seeds)
+    assert @client.connected?
+    @client.hard_refresh!
+    assert @client.connected?
+    @client.close
   end
 
   def test_reconnect
     seeds = @sc.mongos_seeds
-    @con = Mongo::ShardedConnection.new(seeds)
-    assert @con.connected?
+    @client = MongoShardedClient.new(seeds)
+    assert @client.connected?
     router = @sc.servers(:routers).first
     router.stop
     probe(seeds.size)
-    assert @con.connected?
-    @con.close
+    assert @client.connected?
+    @client.close
   end
 
   def test_all_down
     seeds = @sc.mongos_seeds
-    @con = Mongo::ShardedConnection.new(seeds)
-    assert @con.connected?
+    @client = MongoShardedClient.new(seeds)
+    assert @client.connected?
     @sc.servers(:routers).each{|router| router.stop}
     assert_raises Mongo::ConnectionFailure do
       probe(seeds.size)
     end
-    assert_false @con.connected?
-    @con.close
+    assert_false @client.connected?
+    @client.close
   end
 
   def test_cycle
     seeds = @sc.mongos_seeds
-    @con = Mongo::ShardedConnection.new(seeds)
-    assert @con.connected?
+    @client = MongoShardedClient.new(seeds)
+    assert @client.connected?
     routers = @sc.servers(:routers)
     while routers.size > 0 do
       rescue_connection_failure do
         probe(seeds.size)
       end
       probe(seeds.size)
-      #p @con.manager.primary
-      router = routers.detect{|r| r.port == @con.manager.primary.last}
+      router = routers.detect{|r| r.port == @client.manager.primary.last}
       routers.delete(router)
       router.stop
     end
     assert_raises Mongo::ConnectionFailure do
       probe(seeds.size)
     end
-    assert_false @con.connected?
+    assert_false @client.connected?
     routers = @sc.servers(:routers).reverse
     routers.each do |r|
       r.start
-      @con.hard_refresh!
-      #p @con.manager.primary
+      @client.hard_refresh!
       rescue_connection_failure do
         probe(seeds.size)
       end
       probe(seeds.size)
     end
-    @con.close
+    @client.close
   end
 
   private
 
   def probe(size)
-    assert_equal(size, @con['config']['mongos'].find.to_a.size)
+    assert_equal(size, @client['config']['mongos'].find.to_a.size)
   end
 
 end