mongo 1.12.5 → 2.0.0.beta

data/test/replica_set/max_values_test.rb

@@ -1,151 +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 MaxValuesTest < Test::Unit::TestCase
-
-  include Mongo
-
-  def setup
-    ensure_cluster(:rs)
-    @client = MongoReplicaSetClient.from_uri(@uri, :op_timeout => TEST_OP_TIMEOUT)
-    @db = new_mock_db
-    @client.stubs(:[]).returns(@db)
-    @ismaster = {
-      'hosts' => @client.local_manager.hosts.to_a,
-      'arbiters' => @client.local_manager.arbiters
-    }
-  end
-
-  def test_initial_max_and_min_values
-    assert @client.max_bson_size
-    assert @client.max_message_size
-    assert @client.max_wire_version
-    assert @client.min_wire_version
-  end
-
-  def test_updated_max_and_min_sizes_after_node_config_change
-    @db.stubs(:command).returns(
-      @ismaster.merge({'ismaster' => true}),
-      @ismaster.merge({'secondary' => true, 'maxMessageSizeBytes' => 1024 * MESSAGE_SIZE_FACTOR}),
-      @ismaster.merge({'secondary' => true, 'maxBsonObjectSize' => 1024}),
-      @ismaster.merge({'secondary' => true, 'maxWireVersion' => 0}),
-      @ismaster.merge({'secondary' => true, 'minWireVersion' => 0})
-    )
-    @client.local_manager.stubs(:refresh_required?).returns(true)
-    @client.refresh
-
-    assert_equal 1024, @client.max_bson_size
-    assert_equal 1024 * MESSAGE_SIZE_FACTOR, @client.max_message_size
-    assert_equal 0, @client.max_wire_version
-    assert_equal 0, @client.min_wire_version
-  end
-
-  def test_no_values_in_config
-    @db.stubs(:command).returns(
-      @ismaster.merge({'ismaster' => true}),
-      @ismaster.merge({'secondary' => true}),
-      @ismaster.merge({'secondary' => true})
-    )
-    @client.local_manager.stubs(:refresh_required?).returns(true)
-    @client.refresh
-
-    assert_equal DEFAULT_MAX_BSON_SIZE, @client.max_bson_size
-    assert_equal DEFAULT_MAX_BSON_SIZE * MESSAGE_SIZE_FACTOR, @client.max_message_size
-    assert_equal 0, @client.max_wire_version
-    assert_equal 0, @client.min_wire_version
-  end
-
-  def test_only_bson_size_in_config
-    @db.stubs(:command).returns(
-      @ismaster.merge({'ismaster' => true}),
-      @ismaster.merge({'secondary' => true}),
-      @ismaster.merge({'secondary' => true, 'maxBsonObjectSize' => 1024})
-    )
-    @client.local_manager.stubs(:refresh_required?).returns(true)
-    @client.refresh
-
-    assert_equal 1024, @client.max_bson_size
-    assert_equal 1024 * MESSAGE_SIZE_FACTOR, @client.max_message_size
-    assert_equal 0, @client.max_wire_version
-    assert_equal 0, @client.min_wire_version
-  end
-
-  def test_values_in_config
-    #ismaster is called three times on the first node
-    @db.stubs(:command).returns(
-      @ismaster.merge({'ismaster' => true, 'maxMessageSizeBytes' => 1024 * 2 * MESSAGE_SIZE_FACTOR,
-                       'maxBsonObjectSize' => 1024, 'maxWireVersion' => 2, 'minWireVersion' => 1}),
-      @ismaster.merge({'ismaster' => true, 'maxMessageSizeBytes' => 1024 * 2 * MESSAGE_SIZE_FACTOR,
-                       'maxBsonObjectSize' => 1024, 'maxWireVersion' => 2, 'minWireVersion' => 1}),
-      @ismaster.merge({'ismaster' => true, 'maxMessageSizeBytes' => 1024 * 2 * MESSAGE_SIZE_FACTOR,
-                       'maxBsonObjectSize' => 1024, 'maxWireVersion' => 2, 'minWireVersion' => 1}),
-      @ismaster.merge({'secondary' => true, 'maxMessageSizeBytes' => 1024 * 2 * MESSAGE_SIZE_FACTOR,
-                       'maxBsonObjectSize' => 1024, 'maxWireVersion' => 2, 'minWireVersion' => 0}),
-      @ismaster.merge({'secondary' => true, 'maxMessageSizeBytes' => 1024 * 2 * MESSAGE_SIZE_FACTOR,
-                       'maxBsonObjectSize' => 1024, 'maxWireVersion' => 1, 'minWireVersion' => 0})
-    )
-    @client.local_manager.stubs(:refresh_required?).returns(true)
-    @client.refresh
-
-    assert_equal 1024, @client.max_bson_size
-    assert_equal 1024 * 2 * MESSAGE_SIZE_FACTOR, @client.max_message_size
-    assert_equal 1, @client.max_wire_version # minimum of all max_wire_version
-    assert_equal 1, @client.min_wire_version # maximum of all min_wire_version
-  end
-
-  def test_wire_version_not_in_range
-    min_wire_version, max_wire_version = [Mongo::MongoClient::MIN_WIRE_VERSION-1, Mongo::MongoClient::MIN_WIRE_VERSION-1]
-    #ismaster is called three times on the first node
-    @db.stubs(:command).returns(
-      @ismaster.merge({'ismaster' => true, 'maxWireVersion' => max_wire_version, 'minWireVersion' => min_wire_version}),
-      @ismaster.merge({'ismaster' => true, 'maxWireVersion' => max_wire_version, 'minWireVersion' => min_wire_version}),
-      @ismaster.merge({'ismaster' => true, 'maxWireVersion' => max_wire_version, 'minWireVersion' => min_wire_version}),
-      @ismaster.merge({'secondary' => true, 'maxWireVersion' => max_wire_version, 'minWireVersion' => min_wire_version}),
-      @ismaster.merge({'secondary' => true, 'maxWireVersion' => max_wire_version, 'minWireVersion' => min_wire_version})
-    )
-    @client.local_manager.stubs(:refresh_required?).returns(true)
-    assert_raises Mongo::ConnectionFailure do
-      @client.refresh
-    end
-  end
-
-  def test_use_write_command
-    with_write_commands(@client) do
-      assert_true @client.use_write_command?({:w => 1})
-      assert_false @client.use_write_command?({:w => 0})
-    end
-    with_write_operations(@client) do
-      assert_false @client.use_write_command?({:w => 1})
-      assert_false @client.use_write_command?({:w => 0})
-    end
-    @client.local_manager.primary_pool.node.expects(:wire_version_feature?).at_least_once.returns(true)
-    assert_true @client.use_write_command?({:w => 1})
-    assert_false @client.use_write_command?({:w => 0})
-  end
-
-  def test_max_write_batch_size
-    assert_equal Mongo::MongoClient::DEFAULT_MAX_WRITE_BATCH_SIZE, @client.max_write_batch_size
-    @client.local_manager.primary_pool.node.stubs(:max_write_batch_size).returns(999)
-    assert_equal 999, @client.max_write_batch_size
-  end
-
-  def test_max_write_batch_size_no_manager
-    # Simulate no local manager being set yet - RUBY-759
-    @client.stubs(:local_manager).returns(nil)
-    assert_equal Mongo::MongoClient::DEFAULT_MAX_WRITE_BATCH_SIZE, @client.max_write_batch_size
-  end
-end
-

data/test/replica_set/pinning_test.rb

@@ -1,105 +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 ReplicaSetPinningTest < Test::Unit::TestCase
-  def setup
-    ensure_cluster(:rs)
-    @client = MongoReplicaSetClient.from_uri(@uri, :op_timeout => TEST_OP_TIMEOUT)
-    @db = @client.db(TEST_DB)
-    @coll = @db.collection("test-sets")
-    @coll.insert({:a => 1})
-  end
-
-  def test_unpinning
-    # pin primary
-    @coll.find_one
-    assert_equal @client.pinned_pool[:pool], @client.primary_pool
-
-    # pin secondary
-    @coll.find_one({}, :read => :secondary_preferred)
-    assert @client.secondary_pools.include? @client.pinned_pool[:pool]
-
-    # repin primary
-    @coll.find_one({}, :read => :primary_preferred)
-    assert_equal @client.pinned_pool[:pool], @client.primary_pool
-  end
-
-  def test_pinned_pool_is_local_to_thread
-    threads = []
-    30.times do |i|
-      threads << Thread.new do
-        if i % 2 == 0
-          @coll.find_one({}, :read => :secondary_preferred)
-          assert @client.secondary_pools.include? @client.pinned_pool[:pool]
-        else
-          @coll.find_one({}, :read => :primary_preferred)
-          assert_equal @client.pinned_pool[:pool], @client.primary_pool
-        end
-      end
-    end
-    threads.each(&:join)
-  end
-
-  def test_aggregation_cursor_pinning
-    return unless @client.server_version >= '2.5.1'
-    @coll.drop
-
-    [10, 1000].each do |size|
-      @coll.drop
-      size.times {|i| @coll.insert({ :_id => i }) }
-      expected_sum = size.times.reduce(:+)
-
-      cursor = @coll.aggregate(
-          [{ :$project => {:_id => '$_id'}} ],
-          :cursor => { :batchSize => 1 }
-      )
-
-      assert_equal Mongo::Cursor, cursor.class
-
-      cursor_sum = cursor.reduce(0) do |sum, doc|
-        sum += doc['_id']
-      end
-
-      assert_equal expected_sum, cursor_sum
-    end
-    @coll.drop
-  end
-
-  def test_parallel_scan_pinning
-    return unless @client.server_version >= '2.5.5'
-    @coll.drop
-
-    8000.times { |i| @coll.insert({ :_id => i }) }
-
-    lock = Mutex.new
-    doc_ids = Set.new
-    threads = []
-    cursors = @coll.parallel_scan(3)
-    cursors.each_with_index do |cursor, i|
-      threads << Thread.new do
-        docs = cursor.to_a
-        lock.synchronize do
-          docs.each do |doc|
-            doc_ids << doc['_id']
-          end
-        end
-      end
-    end
-    threads.each(&:join)
-    assert_equal 8000, doc_ids.count
-    @coll.drop
-  end
-end

data/test/replica_set/query_test.rb

@@ -1,73 +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 ReplicaSetQueryTest < Test::Unit::TestCase
-
-  def setup
-    ensure_cluster(:rs)
-    @client = MongoReplicaSetClient.from_uri(@uri, :op_timeout => TEST_OP_TIMEOUT)
-    @db = @client.db(TEST_DB)
-    @db.drop_collection("test-sets")
-    @coll = @db.collection("test-sets")
-  end
-
-  def teardown
-    @client.close if @client
-  end
-
-  def test_query
-    @coll.save({:a => 20}, :w => 3)
-    @coll.save({:a => 30}, :w => 3)
-    @coll.save({:a => 40}, :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
-
-    @rs.primary.stop
-
-    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
-
-  # Create a large collection and do a secondary query that returns
-  # enough records to require sending a GETMORE. In between opening
-  # the cursor and sending the GETMORE, do a :primary query. Confirm
-  # that the cursor reading from the secondary continues to talk to
-  # the secondary, rather than trying to read the cursor from the
-  # primary, where it does not exist.
-  # def test_secondary_getmore
-  #   200.times do |i|
-  #     @coll.save({:a => i}, :w => 3)
-  #   end
-  #   as = []
-  #   # Set an explicit batch size, in case the default ever changes.
-  #   @coll.find({}, { :batch_size => 100, :read => :secondary }) do |c|
-  #     c.each do |result|
-  #       as << result['a']
-  #       @coll.find({:a => result['a']}, :read => :primary).map
-  #     end
-  #   end
-  #   assert_equal(as.sort, 0.upto(199).to_a)
-  # end
-
-end

data/test/replica_set/read_preference_test.rb

@@ -1,219 +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 ReadPreferenceTest < Test::Unit::TestCase
-
-  def setup
-    ensure_cluster(:rs)
-    client = make_connection
-    db = client.db(TEST_DB)
-    coll = db.collection('test-sets')
-    coll.save({:a => 20}, {:w => 2})
-  end
-
-  def test_read_primary
-    client = make_connection
-    rescue_connection_failure do
-      assert client.read_primary?
-      assert client.primary?
-    end
-
-    client = make_connection(:primary_preferred)
-    rescue_connection_failure do
-      assert client.read_primary?
-      assert client.primary?
-    end
-
-    client = make_connection(:secondary)
-    rescue_connection_failure do
-      assert !client.read_primary?
-      assert !client.primary?
-    end
-
-    client = make_connection(:secondary_preferred)
-    rescue_connection_failure do
-      assert !client.read_primary?
-      assert !client.primary?
-    end
-  end
-
-  def test_connection_pools
-    client = make_connection
-    assert client.primary_pool, "No primary pool!"
-    assert client.read_pool, "No read pool!"
-    assert client.primary_pool.port == client.read_pool.port,
-      "Primary port and read port are not the same!"
-
-
-    client = make_connection(:primary_preferred)
-    assert client.primary_pool, "No primary pool!"
-    assert client.read_pool, "No read pool!"
-    assert client.primary_pool.port == client.read_pool.port,
-      "Primary port and read port are not the same!"
-
-    client = make_connection(:secondary)
-    assert client.primary_pool, "No primary pool!"
-    assert client.read_pool, "No read pool!"
-    assert client.primary_pool.port != client.read_pool.port,
-      "Primary port and read port are the same!"
-
-    client = make_connection(:secondary_preferred)
-    assert client.primary_pool, "No primary pool!"
-    assert client.read_pool, "No read pool!"
-    assert client.primary_pool.port != client.read_pool.port,
-      "Primary port and read port are the same!"
-  end
-
-  def test_read_routing
-    prepare_routing_test
-
-    # Test that reads are going to the right members
-    assert_query_route(@primary, :primary)
-    assert_query_route(@primary_preferred, :primary)
-    assert_query_route(@secondary, :secondary)
-    assert_query_route(@secondary_preferred, :secondary)
-  end
-
-  def test_read_routing_with_primary_down
-    prepare_routing_test
-
-    # Test that reads are going to the right members
-    assert_query_route(@primary, :primary)
-    assert_query_route(@primary_preferred, :primary)
-    assert_query_route(@secondary, :secondary)
-    assert_query_route(@secondary_preferred, :secondary)
-
-    # Kill the primary so the remaining two members are secondaries
-    @rs.primary.kill
-    sleep(2)
-    # Test that reads are going to the right members
-    assert_raise_error ConnectionFailure do
-      @primary[TEST_DB]['test-sets'].find_one
-    end
-    assert_query_route(@primary_preferred, :secondary)
-    assert_query_route(@secondary, :secondary)
-    assert_query_route(@secondary_preferred, :secondary)
-
-    # Restore set
-    @rs.restart
-    sleep(1)
-    @repl_cons.each { |con| con.refresh }
-    sleep(1)
-
-    # Test that reads are going to the right members
-    assert_query_route(@primary, :primary)
-    assert_query_route(@primary_preferred, :primary)
-    assert_query_route(@secondary, :secondary)
-    assert_query_route(@secondary_preferred, :secondary)
-  end
-
-  def test_read_routing_with_secondary_down
-    prepare_routing_test
-
-    # Test that reads are going to the right members
-    assert_query_route(@primary, :primary)
-    assert_query_route(@primary_preferred, :primary)
-    assert_query_route(@secondary, :secondary)
-    assert_query_route(@secondary_preferred, :secondary)
-
-    secondaries = @rs.secondaries
-    secondaries[0].kill
-    assert_query_route(@secondary_preferred, :secondary)
-
-    secondaries[1].kill
-    sleep(2)
-
-    recovered = false
-    until recovered
-      begin
-        @secondary[TEST_DB]['test-sets'].find_one
-        recovered = true
-      rescue ConnectionFailure
-      end
-    end
-
-    assert_query_route(@secondary_preferred, :secondary)
-    assert_query_route(@secondary, :secondary)
-    assert_query_route(@primary_preferred, :secondary)
-
-    # Restore set
-    @rs.restart
-    sleep(1)
-    @repl_cons.each { |con| con.refresh }
-    sleep(1)
-
-    # Test that reads are going to the right members
-    assert_query_route(@primary, :primary)
-    assert_query_route(@primary_preferred, :primary)
-    assert_query_route(@secondary, :secondary)
-    assert_query_route(@secondary_preferred, :secondary)
-  end
-
-  def test_write_lots_of_data
-    client = make_connection(:secondary_preferred)
-    db = client[TEST_DB]
-    coll = db.collection("test-sets", {:w => 2})
-
-    6000.times do |n|
-      coll.save({:a => n})
-    end
-
-    cursor = coll.find()
-    cursor.next
-    cursor.close
-  end
-
-  private
-
-  def prepare_routing_test
-    # Setup replica set connections
-    @primary = make_connection(:primary)
-    @primary_preferred = make_connection(:primary_preferred)
-    @secondary = make_connection(:secondary)
-    @secondary_preferred = make_connection(:secondary_preferred)
-    @repl_cons = [@primary, @primary_preferred, @secondary, @secondary_preferred]
-
-    @repl_cons.each do |client|
-      client.stubs(:pinned_pool).returns(nil)
-    end
-  end
-
-  def make_connection(mode = :primary, opts = {})
-    opts.merge!(:read => mode)
-    opts.merge!(:op_timeout => nil)
-    client = MongoReplicaSetClient.new(@rs.repl_set_seeds, opts)
-    authenticate_client(client)
-  end
-
-  def query_count(connection)
-    connection['admin'].command({:serverStatus => 1})['opcounters']['query']
-  end
-
-  def assert_query_route(test_connection, type)
-    secondary = type == :secondary
-    authenticate_client(test_connection)
-    cursor = test_connection[TEST_DB]['test-sets'].find
-    assert_nothing_raised do
-      cursor.next
-    end
-    pool = cursor.instance_variable_get("@pool")
-    assert_equal secondary, secondary?(MongoClient.new(pool.host, pool.port))
-  end
-
-  def secondary?(client)
-    client['admin'].command(:isMaster => 1)['secondary']
-  end
-end