mongo 1.12.5 → 2.0.0.beta

data/test/unit/mongo_sharded_client_test.rb

@@ -1,48 +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 MongoShardedClientUnitTest < Test::Unit::TestCase
-  include Mongo
-
-  def test_initialize_with_single_mongos_uri
-    uri = "mongodb://localhost:27017"
-    with_preserved_env_uri(uri) do
-      client = MongoShardedClient.new(:connect => false)
-      assert_equal [[ "localhost", 27017 ]], client.seeds
-    end
-  end
-
-  def test_initialize_with_multiple_mongos_uris
-    uri = "mongodb://localhost:27017,localhost:27018"
-    with_preserved_env_uri(uri) do
-      client = MongoShardedClient.new(:connect => false)
-      assert_equal [[ "localhost", 27017 ], [ "localhost", 27018 ]], client.seeds
-    end
-  end
-
-  def test_from_uri_with_string
-    client = MongoShardedClient.from_uri("mongodb://localhost:27017,localhost:27018", :connect => false)
-    assert_equal [[ "localhost", 27017 ], [ "localhost", 27018 ]], client.seeds
-  end
-
-  def test_from_uri_with_env_variable
-    uri = "mongodb://localhost:27017,localhost:27018"
-    with_preserved_env_uri(uri) do
-      client = MongoShardedClient.from_uri(nil, :connect => false)
-      assert_equal [[ "localhost", 27017 ], [ "localhost", 27018 ]], client.seeds
-    end
-  end
-end

data/test/unit/node_test.rb

@@ -1,93 +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 NodeUnitTest < Test::Unit::TestCase
-
-  def setup
-    @client = stub()
-    manager = mock('pool_manager')
-    manager.stubs(:update_max_sizes)
-    @client.stubs(:local_manager).returns(manager)
-  end
-
-  should "refuse to connect to node without 'hosts' key" do
-    tcp = mock()
-    node = Node.new(@client, ['localhost', 27017])
-    tcp.stubs(:new).returns(new_mock_socket)
-    @client.stubs(:socket_class).returns(tcp)
-
-    admin_db = new_mock_db
-    admin_db.stubs(:command).returns({'ok' => 1, 'ismaster' => 1})
-    @client.stubs(:[]).with('admin').returns(admin_db)
-    @client.stubs(:op_timeout).returns(nil)
-    @client.stubs(:connect_timeout).returns(nil)
-    @client.expects(:log)
-    @client.expects(:mongos?).returns(false)
-    @client.stubs(:socket_opts)
-
-    assert node.connect
-    node.config
-  end
-
-  should "load a node from an array" do
-    node = Node.new(@client, ['power.level.com', 9001])
-    assert_equal 'power.level.com', node.host
-    assert_equal 9001, node.port
-    assert_equal 'power.level.com:9001', node.address
-  end
-
-  should "should default the port for an array" do
-    node = Node.new(@client, ['power.level.com'])
-    assert_equal 'power.level.com', node.host
-    assert_equal MongoClient::DEFAULT_PORT, node.port
-    assert_equal "power.level.com:#{MongoClient::DEFAULT_PORT}", node.address
-  end
-
-  should "load a node from a string" do
-    node = Node.new(@client, 'localhost:1234')
-    assert_equal 'localhost', node.host
-    assert_equal 1234, node.port
-    assert_equal 'localhost:1234', node.address
-  end
-
-  should "should default the port for a string" do
-    node = Node.new(@client, '192.168.0.1')
-    assert_equal '192.168.0.1', node.host
-    assert_equal MongoClient::DEFAULT_PORT, node.port
-    assert_equal "192.168.0.1:#{MongoClient::DEFAULT_PORT}", node.address
-  end
-
-  should "two nodes with the same address should be equal" do
-    assert_equal Node.new(@client, '192.168.0.1'),
-      Node.new(@client, ['192.168.0.1', MongoClient::DEFAULT_PORT])
-  end
-
-  should "two nodes with the same address should have the same hash" do
-    assert_equal Node.new(@client, '192.168.0.1').hash,
-      Node.new(@client, ['192.168.0.1', MongoClient::DEFAULT_PORT]).hash
-  end
-
-  should "two nodes with different addresses should not be equal" do
-    assert_not_equal Node.new(@client, '192.168.0.2'),
-      Node.new(@client, ['192.168.0.1', MongoClient::DEFAULT_PORT])
-  end
-
-  should "two nodes with the same address should have the same hash negate" do
-    assert_not_equal Node.new(@client, '192.168.0.1').hash,
-      Node.new(@client, '1239.33.4.2393:29949').hash
-  end
-
-end

data/test/unit/pool_manager_test.rb

@@ -1,111 +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 PoolManagerUnitTest < Test::Unit::TestCase
-
-  context "Initialization: " do
-
-    setup do
-      TCPSocket.stubs(:new).returns(new_mock_socket)
-      @db = new_mock_db
-
-      @client = stub("MongoClient")
-      @client.stubs(:connect_timeout).returns(5)
-      @client.stubs(:op_timeout).returns(5)
-      @client.stubs(:pool_size).returns(2)
-      @client.stubs(:pool_timeout).returns(100)
-      @client.stubs(:seeds).returns(['localhost:30000'])
-      @client.stubs(:socket_class).returns(TCPSocket)
-      @client.stubs(:mongos?).returns(false)
-      @client.stubs(:[]).returns(@db)
-      @client.stubs(:socket_opts)
-
-      @client.stubs(:replica_set_name).returns(nil)
-      @client.stubs(:log)
-      @arbiters = ['localhost:27020']
-      @hosts = [
-        'localhost:27017',
-        'localhost:27018',
-        'localhost:27019',
-        'localhost:27020'
-      ]
-
-      @ismaster = {
-        'hosts' => @hosts,
-        'arbiters' => @arbiters,
-        'maxBsonObjectSize' => 1024,
-        'maxMessageSizeBytes' => 1024 * 2.5,
-        'maxWireVersion' => 1,
-        'minWireVersion' => 0
-      }
-    end
-
-    should "populate pools correctly" do
-
-      @db.stubs(:command).returns(
-        # First call to get a socket.
-        @ismaster.merge({'ismaster' => true}),
-
-        # Subsequent calls to configure pools.
-        @ismaster.merge({'ismaster' => true}),
-        @ismaster.merge({'secondary' => true, 'maxBsonObjectSize' => 500}),
-        @ismaster.merge({'secondary' => true, 'maxMessageSizeBytes' => 700}),
-        @ismaster.merge({'arbiterOnly' => true})
-      )
-
-      seeds = [['localhost', 27017]]
-      manager = Mongo::PoolManager.new(@client, seeds)
-      @client.stubs(:local_manager).returns(manager)
-      manager.connect
-
-      assert_equal ['localhost', 27017], manager.primary
-      assert_equal 27017, manager.primary_pool.port
-      assert_equal 2, manager.secondaries.length
-      assert_equal [27018, 27019], manager.secondary_pools.map(&:port).sort
-      assert_equal [['localhost', 27020]], manager.arbiters
-      assert_equal 500, manager.max_bson_size
-      assert_equal 700, manager.max_message_size
-    end
-
-    should "populate pools with single unqueryable seed" do
-
-      @db.stubs(:command).returns(
-        # First call to recovering node
-        @ismaster.merge({'ismaster' => false, 'secondary' => false}),
-
-        # Subsequent calls to configure pools.
-        @ismaster.merge({'ismaster' => false, 'secondary' => false}),
-        @ismaster.merge({'ismaster' => true}),
-        @ismaster.merge({'secondary' => true}),
-        @ismaster.merge({'arbiterOnly' => true})
-      )
-
-      seeds = [['localhost', 27017]]
-      manager = PoolManager.new(@client, seeds)
-      @client.stubs(:local_manager).returns(manager)
-      manager.connect
-
-      assert_equal ['localhost', 27018], manager.primary
-      assert_equal 27018, manager.primary_pool.port
-      assert_equal 1, manager.secondaries.length
-      assert_equal 27019, manager.secondary_pools[0].port
-      assert_equal [['localhost', 27020]], manager.arbiters
-    end
-
-  end
-
-end

data/test/unit/read_pref_test.rb

@@ -1,406 +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 ReadPreferenceUnitTest < Test::Unit::TestCase
-
-  include ReadPreference
-
-  def setup
-    mock_pool = mock()
-    mock_pool.stubs(:ping_time).returns(Pool::MAX_PING_TIME)
-
-    stubs(:primary_pool).returns(mock_pool)
-    stubs(:secondary_pools).returns([mock_pool])
-    stubs(:pools).returns([mock_pool])
-  end
-
-  def test_select_pool
-    ReadPreference::READ_PREFERENCES.map do |rp|
-      assert select_pool({:mode => rp, :tags => [], :latency => 15})
-    end
-  end
-
-  def test_sok_mapreduce_out_string_returns_false
-    command = BSON::OrderedHash['mapreduce', 'test-collection',
-                                'out', 'new-test-collection']
-    assert_equal false, ReadPreference::secondary_ok?(command)
-  end
-
-  def test_sok_mapreduce_replace_collection_returns_false
-    command = BSON::OrderedHash['mapreduce', 'test-collection',
-                                'out', BSON::OrderedHash['replace', 'new-test-collection']]
-    assert_equal false, ReadPreference::secondary_ok?(command)
-  end
-
-  def test_sok_mapreduce_inline_collection_returns_false
-    command = BSON::OrderedHash['mapreduce', 'test-collection',
-                                'out', 'inline']
-    assert_equal false, ReadPreference::secondary_ok?(command)
-  end
-
-  def test_sok_inline_symbol_mapreduce_returns_true
-    command = BSON::OrderedHash['mapreduce', 'test-collection',
-                                'out', BSON::OrderedHash[:inline, 'true']]
-    assert_equal true, ReadPreference::secondary_ok?(command)
-  end
-
-  def test_sok_inline_string_mapreduce_returns_true
-    command = BSON::OrderedHash['mapreduce', 'test-collection',
-                                'out', BSON::OrderedHash['inline', 'true']]
-    assert_equal true, ReadPreference::secondary_ok?(command)
-  end
-
-  def test_sok_count_true
-    command = BSON::OrderedHash['count', 'test-collection',
-                                'query', BSON::OrderedHash['a', 'b']]
-    assert_equal true, ReadPreference::secondary_ok?(command)
-  end
-
-  def test_sok_server_status_returns_false
-    command = BSON::OrderedHash['serverStatus', 1]
-    assert_equal false, ReadPreference::secondary_ok?(command)
-  end
-
-  def test_sok_text_returns_true
-    command = BSON::OrderedHash['text', BSON::OrderedHash['search', 'coffee']]
-    assert_equal true, ReadPreference::secondary_ok?(command)
-  end
-
-  def test_cmd_reroute_with_secondary
-    ReadPreference::expects(:warn).with(regexp_matches(/rerouted to primary/))
-    command = BSON::OrderedHash['mapreduce', 'test-collection',
-                                'out', 'new-test-collection']
-    assert_equal :primary, ReadPreference::cmd_read_pref(:secondary, command)
-  end
-
-  def test_find_and_modify_reroute_with_secondary
-    ReadPreference::expects(:warn).with(regexp_matches(/rerouted to primary/))
-    command = BSON::OrderedHash['findAndModify', 'test-collection',
-                                'query', {}]
-    assert_equal :primary, ReadPreference::cmd_read_pref(:secondary, command)
-  end
-
-  def test_cmd_no_reroute_with_secondary
-    command = BSON::OrderedHash['mapreduce', 'test-collection',
-                                'out', BSON::OrderedHash['inline', 'true']]
-    assert_equal :secondary, ReadPreference::cmd_read_pref(:secondary, command)
-  end
-
-  def test_cmd_no_reroute_with_primary
-    command = BSON::OrderedHash['mapreduce', 'test-collection',
-                                'out', 'new-test-collection']
-    assert_equal :primary, ReadPreference::cmd_read_pref(:primary, command)
-  end
-
-  def test_cmd_no_reroute_with_primary_secondary_ok
-    command = BSON::OrderedHash['mapreduce', 'test-collection',
-                                'out', BSON::OrderedHash['inline', 'true']]
-    assert_equal :primary, ReadPreference::cmd_read_pref(:primary, command)
-  end
-
-  def test_parallel_scan_secondary_ok
-    command = BSON::OrderedHash['parallelCollectionScan', 'test-collection',
-                                'numCursors', 3]
-    assert_equal true, ReadPreference::secondary_ok?(command)
-  end
-
-  def test_primary_with_tags_raises_error
-    # Confirm that an error is raised if you provide tags and read pref is primary
-    client = MongoReplicaSetClient.new(["#{TEST_HOST}:#{TEST_PORT}"], :connect => false)
-    client.stubs(:primary_pool).returns(mock_pool)
-    read_pref_tags = {'dc' => 'nyc'}
-    read_pref = client.read_preference.merge(:mode    => :primary,
-                                             :tags    => [read_pref_tags],
-                                             :latency => 6)
-    assert_raise Mongo::MongoArgumentError do
-      client.select_pool(read_pref)
-    end
-  end
-
-  def test_secondary_pref
-    # Confirm that a primary is not selected
-    primary_pool = mock('pool')
-
-    secondary_nyc = mock_pool({'dc' => 'nyc'}, 5)
-    secondary_chi = mock_pool({'dc' => 'chicago'}, 5)
-    secondary_pools = [secondary_nyc, secondary_chi]
-
-    client = MongoReplicaSetClient.new(["#{TEST_HOST}:#{TEST_PORT}"], :connect => false)
-    client.stubs(:primary_pool).returns(primary_pool)
-    client.stubs(:secondary_pools).returns(secondary_pools)
-
-    read_pref = client.read_preference.merge(:mode => :secondary)
-    assert_not_equal Hash.new, client.select_pool(read_pref).tags
-  end
-
-  def test_secondary_tags_pref
-    # Confirm that a secondary with matching tags is selected
-    secondary_nyc = mock_pool({'dc' => 'nyc'}, 5)
-    secondary_chi = mock_pool({'dc' => 'chicago'}, 5)
-    secondary_pools = [secondary_nyc, secondary_chi]
-
-    client = MongoReplicaSetClient.new(["#{TEST_HOST}:#{TEST_PORT}"], :connect => false)
-    client.stubs(:primary_pool).returns(mock_pool)
-    client.stubs(:secondary_pools).returns(secondary_pools)
-
-    read_pref_tags = {'dc' => 'nyc'}
-    read_pref = client.read_preference.merge(:mode => :secondary,
-                                             :tags => [read_pref_tags])
-    assert_equal read_pref_tags, client.select_pool(read_pref).tags
-  end
-
-  def test_secondary_tags_with_latency
-    # Confirm that between more than 1 secondary matching tags, only the one within
-    # max acceptable latency is selected
-    secondary_nyc = mock_pool({'dc' => 'nyc'}, 5)
-    secondary_nyc2 = mock_pool({'dc' => 'nyc'}, 25)
-    secondary_pools = [secondary_nyc, secondary_nyc2]
-
-    client = MongoReplicaSetClient.new(["#{TEST_HOST}:#{TEST_PORT}"], :connect => false)
-    client.stubs(:secondary_pools).returns(secondary_pools)
-
-    read_pref_tags = {'dc' => 'nyc'}
-    read_pref = client.read_preference.merge(:mode => :secondary,
-                                             :tags => [read_pref_tags])
-    assert_equal 5, client.select_pool(read_pref).ping_time
-  end
-
-  def test_secondary_latency_pref
-    # Confirm that only the latency of pools matching tags is considered
-    secondary_nyc = mock_pool({'dc' => 'nyc'}, 10)
-    secondary_chi = mock_pool({'dc' => 'chicago'}, 5)
-    secondary_pools = [secondary_nyc, secondary_chi]
-
-    client = MongoReplicaSetClient.new(["#{TEST_HOST}:#{TEST_PORT}"], :connect => false)
-    client.stubs(:primary_pool).returns(mock_pool)
-    client.stubs(:secondary_pools).returns(secondary_pools)
-
-    read_pref_tags = {'dc' => 'nyc'}
-    read_pref = client.read_preference.merge(:mode    => :secondary,
-                                             :tags    => [read_pref_tags],
-                                             :latency => 3)
-    assert_equal read_pref_tags, client.select_pool(read_pref).tags
-  end
-
-  def test_primary_preferred_primary_available
-    # Confirm that the primary is always selected if it's available
-    secondary_nyc = mock_pool({'dc' => 'nyc'}, 5)
-    secondary_chi = mock_pool({'dc' => 'chicago'}, 10)
-    secondary_pools = [secondary_nyc, secondary_chi]
-    primary_pool = mock_pool
-
-    client = MongoReplicaSetClient.new(["#{TEST_HOST}:#{TEST_PORT}"], :connect => false)
-    client.stubs(:secondary_pools).returns(secondary_pools)
-    client.stubs(:primary_pool).returns(primary_pool)
-
-    read_pref_tags = {'dc' => 'chicago'}
-    read_pref = client.read_preference.merge(:mode    => :primary_preferred,
-                                             :tags    => [read_pref_tags],
-                                             :latency => 6)
-    assert_equal primary_pool, client.select_pool(read_pref)
-  end
-
-  def test_primary_preferred_primary_not_available
-    # Confirm that a secondary with matching tags is selected if primary is
-    # not available
-    secondary_nyc = mock_pool({'dc' => 'nyc'}, 5)
-    secondary_chi = mock_pool({'dc' => 'chicago'}, 10)
-    secondary_pools = [secondary_nyc, secondary_chi]
-
-    client = MongoReplicaSetClient.new(["#{TEST_HOST}:#{TEST_PORT}"], :connect => false)
-    client.stubs(:secondary_pools).returns(secondary_pools)
-
-    read_pref_tags = {'dc' => 'chicago'}
-    read_pref = client.read_preference.merge(:mode    => :primary_preferred,
-                                             :tags    => [read_pref_tags],
-                                             :latency => 6)
-    assert_equal read_pref_tags, client.select_pool(read_pref).tags
-  end
-
-  def test_primary_preferred_primary_not_available_and_no_matching_tags
-    # Confirm that tags are taken into account if primary is not available and
-    # secondaries are considered for selection.
-    secondary_nyc = mock_pool({'dc' => 'nyc'}, 5)
-    secondary_chi = mock_pool({'dc' => 'chicago'}, 10)
-    secondary_pools = [secondary_nyc, secondary_chi]
-
-    client = MongoReplicaSetClient.new(["#{TEST_HOST}:#{TEST_PORT}"], :connect => false)
-    client.stubs(:secondary_pools).returns(secondary_pools)
-
-    read_pref_tags = {'dc' => 'other_city'}
-    read_pref = client.read_preference.merge(:mode    => :primary_preferred,
-                                             :tags    => [read_pref_tags],
-                                             :latency => 6)
-    assert_equal nil, client.select_pool(read_pref)
-  end
-
-  def test_secondary_preferred_with_tags
-    # Confirm that tags are taken into account
-    secondary_nyc = mock_pool({'dc' => 'nyc'}, 5)
-    secondary_chi = mock_pool({'dc' => 'chicago'}, 10)
-    secondary_pools = [secondary_nyc, secondary_chi]
-
-    client = MongoReplicaSetClient.new(["#{TEST_HOST}:#{TEST_PORT}"], :connect => false)
-    client.stubs(:secondary_pools).returns(secondary_pools)
-
-    read_pref_tags = {'dc' => 'chicago'}
-    read_pref = client.read_preference.merge(:mode    => :secondary_preferred,
-                                             :tags    => [read_pref_tags],
-                                             :latency => 6)
-    assert_equal read_pref_tags, client.select_pool(read_pref).tags
-  end
-
-  def test_secondary_preferred_with_no_matching_tags
-    # Confirm that the primary is selected if no secondaries with matching tags
-    # are found
-    secondary_nyc = mock_pool({'dc' => 'nyc'}, 5)
-    secondary_chi = mock_pool({'dc' => 'chicago'}, 10)
-    secondary_pools = [secondary_nyc, secondary_chi]
-
-    client = MongoReplicaSetClient.new(["#{TEST_HOST}:#{TEST_PORT}"], :connect => false)
-    client.stubs(:secondary_pools).returns(secondary_pools)
-    client.stubs(:primary_pool).returns(mock_pool)
-
-    read_pref_tags = {'dc' => 'other_city'}
-    read_pref = client.read_preference.merge(:mode    => :secondary_preferred,
-                                             :tags    => [read_pref_tags],
-                                             :latency => 6)
-    assert_equal Hash.new, client.select_pool(read_pref).tags
-  end
-
-  def test_nearest_with_tags
-    # Confirm that tags are taken into account when selecting nearest
-    secondary_nyc = mock_pool({'dc' => 'nyc'}, 5)
-    secondary_chi = mock_pool({'dc' => 'chicago'}, 10)
-    primary_pool = mock_pool
-    pools = [secondary_nyc, secondary_chi, primary_pool]
-
-    client = MongoReplicaSetClient.new(["#{TEST_HOST}:#{TEST_PORT}"], :connect => false)
-    client.stubs(:pools).returns(pools)
-
-    read_pref_tags = {'dc' => 'nyc'}
-    read_pref = client.read_preference.merge(:mode    => :nearest,
-                                             :tags    => [read_pref_tags],
-                                             :latency => 3)
-    assert_equal read_pref_tags, client.select_pool(read_pref).tags
-  end
-
-  def test_nearest
-    # Confirm that the nearest is selected when tags aren't specified
-    secondary_nyc = mock_pool({'dc' => 'nyc'}, 5)
-    secondary_chi = mock_pool({'dc' => 'chicago'}, 10)
-    primary_pool = mock_pool({}, 1)
-    pools = [secondary_nyc, secondary_chi, primary_pool]
-
-    client = MongoReplicaSetClient.new(["#{TEST_HOST}:#{TEST_PORT}"], :connect => false)
-    client.stubs(:pools).returns(pools)
-
-    read_pref = client.read_preference.merge(:mode    => :nearest,
-                                             :latency => 3)
-    assert_equal Hash.new, client.select_pool(read_pref).tags
-  end
-
-  def test_nearest_primary_matching
-    # Confirm that a primary matching tags is included in nearest candidates
-    secondary_nyc = mock_pool({'dc' => 'nyc'}, 5)
-    secondary_chi = mock_pool({'dc' => 'chicago'}, 10)
-    primary_pool = mock_pool({'dc' => 'boston'}, 1)
-    secondary_pools = [secondary_nyc, secondary_chi]
-
-    client = MongoReplicaSetClient.new(["#{TEST_HOST}:#{TEST_PORT}"], :connect => false)
-    client.stubs(:secondary_pools).returns(secondary_pools)
-    client.stubs(:primary_pool).returns(primary_pool)
-    client.stubs(:pools).returns(secondary_pools << primary_pool)
-
-    read_pref_tags = {'dc' => 'boston'}
-    read_pref = client.read_preference.merge(:mode    => :nearest,
-                                             :tags    => [read_pref_tags])
-    assert_equal primary_pool, client.select_pool(read_pref)
-  end
-
-  def test_nearest_primary_not_matching
-    # Confirm that a primary not matching tags is not included in nearest candidates
-    secondary_nyc = mock_pool({'dc' => 'nyc'}, 25)
-    secondary_chi = mock_pool({'dc' => 'chicago'}, 25)
-    primary_pool = mock_pool({'dc' => 'boston'}, 1)
-    secondary_pools = [secondary_nyc, secondary_chi]
-
-    client = MongoReplicaSetClient.new(["#{TEST_HOST}:#{TEST_PORT}"], :connect => false)
-    client.stubs(:secondary_pools).returns(secondary_pools)
-    client.stubs(:primary_pool).returns(mock_pool)
-    client.stubs(:pools).returns(secondary_pools << primary_pool)
-
-    read_pref_tags = {'dc' => 'SF'}
-    read_pref = client.read_preference.merge(:mode    => :nearest,
-                                             :tags    => [read_pref_tags])
-    assert_equal nil, client.select_pool(read_pref)
-  end
-
-  def test_nearest_primary_not_matching_excluded_from_latency_calculations
-    # Confirm that a primary not matching tags is not included in the latency calculations
-    secondary1 = mock_pool({'dc' => 'nyc'}, 10)
-    secondary2 = mock_pool({'dc' => 'nyc'}, 10)
-    primary_pool = mock_pool({'dc' => 'boston'}, 1)
-    secondary_pools = [secondary1, secondary2]
-
-    client = MongoReplicaSetClient.new(["#{TEST_HOST}:#{TEST_PORT}"], :connect => false)
-    client.stubs(:secondary_pools).returns(secondary_pools)
-    client.stubs(:primary_pool).returns(mock_pool)
-    client.stubs(:pools).returns(secondary_pools << primary_pool)
-
-    read_pref_tags = {'dc' => 'nyc'}
-    read_pref = client.read_preference.merge(:mode    => :nearest,
-                                             :tags    => [read_pref_tags],
-                                             :latency => 5)
-    assert_equal 'nyc', client.select_pool(read_pref).tags['dc']
-  end
-
-  def test_nearest_matching_tags_but_not_available
-    # Confirm that even if a server matches a tag, it's not selected if it's down
-    secondary_nyc = mock_pool({'dc' => 'nyc'}, 5)
-    secondary_chi = mock_pool({'dc' => 'chicago'}, 10)
-    primary_pool = mock_pool({'dc' => 'chicago'}, nil)
-    secondary_pools = [secondary_nyc, secondary_chi]
-
-    client = MongoReplicaSetClient.new(["#{TEST_HOST}:#{TEST_PORT}"], :connect => false)
-    client.stubs(:secondary_pools).returns(secondary_pools)
-    client.stubs(:primary_pool).returns(primary_pool)
-    client.stubs(:pools).returns(secondary_pools << primary_pool)
-
-    tags = [{'dc' => 'nyc'}, {'dc' => 'chicago'}, {}]
-    read_pref = client.read_preference.merge(:mode    => :nearest,
-                                             :tags    => tags)
-    assert_equal secondary_nyc, client.select_pool(read_pref)
-  end
-
-  def test_nearest_multiple_tags
-    # Confirm that with multiple tags in the read preference, servers are still selected
-    secondary_nyc = mock_pool({}, 5)
-    secondary_chi = mock_pool({'dc' => 'chicago'}, 10)
-    primary_pool = mock_pool({}, 1)
-    secondary_pools = [secondary_nyc, secondary_chi]
-
-    client = MongoReplicaSetClient.new(["#{TEST_HOST}:#{TEST_PORT}"], :connect => false)
-    client.stubs(:secondary_pools).returns(secondary_pools)
-    client.stubs(:primary_pool).returns(mock_pool)
-    client.stubs(:pools).returns(secondary_pools << primary_pool)
-
-    tags = [{'dc' => 'nyc'}, {'dc' => 'chicago'}, {}]
-    read_pref = client.read_preference.merge(:mode    => :nearest,
-                                             :tags    => tags)
-    assert_equal secondary_chi, client.select_pool(read_pref)
-  end
-end