mongo 1.11.1 → 1.12.0.rc0

data/test/replica_set/query_test.rb

@@ -25,7 +25,7 @@ class ReplicaSetQueryTest < Test::Unit::TestCase
   end
 
   def teardown
-    @client.close if @conn
+    @client.close if @client
   end
 
   def test_query

data/test/replica_set/replication_ack_test.rb

@@ -37,13 +37,13 @@ class ReplicaSetAckTest < Test::Unit::TestCase
   end
 
   def test_safe_mode_with_w_failure
-    assert_raise_error WriteConcernError, "time" do
+    assert_raise_error WriteConcernError do
       @col.insert({:foo => 1}, :w => 4, :wtimeout => 1, :fsync => true)
     end
-    assert_raise_error WriteConcernError, "time" do
+    assert_raise_error WriteConcernError do
       @col.update({:foo => 1}, {:foo => 2}, :w => 4, :wtimeout => 1, :fsync => true)
     end
-    assert_raise_error WriteConcernError, "time" do
+    assert_raise_error WriteConcernError do
       @col.remove({:foo => 2}, :w => 4, :wtimeout => 1, :fsync => true)
     end
     if @client.server_version >= '2.5.4'

data/test/shared/authentication/basic_auth_shared.rb

@@ -23,7 +23,10 @@ module BasicAuthTests
   end
 
   def teardown
-    @client[TEST_DB].authenticate(TEST_USER, TEST_USER_PWD) unless has_auth?(TEST_DB, TEST_USER)
+    return unless @client && @db
+    unless has_auth?(TEST_DB, TEST_USER)
+      @client[TEST_DB].authenticate(TEST_USER, TEST_USER_PWD)
+    end
 
     if @client.server_version < '2.5'
       @db['system.users'].remove
@@ -42,6 +45,16 @@ module BasicAuthTests
     @client.auths.any? { |a| a[:source] == db_name && a[:username] == username }
   end
 
+  def test_descriptive_mech_error
+    assert_raise_error Mongo::MongoArgumentError, Mongo::Authentication::MECHANISM_ERROR do
+      @db.authenticate('emily', nil, nil, nil, 'FAKE_MECHANISM')
+    end
+    assert_raise_error Mongo::MongoArgumentError, Mongo::Authentication::MECHANISM_ERROR do
+      uri = "mongodb://user:pwd@host:port/example?authSource=$external&authMechanism=FAKE_MECHANISM"
+      Mongo::MongoClient.from_uri(uri)
+    end
+  end
+
   def test_add_remove_user
     init_auth_basic
 

data/test/shared/authentication/gssapi_shared.rb

@@ -75,7 +75,7 @@ module GSSAPITests
     end
 
     def test_wrong_service_name_fails
-      extra_opts = { :gssapi_service_name => 'example' }
+      extra_opts = { :service_name => 'example' }
       client = Mongo::MongoClient.new(MONGODB_GSSAPI_HOST, MONGODB_GSSAPI_PORT)
       if client['admin'].command(:isMaster => 1)['setName']
         client = Mongo::MongoReplicaSetClient.new(["#{MONGODB_GSSAPI_HOST}:#{MONGODB_GSSAPI_PORT}"])
@@ -93,7 +93,7 @@ module GSSAPITests
       require 'cgi'
       username = CGI::escape(ENV['MONGODB_GSSAPI_USER'])
       uri = "mongodb://#{username}@#{ENV['MONGODB_GSSAPI_HOST']}:#{ENV['MONGODB_GSSAPI_PORT']}/?" +
-         "authMechanism=GSSAPI&gssapiServiceName=example"
+         "authMechanism=GSSAPI&authMechanismProperties=SERVICE_NAME:example"
       client = @client.class.from_uri(uri)
       assert_raise_error Mongo::AuthenticationError do
         client[MONGODB_GSSAPI_DB].command(:dbstats => 1)
@@ -101,32 +101,37 @@ module GSSAPITests
     end
 
     def test_extra_opts
-      extra_opts = { :gssapi_service_name => 'example', :canonicalize_host_name => true }
-      client = Mongo::MongoClient.new(MONGODB_GSSAPI_HOST, MONGODB_GSSAPI_PORT)
+      extra_opts = { :service_name => 'example', :canonicalize_host_name => true, 
+                     :service_realm => 'dumdum' }
+      client = Mongo::MongoClient.new(TEST_HOST, MONGODB_GSSAPI_PORT)
       set_system_properties
 
       Mongo::Sasl::GSSAPI.expects(:authenticate).with do |username, client, socket, opts|
-        assert_equal opts[:gssapi_service_name], extra_opts[:gssapi_service_name]
+        assert_equal opts[:service_name], extra_opts[:service_name]
         assert_equal opts[:canonicalize_host_name], extra_opts[:canonicalize_host_name]
+        assert_equal opts[:service_realm], extra_opts[:service_realm]
         [ username, client, socket, opts ]
       end.returns('ok' => true )
       client[MONGODB_GSSAPI_DB].authenticate(MONGODB_GSSAPI_USER, nil, nil, nil, 'GSSAPI', extra_opts)
     end
 
     def test_extra_opts_uri
-      extra_opts = { :gssapi_service_name => 'example', :canonicalize_host_name => true }
+      extra_opts = { :service_name => 'example', :canonicalize_host_name => true,
+                     :service_realm => 'dumdum' }
       set_system_properties
 
       Mongo::Sasl::GSSAPI.expects(:authenticate).with do |username, client, socket, opts|
-        assert_equal opts[:gssapi_service_name], extra_opts[:gssapi_service_name]
+        assert_equal opts[:service_name], extra_opts[:service_name]
         assert_equal opts[:canonicalize_host_name], extra_opts[:canonicalize_host_name]
+        assert_equal opts[:service_realm], extra_opts[:service_realm]
         [ username, client, socket, opts ]
       end.returns('ok' => true)
 
       require 'cgi'
       username = CGI::escape(ENV['MONGODB_GSSAPI_USER'])
       uri = "mongodb://#{username}@#{ENV['MONGODB_GSSAPI_HOST']}:#{ENV['MONGODB_GSSAPI_PORT']}/?" +
-         "authMechanism=GSSAPI&gssapiServiceName=example&canonicalizeHostName=true"
+         "authMechanism=GSSAPI&authmechanismproperties=SERVICE_NAME:example," +
+         "CANONICALIZE_HOST_NAME:true,SERVICE_REALM:dumdum"
       client = @client.class.from_uri(uri)
       client.expects(:receive_message).returns([[{ 'ok' => 1 }], 1, 1])
       client[MONGODB_GSSAPI_DB].command(:dbstats => 1)

data/test/shared/authentication/scram_shared.rb

@@ -0,0 +1,92 @@
+# Copyright (C) 2014 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.
+
+module SCRAMTests
+
+  def setup_conversation
+    SecureRandom.expects(:base64).returns('NDA2NzU3MDY3MDYwMTgy')
+    @password = Digest::MD5.hexdigest("user:mongo:pencil")
+    @scram = Mongo::Authentication::SCRAM.new({ :username => 'user' }, @password)
+  end
+
+  def test_scram_authenticate
+    if @version.to_s > '2.7'
+      @client.clear_auths
+      assert @db.authenticate(TEST_USER, TEST_USER_PWD, nil, 'admin', 'SCRAM-SHA-1')
+    end
+  end
+
+  def test_scram_conversation_start
+    setup_conversation
+    command = @scram.start
+    assert_equal 1, command['saslStart']
+    assert_equal 'SCRAM-SHA-1', command['mechanism']
+    assert_equal 'n,,n=user,r=NDA2NzU3MDY3MDYwMTgy', command['payload'].to_s
+  end
+
+  def test_scram_conversation_continue
+    setup_conversation
+    payload = BSON::Binary.new(
+      'r=NDA2NzU3MDY3MDYwMTgyt7/+IWaw1HaZZ5NmPJUTWapLpH2Gg+d8,s=AVvQXzAbxweH2RYDICaplw==,i=10000'
+    )
+    reply = { 'conversationId' => 1, 'done' => false, 'payload' => payload, 'ok' => 1.0 }
+    command = @scram.continue(reply)
+    assert_equal 1, command['saslContinue']
+    assert_equal 1, command['conversationId']
+    assert_equal(
+      'c=biws,r=NDA2NzU3MDY3MDYwMTgyt7/+IWaw1HaZZ5NmPJUTWapLpH2Gg+d8,p=qYUYNy6SQ9Jucq9rFA9nVgXQdbM=',
+      command['payload'].to_s
+    )
+  end
+
+  def test_scram_conversation_continue_with_invalid_nonce
+    setup_conversation
+    payload = BSON::Binary.new(
+      'r=NDA2NzU4MDY3MDYwMTgyt7/+IWaw1HaZZ5NmPJUTWapLpH2Gg+d8,s=AVvQXzAbxweH2RYDICaplw==,i=10000'
+    )
+    reply = { 'conversationId' => 1, 'done' => false, 'payload' => payload, 'ok' => 1.0 }
+    assert_raise_error Mongo::InvalidNonce do
+      @scram.continue(reply)
+    end
+  end
+
+  def test_scram_conversation_finalize
+    setup_conversation
+    continue_payload = BSON::Binary.new(
+      'r=NDA2NzU3MDY3MDYwMTgyt7/+IWaw1HaZZ5NmPJUTWapLpH2Gg+d8,s=AVvQXzAbxweH2RYDICaplw==,i=10000'
+    )
+    continue_reply = { 'conversationId' => 1, 'done' => false, 'payload' => continue_payload, 'ok' => 1.0 }
+    @scram.continue(continue_reply)
+    payload = BSON::Binary.new('v=gwo9E8+uifshm7ixj441GvIfuUY=')
+    reply = { 'conversationId' => 1, 'done' => false, 'payload' => payload, 'ok' => 1.0 }
+    command = @scram.finalize(reply)
+    assert_equal 1, command['saslContinue']
+    assert_equal 1, command['conversationId']
+    assert_equal '', command['payload'].to_s
+  end
+
+  def test_scram_conversation_finalize_with_invalid_server_signature
+    setup_conversation
+    continue_payload = BSON::Binary.new(
+      'r=NDA2NzU3MDY3MDYwMTgyt7/+IWaw1HaZZ5NmPJUTWapLpH2Gg+d8,s=AVvQXzAbxweH2RYDICaplw==,i=10000'
+    )
+    continue_reply = { 'conversationId' => 1, 'done' => false, 'payload' => continue_payload, 'ok' => 1.0 }
+    @scram.continue(continue_reply)
+    payload = BSON::Binary.new('v=LQ+8yhQeVL2a3Dh+TDJ7xHz4Srk=')
+    reply = { 'conversationId' => 1, 'done' => false, 'payload' => payload, 'ok' => 1.0 }
+    assert_raise_error Mongo::InvalidSignature do
+      @scram.finalize(reply)
+    end
+  end
+end

data/test/tools/mongo_config.rb

@@ -121,6 +121,7 @@ module Mongo
       fast_sync  = opts[:fastsync]   || false
       auth       = opts[:auth]       || true
       ipv6       = opts[:ipv6].nil? ? true : opts[:ipv6]
+      setParameter = opts[:setParameter] || 'enableTestCommands=1'
 
       params.merge(:command    => mongod,
                    :dbpath     => path,
@@ -129,7 +130,8 @@ module Mongo
                    :quiet      => quiet,
                    :fastsync   => fast_sync,
                    :auth       => auth,
-                   :ipv6       => ipv6)
+                   :ipv6       => ipv6,
+                   :setParameter => setParameter)
     end
 
     def self.key_file(opts)
@@ -301,6 +303,11 @@ module Mongo
 
       def initialize(config)
         @config = config
+        cmd = init_config!
+        super(cmd, @config[:host], @config[:port])
+      end
+
+      def init_config!
         dbpath = @config[:dbpath]
         [dbpath, File.dirname(@config[:logpath])].compact.each{|dir| FileUtils.mkdir_p(dir) unless File.directory?(dir) }
         command = @config[:command] || 'mongod'
@@ -314,7 +321,6 @@ module Mongo
           end
         end
         cmd = [command, arguments].flatten.compact
-        super(cmd, @config[:host], @config[:port])
       end
 
       def start(verifies = DEFAULT_VERIFIES)
@@ -334,8 +340,13 @@ module Mongo
             sleep 1
           end
         end
-        system "ps -fp #{@pid}; cat #{@config[:logpath]}"
-        raise Mongo::ConnectionFailure, "DbServer.start verify via connection probe failed - port:#{@port.inspect} @pid:#{@pid.inspect} kill:#{Process.kill(0, @pid).inspect} running?:#{running?.inspect} cmd:#{cmd.inspect}"
+        if @config.delete(:setParameter)
+          @cmd = init_config!
+          start(verifies)
+        else
+          system "ps -fp #{@pid}; cat #{@config[:logpath]}"
+          raise Mongo::ConnectionFailure, "DbServer.start verify via connection probe failed - port:#{@port.inspect} @pid:#{@pid.inspect} kill:#{Process.kill(0, @pid).inspect} running?:#{running?.inspect} cmd:#{cmd.inspect}"
+        end
       end
 
     end
@@ -346,7 +357,7 @@ module Mongo
         @config = config
         @servers = {}
         Mongo::Config::CLUSTER_OPT_KEYS.each do |key|
-          @servers[key] = @config[key].collect{|conf| DbServer.new(conf)} if @config[key]
+          @servers[key] = @config[key].collect{|conf| p conf; DbServer.new(conf)} if @config[key]
         end
       end
 
@@ -646,7 +657,8 @@ module Mongo
         servers.each{|server| server.start}
         # TODO - sharded replica sets - pending
         if @config[:replicas]
-          repl_set_initiate if repl_set_get_status.first['startupStatus'] == 3
+          repl_set_initiate if repl_set_get_status.first['code'] == 94 ||
+            (repl_set_get_status.first['startupStatus'] && repl_set_get_status.first['startupStatus'] == 3)
           repl_set_startup
         end
         if @config[:routers]

data/test/unit/client_test.rb

@@ -41,6 +41,10 @@ class ClientUnitTest < Test::Unit::TestCase
         assert_equal 1, @client.primary_pool.size
       end
 
+      should "set op timeout to default" do
+        assert_equal Mongo::MongoClient::DEFAULT_OP_TIMEOUT, @client.op_timeout
+      end
+
       should "default slave_ok to false" do
         assert !@client.slave_ok?
       end
@@ -67,6 +71,26 @@ class ClientUnitTest < Test::Unit::TestCase
         client.send(:initialize, *args)
       end
 
+      context 'specifying nil op timeout explicitly' do
+        setup do
+          @client = MongoClient.new('localhost', 27017, :connect => false, :op_timeout => nil)
+        end
+
+        should 'set op timeout to nil' do
+          assert_equal nil, @client.op_timeout
+        end
+      end
+
+      context 'specifying a different op timeout than default' do
+        setup do
+          @client = MongoClient.new('localhost', 27017, :connect => false, :op_timeout => 50)
+        end
+
+        should 'set op timeout to the specified value' do
+          assert_equal 50, @client.op_timeout
+        end
+      end
+
       context "given a replica set" do
 
         should "warn if invalid options are specified" do
@@ -92,11 +116,21 @@ class ClientUnitTest < Test::Unit::TestCase
 
     context "initializing with a unix socket" do
       setup do
-          @connection = Mongo::Connection.new('/tmp/mongod.sock', :connect => false)
+        @client = MongoClient.new('/tmp/mongod.sock', :connect => false)
+        UNIXSocket.stubs(:new).returns(new_mock_unix_socket)
+      end
+      should "parse a unix socket" do
+        assert_equal "/tmp/mongod.sock", @client.host_port.first
+      end
+    end
+
+    context "initializing with a unix socket in uri" do
+      setup do
+          @client = MongoClient.from_uri("mongodb:///tmp/mongod.sock", :connect => false)
           UNIXSocket.stubs(:new).returns(new_mock_unix_socket)
       end
       should "parse a unix socket" do
-          assert_equal "/tmp/mongod.sock", @connection.host_port.first
+          assert_equal "/tmp/mongod.sock", @client.host_port.first
       end
     end
 
@@ -153,11 +187,11 @@ class ClientUnitTest < Test::Unit::TestCase
 
         auth_hash = {
           :db_name   => 'db',
+          :extra=>{},
           :username  => 'hyphen-user_name',
           :password  => 'p-s_s',
           :source    => 'db',
-          :mechanism => Authentication::DEFAULT_MECHANISM,
-          :extra     => {}
+          :mechanism => nil
         }
         assert_equal auth_hash, @client.auths.first
       end
@@ -272,11 +306,11 @@ class ClientUnitTest < Test::Unit::TestCase
 
           auth_hash = {
             :db_name   => 'db',
+            :extra=>{},
             :username  => 'hyphen-user_name',
             :password  => 'p-s_s',
             :source    => 'db',
-            :mechanism => Authentication::DEFAULT_MECHANISM,
-            :extra     => {}
+            :mechanism => nil
           }
           assert_equal auth_hash, @client.auths.first
         end

data/test/unit/connection_test.rb

@@ -70,7 +70,17 @@ class ConnectionUnitTest < Test::Unit::TestCase
 
     context "initializing with a unix socket" do
       setup do
-          @connection = Mongo::Connection.new('/tmp/mongod.sock', :safe => true, :connect => false)
+        @connection = Mongo::Connection.new('/tmp/mongod.sock', :safe => true, :connect => false)
+        UNIXSocket.stubs(:new).returns(new_mock_unix_socket)
+      end
+      should "parse a unix socket" do
+        assert_equal "/tmp/mongod.sock", @connection.host_port.first
+      end
+    end
+
+    context "initializing with a unix socket in uri" do
+      setup do
+          @connection = Mongo::Connection.from_uri("mongodb:///tmp/mongod.sock", :connect => false)
           UNIXSocket.stubs(:new).returns(new_mock_unix_socket)
       end
       should "parse a unix socket" do
@@ -131,11 +141,11 @@ class ConnectionUnitTest < Test::Unit::TestCase
 
         auth_hash = {
           :db_name   => 'db',
+          :extra=>{},
           :username  => 'hyphen-user_name',
           :password  => 'p-s_s',
           :source    => 'db',
-          :mechanism => Authentication::DEFAULT_MECHANISM,
-          :extra     => {}
+          :mechanism => nil
         }
         assert_equal auth_hash, @connection.auths.first
       end
@@ -250,11 +260,11 @@ class ConnectionUnitTest < Test::Unit::TestCase
 
           auth_hash = {
             :db_name   => 'db',
+            :extra=>{},
             :username  => 'hyphen-user_name',
             :password  => 'p-s_s',
             :source    => 'db',
-            :mechanism => Authentication::DEFAULT_MECHANISM,
-            :extra     => {}
+            :mechanism => nil
           }
           assert_equal auth_hash, @connection.auths.first
         end

data/test/unit/db_test.rb

@@ -127,7 +127,7 @@ class DBUnitTest < Test::Unit::TestCase
       end
 
       should "allow extra authentication options" do
-        extra_opts = { :gssapiservicename => 'example', :canonicalizehostname => true }
+        extra_opts = { :service_name => 'example', :canonicalize_host_name => true }
         assert @client.expects(:add_auth).with(@db.name, 'emily', nil, nil, 'GSSAPI', extra_opts)
         @db.authenticate('emily', nil, nil, nil, 'GSSAPI', extra_opts)
       end

data/test/unit/read_pref_test.rb

@@ -74,6 +74,11 @@ class ReadPreferenceUnitTest < Test::Unit::TestCase
     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',
@@ -112,4 +117,290 @@ class ReadPreferenceUnitTest < Test::Unit::TestCase
     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