mongo-lyon 1.2.4

data/test/replica_sets/connection_string_test.rb

@@ -0,0 +1,32 @@
+$:.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 RS.host,
+# on ports TEST_PORT, RS.ports[1], and TEST + 2.
+class ConnectionStringTest < Test::Unit::TestCase
+  include Mongo
+
+  def setup
+    RS.restart_killed_nodes
+  end
+
+  def teardown
+    RS.restart_killed_nodes
+  end
+
+  def test_connect_with_connection_string
+    @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_full_connection_string
+    @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]
+    assert @conn.safe[:fsync]
+    assert @conn.read_pool
+  end
+
+end

data/test/replica_sets/count_test.rb

@@ -0,0 +1,35 @@
+$:.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 ReplicaSetCountTest < Test::Unit::TestCase
+  include Mongo
+
+  def setup
+    @conn = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]], [RS.host, 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
+  end
+
+  def test_correct_count_after_insertion_reconnect
+    @coll.insert({:a => 20}, :safe => {:w => 2, :wtimeout => 10000})
+    assert_equal 1, @coll.count
+
+    # Kill the current master node
+    @node = RS.kill_primary
+
+    rescue_connection_failure do
+      @coll.insert({:a => 30}, :safe => true)
+    end
+
+    @coll.insert({:a => 40}, :safe => true)
+    assert_equal 3, @coll.count, "Second count failed"
+  end
+
+end

data/test/replica_sets/insert_test.rb

@@ -0,0 +1,53 @@
+$:.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
+
+  def setup
+    @conn = ReplSetConnection.new([TEST_HOST, RS.ports[0]], [TEST_HOST, RS.ports[1]], [TEST_HOST, 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
+  end
+
+  def test_insert
+    @coll.save({:a => 20}, :safe => true)
+
+    RS.kill_primary
+
+    rescue_connection_failure do
+      @coll.save({:a => 30}, :safe => true)
+    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)
+
+    # Restart the old master and wait for sync
+    RS.restart_killed_nodes
+    sleep(1)
+    results = []
+
+    rescue_connection_failure do
+      @coll.find.each {|r| results << r}
+      [20, 30, 40, 50, 60, 70].each do |a|
+        assert results.any? {|r| r['a'] == a}, "Could not find record for a => #{a}"
+      end
+    end
+
+    @coll.save({:a => 80}, :safe => true)
+    @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"
+    end
+  end
+
+end

data/test/replica_sets/pooled_insert_test.rb

@@ -0,0 +1,55 @@
+$:.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 ReplicaSetPooledInsertTest < Test::Unit::TestCase
+  include Mongo
+
+  def setup
+    @conn = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
+      [RS.host, RS.ports[2]], :pool_size => 10, :timeout => 5)
+    @db = @conn.db(MONGO_TEST_DB)
+    @db.drop_collection("test-sets")
+    @coll = @db.collection("test-sets")
+  end
+
+  def teardown
+    RS.restart_killed_nodes
+  end
+
+  def test_insert
+    expected_results = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    @coll.save({:a => -1}, :safe => true)
+
+    RS.kill_primary
+
+    threads = []
+    10.times do |i|
+      threads[i] = Thread.new do
+        rescue_connection_failure do
+          @coll.save({:a => i}, :safe => true)
+        end
+      end
+    end
+
+    # Restart the old master and wait for sync
+    RS.restart_killed_nodes
+    sleep(1)
+    results = []
+
+    rescue_connection_failure do
+      @coll.find.each {|r| results << r}
+      expected_results.each do |a|
+        assert results.any? {|r| r['a'] == a}, "Could not find record for a => #{a}"
+      end
+    end
+
+    @coll.save({:a => 10}, :safe => true)
+    @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"
+    end
+  end
+
+end

data/test/replica_sets/query_secondaries.rb

@@ -0,0 +1,96 @@
+$:.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 ReplicaSetQuerySecondariesTest < Test::Unit::TestCase
+  include Mongo
+
+  def setup
+    @conn = ReplSetConnection.new([RS.host, RS.ports[0]], :read_secondary => true)
+    @db = @conn.db(MONGO_TEST_DB)
+    @db.drop_collection("test-sets")
+  end
+
+  def teardown
+    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
+    @coll = @db.collection("test-sets", :safe => {:w => 3, :wtimeout => 10000})
+    @coll.save({:a => 20})
+    @coll.save({:a => 30})
+    @coll.save({:a => 40})
+    results = []
+    @coll.find.each {|r| results << r["a"]}
+    assert results.include?(20)
+    assert results.include?(30)
+    assert results.include?(40)
+
+    RS.kill_primary
+
+    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
+
+  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
+    RS.kill_primary
+    assert_equal 2, @coll.find.to_a.length
+    rescue_connection_failure do
+      @coll.save({:a => 50}, :safe => {:w => 2, :wtimeout => 10000})
+    end
+    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 => 10000}})
+    @coll.save({:a => 20})
+    @coll.save({:a => 30})
+    assert_equal 2, @coll.find.to_a.length
+
+    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
+    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 != new_read_pool
+  end
+
+end

data/test/replica_sets/query_test.rb

@@ -0,0 +1,51 @@
+$:.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
+
+  def setup
+    @conn = ReplSetConnection.new([RS.host, RS.ports[0]])
+    @db = @conn.db(MONGO_TEST_DB)
+    @db.drop_collection("test-sets")
+    @coll = @db.collection("test-sets")
+  end
+
+  def teardown
+    RS.restart_killed_nodes
+  end
+
+  def test_query
+    @coll.save({:a => 20}, :safe => {:w => 3})
+    @coll.save({:a => 30}, :safe => {:w => 3})
+    @coll.save({:a => 40}, :safe => {: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
+
+    puts "Benchmark before failover: #{benchmark_queries}"
+
+    RS.kill_primary
+
+    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
+
+    puts "Benchmark after failover: #{benchmark_queries}"
+    end
+  end
+
+  def benchmark_queries
+    t1 = Time.now
+    10000.times { @coll.find_one }
+    Time.now - t1
+  end
+
+end

data/test/replica_sets/replication_ack_test.rb

@@ -0,0 +1,66 @@
+$:.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
+
+  def setup
+    RS.ensure_up
+
+    @conn = ReplSetConnection.new([RS.host, RS.ports[0]])
+
+    @slave1 = Connection.new(@conn.secondary_pools[0].host,
+      @conn.secondary_pools[0].port, :slave_ok => true)
+
+    assert !@slave1.read_primary?
+
+    @db = @conn.db(MONGO_TEST_DB)
+    @db.drop_collection("test-sets")
+    @col = @db.collection("test-sets")
+  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})
+    end
+    assert_raise_error OperationFailure, "timeout" do
+      @col.update({:foo => 1}, {:foo => 2}, :safe => {:w => 4, :wtimeout => 1, :fsync => true})
+    end
+    assert_raise_error OperationFailure, "timeout" do
+      @col.remove({:foo => 2}, :safe => {:w => 4, :wtimeout => 1, :fsync => true})
+    end
+  end
+
+  def test_safe_mode_replication_ack
+    @col.insert({:baz => "bar"}, :safe => {:w => 2, :wtimeout => 5000})
+
+    assert @col.insert({:foo => "0" * 5000}, :safe => {:w => 2, :wtimeout => 5000})
+    assert_equal 2, @slave1[MONGO_TEST_DB]["test-sets"].count
+
+    assert @col.update({:baz => "bar"}, {:baz => "foo"}, :safe => {:w => 2, :wtimeout => 5000})
+    assert @slave1[MONGO_TEST_DB]["test-sets"].find_one({:baz => "foo"})
+
+    assert @col.remove({}, :safe => {:w => 2, :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)
+    assert response['ok'] == 1
+    assert response['lastOp']
+
+    @col.update({}, {:baz => "foo"}, :multi => true)
+    response = @db.get_last_error(:w => 2, :wtimeout => 5000)
+    assert response['ok'] == 1
+    assert response['lastOp']
+
+    @col.remove({})
+    response =  @db.get_last_error(:w => 2, :wtimeout => 5000)
+    assert response['ok'] == 1
+    assert response['n'] == 20
+    assert response['lastOp']
+  end
+
+end

data/test/replica_sets/rs_test_helper.rb

@@ -0,0 +1,27 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require './test/test_helper'
+require './test/tools/repl_set_manager'
+
+unless defined? RS
+  RS = ReplSetManager.new
+  RS.start_set
+end
+
+class Test::Unit::TestCase
+
+  # Generic code for rescuing connection failures and retrying operations.
+  # This could be combined with some timeout functionality.
+  def rescue_connection_failure(max_retries=60)
+    retries = 0
+    begin
+      yield
+    rescue Mongo::ConnectionFailure => ex
+      puts "Rescue attempt #{retries}: from #{ex}"
+      retries += 1
+      raise ex if retries > max_retries
+      sleep(1)
+      retry
+    end
+  end
+
+end

data/test/safe_test.rb

@@ -0,0 +1,68 @@
+require './test/test_helper'
+include Mongo
+
+class SafeTest < Test::Unit::TestCase
+  context "Safe mode propogation: " do
+    setup do
+      @con = standard_connection(:safe => {:w => 1})
+      @db  = @con[MONGO_TEST_DB]
+      @col = @db['test-safe']
+      @col.create_index([[:a, 1]], :unique => true)
+      @col.remove
+    end
+
+    should "propogate safe option on insert" do
+      @col.insert({:a => 1})
+
+      assert_raise_error(OperationFailure, "duplicate key") do
+        @col.insert({:a => 1})
+      end
+    end
+
+    should "allow safe override on insert" do
+      @col.insert({:a => 1})
+      @col.insert({:a => 1}, :safe => false)
+    end
+
+    should "propogate safe option on update" do
+      @col.insert({:a => 1})
+      @col.insert({:a => 2})
+
+      assert_raise_error(OperationFailure, "duplicate key") do
+        @col.update({:a => 2}, {:a => 1})
+      end
+    end
+
+    should "allow safe override on update" do
+      @col.insert({:a => 1})
+      @col.insert({:a => 2})
+      @col.update({:a => 2}, {:a => 1}, :safe => false)
+    end
+  end
+
+  context "Safe error objects" do
+    setup do
+      @con = standard_connection
+      @db  = @con[MONGO_TEST_DB]
+      @col = @db['test']
+      @col.remove
+      @col.insert({:a => 1})
+      @col.insert({:a => 1})
+      @col.insert({:a => 1})
+    end
+
+    should "return object on update" do
+      response = @col.update({:a => 1}, {"$set" => {:a => 2}},
+                             :multi => true, :safe => true)
+
+      assert response['updatedExisting']
+      assert_equal 3, response['n']
+    end
+
+    should "return object on remove" do
+      response = @col.remove({}, :safe => true)
+      assert_equal 3, response['n']
+    end
+  end
+
+end