mongo 1.12.5 → 2.0.0.beta

data/test/replica_set/refresh_test.rb

@@ -1,211 +0,0 @@
-# Copyright (C) 2009-2013 MongoDB, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'test_helper'
-
-class ReplicaSetRefreshTest < Test::Unit::TestCase
-
-  def setup
-    ensure_cluster(:rs)
-  end
-
-  def test_connect_and_manual_refresh_with_secondary_down
-    num_secondaries = @rs.secondaries.size
-    client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :refresh_mode => false,
-                                       :op_timeout => TEST_OP_TIMEOUT)
-    authenticate_client(client)
-
-    assert_equal num_secondaries, client.secondaries.size
-    assert client.connected?
-    assert_equal client.read_pool, client.primary_pool
-    old_refresh_version = client.refresh_version
-
-    @rs.stop_secondary
-
-    client.refresh
-    assert_equal num_secondaries - 1, client.secondaries.size
-    assert client.connected?
-    assert_equal client.read_pool, client.primary_pool
-    assert client.refresh_version > old_refresh_version
-    old_refresh_version = client.refresh_version
-
-    # Test no changes after restart until manual refresh
-    @rs.restart
-    assert_equal num_secondaries - 1, client.secondaries.size
-    assert client.connected?
-    assert_equal client.read_pool, client.primary_pool
-    assert_equal client.refresh_version, old_refresh_version
-
-    # Refresh and ensure state
-    client.refresh
-    assert_equal num_secondaries, client.secondaries.size
-    assert client.connected?
-    assert_equal client.read_pool, client.primary_pool
-    assert client.refresh_version > old_refresh_version
-  end
-
-  def test_automated_refresh_with_secondary_down
-    num_secondaries = @rs.secondaries.size
-    client = MongoReplicaSetClient.new(@rs.repl_set_seeds,
-      :refresh_interval => 1, :refresh_mode => :sync, :read => :secondary_preferred,
-      :op_timeout => TEST_OP_TIMEOUT)
-    authenticate_client(client)
-
-    # Ensure secondaries are all recognized by client and client is connected
-    assert_equal num_secondaries, client.secondaries.size
-    assert client.connected?
-    assert client.secondary_pools.include?(client.read_pool)
-    pool = client.read_pool
-
-    @rs.member_by_name(pool.host_string).stop
-    sleep(2)
-
-    old_refresh_version = client.refresh_version
-    # Trigger synchronous refresh
-    client[TEST_DB]['rs-refresh-test'].find_one
-
-    assert client.connected?
-    assert client.refresh_version > old_refresh_version
-    assert_equal num_secondaries - 1, client.secondaries.size
-    assert client.secondary_pools.include?(client.read_pool)
-    assert_not_equal pool, client.read_pool
-
-    # Restart nodes and ensure refresh interval has passed
-    @rs.restart
-    sleep(2)
-
-    old_refresh_version = client.refresh_version
-    # Trigger synchronous refresh
-    client[TEST_DB]['rs-refresh-test'].find_one
-
-    assert client.connected?
-    assert client.refresh_version > old_refresh_version,
-      "Refresh version hasn't changed."
-    assert_equal num_secondaries, client.secondaries.size
-      "No secondaries have been added."
-    assert_equal num_secondaries, client.secondary_pools.size
-  end
-
-  def test_concurrent_refreshes
-    factor = 5
-    nthreads = factor * 10
-    threads = []
-    client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :refresh_mode => :sync,
-                                       :refresh_interval => 1, :op_timeout => TEST_OP_TIMEOUT)
-    authenticate_client(client)
-
-    nthreads.times do |i|
-      threads << Thread.new do
-        # force a connection failure every couple of threads that causes a refresh
-        if i % factor == 0
-          cursor = client[TEST_DB]['rs-refresh-test'].find
-          cursor.stubs(:checkout_socket_from_connection).raises(ConnectionFailure)
-          begin
-            cursor.next
-          rescue => ex
-            raise ex unless ex.class == ConnectionFailure
-            next
-          end
-        else
-          # synchronous refreshes will happen every couple of find_ones
-          cursor = client[TEST_DB]['rs-refresh-test'].find_one
-        end
-      end
-    end
-
-    threads.each do |t|
-      t.join
-    end
-  end
-
-  def test_manager_recursive_locking
-  # See RUBY-775
-  # This tests that there isn't recursive locking when a pool manager reconnects
-  # to all replica set members. The bug in RUBY-775 occurred because the same lock
-  # acquired in order to connect the pool manager was used to read the pool manager's
-  # state.
-    client = MongoReplicaSetClient.from_uri(@uri)
-
-    cursor = client[TEST_DB]['rs-refresh-test'].find
-    client.stubs(:receive_message).raises(ConnectionFailure)
-    client.manager.stubs(:refresh_required?).returns(true)
-    client.manager.stubs(:check_connection_health).returns(true)
-    assert_raise ConnectionFailure do
-       cursor.next
-    end
-  end
-
-  def test_ping_with_op_timeout
-    [nil, 10].each do |op_timeout|
-      client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :op_timeout => op_timeout)
-      pool = client.primary_pool
-      admin_db = pool.client['admin']
-      admin_db.expects(:command).with({:ping => 1}, :socket => pool.node.socket,
-                                      :timeout => op_timeout || MongoClient::DEFAULT_OP_TIMEOUT).returns({'ok' => 1})
-      client.expects(:[]).with('admin').returns(admin_db)
-      assert pool.ping
-    end
-  end
-
-=begin
-  def test_automated_refresh_with_removed_node
-    client = MongoReplicaSetClient.new(@rs.repl_set_seeds,
-      :refresh_interval => 1, :refresh_mode => :sync)
-    authenticate_client(client)
-
-    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[TEST_DB]['rs-refresh-test'].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[TEST_DB]['rs-refresh-test'].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_set/replication_ack_test.rb

@@ -1,95 +0,0 @@
-# Copyright (C) 2009-2013 MongoDB, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'test_helper'
-
-class ReplicaSetAckTest < Test::Unit::TestCase
-
-  def setup
-    ensure_cluster(:rs)
-    @client = MongoReplicaSetClient.from_uri(@uri, :op_timeout => TEST_OP_TIMEOUT)
-
-    @slave1 = MongoClient.new(
-      @client.secondary_pools.first.host,
-      @client.secondary_pools.first.port, :slave_ok => true)
-    authenticate_client(@slave1)
-
-    assert !@slave1.read_primary?
-
-    @db = @client.db(TEST_DB)
-    @db.drop_collection("test-sets")
-    @col = @db.collection("test-sets")
-  end
-
-  def teardown
-    @client.close if @client
-  end
-
-  def test_safe_mode_with_w_failure
-    assert_raise_error WriteConcernError do
-      @col.insert({:foo => 1}, :w => 4, :wtimeout => 1, :fsync => true)
-    end
-    assert_raise_error WriteConcernError do
-      @col.update({:foo => 1}, {:foo => 2}, :w => 4, :wtimeout => 1, :fsync => true)
-    end
-    assert_raise_error WriteConcernError do
-      @col.remove({:foo => 2}, :w => 4, :wtimeout => 1, :fsync => true)
-    end
-    if @client.server_version >= '2.5.4'
-      assert_raise_error WriteConcernError do
-        @col.insert({:foo => 3}, :w => "test-tag")
-      end
-    else # indistinguishable "errmsg"=>"exception: unrecognized getLastError mode: test-tag"
-      assert_raise_error OperationFailure do
-        @col.insert({:foo => 3}, :w => "test-tag")
-      end
-    end
-  end
-
-  def test_safe_mode_replication_ack
-    @col.insert({:baz => "bar"}, :w => 3, :wtimeout => 5000)
-
-    assert @col.insert({:foo => "0" * 5000}, :w => 3, :wtimeout => 5000)
-    assert_equal 2, @slave1[TEST_DB]["test-sets"].count
-
-    assert @col.update({:baz => "bar"}, {:baz => "foo"}, :w => 3, :wtimeout => 5000)
-    assert @slave1[TEST_DB]["test-sets"].find_one({:baz => "foo"})
-
-    assert @col.insert({:foo => "bar"}, :w => "majority")
-
-    assert @col.insert({:bar => "baz"}, :w => :majority)
-
-    assert @col.remove({}, :w => 3, :wtimeout => 5000)
-    assert_equal 0, @slave1[TEST_DB]["test-sets"].count
-  end
-
-  def test_last_error_responses
-    20.times { @col.insert({:baz => "bar"}) }
-    response = @db.get_last_error(:w => 3, :wtimeout => 5000)
-    assert response['ok'] == 1
-    assert response['lastOp']
-
-    @col.update({}, {:baz => "foo"})
-    response = @db.get_last_error(:w => 3, :wtimeout => 5000)
-    assert response['ok'] == 1
-    assert response['lastOp']
-
-    @col.remove({})
-    response =  @db.get_last_error(:w => 3, :wtimeout => 5000)
-    assert response['ok'] == 1
-    assert response['n'] == 20
-    assert response['lastOp']
-  end
-
-end

data/test/sharded_cluster/basic_test.rb

@@ -1,203 +0,0 @@
-# Copyright (C) 2009-2013 MongoDB, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'test_helper'
-include Mongo
-
-class Cursor
-  public :construct_query_spec
-end
-
-class ShardedClusterBasicTest < Test::Unit::TestCase
-
-  def setup
-    ensure_cluster(:sc)
-    @document = { "name" => "test_user" }
-    @seeds    = @sc.mongos_seeds
-  end
-
-  # TODO member.primary? ==> true
-  def test_connect
-    @client = sharded_connection
-    assert @client.connected?
-    assert_equal(@seeds.size, @client.seeds.size)
-    probe(@seeds.size)
-    @client.close
-  end
-
-  def test_connect_from_standard_client
-    mongos = @seeds.first
-    @client = MongoClient.new(*mongos.split(':'))
-    assert @client.connected?
-    assert @client.mongos?
-    @client.close
-  end
-
-  def test_read_from_client
-    host, port = @seeds.first.split(':')
-    tags = [{:dc => "mongolia"}]
-    @client = MongoClient.new(host, port, {:read => :secondary, :tag_sets => tags})
-    assert @client.connected?
-    cursor = Cursor.new(@client[TEST_DB]['whatever'], {})
-    assert_equal cursor.construct_query_spec['$readPreference'], {:mode => 'secondary', :tags => tags}
-  end
-
-  def test_find_one_with_read_secondary
-    @client = sharded_connection(:read => :secondary)
-    @client[TEST_DB]["users"].insert([ @document ])
-    assert_equal @client[TEST_DB]['users'].find_one["name"], "test_user"
-  end
-
-  def test_find_one_with_read_secondary_preferred
-    @client = sharded_connection(:read => :secondary_preferred)
-    @client[TEST_DB]["users"].insert([ @document ])
-    assert_equal @client[TEST_DB]['users'].find_one["name"], "test_user"
-  end
-
-  def test_find_one_with_read_primary
-    @client = sharded_connection(:read => :primary)
-    @client[TEST_DB]["users"].insert([ @document ])
-    assert_equal @client[TEST_DB]['users'].find_one["name"], "test_user"
-  end
-
-  def test_find_one_with_read_primary_preferred
-    @client = sharded_connection(:read => :primary_preferred)
-    @client[TEST_DB]["users"].insert([ @document ])
-    assert_equal @client[TEST_DB]['users'].find_one["name"], "test_user"
-  end
-
-  def test_read_from_sharded_client
-    tags = [{:dc => "mongolia"}]
-    @client = sharded_connection(:read => :secondary, :tag_sets => tags)
-    assert @client.connected?
-    cursor = Cursor.new(@client[TEST_DB]['whatever'], {})
-    assert_equal cursor.construct_query_spec['$readPreference'], {:mode => 'secondary', :tags => tags}
-  end
-
-  def test_hard_refresh
-    @client = sharded_connection
-    assert @client.connected?
-    @client.hard_refresh!
-    assert @client.connected?
-    @client.close
-  end
-
-  def test_reconnect
-    @client = sharded_connection
-    assert @client.connected?
-    router = @sc.servers(:routers).first
-    router.stop
-    probe(@seeds.size)
-    assert @client.connected?
-    @client.close
-  end
-
-  def test_mongos_failover
-    @client = sharded_connection(:refresh_interval => 5, :refresh_mode => :sync)
-    assert @client.connected?
-    # do a find to pin a pool
-    @client[TEST_DB]['test'].find_one
-    original_primary = @client.manager.primary
-    # stop the pinned member
-    @sc.member_by_name("#{original_primary[0]}:#{original_primary[1]}").stop
-    # assert that the client fails over to the next available mongos
-    assert_nothing_raised do
-      @client[TEST_DB]['test'].find_one
-    end
-
-    assert_not_equal original_primary, @client.manager.primary
-    assert @client.connected?
-    @client.close
-  end
-
-  def test_all_down
-    @client = sharded_connection
-    assert @client.connected?
-    @sc.servers(:routers).each{|router| router.stop}
-    assert_raises Mongo::ConnectionFailure do
-      probe(@seeds.size)
-    end
-    assert_false @client.connected?
-    @client.close
-  end
-
-  def test_cycle
-    @client = sharded_connection
-    assert @client.connected?
-    routers = @sc.servers(:routers)
-    while routers.size > 0 do
-      rescue_connection_failure do
-        probe(@seeds.size)
-      end
-      probe(@seeds.size)
-      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 @client.connected?
-    routers = @sc.servers(:routers).reverse
-    routers.each do |r|
-      r.start
-      @client.hard_refresh!
-      rescue_connection_failure do
-        probe(@seeds.size)
-      end
-      probe(@seeds.size)
-    end
-    @client.close
-  end
-
-  def test_wire_version_not_in_range
-    [
-      [Mongo::MongoClient::MAX_WIRE_VERSION+1, Mongo::MongoClient::MAX_WIRE_VERSION+1],
-      [Mongo::MongoClient::MIN_WIRE_VERSION-1, Mongo::MongoClient::MIN_WIRE_VERSION-1]
-    ].each do |min_wire_version_value, max_wire_version_value|
-      Mongo.module_eval <<-EVAL
-        class ShardingPoolManager
-          def max_wire_version
-            return #{max_wire_version_value}
-          end
-          def min_wire_version
-            return #{min_wire_version_value}
-          end
-        end
-      EVAL
-      @client = MongoShardedClient.new(@seeds, :connect => false)
-      assert !@client.connected?
-      assert_raises Mongo::ConnectionFailure do
-        @client.connect
-      end
-    end
-    Mongo.module_eval <<-EVAL
-      class ShardingPoolManager
-        attr_reader :max_wire_version, :min_wire_version
-      end
-    EVAL
-  end
-
-  private
-
-  def sharded_connection(opts={})
-    client = MongoShardedClient.new(@seeds, opts)
-    authenticate_client(client)
-  end
-
-  def probe(size)
-    authenticate_client(@client)
-    assert_equal(size, @client['config']['mongos'].find.to_a.size)
-  end
-end