mongo 1.4.0 → 1.5.0.rc0

data/test/replica_sets/insert_test.rb

@@ -1,27 +1,26 @@
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 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 ReplicaSetInsertTest < Test::Unit::TestCase
-  include Mongo
+  include ReplicaSetTest
 
   def setup
-    @conn = ReplSetConnection.new([TEST_HOST, RS.ports[0]], [TEST_HOST, RS.ports[1]], [TEST_HOST, RS.ports[2]])
+    @conn = ReplSetConnection.new([TEST_HOST, self.rs.ports[0]],
+                                  [TEST_HOST, self.rs.ports[1]], [TEST_HOST, self.rs.ports[2]])
     @db = @conn.db(MONGO_TEST_DB)
     @db.drop_collection("test-sets")
     @coll = @db.collection("test-sets")
   end
 
   def teardown
-    RS.restart_killed_nodes
+    self.rs.restart_killed_nodes
     @conn.close if @conn
   end
 
   def test_insert
     @coll.save({:a => 20}, :safe => true)
 
-    RS.kill_primary
+    self.rs.kill_primary
 
     rescue_connection_failure do
       @coll.save({:a => 30}, :safe => true)
@@ -33,7 +32,7 @@ class ReplicaSetInsertTest < Test::Unit::TestCase
     @coll.save({:a => 70}, :safe => true)
 
     # Restart the old master and wait for sync
-    RS.restart_killed_nodes
+    self.rs.restart_killed_nodes
     sleep(1)
     results = []
 

data/test/replica_sets/query_test.rb

@@ -1,20 +1,18 @@
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 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 ReplicaSetQueryTest < Test::Unit::TestCase
-  include Mongo
+  include ReplicaSetTest
 
   def setup
-    @conn = ReplSetConnection.new([RS.host, RS.ports[0], RS.ports[1]])
+    @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0], self.rs.ports[1]])
     @db = @conn.db(MONGO_TEST_DB)
     @db.drop_collection("test-sets")
     @coll = @db.collection("test-sets")
   end
 
   def teardown
-    RS.restart_killed_nodes
+    self.rs.restart_killed_nodes
     @conn.close if @conn
   end
 
@@ -30,7 +28,7 @@ class ReplicaSetQueryTest < Test::Unit::TestCase
 
     puts "Benchmark before failover: #{benchmark_queries}"
 
-    RS.kill_primary
+    self.rs.kill_primary
 
     results = []
     rescue_connection_failure do

data/test/replica_sets/read_preference_test.rb

@@ -1,15 +1,119 @@
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require './test/replica_sets/rs_test_helper'
+require 'logger'
 
-# TODO: enable this once we enable reads from tags.
 class ReadPreferenceTest < Test::Unit::TestCase
-  include Mongo
+  include ReplicaSetTest
 
-  #def setup
-  #  @conn = ReplSetConnection.new([RS.host, RS.ports[0], RS.host, RS.ports[1]], :read => :secondary, :pool_size => 50)
-  #  @db = @conn.db(MONGO_TEST_DB)
-  #  @db.drop_collection("test-sets")
-  #end
+  def setup
+    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)
+    @db = @conn.db(MONGO_TEST_DB)
+    @db.drop_collection("test-sets")
+    col = @db['mongo-test']
+  end
+
+  def teardown
+    self.rs.restart_killed_nodes
+  end
+
+  def test_read_primary
+    rescue_connection_failure do
+      assert !@conn.read_primary?
+      assert !@conn.primary?
+    end
+  end
+
+  def test_con
+    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 at the same!"
+  end
+
+  def test_query_secondaries
+    @secondary = Connection.new(self.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})
+    @coll.save({:a => 40})
+    results = []
+    queries_before = @secondary['admin'].command({:serverStatus => 1})['opcounters']['query']
+    @coll.find.each {|r| results << r["a"]}
+    queries_after = @secondary['admin'].command({:serverStatus => 1})['opcounters']['query']
+    assert_equal 1, queries_after - queries_before
+    assert results.include?(20)
+    assert results.include?(30)
+    assert results.include?(40)
+
+    self.rs.kill_primary
+
+    results = []
+    rescue_connection_failure do
+      puts "@coll.find().each"
+      @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
+
+  def test_kill_primary
+    @coll = @db.collection("test-sets", :safe => {:w => 3, :wtimeout => 10000})
+    @coll.save({:a => 20})
+    @coll.save({:a => 30})
+    assert_equal 2, @coll.find.to_a.length
+
+    # Should still be able to read immediately after killing master node
+    self.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
+    @coll.save({:a => 50}, :safe => {:w => 2, :wtimeout => 10000})
+    assert_equal 4, @coll.find.to_a.length
+  end
+
+  def test_kill_secondary
+    @coll = @db.collection("test-sets", {:safe => {:w => 3, :wtimeout => 20000}})
+    @coll.save({:a => 20})
+    @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)
+
+    # Should fail immediately on next read
+    old_read_pool_port = @conn.read_pool.port
+    assert_raise ConnectionFailure do
+      @coll.find.to_a.length
+    end
+
+    # Should eventually reconnect and be able to read
+    rescue_connection_failure do
+      length = @coll.find.to_a.length
+      assert_equal 2, length
+    end
+    new_read_pool_port = @conn.read_pool.port
+    assert old_read_pool_port != new_read_pool_port
+  end
+
+  def test_write_lots_of_data
+    @coll = @db.collection("test-sets", {:safe => {:w => 2}})
+
+    6000.times do |n|
+      @coll.save({:a => n})
+    end
+
+    cursor = @coll.find()
+    cursor.next
+    cursor.close
+  end
 
   # TODO: enable this once we enable reads from tags.
   # def test_query_tagged
@@ -37,7 +141,7 @@ class ReadPreferenceTest < Test::Unit::TestCase
   # end
 
   #def teardown
-  #  RS.restart_killed_nodes
+  #  self.rs.restart_killed_nodes
   #end
 
 end

data/test/replica_sets/refresh_test.rb

@@ -2,16 +2,15 @@ $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require './test/replica_sets/rs_test_helper'
 require 'benchmark'
 
-# on ports TEST_PORT, RS.ports[1], and TEST + 2.
 class ReplicaSetRefreshTest < Test::Unit::TestCase
-  include Mongo
+  include ReplicaSetTest
 
   def setup
     @conn = nil
   end
 
   def teardown
-    RS.restart_killed_nodes
+    self.rs.restart_killed_nodes
     @conn.close if @conn
   end
 
@@ -19,13 +18,17 @@ class ReplicaSetRefreshTest < Test::Unit::TestCase
     Benchmark.bm do |x|
       x.report("Connect") do
         10.times do
-          ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
-            [RS.host, RS.ports[2]], :background_refresh => false)
+          ReplSetConnection.new([self.rs.host, self.rs.ports[0]],
+                                [self.rs.host, self.rs.ports[1]],
+                                [self.rs.host, self.rs.ports[2]],
+                                :refresh_mode => false)
         end
       end
 
-          @con = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
-            [RS.host, RS.ports[2]], :background_refresh => false)
+          @con = ReplSetConnection.new([self.rs.host, self.rs.ports[0]],
+                                       [self.rs.host, self.rs.ports[1]],
+                                       [self.rs.host, self.rs.ports[2]],
+                                       :refresh_mode => false)
 
       x.report("manager") do
         man = Mongo::PoolManager.new(@con, @con.seeds)
@@ -37,11 +40,13 @@ class ReplicaSetRefreshTest < Test::Unit::TestCase
   end
 
   def test_connect_and_manual_refresh_with_secondaries_down
-    RS.kill_all_secondaries
+    self.rs.kill_all_secondaries
 
     rescue_connection_failure do
-      @conn = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
-        [RS.host, RS.ports[2]], :background_refresh => false)
+      @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]],
+                                    [self.rs.host, self.rs.ports[1]],
+                                    [self.rs.host, self.rs.ports[2]],
+                                    :refresh_mode => false)
     end
 
     assert_equal [], @conn.secondaries
@@ -54,7 +59,7 @@ class ReplicaSetRefreshTest < Test::Unit::TestCase
     assert @conn.connected?
     assert_equal @conn.read_pool, @conn.primary_pool
 
-    RS.restart_killed_nodes
+    self.rs.restart_killed_nodes
     assert_equal [], @conn.secondaries
     assert @conn.connected?
     assert_equal @conn.read_pool, @conn.primary_pool
@@ -66,57 +71,82 @@ class ReplicaSetRefreshTest < Test::Unit::TestCase
   end
 
   def test_automated_refresh_with_secondaries_down
-    RS.kill_all_secondaries
+    self.rs.kill_all_secondaries
 
     rescue_connection_failure do
-      @conn = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
-        [RS.host, RS.ports[2]], :refresh_interval => 2, :background_refresh => true)
+      @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]],
+                                    [self.rs.host, self.rs.ports[1]],
+                                    [self.rs.host, self.rs.ports[2]],
+                                    :refresh_interval => 2,
+                                    :refresh_mode => :sync)
     end
 
     assert_equal [], @conn.secondaries
     assert @conn.connected?
     assert_equal @conn.read_pool, @conn.primary_pool
+    old_refresh_version = @conn.refresh_version
 
-    RS.restart_killed_nodes
-
-    sleep(3)
-
-    assert @conn.read_pool != @conn.primary_pool, "Read pool and primary pool are identical."
-    assert @conn.secondaries.length > 0, "No secondaries have been added."
+    self.rs.restart_killed_nodes
+    sleep(4)
+    @conn['foo']['bar'].find_one
+    @conn['foo']['bar'].insert({:a => 1})
+
+    assert @conn.refresh_version > old_refresh_version,
+      "Refresh version hasn't changed."
+    assert @conn.secondaries.length > 0,
+      "No secondaries have been added."
+    assert @conn.read_pool != @conn.primary_pool,
+      "Read pool and primary pool are identical."
   end
 
   def test_automated_refresh_with_removed_node
-    @conn = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
-      [RS.host, RS.ports[2]], :refresh_interval => 2, :background_refresh => true)
+    @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]],
+                                  [self.rs.host, self.rs.ports[1]],
+                                  [self.rs.host, self.rs.ports[2]],
+                                  :refresh_interval => 2,
+                                  :refresh_mode => :sync)
 
-    assert_equal 2, @conn.secondary_pools.length
-    assert_equal 2, @conn.secondaries.length
+    num_secondaries = @conn.secondary_pools.length
+    old_refresh_version = @conn.refresh_version
 
-    n = RS.remove_secondary_node
+    n = self.rs.remove_secondary_node
     sleep(4)
+    @conn['foo']['bar'].find_one
 
-    assert_equal 1, @conn.secondaries.length
-    assert_equal 1, @conn.secondary_pools.length
+    assert @conn.refresh_version > old_refresh_version,
+      "Refresh version hasn't changed."
+    assert_equal num_secondaries - 1, @conn.secondaries.length
+    assert_equal num_secondaries - 1, @conn.secondary_pools.length
 
-    RS.add_node(n)
+    self.rs.add_node(n)
   end
 
   def test_adding_and_removing_nodes
-    @conn = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
-      [RS.host, RS.ports[2]], :refresh_interval => 2, :background_refresh => true)
+    @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]],
+                                  [self.rs.host, self.rs.ports[1]],
+                                  [self.rs.host, self.rs.ports[2]],
+                                  :refresh_interval => 2, :refresh_mode => :sync)
 
-    RS.add_node
-    sleep(5)
+    self.rs.add_node
+    sleep(4)
+    @conn['foo']['bar'].find_one
 
-    @conn2 = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
-      [RS.host, RS.ports[2]], :refresh_interval => 2, :background_refresh => true)
+    @conn2 = ReplSetConnection.new([self.rs.host, self.rs.ports[0]],
+                                   [self.rs.host, self.rs.ports[1]],
+                                   [self.rs.host, self.rs.ports[2]],
+                                   :refresh_interval => 2, :refresh_mode => :sync)
 
-    assert @conn2.secondaries == @conn.secondaries
+    assert @conn2.secondaries.sort == @conn.secondaries.sort,
+      "Second connection secondaries not equal to first."
     assert_equal 3, @conn.secondary_pools.length
     assert_equal 3, @conn.secondaries.length
 
-    RS.remove_secondary_node
+    config = @conn['admin'].command({:ismaster => 1})
+
+    self.rs.remove_secondary_node
     sleep(4)
+    config = @conn['admin'].command({:ismaster => 1})
+
     assert_equal 2, @conn.secondary_pools.length
     assert_equal 2, @conn.secondaries.length
   end

data/test/replica_sets/refresh_with_threads_test.rb

@@ -0,0 +1,55 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require './test/replica_sets/rs_test_helper'
+require 'benchmark'
+
+class ReplicaSetRefreshWithThreadsTest < Test::Unit::TestCase
+  include ReplicaSetTest
+
+  def setup
+    @conn = nil
+  end
+
+  def teardown
+    self.rs.restart_killed_nodes
+    @conn.close if @conn
+  end
+
+  def test_read_write_load_with_added_nodes
+    @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]],
+                                  [self.rs.host, self.rs.ports[1]],
+                                  [self.rs.host, self.rs.ports[2]],
+                                  :refresh_interval => 5,
+                                  :refresh_mode => :sync,
+                                  :read => :secondary)
+    @duplicate = @conn[MONGO_TEST_DB]['duplicate']
+    @unique    = @conn[MONGO_TEST_DB]['unique']
+    @duplicate.insert("test" => "insert")
+    @duplicate.insert("test" => "update")
+    @unique.insert("test" => "insert")
+    @unique.insert("test" => "update")
+    @unique.create_index("test", :unique => true)
+
+    threads = []
+    10.times do
+      threads << Thread.new do
+        1000.times do |i|
+          if i % 2 == 0
+            assert_raise Mongo::OperationFailure do
+              @unique.insert({"test" => "insert"}, :safe => true)
+            end
+          else
+            @duplicate.insert({"test" => "insert"}, :safe => true)
+          end
+        end
+      end
+    end
+
+    self.rs.add_node
+    threads.each {|t| t.join }
+
+    config = @conn['admin'].command({:ismaster => 1})
+
+    assert_equal 3, @conn.secondary_pools.length
+    assert_equal 3, @conn.secondaries.length
+  end
+end

data/test/replica_sets/replication_ack_test.rb

@@ -1,14 +1,11 @@
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require './test/replica_sets/rs_test_helper'
 
-# NOTE: This test expects a replica set of three nodes to be running on local host.
 class ReplicaSetAckTest < Test::Unit::TestCase
-  include Mongo
+  include ReplicaSetTest
 
   def setup
-    RS.ensure_up
-
-    @conn = ReplSetConnection.new([RS.host, RS.ports[0]])
+    @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]])
 
     @slave1 = Connection.new(@conn.secondary_pools[0].host,
       @conn.secondary_pools[0].port, :slave_ok => true)
@@ -21,7 +18,7 @@ class ReplicaSetAckTest < Test::Unit::TestCase
   end
 
   def teardown
-    RS.restart_killed_nodes
+    self.rs.restart_killed_nodes
     @conn.close if @conn
   end