mongo 1.7.1 → 1.8.0

data/test/replica_sets/refresh_test.rb

@@ -1,156 +0,0 @@
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require './test/replica_sets/rs_test_helper'
-require 'benchmark'
-
-class ReplicaSetRefreshTest < Test::Unit::TestCase
-
-  def setup
-    ensure_rs
-  end
-
-  def teardown
-    @rs.restart_killed_nodes
-    @conn.close if defined?(@conn)
-  end
-
-=begin
-  def test_connect_speed
-    Benchmark.bm do |x|
-      x.report("Connect") do
-        10.times do
-          ReplSetConnection.new(build_seeds(3), :refresh_mode => false)
-        end
-      end
-
-      @con = ReplSetConnection.new(build_seeds(3), :refresh_mode => false)
-
-      x.report("manager") do
-        man = Mongo::PoolManager.new(@con, @con.seeds)
-        10.times do
-          man.connect
-        end
-      end
-    end
-  end
-=end
-
-  def test_connect_and_manual_refresh_with_secondaries_down
-    @rs.kill_all_secondaries
-    sleep(4)
-
-    rescue_connection_failure do
-      @conn = ReplSetConnection.new(build_seeds(3), :refresh_mode => false)
-    end
-
-    assert_equal [], @conn.secondaries
-    assert @conn.connected?
-    assert_equal @conn.read_pool, @conn.primary_pool
-
-    # Refresh with no change to set
-    @conn.refresh
-    assert_equal [], @conn.secondaries
-    assert @conn.connected?
-    assert_equal @conn.read_pool, @conn.primary_pool
-
-    @rs.restart_killed_nodes
-    assert_equal [], @conn.secondaries
-    assert @conn.connected?
-    assert_equal @conn.read_pool, @conn.primary_pool
-
-    # Refresh with everything up
-    @conn.refresh
-    assert @conn.read_pool
-    assert @conn.secondaries.length > 0
-  end
-
-  def test_automated_refresh_with_secondaries_down
-    @rs.kill_all_secondaries
-    sleep(4)
-    
-    rescue_connection_failure do
-      @conn = ReplSetConnection.new(build_seeds(3),
-        :refresh_interval => 2, :refresh_mode => :sync, :read => :secondary_preferred)
-    end
-
-    assert_equal [], @conn.secondaries
-    assert @conn.connected?
-    assert_equal @conn.manager.read, @conn.manager.primary
-    old_refresh_version = @conn.refresh_version
-
-    @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.manager.read != @conn.manager.primary,
-      "Read pool and primary pool are identical."
-  end
-  
-  def test_automated_refresh_when_secondary_goes_down
-    @conn = ReplSetConnection.new(build_seeds(3),
-      :refresh_interval => 2, :refresh_mode => :sync)
-
-    num_secondaries = @conn.secondary_pools.length
-    old_refresh_version = @conn.refresh_version
-
-    @rs.kill_secondary
-    sleep(4)
-    @conn['foo']['bar'].find_one
-
-    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.restart_killed_nodes
-  end
-
-  def test_automated_refresh_with_removed_node
-    @conn = ReplSetConnection.new(build_seeds(3),
-      :refresh_interval => 2, :refresh_mode => :sync)
-
-    num_secondaries = @conn.secondary_pools.length
-    old_refresh_version = @conn.refresh_version
-
-    n = @rs.remove_secondary_node
-    sleep(4)
-    @conn['foo']['bar'].find_one
-
-    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)
-  end
-
-  def test_adding_and_removing_nodes
-    @conn = ReplSetConnection.new(build_seeds(3),
-      :refresh_interval => 2, :refresh_mode => :sync)
-
-    @rs.add_node
-    sleep(4)
-    @conn['foo']['bar'].find_one
-
-    @conn2 = ReplSetConnection.new(build_seeds(3),
-      :refresh_interval => 2, :refresh_mode => :sync)
-
-    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
-
-    config = @conn['admin'].command({:ismaster => 1})
-
-    @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
-end

data/test/replica_sets/refresh_with_threads_test.rb

@@ -1,60 +0,0 @@
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require './test/replica_sets/rs_test_helper'
-require 'benchmark'
-
-class ReplicaSetRefreshWithThreadsTest < Test::Unit::TestCase
-
-  def setup
-    ensure_rs
-    @conn = nil
-  end
-
-  def teardown
-    @conn.close if @conn
-  end
-
-  def test_read_write_load_with_added_nodes
-    # MongoDB < 2.0 will disconnect clients on rs.reconfig()
-    return true if @rs.version < "2"
-
-    seeds = build_seeds(3)
-    args = {
-      :refresh_interval => 5,
-      :refresh_mode => :sync,
-      :read => :secondary_preferred
-    }
-    @conn = ReplSetConnection.new(seeds, args)
-    @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
-
-    @rs.add_node
-    threads.each {|t| t.join }
-
-    sleep(1)
-    
-    @conn['admin'].command({:ismaster => 1})
-
-    assert_equal 3, @conn.secondary_pools.length
-    assert_equal 3, @conn.secondaries.length
-  end
-end

data/test/replica_sets/rs_test_helper.rb

@@ -1,39 +0,0 @@
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require File.expand_path("../../test_helper", __FILE__)
-require './test/tools/repl_set_manager'
-
-class Test::Unit::TestCase
-  # Ensure replica set is available as an instance variable and that
-  # a new set is spun up for each TestCase class
-  def ensure_rs(opts={})
-    unless defined?(@@current_class) and @@current_class == self.class
-      @@current_class = self.class 
-      @@rs = ReplSetManager.new(opts)
-      @@rs.start_set
-    end
-    @rs = @@rs
-  end
-
-  # Generic code for rescuing connection failures and retrying operations.
-  # This could be combined with some timeout functionality.
-  def rescue_connection_failure(max_retries=30)
-    retries = 0
-    begin
-      yield
-    rescue Mongo::ConnectionFailure => ex
-      #puts "Rescue attempt #{retries}: from #{ex}"
-      retries += 1
-      raise ex if retries > max_retries
-      sleep(2)
-      retry
-    end
-  end
-  
-  def build_seeds(num_hosts)
-    seeds = []
-    num_hosts.times do |n|
-      seeds << "#{@rs.host}:#{@rs.ports[n]}"
-    end
-    seeds
-  end
-end

data/test/safe_test.rb

@@ -1,68 +0,0 @@
-require File.expand_path("../test_helper", __FILE__)
-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

data/test/sharded_cluster/mongo_config_test.rb

@@ -1,126 +0,0 @@
-$:.unshift(File.expand_path('../../lib', File.dirname(__FILE__))).unshift(File.expand_path('../..', File.dirname(__FILE__)))
-require 'test-unit'
-require 'test/tools/mongo_config'
-
-class MongoConfig < Test::Unit::TestCase
-
-  def self.suite
-    s = super
-    def s.setup
-
-    end
-    def s.teardown
-
-    end
-    def s.run(*args)
-      setup
-      super
-      teardown
-    end
-    s
-  end
-
-  test "config defaults" do
-    [ Mongo::Config::DEFAULT_BASE_OPTS,
-      Mongo::Config::DEFAULT_REPLICA_SET,
-      Mongo::Config::DEFAULT_SHARDED_SIMPLE,
-      Mongo::Config::DEFAULT_SHARDED_REPLICA
-    ].each do |params|
-      config = Mongo::Config.cluster(params)
-      assert(config.size > 0)
-    end
-  end
-
-  test "get available port" do
-    assert_not_nil(Mongo::Config.get_available_port)
-  end
-
-  test "SysProc start" do
-    cmd = "true"
-    sys_proc = Mongo::Config::SysProc.new(cmd)
-    assert_equal(cmd, sys_proc.cmd)
-    assert_nil(sys_proc.pid)
-    assert_not_nil(sys_proc.start(0))
-    assert_not_nil(sys_proc.pid)
-  end
-
-  test "SysProc wait" do
-    sys_proc = Mongo::Config::SysProc.new("true")
-    assert_not_nil(sys_proc.start(0))
-    assert(sys_proc.running?)
-    sys_proc.wait
-    assert(!sys_proc.running?)
-  end
-
-  test "SysProc kill" do
-    sys_proc = Mongo::Config::SysProc.new("true")
-    assert_not_nil(sys_proc.start(0))
-    sys_proc.kill
-    sys_proc.wait
-    assert(!sys_proc.running?)
-  end
-
-  test "SysProc stop" do
-    sys_proc = Mongo::Config::SysProc.new("true")
-    assert_not_nil(sys_proc.start(0))
-    sys_proc.stop
-    assert(!sys_proc.running?)
-  end
-
-  test "Server" do
-    server = Mongo::Config::Server.new('a cmd', 'host', 1234)
-    assert_equal('a cmd', server.cmd)
-    assert_equal('host', server.host)
-    assert_equal(1234, server.port)
-  end
-
-  test "DbServer" do
-    config = Mongo::Config::DEFAULT_BASE_OPTS
-    server = Mongo::Config::DbServer.new(config)
-    assert_equal(config, server.config)
-    assert_equal("mongod --logpath data/log --dbpath data", server.cmd)
-    assert_equal(config[:host], server.host)
-    assert_equal(config[:port], server.port)
-  end
-
-  def cluster_test(opts)
-    #debug 1, opts.inspect
-    config =  Mongo::Config.cluster(opts)
-    #debug 1, config.inspect
-    manager = Mongo::Config::ClusterManager.new(config)
-    assert_equal(config, manager.config)
-    manager.start
-    manager.servers.each{|s| p s}
-    manager.stop
-    manager.servers.each{|s| assert_equal(false, s.running?)}
-    manager.clobber
-  end
-
-  test "cluster manager base" do
-    #cluster_test(Mongo::Config::DEFAULT_BASE_OPTS)
-  end
-
-  test "cluster manager replica set" do
-    #cluster_test(Mongo::Config::DEFAULT_REPLICA_SET)
-  end
-
-  test "cluster manager sharded simple" do
-    #manager = Mongo::Config::ClusterManager.new(Mongo::Config.cluster(Mongo::Config::DEFAULT_SHARDED_SIMPLE)).start
-    opts = Mongo::Config::DEFAULT_SHARDED_SIMPLE
-    #debug 1, opts.inspect
-    config =  Mongo::Config.cluster(opts)
-    #debug 1, config.inspect
-    manager = Mongo::Config::ClusterManager.new(config)
-    assert_equal(config, manager.config)
-    manager.start
-    #debug 1, manager.ismaster
-    #debug 1, manager.mongos_discover
-    manager.stop.clobber
-  end
-
-  test "cluster manager sharded replica" do
-    #cluster_test(Mongo::Config::DEFAULT_SHARDED_REPLICA)
-  end
-
-end
-