mongo 1.8.6 → 1.12.5

data/test/unit/read_pref_test.rb

@@ -1,6 +1,21 @@
+# 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 ReadPrefTest < Test::Unit::TestCase
+class ReadPreferenceUnitTest < Test::Unit::TestCase
+
   include ReadPreference
 
   def setup
@@ -18,4 +33,374 @@ class ReadPrefTest < Test::Unit::TestCase
     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

data/test/unit/read_test.rb

@@ -1,6 +1,20 @@
+# 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 ReadTest < Test::Unit::TestCase
+class ReadUnitTest < Test::Unit::TestCase
 
   context "Read mode on standard connection: " do
     setup do
@@ -32,29 +46,29 @@ class ReadTest < Test::Unit::TestCase
     end
 
     should "propogate to DB" do
-      db = @client['foo']
+      db = @client[TEST_DB]
       assert_equal @read, db.read
       assert_equal @tags, db.tag_sets
       assert_equal @acceptable_latency, db.acceptable_latency
 
-      db = @client.db('foo')
+      db = @client.db(TEST_DB)
       assert_equal @read, db.read
       assert_equal @tags, db.tag_sets
       assert_equal @acceptable_latency, db.acceptable_latency
 
-      db = DB.new('foo', @client)
+      db = DB.new(TEST_DB, @client)
       assert_equal @read, db.read
       assert_equal @tags, db.tag_sets
       assert_equal @acceptable_latency, db.acceptable_latency
     end
 
     should "allow db override" do
-      db = DB.new('foo', @client, :read => :primary, :tag_sets => @bad_tags, :acceptable_latency => 25)
+      db = DB.new(TEST_DB, @client, :read => :primary, :tag_sets => @bad_tags, :acceptable_latency => 25)
       assert_equal :primary, db.read
       assert_equal @bad_tags, db.tag_sets
       assert_equal 25, db.acceptable_latency
 
-      db = @client.db('foo', :read => :primary, :tag_sets => @bad_tags, :acceptable_latency => 25)
+      db = @client.db(TEST_DB, :read => :primary, :tag_sets => @bad_tags, :acceptable_latency => 25)
       assert_equal :primary, db.read
       assert_equal @bad_tags, db.tag_sets
       assert_equal 25, db.acceptable_latency
@@ -62,33 +76,33 @@ class ReadTest < Test::Unit::TestCase
 
     context "on DB: " do
       setup do
-        @db = @client['foo']
+        @db = @client[TEST_DB]
       end
 
       should "propogate to collection" do
-        col = @db.collection('bar')
+        col = @db.collection('read-unit-test')
         assert_equal @read, col.read
         assert_equal @tags, col.tag_sets
         assert_equal @acceptable_latency, col.acceptable_latency
 
-        col = @db['bar']
+        col = @db['read-unit-test']
         assert_equal @read, col.read
         assert_equal @tags, col.tag_sets
         assert_equal @acceptable_latency, col.acceptable_latency
 
-        col = Collection.new('bar', @db)
+        col = Collection.new('read-unit-test', @db)
         assert_equal @read, col.read
         assert_equal @tags, col.tag_sets
         assert_equal @acceptable_latency, col.acceptable_latency
       end
 
       should "allow override on collection" do
-        col = @db.collection('bar', :read => :primary, :tag_sets => @bad_tags, :acceptable_latency => 25)
+        col = @db.collection('read-unit-test', :read => :primary, :tag_sets => @bad_tags, :acceptable_latency => 25)
         assert_equal :primary, col.read
         assert_equal @bad_tags, col.tag_sets
         assert_equal 25, col.acceptable_latency
 
-        col = Collection.new('bar', @db, :read => :primary, :tag_sets => @bad_tags, :acceptable_latency => 25)
+        col = Collection.new('read-unit-test', @db, :read => :primary, :tag_sets => @bad_tags, :acceptable_latency => 25)
         assert_equal :primary, col.read
         assert_equal @bad_tags, col.tag_sets
         assert_equal 25, col.acceptable_latency
@@ -97,7 +111,7 @@ class ReadTest < Test::Unit::TestCase
 
     context "on read mode ops" do
       setup do
-        @col = @client['foo']['bar']
+        @col = @client[TEST_DB]['read-unit-test']
         @mock_socket = new_mock_socket
       end
 

data/test/unit/safe_test.rb

@@ -1,6 +1,20 @@
+# 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 SafeTest < Test::Unit::TestCase
+class SafeUnitTest < Test::Unit::TestCase
 
   context "Write-Concern modes on Mongo::Connection " do
     setup do
@@ -9,28 +23,28 @@ class SafeTest < Test::Unit::TestCase
     end
 
     should "propogate to DB" do
-      db = @connection['foo']
+      db = @connection[TEST_DB]
       assert_equal @safe_value[:w], db.write_concern[:w]
 
 
-      db = @connection.db('foo')
+      db = @connection.db(TEST_DB)
       assert_equal @safe_value[:w], db.write_concern[:w]
 
-      db = DB.new('foo', @connection)
+      db = DB.new(TEST_DB, @connection)
       assert_equal @safe_value[:w], db.write_concern[:w]
     end
 
     should "allow db override" do
-      db = DB.new('foo', @connection, :safe => false)
+      db = DB.new(TEST_DB, @connection, :safe => false)
       assert_equal 0, db.write_concern[:w]
 
-      db = @connection.db('foo', :safe => false)
+      db = @connection.db(TEST_DB, :safe => false)
       assert_equal 0, db.write_concern[:w]
     end
 
     context "on DB: " do
       setup do
-        @db = @connection['foo']
+        @db = @connection[TEST_DB]
       end
 
       should "propogate to collection" do
@@ -55,7 +69,7 @@ class SafeTest < Test::Unit::TestCase
 
     context "on operations supporting safe mode" do
       setup do
-        @col = @connection['foo']['bar']
+        @col = @connection[TEST_DB]['bar']
       end
 
       should "use default value on insert" do

data/test/unit/sharding_pool_manager_test.rb

@@ -1,7 +1,21 @@
+# 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 ShardingPoolManagerTest < Test::Unit::TestCase
+class ShardingPoolManagerUnitTest < Test::Unit::TestCase
 
   context "Initialization: " do
 
@@ -17,6 +31,7 @@ class ShardingPoolManagerTest < Test::Unit::TestCase
       @client.stubs(:socket_class).returns(TCPSocket)
       @client.stubs(:mongos?).returns(true)
       @client.stubs(:[]).returns(@db)
+      @client.stubs(:socket_opts)
 
       @client.stubs(:replica_set_name).returns(nil)
       @client.stubs(:log)
@@ -30,8 +45,10 @@ class ShardingPoolManagerTest < Test::Unit::TestCase
       @ismaster = {
         'hosts' => @hosts,
         'arbiters' => @arbiters,
+        'maxBsonObjectSize' => 1024,
         'maxMessageSizeBytes' => 1024 * 2.5,
-        'maxBsonObjectSize' => 1024
+        'maxWireVersion' => 1,
+        'minWireVersion' => 0
       }
     end
 
@@ -43,8 +60,10 @@ class ShardingPoolManagerTest < Test::Unit::TestCase
 
         # Subsequent calls to configure pools.
         @ismaster.merge({'ismaster' => true}),
-        @ismaster.merge({'secondary' => true, 'maxMessageSizeBytes' => 700}),
         @ismaster.merge({'secondary' => true, 'maxBsonObjectSize' => 500}),
+        @ismaster.merge({'secondary' => true, 'maxMessageSizeBytes' => 700}),
+        @ismaster.merge({'secondary' => true, 'maxWireVersion' => 0}),
+        @ismaster.merge({'secondary' => true, 'minWireVersion' => 0}),
         @ismaster.merge({'arbiterOnly' => true})
       )
 
@@ -57,7 +76,9 @@ class ShardingPoolManagerTest < Test::Unit::TestCase
 
       assert manager.seeds.include? formatted_seed
       assert_equal 500, manager.max_bson_size
-      assert_equal 700 , manager.max_message_size
+      assert_equal 700, manager.max_message_size
+      assert_equal 0, manager.max_wire_version
+      assert_equal 0, manager.min_wire_version
     end
   end
 end