mongo 1.12.5 → 2.0.0

data/test/shared/authentication/basic_auth_shared.rb

@@ -1,260 +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.
-
-module BasicAuthTests
-
-  def init_auth_basic
-    @test_user = 'bob'
-    @test_user_pwd = 'user'
-
-    # db user for cleanup (for pre-2.4)
-    @db.add_user('admin', 'cleanup', nil, :roles => [])
-  end
-
-  def teardown
-    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
-    else
-      @db.command(:dropAllUsersFromDatabase => 1)
-    end
-  end
-
-  def remove_user(database, username, password)
-    database.authenticate(username, password) unless has_auth?(database.name, username)
-    database.remove_user(username)
-    database.logout
-  end
-
-  def has_auth?(db_name, username)
-    @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
-
-    # add user
-    silently { @db.add_user(@test_user, @test_user_pwd) }
-    assert @db.authenticate(@test_user, @test_user_pwd)
-
-    # remove user
-    assert @db.remove_user(@test_user)
-  end
-
-  def test_update_user
-    init_auth_basic
-
-    # add user
-    silently { @db.add_user(@test_user, @test_user_pwd) }
-    assert @db.authenticate(@test_user, @test_user_pwd)
-    @db.logout
-
-    # update user
-    silently { @db.add_user(@test_user, 'updated') }
-    assert_raise Mongo::AuthenticationError do
-      @db.authenticate('bob', 'user')
-    end
-    assert @db.authenticate('bob', 'updated')
-  end
-
-  def test_remove_non_existent_user
-    init_auth_basic
-
-    if @client.server_version < '2.5'
-      assert_equal false, @db.remove_user('joe')
-    else
-      assert_raise Mongo::OperationFailure do
-        assert @db.remove_user('joe')
-      end
-    end
-  end
-
-  def test_authenticate
-    init_auth_basic
-    silently { @db.add_user(@test_user, @test_user_pwd) }
-    assert @db.authenticate(@test_user, @test_user_pwd)
-  end
-
-  def test_authenticate_non_existent_user
-    init_auth_basic
-    assert_raise Mongo::AuthenticationError do
-      @db.authenticate('frank', 'thetank')
-    end
-  end
-
-  def test_logout
-    init_auth_basic
-    silently { @db.add_user(@test_user, @test_user_pwd) }
-    assert @db.authenticate(@test_user, @test_user_pwd)
-    assert @db.logout
-  end
-
-  def test_authenticate_with_special_characters
-    init_auth_basic
-    silently { assert @db.add_user('foo:bar','@foo') }
-    assert @db.authenticate('foo:bar','@foo')
-  end
-
-  def test_authenticate_read_only
-    init_auth_basic
-    silently { @db.add_user(@test_user, @test_user_pwd, true) }
-    assert @db.authenticate(@test_user, @test_user_pwd)
-  end
-
-  def test_authenticate_with_connection_uri
-    init_auth_basic
-    silently { @db.add_user(@test_user, @test_user_pwd) }
-
-    uri    = "mongodb://#{@test_user}:#{@test_user_pwd}@#{@host_info}/#{@db.name}"
-    client = Mongo::URIParser.new(uri).connection
-
-    assert client
-    assert_equal client.auths.size, 1
-    assert client[@db.name]['auth_test'].count
-
-    auth = client.auths.first
-    assert_equal @db.name, auth[:db_name]
-    assert_equal @test_user, auth[:username]
-    assert_equal @test_user_pwd, auth[:password]
-  end
-
-  def test_socket_auths
-    init_auth_basic
-    # setup
-    db_a = @client[TEST_DB + '_a']
-    silently { db_a.add_user('user_a', 'password') }
-    assert db_a.authenticate('user_a', 'password')
-
-    db_b = @client[TEST_DB + '_b']
-    silently { db_b.add_user('user_b', 'password') }
-    assert db_b.authenticate('user_b', 'password')
-
-    db_c = @client[TEST_DB + '_c']
-    silently { db_c.add_user('user_c', 'password') }
-    assert db_c.authenticate('user_c', 'password')
-
-    # client auths should be applied to socket on checkout
-    socket = @client.checkout_reader(:mode => :primary)
-    assert_equal 4, socket.auths.size
-    assert_equal @client.auths, socket.auths
-    @client.checkin(socket)
-
-    # logout should remove saved auth on socket and client
-    assert db_b.logout
-    socket = @client.checkout_reader(:mode => :primary)
-    assert_equal 3, socket.auths.size
-    assert_equal @client.auths, socket.auths
-    @client.checkin(socket)
-
-    # clean-up
-    db_b.authenticate('user_b', 'password')
-    remove_user(db_a, 'user_a', 'password')
-    remove_user(db_b, 'user_b', 'password')
-    remove_user(db_c, 'user_c', 'password')
-  end
-
-  def test_default_roles_non_admin
-    init_auth_basic
-    @db.stubs(:command).returns({}, true)
-    @db.expects(:command).with do |command, cmd_opts|
-      command[:createUser] == @test_user
-      cmd_opts[:roles] == ['dbOwner'] if cmd_opts
-    end
-
-    silently { @db.add_user(@test_user, @test_user_pwd) }
-  end
-
-  def test_default_roles_non_admin_read_only
-    init_auth_basic
-    @db.stubs(:command).returns({}, true)
-    @db.expects(:command).with do |command, cmd_opts|
-      command[:createUser] == @test_user
-      cmd_opts[:roles] == ['read'] if cmd_opts
-    end
-    silently { @db.add_user(@test_user, @test_user_pwd, true) }
-  end
-
-  def test_delegated_authentication
-    return unless @client.server_version >= '2.4' && @client.server_version < '2.5'
-    with_auth(@client) do
-      init_auth_basic
-      # create user in test databases
-      accounts = @client[TEST_DB + '_accounts']
-      silently do
-        accounts.add_user('emily', 'password')
-        @db.add_user('emily', nil, nil, :roles => ['read'], :userSource => accounts.name)
-      end
-      @admin.logout
-
-      # validate that direct authentication is not allowed
-      assert_raise Mongo::AuthenticationError do
-        @db.authenticate('emily', 'password')
-      end
-
-      # validate delegated authentication
-      assert accounts.authenticate('emily', 'password')
-      assert @db.collection_names
-      accounts.logout
-      assert_raise Mongo::OperationFailure do
-        @db.collection_names
-      end
-
-      # validate auth using source database
-      @db.authenticate('emily', 'password', nil, accounts.name)
-      assert @db.collection_names
-      accounts.logout
-      assert_raise Mongo::OperationFailure do
-        @db.collection_names
-      end
-
-      remove_user(accounts, 'emily', 'password')
-    end
-  end
-
-  def test_update_user_to_read_only
-    with_auth(@client) do
-      init_auth_basic
-      silently { @db.add_user(@test_user, @test_user_pwd) }
-      @admin.logout
-      @db.authenticate(@test_user, @test_user_pwd)
-      @db['test'].insert({})
-      @db.logout
-
-      @admin.authenticate(TEST_USER, TEST_USER_PWD)
-      silently { @db.add_user('emily', 'password', true) }
-      @admin.logout
-
-      silently { @db.authenticate('emily', 'password') }
-      assert_raise Mongo::OperationFailure do
-        @db['test'].insert({})
-      end
-      @db.logout
-      @admin.authenticate(TEST_USER, TEST_USER_PWD)
-    end
-  end
-end

data/test/shared/authentication/bulk_api_auth_shared.rb

@@ -1,249 +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.0x
-#
-# 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 BulkAPIAuthTests
-
-  include Mongo
-
-  def init_auth_bulk
-    # Set up the test db
-    @collection = @db["bulk-api-auth-tests"]
-
-    # db user can insert but not remove
-    res = BSON::OrderedHash.new
-    res[:db] = @db.name
-    res[:collection] = ""
-
-    cmd = BSON::OrderedHash.new
-    cmd[:createRole] = "insertOnly"
-    cmd[:privileges] = [{:resource => res, :actions => [ "insert", "find" ]}]
-    cmd[:roles] = []
-    @db.command(cmd)
-    @db.add_user('insertOnly', 'password', nil, :roles => ['insertOnly'])
-
-    # db user can insert and remove
-    cmd = BSON::OrderedHash.new
-    cmd[:createRole] = "insertAndRemove"
-    cmd[:privileges] = [{:resource => res, :actions => [ "insert", "remove", "find" ]}]
-    cmd[:roles] = []
-    @db.command(cmd)
-    @db.add_user('insertAndRemove', 'password', nil, :roles => ['insertAndRemove'])
-
-    @admin.logout
-  end
-
-  def clear_collection(collection)
-    @admin.authenticate(TEST_USER, TEST_USER_PWD)
-    collection.remove
-    @admin.logout
-  end
-
-  def teardown_bulk
-    remove_all_users_and_roles(@db)
-    remove_all_users_and_roles(@admin)
-  end
-
-  def remove_all_users_and_roles(database)
-    @admin.authenticate(TEST_USER, TEST_USER_PWD)
-    if @version < '2.5.3'
-      database['system.users'].remove
-    else
-      database.command({:dropAllRolesFromDatabase => 1})
-      # Don't delete the TEST_USER from the TEST_DB, it is needed for future tests
-      database.command({:dropAllUsersFromDatabase => 1}) unless database.name == TEST_DB
-    end
-    @admin.logout
-  end
-
-  def test_auth_no_error
-    return unless @version >= '2.5.3'
-    init_auth_bulk
-    with_write_commands_and_operations(@db.connection) do |wire_version|
-      clear_collection(@collection)
-      @db.authenticate('insertAndRemove', 'password')
-      bulk = @collection.initialize_ordered_bulk_op
-      bulk.insert({:a => 1})
-      bulk.find({:a => 1}).remove_one
-
-      result = bulk.execute
-      assert_match_document(
-          {
-              "ok" => 1,
-              "nInserted" => 1,
-              "nRemoved" => 1
-          }, result, "wire_version:#{wire_version}")
-      assert_equal 0, @collection.count
-      @db.logout
-    end
-    teardown_bulk
-  end
-
-  def test_auth_error
-    return unless @version >= '2.5.3'
-    init_auth_bulk
-    with_write_commands_and_operations(@db.connection) do |wire_version|
-      clear_collection(@collection)
-      @db.authenticate('insertOnly', 'password')
-      bulk = @collection.initialize_ordered_bulk_op
-      bulk.insert({:a => 1})
-      bulk.find({:a => 1}).remove
-      bulk.insert({:a => 2})
-
-      ex = assert_raise Mongo::BulkWriteError do
-        bulk.execute
-      end
-      result = ex.result
-      assert_match_document(
-          {
-              "ok" => 1,
-              "n" => 1,
-              "writeErrors" =>
-                  [{
-                       "index" => 1,
-                       "code" => 13,
-                       "errmsg" => /not authorized/
-                  }],
-              "code" => 65,
-              "errmsg" => "batch item errors occurred",
-              "nInserted" => 1
-           }, result, "wire_version:#{wire_version}")
-      assert_equal 1, @collection.count
-      @db.logout
-    end
-    teardown_bulk
-  end
-
-  def test_auth_error_unordered
-    return unless @version >= '2.5.3'
-    init_auth_bulk
-    with_write_commands_and_operations(@db.connection) do |wire_version|
-      clear_collection(@collection)
-      @db.authenticate('insertOnly', 'password')
-      bulk = @collection.initialize_unordered_bulk_op
-      bulk.insert({:a => 1})
-      bulk.find({:a => 1}).remove_one
-      bulk.insert({:a => 2})
-
-      ex = assert_raise Mongo::BulkWriteError do
-        bulk.execute
-      end
-      result = ex.result
-      assert_equal 1, result["writeErrors"].length
-      assert_equal 2, result["n"]
-      assert_equal 2, result["nInserted"]
-      assert_equal 2, @collection.count
-      @db.logout
-    end
-    teardown_bulk
-  end
-
-  def test_duplicate_key_with_auth_error
-    return unless @version >= '2.5.3'
-    init_auth_bulk
-    with_write_commands_and_operations(@db.connection) do |wire_version|
-      clear_collection(@collection)
-      @db.authenticate('insertOnly', 'password')
-      bulk = @collection.initialize_ordered_bulk_op
-      bulk.insert({:_id => 1, :a => 1})
-      bulk.insert({:_id => 1, :a => 2})
-      bulk.find({:a => 1}).remove_one
-
-      ex = assert_raise Mongo::BulkWriteError do
-        bulk.execute
-      end
-      result = ex.result
-      assert_match_document(
-          {
-              "ok" => 1,
-              "n" => 1,
-              "writeErrors" =>
-                  [{
-                       "index" => 1,
-                       "code" => 11000,
-                       "errmsg" => /duplicate key error/
-                  }],
-              "code" => 65,
-              "errmsg" => "batch item errors occurred",
-              "nInserted" => 1
-           }, result, "wire_version:#{wire_version}")
-      assert_equal 1, @collection.count
-      @db.logout
-    end
-    teardown_bulk
-  end
-
-  def test_duplicate_key_with_auth_error_unordered
-    return unless @version >= '2.5.3'
-    init_auth_bulk
-    with_write_commands_and_operations(@db.connection) do |wire_version|
-      clear_collection(@collection)
-      @db.authenticate('insertOnly', 'password')
-      bulk = @collection.initialize_unordered_bulk_op
-      bulk.insert({:_id => 1, :a => 1})
-      bulk.insert({:_id => 1, :a => 1})
-      bulk.find({:a => 1}).remove_one
-
-      ex = assert_raise Mongo::BulkWriteError do
-        bulk.execute
-      end
-      result = ex.result
-      assert_equal 2, result["writeErrors"].length
-      assert_equal 1, result["n"]
-      assert_equal 1, result["nInserted"]
-      assert_equal 1, @collection.count
-      @db.logout
-    end
-    teardown_bulk
-  end
-
-  def test_write_concern_error_with_auth_error
-    with_no_replication(@db.connection) do
-      return unless @version >= '2.5.3'
-      init_auth_bulk
-      with_write_commands_and_operations(@db.connection) do |wire_version|
-        clear_collection(@collection)
-        @db.authenticate('insertOnly', 'password')
-        bulk = @collection.initialize_ordered_bulk_op
-        bulk.insert({:_id => 1, :a => 1})
-        bulk.insert({:_id => 2, :a => 1})
-        bulk.find({:a => 1}).remove_one
-        
-        ex = assert_raise Mongo::BulkWriteError do
-          bulk.execute({:w => 2})
-        end
-        result = ex.result
-        
-        assert_match_document(
-            {
-                "ok" => 0,
-                "n" => 0,
-                "nInserted" => 0,
-                "writeErrors" =>
-                    [{
-                         "index" => 0,
-                         "code" => 2,
-                         "errmsg" => /'w' > 1/
-                    }],
-                "code" => 65,
-                "errmsg" => "batch item errors occurred"
-             }, result, "wire_version#{wire_version}")
-# Re-visit this when RUBY-731 is resolved:
-        assert (@collection.count == batch_commands?(wire_version) ? 0 : 1)
-        @db.logout
-      end
-      teardown_bulk
-    end
-  end
-
-end

data/test/shared/authentication/gssapi_shared.rb

@@ -1,176 +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.
-
-module GSSAPITests
-
-  # Tests for the GSSAPI Authentication Mechanism.
-  #
-  # Note: These tests will be skipped automatically unless the test environment
-  # has been configured.  
-  #
-  # In order to run these tests, you must be using JRuby and must set the following
-  #   environment variables. The realm and KDC are required so that the corresponding
-  #   system properties can be set:
-  #
-  #   export MONGODB_GSSAPI_HOST='server.domain.com'
-  #   export MONGODB_GSSAPI_USER='applicationuser@example.com'
-  #   export MONGODB_GSSAPI_REALM='applicationuser@example.com'
-  #   export MONGODB_GSSAPI_KDC='SERVER.DOMAIN.COM'
-  #
-  # You must use kinit when on MRI.
-  # You have the option of providing a config file that references a keytab file on JRuby:
-  #
-  #   export JAAS_LOGIN_CONFIG_FILE='file:///path/to/config/file'
-  #
-  MONGODB_GSSAPI_HOST    = ENV['MONGODB_GSSAPI_HOST']
-  MONGODB_GSSAPI_USER    = ENV['MONGODB_GSSAPI_USER']
-  MONGODB_GSSAPI_REALM   = ENV['MONGODB_GSSAPI_REALM']
-  MONGODB_GSSAPI_KDC     = ENV['MONGODB_GSSAPI_KDC']
-  MONGODB_GSSAPI_PORT    = ENV['MONGODB_GSSAPI_PORT'] || '27017'
-  MONGODB_GSSAPI_DB      = ENV['MONGODB_GSSAPI_DB']
-  JAAS_LOGIN_CONFIG_FILE = ENV['JAAS_LOGIN_CONFIG_FILE'] # only JRuby
-
-  if ENV.key?('MONGODB_GSSAPI_HOST') && ENV.key?('MONGODB_GSSAPI_USER') &&
-     ENV.key?('MONGODB_GSSAPI_REALM') && ENV.key?('MONGODB_GSSAPI_KDC') &&
-     ENV.key?('MONGODB_GSSAPI_DB')
-    def test_gssapi_authenticate
-      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}"])
-      end
-
-      set_system_properties
-      db = client[MONGODB_GSSAPI_DB]
-      db.authenticate(MONGODB_GSSAPI_USER, nil, nil, nil, 'GSSAPI')
-      assert db.command(:dbstats => 1)
-
-      threads = []
-      4.times do
-        threads << Thread.new do
-          assert db.command(:dbstats => 1)
-        end
-      end
-      threads.each(&:join)
-    end
-
-    def test_gssapi_authenticate_uri
-      require 'cgi'
-      set_system_properties
-      username = CGI::escape(ENV['MONGODB_GSSAPI_USER'])
-      uri = "mongodb://#{username}@#{ENV['MONGODB_GSSAPI_HOST']}:#{ENV['MONGODB_GSSAPI_PORT']}/?" +
-         "authMechanism=GSSAPI"
-      client = @client.class.from_uri(uri)
-      assert client[MONGODB_GSSAPI_DB].command(:dbstats => 1)
-    end
-
-    def test_wrong_service_name_fails
-      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}"])
-      end
-
-      set_system_properties
-      assert_raise_error Mongo::AuthenticationError do
-        client[MONGODB_GSSAPI_DB].authenticate(MONGODB_GSSAPI_USER, nil, nil, nil, 'GSSAPI', extra_opts)
-      end
-    end
-
-    def test_wrong_service_name_fails_uri
-      set_system_properties
-
-      require 'cgi'
-      username = CGI::escape(ENV['MONGODB_GSSAPI_USER'])
-      uri = "mongodb://#{username}@#{ENV['MONGODB_GSSAPI_HOST']}:#{ENV['MONGODB_GSSAPI_PORT']}/?" +
-         "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)
-      end
-    end
-
-    def test_extra_opts
-      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[: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 = { :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[: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&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)
-    end
-
-    # In order to run this test, you must set the following environment variable:
-    #
-    #   export MONGODB_GSSAPI_HOST_IP='---.---.---.---'
-    #
-    if ENV.key?('MONGODB_GSSAPI_HOST_IP')
-      def test_canonicalize_host_name
-        extra_opts = { :canonicalize_host_name => true }
-        set_system_properties
-        client = Mongo::MongoClient.new(ENV['MONGODB_GSSAPI_HOST_IP'], MONGODB_GSSAPI_PORT)
-
-        db = client[MONGODB_GSSAPI_DB]
-        db.authenticate(MONGODB_GSSAPI_USER, nil, nil, nil, 'GSSAPI', extra_opts)
-        assert db.command(:dbstats => 1)
-      end
-    end
-
-    def test_invalid_extra_options
-      extra_opts = { :invalid => true, :option => true }
-      client = Mongo::MongoClient.new(MONGODB_GSSAPI_HOST)
-
-      assert_raise Mongo::MongoArgumentError do
-        client[MONGODB_GSSAPI_DB].authenticate(MONGODB_GSSAPI_USER, nil, nil, nil, 'GSSAPI', extra_opts)
-      end
-    end
-
-    private
-    def set_system_properties
-      if RUBY_PLATFORM =~ /java/
-        java.lang.System.set_property 'javax.security.auth.useSubjectCredsOnly', 'false'
-        java.lang.System.set_property "java.security.krb5.realm", MONGODB_GSSAPI_REALM
-        java.lang.System.set_property "java.security.krb5.kdc", MONGODB_GSSAPI_KDC
-        java.lang.System.set_property "java.security.auth.login.config", JAAS_LOGIN_CONFIG_FILE if JAAS_LOGIN_CONFIG_FILE
-      end
-    end
-  end
-
-end