mongo 1.12.5 → 2.0.0

data/test/replica_set/connection_test.rb

@@ -1,138 +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 ReplicaSetConnectionTest < Test::Unit::TestCase
-
-  def setup
-    ensure_cluster(:rs)
-  end
-
-  def test_connect_with_deprecated_multi
-    silently do
-      @connection = Connection.multi(@rs.repl_set_seeds_old, :name => @rs.repl_set_name)
-    end
-    assert !@connection.nil?
-    assert @connection.connected?
-  end
-
-  def test_connect_bad_name
-    assert_raise_error(ReplicaSetConnectionError, "-wrong") do
-      @connection = ReplSetConnection.new(@rs.repl_set_seeds, :safe => true, :name => @rs.repl_set_name + "-wrong")
-    end
-  end
-
-  def test_connect_with_first_secondary_node_terminated
-    @rs.secondaries.first.stop
-
-    rescue_connection_failure do
-      @connection = ReplSetConnection.new @rs.repl_set_seeds
-    end
-    assert @connection.connected?
-  end
-
-  def test_connect_with_last_secondary_node_terminated
-    @rs.secondaries.last.stop
-
-    rescue_connection_failure do
-      @connection = ReplSetConnection.new @rs.repl_set_seeds
-    end
-    assert @connection.connected?
-  end
-
-  def test_connect_with_connection_string
-    @connection = Connection.from_uri("mongodb://#{@rs.repl_set_seeds_uri}?replicaset=#{@rs.repl_set_name}")
-    assert !@connection.nil?
-    assert @connection.connected?
-  end
-
-  def test_connect_with_connection_string_in_env_var
-    uri = "mongodb://#{@rs.repl_set_seeds_uri}?replicaset=#{@rs.repl_set_name}"
-    with_preserved_env_uri(uri) do
-      @connection = ReplSetConnection.new
-      assert !@connection.nil?
-      assert_equal 3, @connection.seeds.length
-      assert_equal @rs.replicas[0].host, @connection.seeds[0][0]
-      assert_equal @rs.replicas[1].host, @connection.seeds[1][0]
-      assert_equal @rs.replicas[2].host, @connection.seeds[2][0]
-      assert_equal @rs.replicas[0].port, @connection.seeds[0][1]
-      assert_equal @rs.replicas[1].port, @connection.seeds[1][1]
-      assert_equal @rs.replicas[2].port, @connection.seeds[2][1]
-      assert_equal @rs.repl_set_name, @connection.replica_set_name
-      assert @connection.connected?
-    end
-  end
-
-  def test_connect_with_connection_string_in_implicit_mongodb_uri
-    uri = "mongodb://#{@rs.repl_set_seeds_uri}?replicaset=#{@rs.repl_set_name}"
-    with_preserved_env_uri(uri) do
-      @connection = Connection.from_uri
-      assert !@connection.nil?
-      assert_equal 3, @connection.seeds.length
-      assert_equal @rs.replicas[0].host, @connection.seeds[0][0]
-      assert_equal @rs.replicas[1].host, @connection.seeds[1][0]
-      assert_equal @rs.replicas[2].host, @connection.seeds[2][0]
-      assert_equal @rs.replicas[0].port, @connection.seeds[0][1]
-      assert_equal @rs.replicas[1].port, @connection.seeds[1][1]
-      assert_equal @rs.replicas[2].port, @connection.seeds[2][1]
-      assert_equal @rs.repl_set_name, @connection.replica_set_name
-      assert @connection.connected?
-    end
-  end
-
-  def test_connect_with_new_seed_format
-    @connection = ReplSetConnection.new @rs.repl_set_seeds
-    assert @connection.connected?
-  end
-
-  def test_connect_with_old_seed_format
-    silently do
-      @connection = ReplSetConnection.new(@rs.repl_set_seeds_old)
-    end
-    assert @connection.connected?
-  end
-
-  def test_connect_with_full_connection_string
-    @connection = Connection.from_uri("mongodb://#{@rs.repl_set_seeds_uri}?replicaset=#{@rs.repl_set_name};safe=true;w=2;fsync=true;slaveok=true")
-    assert !@connection.nil?
-    assert @connection.connected?
-    assert_equal 2, @connection.write_concern[:w]
-    assert @connection.write_concern[:fsync]
-    assert @connection.read_pool
-  end
-
-  def test_connect_with_full_connection_string_in_env_var
-    uri = "mongodb://#{@rs.repl_set_seeds_uri}?replicaset=#{@rs.repl_set_name};safe=true;w=2;fsync=true;slaveok=true"
-    with_preserved_env_uri(uri) do
-      @connection = ReplSetConnection.new
-      assert !@connection.nil?
-      assert @connection.connected?
-      assert_equal 2, @connection.write_concern[:w]
-      assert @connection.write_concern[:fsync]
-      assert @connection.read_pool
-    end
-  end
-
-  def test_connect_options_override_env_var
-    uri = "mongodb://#{@rs.repl_set_seeds_uri}?replicaset=#{@rs.repl_set_name};safe=true;w=2;fsync=true;slaveok=true"
-    with_preserved_env_uri(uri) do
-      @connection = ReplSetConnection.new({:safe => {:w => 1}})
-      assert !@connection.nil?
-      assert @connection.connected?
-      assert_equal 1, @connection.write_concern[:w]
-    end
-  end
-
-end

data/test/replica_set/count_test.rb

@@ -1,66 +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 ReplicaSetCountTest < Test::Unit::TestCase
-
-  def setup
-    ensure_cluster(:rs)
-    @client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :read => :primary_preferred, :op_timeout => TEST_OP_TIMEOUT)
-    authenticate_client(@client)
-    assert @client.primary_pool
-    @primary = MongoClient.new(@client.primary_pool.host, @client.primary_pool.port)
-    authenticate_client(@primary)
-    @db = @client.db(TEST_DB)
-    @db.drop_collection("test-sets")
-    @coll = @db.collection("test-sets")
-  end
-
-  def teardown
-    @client.close if @conn
-  end
-
-  def test_correct_count_after_insertion_reconnect
-    @coll.insert({:a => 20}, :w => 3, :wtimeout => 10000)
-    assert_equal 1, @coll.count
-
-    # Kill the current master node
-    @rs.primary.stop
-
-    rescue_connection_failure do
-      @coll.insert({:a => 30})
-    end
-
-    @coll.insert({:a => 40})
-    assert_equal 3, @coll.count, "Second count failed"
-  end
-
-  def test_count_command_sent_to_primary
-    @coll.insert({:a => 20}, :w => 3, :wtimeout => 10000)
-    count_before = @primary['admin'].command({:serverStatus => 1})['opcounters']['command']
-    assert_equal 1, @coll.count
-    count_after = @primary['admin'].command({:serverStatus => 1})['opcounters']['command']
-    assert_equal 2, count_after - count_before
-  end
-
-  def test_count_with_read
-    @coll.insert({:a => 20}, :w => 3, :wtimeout => 10000)
-    count_before = @primary['admin'].command({:serverStatus => 1})['opcounters']['command']
-    assert_equal 1, @coll.count(:read => :secondary)
-    assert_equal 1, @coll.find({}, :read => :secondary).count()
-    count_after = @primary['admin'].command({:serverStatus => 1})['opcounters']['command']
-    assert_equal 1, count_after - count_before
-  end
-end

data/test/replica_set/cursor_test.rb

@@ -1,220 +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 ReplicaSetCursorTest < Test::Unit::TestCase
-
-  def setup
-    ensure_cluster(:rs)
-  end
-
-  def test_get_more_primary
-    setup_client(:primary)
-    cursor_get_more_test(:primary)
-  end
-
-  def test_get_more_secondary
-    setup_client(:secondary)
-    cursor_get_more_test(:secondary)
-  end
-
-  def test_close_primary
-    setup_client(:primary)
-    kill_cursor_test(:primary)
-  end
-
-  def test_close_secondary
-    setup_client(:secondary)
-    kill_cursor_test(:secondary)
-  end
-
-  def test_cursors_get_closed
-    setup_client
-    assert_cursors_on_members
-  end
-
-  def test_cursors_get_closed_secondary
-    setup_client(:secondary)
-    assert_cursors_on_members(:secondary)
-  end
-
-  def test_cursors_get_closed_secondary_query
-    setup_client(:primary)
-    assert_cursors_on_members(:secondary)
-  end
-
-  def test_intervening_query_secondary
-    setup_client(:primary)
-    refresh_while_iterating(:secondary)
-  end
-
-  private
-
-  def setup_client(read=:primary)
-    route_read ||= read
-    # Setup ReplicaSet Connection
-    @client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :read => read, :op_timeout => TEST_OP_TIMEOUT)
-    authenticate_client(@client)
-
-    @db = @client.db(TEST_DB)
-    @db.drop_collection("cursor_tests")
-    @coll = @db.collection("cursor_tests")
-    insert_docs
-
-    # Setup Direct Connections
-    @primary = Mongo::MongoClient.new(*@client.manager.primary)
-    authenticate_client(@primary)
-  end
-
-  def insert_docs
-    @n_docs = 102 # batch size is 101
-    @n_docs.times do |i|
-      @coll.insert({ "x" => i }, :w => 3)
-    end
-  end
-
-  def set_read_client_and_tag(read)
-    read_opts = {:read => read}
-    @tag = (0...3).map{|i|i.to_s}.detect do |tag|
-      begin
-        read_opts[:tag_sets] = [{:node => tag}] unless read == :primary
-        cursor = @coll.find({}, read_opts)
-        cursor.next
-        pool = cursor.instance_variable_get(:@pool)
-        cursor.close
-        @read = Mongo::MongoClient.new(pool.host, pool.port, :slave_ok => true)
-        authenticate_client(@read)
-        tag
-      rescue Mongo::ConnectionFailure
-        false
-      end
-    end
-  end
-
-  def route_query(read)
-    read_opts = {:read => read}
-    read_opts[:tag_sets] = [{:node => @tag}] unless read == :primary
-    object_id = BSON::ObjectId.new
-    read_opts[:comment] = object_id
-
-    # set profiling level to 2 on client and member to which the query will be routed
-    @client.db(TEST_DB).profiling_level = :all
-    @client.secondaries.each do |node|
-      node = Mongo::MongoClient.new(node[0], node[1], :slave_ok => true)
-      authenticate_client(node)
-      node.db(TEST_DB).profiling_level = :all
-    end
-
-    @cursor = @coll.find({}, read_opts)
-    @cursor.next
-
-    # on client and other members set profiling level to 0
-    @client.db(TEST_DB).profiling_level = :off
-    @client.secondaries.each do |node|
-      node = Mongo::MongoClient.new(node[0], node[1], :slave_ok => true)
-      authenticate_client(node)
-      node.db(TEST_DB).profiling_level = :off
-    end
-    # do a query on system.profile of the reader to see if it was used for the query
-    profiled_queries = @read.db(TEST_DB).collection('system.profile').find({
-      'ns' => "#{TEST_DB}.cursor_tests", "query.$comment" => object_id })
-
-    assert_equal 1, profiled_queries.count
-  end
-
-  # batch from send_initial_query is 101 documents
-  # check that you get n_docs back from the query, with the same port
-  def cursor_get_more_test(read=:primary)
-    return if subject_to_server_4754?(@client)
-    set_read_client_and_tag(read)
-    10.times do
-      # assert that the query went to the correct member
-      route_query(read)
-      docs_count = 1
-      port = @cursor.instance_variable_get(:@pool).port
-      assert @cursor.alive?
-      while @cursor.has_next?
-        docs_count += 1
-        @cursor.next
-        assert_equal port, @cursor.instance_variable_get(:@pool).port
-      end
-      assert !@cursor.alive?
-      assert_equal @n_docs, docs_count
-      @cursor.close #cursor is already closed
-    end
-  end
-
-  # batch from get_more can be huge, so close after send_initial_query
-  def kill_cursor_test(read=:primary)
-    return if subject_to_server_4754?(@client)
-    set_read_client_and_tag(read)
-    10.times do
-      # assert that the query went to the correct member
-      route_query(read)
-      cursor_id = @cursor.cursor_id
-      cursor_clone = @cursor.clone
-      assert_equal cursor_id, cursor_clone.cursor_id
-      assert @cursor.instance_variable_get(:@pool)
-      # .next was called once already and leave one for get more
-      (@n_docs-2).times { @cursor.next }
-      @cursor.close
-      # an exception confirms the cursor has indeed been closed
-      assert_raise Mongo::OperationFailure do
-        cursor_clone.next
-      end
-    end
-  end
-
-  def assert_cursors_on_members(read=:primary)
-    return if subject_to_server_4754?(@client)
-    set_read_client_and_tag(read)
-    # assert that the query went to the correct member
-    route_query(read)
-    cursor_id = @cursor.cursor_id
-    cursor_clone = @cursor.clone
-    assert_equal cursor_id, cursor_clone.cursor_id
-    assert @cursor.instance_variable_get(:@pool)
-    port = @cursor.instance_variable_get(:@pool).port
-    while @cursor.has_next?
-      @cursor.next
-      assert_equal port, @cursor.instance_variable_get(:@pool).port
-    end
-    # an exception confirms the cursor has indeed been closed after query
-    assert_raise Mongo::OperationFailure do
-      cursor_clone.next
-    end
-  end
-
-  def refresh_while_iterating(read)
-    set_read_client_and_tag(read)
-
-    read_opts = {:read => read}
-    read_opts[:tag_sets] = [{:node => @tag}]
-    read_opts[:batch_size] = 2
-    cursor = @coll.find({}, read_opts)
-
-    2.times { cursor.next }
-    port = cursor.instance_variable_get(:@pool).port
-    host = cursor.instance_variable_get(:@pool).host
-    # Refresh connection
-    @client.refresh
-    assert_nothing_raised do
-      cursor.next
-    end
-
-    assert_equal port, cursor.instance_variable_get(:@pool).port
-    assert_equal host, cursor.instance_variable_get(:@pool).host
-  end
-end

data/test/replica_set/insert_test.rb

@@ -1,157 +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 ReplicaSetInsertTest < Test::Unit::TestCase
-
-  def setup
-    ensure_cluster(:rs)
-    @client = MongoReplicaSetClient.from_uri(@uri, :op_timeout => TEST_OP_TIMEOUT)
-    @version = @client.server_version
-    @db = @client.db(TEST_DB)
-    @db.drop_collection("test-sets")
-    @coll = @db.collection("test-sets")
-  end
-
-  def teardown
-    @client.close if @conn
-  end
-
-  def test_insert
-    @coll.save({:a => 20}, :w => 3)
-
-    @rs.primary.stop
-
-    rescue_connection_failure do
-      @coll.save({:a => 30}, :w => 1)
-    end
-
-    @coll.save({:a => 40}, :w => 1)
-    @coll.save({:a => 50}, :w => 1)
-    @coll.save({:a => 60}, :w => 1)
-    @coll.save({:a => 70}, :w => 1)
-
-    # Restart the old master and wait for sync
-    @rs.start
-    sleep(5)
-    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}, :w => 3)
-    @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
-
-  context "Bulk API CollectionView" do
-    setup do
-      setup
-    end
-
-    should "handle error with deferred write concern error - spec Merging Results" do
-      if @client.wire_version_feature?(MongoClient::MONGODB_3_0)
-        @coll.remove
-        @coll.ensure_index(BSON::OrderedHash[:a, Mongo::ASCENDING], {:unique => true})
-        bulk = @coll.initialize_ordered_bulk_op
-        bulk.insert({:a => 1})
-        bulk.find({:a => 2}).upsert.update({'$set' => {:a => 2}})
-        bulk.insert({:a => 1})
-        secondary = MongoClient.new(@rs.secondaries.first.host, @rs.secondaries.first.port)
-        cmd = BSON::OrderedHash[:configureFailPoint, 'rsSyncApplyStop', :mode, 'alwaysOn']
-        secondary['admin'].command(cmd)
-        ex = assert_raise BulkWriteError do
-          bulk.execute({:w => @rs.servers.size, :wtimeout => 1})
-        end
-        cmd = BSON::OrderedHash[:configureFailPoint, 'rsSyncApplyStop', :mode, 'off']
-        secondary['admin'].command(cmd)
-      else
-        with_write_commands_and_operations(@db.connection) do |wire_version|
-          @coll.remove
-          @coll.ensure_index(BSON::OrderedHash[:a, Mongo::ASCENDING], {:unique => true})
-          bulk = @coll.initialize_ordered_bulk_op
-          bulk.insert({:a => 1})
-          bulk.find({:a => 2}).upsert.update({'$set' => {:a => 2}})
-          bulk.insert({:a => 1})
-          ex = assert_raise BulkWriteError do
-            bulk.execute({:w => 5, :wtimeout => 1})
-          end
-        end
-      end
-      result = ex.result
-      assert_match_document(
-          {
-              "ok" => 1,
-              "n" => 2,
-              "writeErrors" => [
-                  {
-                      "index" => 2,
-                      "code" => 11000,
-                      "errmsg" => /duplicate key error/,
-                  }
-              ],
-              "writeConcernError" => [
-                  {
-                      "errmsg" => /waiting for replication timed out|timed out waiting for slaves|timeout/,
-                      "code" => 64,
-                      "errInfo" => {"wtimeout" => true},
-                      "index" => 0
-                  },
-                  {
-                      "errmsg" => /waiting for replication timed out|timed out waiting for slaves|timeout/,
-                      "code" => 64,
-                      "errInfo" => {"wtimeout" => true},
-                      "index" => 1
-                  }
-              ],
-              "code" => 65,
-              "errmsg" => "batch item errors occurred",
-              "nInserted" => 1
-          }, result)
-      assert_equal 2, @coll.find.to_a.size
-    end
-
-    should "handle unordered errors with deferred write concern error - spec Merging Results" do # TODO - spec review
-      with_write_commands_and_operations(@db.connection) do |wire_version|
-        @coll.remove
-        @coll.ensure_index(BSON::OrderedHash[:a, Mongo::ASCENDING], {:unique => true})
-        bulk = @coll.initialize_unordered_bulk_op
-        bulk.insert({:a => 1})
-        bulk.find({:a => 2}).upsert.update({'$set' => {:a => 1}})
-        bulk.insert({:a => 3})
-        ex = assert_raise BulkWriteError do
-          bulk.execute({:w => 5, :wtimeout => 1})
-        end
-        result = ex.result # unordered varies, don't use assert_bulk_exception
-        assert_equal(1, result["ok"], "wire_version:#{wire_version}")
-        assert_equal(2, result["n"], "wire_version:#{wire_version}")
-        assert(result["nInserted"] >= 1, "wire_version:#{wire_version}")
-        assert_equal(65, result["code"], "wire_version:#{wire_version}")
-        assert_equal("batch item errors occurred", result["errmsg"], "wire_version:#{wire_version}")
-        assert(result["writeErrors"].size >= 1,  "wire_version:#{wire_version}")
-        assert(result["writeConcernError"].size >= 1, "wire_version:#{wire_version}") if wire_version >= 2
-        assert(@coll.size >= 1, "wire_version:#{wire_version}")
-      end
-    end
-
-  end
-
-end