mongo 1.12.5 → 2.0.0.beta

data/test/functional/pool_test.rb

@@ -1,136 +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 PoolTest < Test::Unit::TestCase
-  include Mongo
-
-  def setup
-    @client    ||= standard_connection({:pool_size => 15, :pool_timeout => 5})
-    @db         = @client.db(TEST_DB)
-    @collection = @db.collection("pool_test")
-  end
-
-  def test_pool_affinity
-    pool = Pool.new(@client, TEST_HOST, TEST_PORT, :size => 5)
-
-    threads = []
-    10.times do
-      threads << Thread.new do
-        original_socket = pool.checkout
-        pool.checkin(original_socket)
-        500.times do
-          socket = pool.checkout
-          assert_equal original_socket, socket
-          pool.checkin(socket)
-        end
-      end
-    end
-
-    threads.each { |t| t.join }
-  end
-
-  def test_pool_affinity_max_size
-    client = standard_connection({:pool_size => 15, :pool_timeout => 5,
-                                  :op_timeout => nil})
-    coll = client[TEST_DB]['pool_test']
-    docs = []
-    8000.times {|x| docs << {:value => x}}
-    coll.insert(docs)
-
-    threads = []
-    threads << Thread.new do
-      coll.find({"value" => {"$lt" => 100}}).each {|e| e}
-      Thread.pass
-      sleep(0.125)
-      coll.find({"value" => {"$gt" => 100}}).each {|e| e}
-    end
-    threads << Thread.new do
-      coll.find({'$where' => "function() {for(i=0;i<500;i++) {this.value};}"}).each {|e| e}
-    end
-    threads.each(&:join)
-  end
-
-  def test_auth_network_error
-    # Make sure there's no semaphore leak if we get a network error
-    # when authenticating a new socket with cached credentials.
-
-    # Get a client with one socket so we detect if it's leaked.
-    client = MongoClient.new(TEST_HOST, TEST_PORT, :pool_size => 1, :pool_timeout => 1)
-    assert_equal 1, client.pool_size
-
-    # Set up the client with a pool
-    client[TEST_DB].command(:ping => 1)
-
-    # Close the one socket in the pool
-    pool = client.primary_pool
-    socket = pool.instance_variable_get(:@sockets).first
-    socket.close
-
-    # Simulate an authenticate() call on a different socket.
-    # Cache the creds on the client.
-    creds = {
-        :db_name   => TEST_DB,
-        :username  => TEST_USER,
-        :password  => TEST_USER_PWD,
-        :source    => TEST_DB,
-        :extra     => {}
-    }
-    client.auths << creds
-
-    # The client authenticates its socket with the
-    # new credential, but gets a socket.error.
-    client[TEST_DB]['ruby-test'].find_one
-
-    # # No semaphore leak, the pool is allowed to make a new socket.
-    assert_equal 1, pool.instance_variable_get(:@sockets).size
-  end
-
-  def test_socket_cleanup
-    # Get a client with one socket so we detect if it's leaked.
-    client = MongoClient.new(TEST_HOST, TEST_PORT, :pool_size => 1, :pool_timeout => 1)
-    assert_equal 1, client.pool_size
-
-    # Set up the client with a pool
-    client[TEST_DB].command(:ping => 1)
-
-    # Simulate an authenticate() call on a different socket.
-    # Cache the creds on the client.
-    creds = {
-        :db_name   => TEST_DB,
-        :username  => TEST_USER,
-        :password  => TEST_USER_PWD,
-        :source    => TEST_DB,
-        :extra     => {}
-    }
-    client.auths << creds
-
-    # Mock the socket to raise a ConnectionFailure when applying auths
-    pool   = client.primary_pool
-    socket = pool.instance_variable_get(:@sockets).first
-    socket.expects(:send).raises(ConnectionFailure)
-
-    # Checkout a socket from the pool to force it to get a new socket
-    pool.checkout
-    new_socket = pool.instance_variable_get(:@sockets).first
-
-    # Make sure the pool is cleaned up properly
-    assert_not_equal socket, new_socket
-    assert_equal 1, pool.instance_variable_get(:@sockets).size
-    assert_equal 1, pool.instance_variable_get(:@thread_ids_to_sockets).size
-    assert !pool.instance_variable_get(:@checked_out).include?(socket)
-    assert !pool.instance_variable_get(:@sockets).include?(socket)
-  end
-end

data/test/functional/safe_test.rb

@@ -1,98 +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 SafeTest < Test::Unit::TestCase
-  context "Safe mode propogation: " do
-    setup do
-      @connection = standard_connection({:safe => true}, true) # Legacy
-      @db         = @connection[TEST_DB]
-      @collection = @db['test-safe']
-      @collection.create_index([[:a, 1]], :unique => true)
-      @collection.remove
-    end
-
-    should "propogate safe option on insert" do
-      @collection.insert({:a => 1})
-
-      assert_raise_error(OperationFailure, "duplicate key") do
-        @collection.insert({:a => 1})
-      end
-    end
-
-    should "allow safe override on insert" do
-      @collection.insert({:a => 1})
-      @collection.insert({:a => 1}, :safe => false)
-    end
-
-    should "allow safe override on save" do
-      @collection.insert({:a => 1})
-      id = @collection.insert({:a => 2})
-      assert_nothing_raised do
-        @collection.save({:_id => id.to_s, :a => 1}, :safe => false)
-      end
-    end
-
-    should "propogate safe option on save" do
-      @collection.insert({:a => 1})
-      id = @collection.insert({:a => 2})
-      assert_raise(OperationFailure) do
-        @collection.save({:_id => id.to_s, :a => 1})
-      end
-    end
-
-    should "propogate safe option on update" do
-      @collection.insert({:a => 1})
-      @collection.insert({:a => 2})
-
-      assert_raise_error(OperationFailure, "duplicate key") do
-        @collection.update({:a => 2}, {:a => 1})
-      end
-    end
-
-    should "allow safe override on update" do
-      @collection.insert({:a => 1})
-      @collection.insert({:a => 2})
-      @collection.update({:a => 2}, {:a => 1}, :safe => false)
-    end
-  end
-
-  context "Safe error objects" do
-    setup do
-      @connection = standard_connection({:safe => true}, true) # Legacy
-      @db         = @connection[TEST_DB]
-      @collection = @db['test']
-      @collection.remove
-      @collection.insert({:a => 1})
-      @collection.insert({:a => 1})
-      @collection.insert({:a => 1})
-    end
-
-    should "return object on update" do
-      response = @collection.update({:a => 1}, {"$set" => {:a => 2}},
-                             :multi => true)
-
-      assert(response['updatedExisting'] || @db.connection.wire_version_feature?(Mongo::MongoClient::BATCH_COMMANDS)) # TODO - review new write command return values
-      assert(response['n'] == 3 || @db.connection.wire_version_feature?(Mongo::MongoClient::BATCH_COMMANDS)) # TODO - update command top pending
-    end
-
-    should "return object on remove" do
-      response = @collection.remove({})
-      assert_equal 3, response['n']
-    end
-  end
-
-end

data/test/functional/support_test.rb

@@ -1,62 +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 SupportTest < Test::Unit::TestCase
-
-  def test_command_response_succeeds
-    assert Support.ok?('ok' => 1)
-    assert Support.ok?('ok' => 1.0)
-    assert Support.ok?('ok' => true)
-  end
-
-  def test_command_response_fails
-    assert !Support.ok?('ok' => 0)
-    assert !Support.ok?('ok' => 0.0)
-    assert !Support.ok?('ok' => 0.0)
-    assert !Support.ok?('ok' => 'str')
-    assert !Support.ok?('ok' => false)
-  end
-
-  def test_array_of_pairs
-    hps = [["localhost", 27017], ["localhost", 27018], ["localhost", 27019]]
-    assert_equal [["localhost", 27017], ["localhost", 27018], ["localhost", 27019]], Support.normalize_seeds(hps)
-  end
-
-  def test_array_of_strings
-    hps = ["localhost:27017", "localhost:27018", "localhost:27019"]
-    assert_equal [["localhost", 27017], ["localhost", 27018], ["localhost", 27019]], Support.normalize_seeds(hps)
-  end
-
-  def test_single_string_with_host_port
-    hps = "localhost:27017"
-    assert_equal ["localhost", 27017], Support.normalize_seeds(hps)
-  end
-
-  def test_single_string_missing_port
-    hps = "localhost"
-    assert_equal ["localhost", 27017], Support.normalize_seeds(hps)
-  end
-
-  def test_single_element_array_missing_port
-    hps = ["localhost"]
-    assert_equal ["localhost", 27017], Support.normalize_seeds(hps)
-  end
-
-  def test_pair_doesnt_get_converted
-    hps = ["localhost", 27017]
-    assert_equal ["localhost", 27017], Support.normalize_seeds(hps)
-  end
-end

data/test/functional/timeout_test.rb

@@ -1,60 +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 TimeoutTest < Test::Unit::TestCase
-
-  def test_op_timeout
-    grant_admin_user_eval_role(standard_connection)
-    connection = standard_connection(:op_timeout => 0.5)
-
-    admin = connection.db('admin')
-
-    command = {:eval => "sleep(100)"}
-    # Should not timeout
-    assert admin.command(command)
-
-    # Should timeout
-    command = {:eval => "sleep(1000)"}
-    assert_raise Mongo::OperationTimeout do
-      admin.command(command)
-    end
-  end
-
-  def test_external_timeout_does_not_leave_socket_in_bad_state
-    client = standard_connection
-    db     = client[TEST_DB]
-    coll   = db['timeout-tests']
-    grant_admin_user_eval_role(client)
-
-    # prepare the database
-    coll.drop
-    coll.insert({:a => 1})
-
-    # use external timeout to mangle socket
-    begin
-      Timeout::timeout(0.5) do
-        db.command({:eval => "sleep(1000)"})
-      end
-    rescue Timeout::Error
-      #puts "Thread timed out and has now mangled the socket"
-    end
-
-    assert_nothing_raised do
-      coll.find_one
-    end
-  end
-
-end

data/test/functional/uri_test.rb

@@ -1,446 +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 URITest < Test::Unit::TestCase
-  include Mongo
-
-  def test_uri_without_port
-    parser = Mongo::URIParser.new('mongodb://localhost')
-    assert_equal 1, parser.nodes.length
-    assert_equal 'localhost', parser.nodes[0][0]
-    assert_equal 27017, parser.nodes[0][1]
-  end
-
-  def test_basic_uri
-    parser = Mongo::URIParser.new('mongodb://localhost:27018')
-    assert_equal 1, parser.nodes.length
-    assert_equal 'localhost', parser.nodes[0][0]
-    assert_equal 27018, parser.nodes[0][1]
-  end
-
-  def test_unix_socket
-    parser = Mongo::URIParser.new('mongodb:///tmp/mongod.sock')
-    assert_equal 1, parser.nodes.length
-    assert_equal '/tmp/mongod.sock', parser.nodes[0][0]
-  end
-
-  def test_unix_socket_with_user
-    parser = Mongo::URIParser.new('mongodb://bob:secret.word@/tmp/mongod.sock')
-    assert_equal 1, parser.nodes.length
-    assert_equal '/tmp/mongod.sock', parser.nodes[0][0]
-    assert_equal "bob", parser.auths.first[:username]
-    assert_equal "secret.word", parser.auths.first[:password]
-    assert_equal 'admin', parser.auths.first[:source]
-  end
-
-  def test_unix_socket_with_db
-    parser = Mongo::URIParser.new('mongodb://bob:secret.word@/tmp/mongod.sock/some_db')
-    assert_equal 1, parser.nodes.length
-    assert_equal '/tmp/mongod.sock', parser.nodes[0][0]
-    assert_equal 'bob', parser.auths.first[:username]
-    assert_equal 'secret.word', parser.auths.first[:password]
-    assert_equal 'some_db', parser.auths.first[:source]
-  end
-
-  def test_ipv6_format
-    parser = Mongo::URIParser.new('mongodb://[::1]:27018')
-    assert_equal 1, parser.nodes.length
-    assert_equal '::1', parser.nodes[0][0]
-    assert_equal 27018, parser.nodes[0][1]
-
-    parser = Mongo::URIParser.new('mongodb://[::1]')
-    assert_equal 1, parser.nodes.length
-    assert_equal '::1', parser.nodes[0][0]
-  end
-
-  def test_ipv6_format_multi
-    parser = Mongo::URIParser.new('mongodb://[::1]:27017,[::1]:27018')
-    assert_equal 2, parser.nodes.length
-    assert_equal '::1', parser.nodes[0][0]
-    assert_equal 27017, parser.nodes[0][1]
-    assert_equal '::1', parser.nodes[1][0]
-    assert_equal 27018, parser.nodes[1][1]
-
-    parser = Mongo::URIParser.new('mongodb://[::1]:27017,localhost:27018')
-    assert_equal 2, parser.nodes.length
-    assert_equal '::1', parser.nodes[0][0]
-    assert_equal 27017, parser.nodes[0][1]
-    assert_equal 'localhost', parser.nodes[1][0]
-    assert_equal 27018, parser.nodes[1][1]
-
-    parser = Mongo::URIParser.new('mongodb://localhost:27017,[::1]:27018')
-    assert_equal 2, parser.nodes.length
-    assert_equal 'localhost', parser.nodes[0][0]
-    assert_equal 27017, parser.nodes[0][1]
-    assert_equal '::1', parser.nodes[1][0]
-    assert_equal 27018, parser.nodes[1][1]
-  end
-
-  def test_multiple_uris
-    parser = Mongo::URIParser.new('mongodb://a.example.com:27018,b.example.com')
-    assert_equal 2, parser.nodes.length
-    assert_equal ['a.example.com', 27018], parser.nodes[0]
-    assert_equal ['b.example.com', 27017], parser.nodes[1]
-  end
-
-  def test_username_without_password
-    parser = Mongo::URIParser.new('mongodb://bob:@localhost?authMechanism=GSSAPI')
-    assert_equal "bob", parser.auths.first[:username]
-    assert_equal nil, parser.auths.first[:password]
-
-    parser = Mongo::URIParser.new('mongodb://bob@localhost?authMechanism=GSSAPI')
-    assert_equal nil, parser.auths.first[:password]
-
-    assert_raise_error MongoArgumentError do
-      Mongo::URIParser.new('mongodb://bob:@localhost')
-    end
-
-    assert_raise_error MongoArgumentError do
-      Mongo::URIParser.new('mongodb://bob@localhost')
-    end
-  end
-
-  def test_username_without_password_unix_socket
-    parser = Mongo::URIParser.new('mongodb://bob:@/tmp/mongod.sock?authMechanism=GSSAPI')
-    assert_equal "bob", parser.auths.first[:username]
-    assert_equal nil, parser.auths.first[:password]
-
-    parser = Mongo::URIParser.new('mongodb://bob@/tmp/mongod.sock?authMechanism=GSSAPI')
-    assert_equal nil, parser.auths.first[:password]
-
-    assert_raise_error MongoArgumentError do
-      Mongo::URIParser.new('mongodb://bob:@/tmp/mongod.sock')
-    end
-
-    assert_raise_error MongoArgumentError do
-      Mongo::URIParser.new('mongodb://bob@/tmp/mongod.sock')
-    end
-  end
-
-  def test_complex_passwords
-    parser = Mongo::URIParser.new('mongodb://bob:secret.word@a.example.com:27018/test')
-    assert_equal "bob", parser.auths.first[:username]
-    assert_equal "secret.word", parser.auths.first[:password]
-
-    parser = Mongo::URIParser.new('mongodb://bob:s-_3#%R.t@a.example.com:27018/test')
-    assert_equal "bob", parser.auths.first[:username]
-    assert_equal "s-_3#%R.t", parser.auths.first[:password]
-
-    assert_raise_error MongoArgumentError do
-      Mongo::URIParser.new('mongodb://doctor:bad:wolf@gallifrey.com:27018/test')
-    end
-
-    assert_raise_error MongoArgumentError do
-      Mongo::URIParser.new('mongodb://doctor:bow@tie@gallifrey.com:27018/test')
-    end
-  end
-
-  def test_complex_usernames
-    parser = Mongo::URIParser.new('mongodb://s-_3#%R.t:secret.word@a.example.com:27018/test')
-    assert_equal "s-_3#%R.t", parser.auths.first[:username]
-
-    assert_raise_error MongoArgumentError do
-      Mongo::URIParser.new('mongodb://doc:tor:badwolf@gallifrey.com:27018/test')
-    end
-
-    assert_raise_error MongoArgumentError do
-      Mongo::URIParser.new('mongodb://d@ctor:bowtie@gallifrey.com:27018/test')
-    end
-  end
-
-  def test_username_with_encoded_symbol
-    parser = Mongo::URIParser.new('mongodb://f%40o:bar@localhost/admin')
-    username = parser.auths.first[:username]
-    assert_equal 'f@o', username
-
-    parser = Mongo::URIParser.new('mongodb://f%3Ao:bar@localhost/admin')
-    username = parser.auths.first[:username]
-    assert_equal 'f:o', username
-  end
-
-  def test_password_with_encoded_symbol
-    parser = Mongo::URIParser.new('mongodb://foo:b%40r@localhost/admin')
-    password = parser.auths.first[:password]
-    assert_equal 'b@r', password
-
-    parser = Mongo::URIParser.new('mongodb://foo:b%3Ar@localhost/admin')
-    password = parser.auths.first[:password]
-    assert_equal 'b:r', password
-  end
-
-  def test_opts_with_semincolon_separator
-    parser = Mongo::URIParser.new('mongodb://localhost:27018?connect=direct;slaveok=true;safe=true')
-    assert_equal 'direct', parser.connect
-    assert parser.direct?
-    assert parser.slaveok
-    assert parser.safe
-  end
-
-  def test_opts_with_amp_separator
-    parser = Mongo::URIParser.new('mongodb://localhost:27018?connect=direct&slaveok=true&safe=true')
-    assert_equal 'direct', parser.connect
-    assert parser.direct?
-    assert parser.slaveok
-    assert parser.safe
-  end
-
-  def test_opts_with_uri_encoded_stuff
-    parser = Mongo::URIParser.new('mongodb://localhost:27018?connect=%64%69%72%65%63%74&slaveok=%74%72%75%65&safe=true')
-    assert_equal 'direct', parser.connect
-    assert parser.direct?
-    assert parser.slaveok
-    assert parser.safe
-  end
-
-  def test_opts_made_invalid_by_mixed_separators
-    assert_raise_error MongoArgumentError, "must not mix URL separators ; and &" do
-      Mongo::URIParser.new('mongodb://localhost:27018?replicaset=foo;bar&slaveok=true&safe=true')
-    end
-  end
-
-  def test_opts_safe
-    parser = Mongo::URIParser.new('mongodb://localhost:27018?safe=true;w=2;journal=true;fsync=true;wtimeoutMS=200')
-    assert parser.safe
-    assert_equal 2, parser.w
-    assert parser.fsync
-    assert parser.journal
-    assert_equal 200, parser.wtimeoutms
-  end
-
-  def test_opts_ssl
-    parser = Mongo::URIParser.new('mongodb://localhost:27018?ssl=true;w=2;journal=true;fsync=true;wtimeoutMS=200')
-    assert parser.ssl
-  end
-
-  def test_opts_nonsafe_timeout
-    parser = Mongo::URIParser.new('mongodb://localhost:27018?connectTimeoutMS=5500&socketTimeoutMS=500')
-    assert_equal 5.5, parser.connecttimeoutms
-    assert_equal 0.5, parser.sockettimeoutms
-  end
-
-  def test_opts_replica_set
-    parser = Mongo::URIParser.new('mongodb://localhost:27018?connect=replicaset;replicaset=foo')
-    assert_equal 'foo', parser.replicaset
-    assert_equal 'replicaset', parser.connect
-    assert parser.replicaset?
-  end
-
-  def test_opts_conflicting_replica_set
-    assert_raise_error MongoArgumentError, "connect=direct conflicts with setting a replicaset name" do
-      Mongo::URIParser.new('mongodb://localhost:27018?connect=direct;replicaset=foo')
-    end
-  end
-
-  def test_case_insensitivity
-    parser = Mongo::URIParser.new('mongodb://localhost:27018?wtimeoutms=500&JOURNAL=true&SaFe=true')
-    assert_equal 500, parser.wtimeoutms
-    assert_equal true, parser.journal
-    assert_equal true, parser.safe
-  end
-
-  def test_read_preference_option_primary
-    parser = Mongo::URIParser.new("mongodb://localhost:27018?readPreference=primary")
-    assert_equal :primary, parser.readpreference
-  end
-
-  def test_read_preference_option_primary_unix_sock
-    parser = Mongo::URIParser.new("mongodb:///tmp/mongod.sock?readPreference=primary")
-    assert_equal :primary, parser.readpreference
-  end
-
-  def test_read_preference_option_primary_preferred
-    parser = Mongo::URIParser.new("mongodb://localhost:27018?readPreference=primaryPreferred")
-    assert_equal :primary_preferred, parser.readpreference
-  end
-
-  def test_read_preference_option_secondary
-    parser = Mongo::URIParser.new("mongodb://localhost:27018?readPreference=secondary")
-    assert_equal :secondary, parser.readpreference
-  end
-
-  def test_read_preference_option_secondary_preferred
-    parser = Mongo::URIParser.new("mongodb://localhost:27018?readPreference=secondaryPreferred")
-    assert_equal :secondary_preferred, parser.readpreference
-  end
-
-  def test_read_preference_option_nearest
-    parser = Mongo::URIParser.new("mongodb://localhost:27018?readPreference=nearest")
-    assert_equal :nearest, parser.readpreference
-  end
-
-  def test_read_preference_option_with_invalid
-    assert_raise_error MongoArgumentError  do
-      Mongo::URIParser.new("mongodb://localhost:27018?readPreference=invalid")
-    end
-  end
-
-  def test_read_preference_connection_options
-    parser = Mongo::URIParser.new("mongodb://localhost:27018?replicaset=test&readPreference=nearest")
-    assert_equal :nearest, parser.connection_options[:read]
-  end
-
-  def test_read_preference_connection_options_with_no_replica_set
-    parser = Mongo::URIParser.new("mongodb://localhost:27018?readPreference=nearest")
-    assert_equal :nearest, parser.connection_options[:read]
-  end
-
-  def test_read_preference_connection_options_prefers_preference_over_slaveok
-    parser = Mongo::URIParser.new("mongodb://localhost:27018?replicaset=test&readPreference=nearest&slaveok=true")
-    assert_equal :nearest, parser.connection_options[:read]
-  end
-
-  def test_read_preference_tags
-    parser = Mongo::URIParser.new("mongodb://localhost:27017?replicaset=test&" +
-                                  "readPreferenceTags=dc:ny,rack:1")
-    expected_tags = [{ 'dc' => 'ny', 'rack' => '1' }]
-    assert_equal expected_tags, parser.connection_options[:tag_sets]
-  end
-
-  def test_read_preference_tags_multiple
-    parser = Mongo::URIParser.new("mongodb://localhost:27017?replicaset=test&" +
-                                  "readPreferenceTags=dc:ny,rack:1&readPreferenceTags=dc:bos")
-    expected_tags = [{'dc' => 'ny', 'rack' => '1'}, { 'dc' => 'bos' }]
-    assert_equal expected_tags, parser.connection_options[:tag_sets]
-  end
-
-  def test_invalid_read_preference_tags
-    assert_raise_error MongoArgumentError do
-      Mongo::URIParser.new("mongodb://localhost:27017?replicaset=test&" +
-                                  "readPreferenceTags=dc")
-    end
-  end
-
-  def test_invalid_read_preference_tags_multiple
-    assert_raise_error MongoArgumentError do
-      Mongo::URIParser.new("mongodb://localhost:27017?replicaset=test&" +
-                                  "readPreferenceTags=dc:nyc&readPreferenceTags=dc")
-    end
-  end
-
-  def test_connection_when_sharded_with_no_options
-    parser = Mongo::URIParser.new("mongodb://localhost:27017,localhost:27018")
-    client = parser.connection({}, false, true)
-    assert_equal [[ "localhost", 27017 ], [ "localhost", 27018 ]], client.seeds
-    assert_true client.mongos?
-  end
-
-  def test_connection_when_sharded_with_options
-    parser = Mongo::URIParser.new("mongodb://localhost:27017,localhost:27018")
-    client = parser.connection({ :refresh_interval => 10 }, false, true)
-    assert_equal [[ "localhost", 27017 ], [ "localhost", 27018 ]], client.seeds
-    assert_equal 10, client.refresh_interval
-    assert_true client.mongos?
-  end
-
-  def test_connection_when_sharded_with_uri_options
-    parser = Mongo::URIParser.new("mongodb://localhost:27017,localhost:27018?readPreference=nearest")
-    client = parser.connection({}, false, true)
-    assert_equal [[ "localhost", 27017 ], [ "localhost", 27018 ]], client.seeds
-    assert_equal :nearest, client.read
-    assert_true client.mongos?
-  end
-
-  def test_auth_source
-    parser = Mongo::URIParser.new("mongodb://user:pass@localhost?authSource=foobar")
-    assert_equal 'foobar', parser.authsource
-  end
-
-  def test_auth_mechanism
-    parser = Mongo::URIParser.new("mongodb://user@localhost?authMechanism=MONGODB-X509")
-    assert_equal 'MONGODB-X509', parser.authmechanism
-
-    assert_raise_error MongoArgumentError do
-      Mongo::URIParser.new("mongodb://user@localhost?authMechanism=INVALID")
-    end
-  end
-
-  def test_auth_mechanism_properties
-    uri = "mongodb://user@localhost?authMechanism=GSSAPI&authMechanismProperties=SERVICE_NAME" +
-            ":mongodb,CANONICALIZE_HOST_NAME:true"
-    parser = Mongo::URIParser.new(uri)
-    properties = {:service_name => "mongodb", :canonicalize_host_name => true}
-    assert_equal properties, parser.authmechanismproperties
-    assert_equal 'GSSAPI', parser.authmechanism
-
-    uri = "mongodb://user@localhost?authMechanism=GSSAPI&authMechanismProperties=SERVICE_NAME" +
-            ":MongoDB,CANONICALIZE_HOST_NAME:false,SERVICE_REALM:test"
-    parser = Mongo::URIParser.new(uri)
-    properties = {:service_name => "MongoDB", :canonicalize_host_name => false, :service_realm => "test"}
-    assert_equal properties, parser.authmechanismproperties
-    assert_equal 'GSSAPI', parser.authmechanism
-  end
-
-  def test_invalid_auth_mechanism_properties
-    uri = "mongodb://user@localhost?authMechanism=GSSAPI&authMechanismProperties=SERVICE_NAME" +
-            ":mongodb,INVALID_PROPERTY:true"
-    assert_raise_error MongoArgumentError do
-      parser = Mongo::URIParser.new(uri)
-    end
-
-    uri = "mongodb://user@localhost?authMechanism=PLAIN&authMechanismProperties="+
-            "SERVICE_NAME:mongodb"
-    assert_raise_error MongoArgumentError do
-      parser = Mongo::URIParser.new(uri)
-    end
-  end
-
-  def test_sasl_plain
-    parser = Mongo::URIParser.new("mongodb://user:pass@localhost?authMechanism=PLAIN")
-    assert_equal 'PLAIN', parser.auths.first[:mechanism]
-    assert_equal 'user', parser.auths.first[:username]
-    assert_equal 'pass', parser.auths.first[:password]
-    assert_equal 'admin', parser.auths.first[:source]
-
-    parser = Mongo::URIParser.new("mongodb://foo%2Fbar%40example.net:pass@localhost/some_db?authMechanism=PLAIN")
-    assert_equal 'PLAIN', parser.auths.first[:mechanism]
-    assert_equal 'foo/bar@example.net', parser.auths.first[:username]
-    assert_equal 'pass', parser.auths.first[:password]
-    assert_equal 'some_db', parser.auths.first[:source]
-
-    assert_raise_error MongoArgumentError  do
-      Mongo::URIParser.new("mongodb://user@localhost/some_db?authMechanism=PLAIN")
-    end
-  end
-
-  def test_gssapi
-    uri = "mongodb://foo%2Fbar%40example.net@localhost?authMechanism=GSSAPI;"
-    parser = Mongo::URIParser.new(uri)
-    assert_equal 'GSSAPI', parser.auths.first[:mechanism]
-    assert_equal 'foo/bar@example.net', parser.auths.first[:username]
-
-
-    uri = "mongodb://foo%2Fbar%40example.net@localhost?authMechanism=GSSAPI;" +
-            "authMechanismProperties=SERVICE_NAME:mongodb,SERVICE_REALM:example," +
-            "CANONICALIZE_HOST_NAME:true"
-    parser = Mongo::URIParser.new(uri)
-    assert_equal 'GSSAPI', parser.auths.first[:mechanism]
-    assert_equal 'foo/bar@example.net', parser.auths.first[:username]
-    assert_equal 'mongodb', parser.auths.first[:extra][:service_name]
-    assert_equal true, parser.auths.first[:extra][:canonicalize_host_name]
-    assert_equal 'example', parser.auths.first[:extra][:service_realm]
-  end
-
-  def test_opts_case_sensitivity
-    # options authsource, replicaset, w should be case sensitive
-    uri = "mongodb://localhost?authSource=FooBar;" +
-            "replicaSet=Foo;" +
-            "w=Majority"
-    parser = Mongo::URIParser.new(uri)
-    assert_equal 'FooBar',  parser.authsource
-    assert_equal 'Foo',     parser.replicaset
-    assert_equal :Majority, parser.w
-  end
-end