mongo 1.3.0 → 1.12.5

data/test/replica_sets/connect_test.rb

@@ -1,94 +0,0 @@
-$:.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 ConnectTest < Test::Unit::TestCase
-  include Mongo
-
-  def setup
-    RS.restart_killed_nodes
-  end
-
-  def teardown
-    RS.restart_killed_nodes
-  end
-
-  def test_connect_with_deprecated_multi
-    @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
-      ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
-        [RS.host, RS.ports[2]], :rs_name => RS.name + "-wrong")
-    end
-  end
-
-  def test_connect
-    @conn = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
-      [RS.host, RS.ports[2]], :name => RS.name)
-    assert @conn.connected?
-    assert @conn.read_primary?
-    assert @conn.primary?
-
-    assert_equal RS.primary, @conn.primary
-    assert_equal RS.secondaries.sort, @conn.secondaries.sort
-    assert_equal RS.arbiters.sort, @conn.arbiters.sort
-  end
-
-  def test_host_port_accessors
-    @conn = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
-      [RS.host, RS.ports[2]], :name => RS.name)
-
-    assert_equal @conn.host, RS.primary[0]
-    assert_equal @conn.port, RS.primary[1]
-  end
-
-  def test_connect_with_primary_node_killed
-    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([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
-        [RS.host, RS.ports[2]])
-    end
-
-    # This allows the secondary to come up as a primary
-    rescue_connection_failure do
-      @conn = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
-        [RS.host, RS.ports[2]])
-    end
-    assert @conn.connected?
-  end
-
-  def test_connect_with_secondary_node_killed
-    node = RS.kill_secondary
-
-    @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_third_node_killed
-    RS.kill(RS.get_node_from_port(RS.ports[2]))
-
-    @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_primary_stepped_down
-    RS.step_down_primary
-
-    rescue_connection_failure do
-      @conn = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
-        [RS.host, RS.ports[2]])
-    end
-    assert @conn.connected?
-  end
-
-end

data/test/replica_sets/connection_string_test.rb

@@ -1,32 +0,0 @@
-$:.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

@@ -1,35 +0,0 @@
-$:.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

@@ -1,53 +0,0 @@
-$:.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

@@ -1,55 +0,0 @@
-$:.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

@@ -1,96 +0,0 @@
-$:.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

@@ -1,51 +0,0 @@
-$:.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

@@ -1,66 +0,0 @@
-$:.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

@@ -1,27 +0,0 @@
-$:.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

@@ -1,68 +0,0 @@
-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