mongo 1.10.2 → 1.11.1

data/test/replica_set/count_test.rb

@@ -19,8 +19,10 @@ class ReplicaSetCountTest < Test::Unit::TestCase
   def setup
     ensure_cluster(:rs)
     @client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :read => :primary_preferred)
+    authenticate_client(@client)
     assert @client.primary_pool
     @primary = MongoClient.new(@client.primary_pool.host, @client.primary_pool.port)
+    authenticate_client(@primary)
     @db = @client.db(TEST_DB)
     @db.drop_collection("test-sets")
     @coll = @db.collection("test-sets")

data/test/replica_set/cursor_test.rb

@@ -66,6 +66,7 @@ class ReplicaSetCursorTest < Test::Unit::TestCase
     route_read ||= read
     # Setup ReplicaSet Connection
     @client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :read => read)
+    authenticate_client(@client)
 
     @db = @client.db(TEST_DB)
     @db.drop_collection("cursor_tests")
@@ -74,6 +75,7 @@ class ReplicaSetCursorTest < Test::Unit::TestCase
 
     # Setup Direct Connections
     @primary = Mongo::MongoClient.new(*@client.manager.primary)
+    authenticate_client(@primary)
   end
 
   def insert_docs
@@ -93,6 +95,7 @@ class ReplicaSetCursorTest < Test::Unit::TestCase
         pool = cursor.instance_variable_get(:@pool)
         cursor.close
         @read = Mongo::MongoClient.new(pool.host, pool.port, :slave_ok => true)
+        authenticate_client(@read)
         tag
       rescue Mongo::ConnectionFailure
         false
@@ -110,6 +113,7 @@ class ReplicaSetCursorTest < Test::Unit::TestCase
     @client.db(TEST_DB).profiling_level = :all
     @client.secondaries.each do |node|
       node = Mongo::MongoClient.new(node[0], node[1], :slave_ok => true)
+      authenticate_client(node)
       node.db(TEST_DB).profiling_level = :all
     end
 
@@ -120,6 +124,7 @@ class ReplicaSetCursorTest < Test::Unit::TestCase
     @client.db(TEST_DB).profiling_level = :off
     @client.secondaries.each do |node|
       node = Mongo::MongoClient.new(node[0], node[1], :slave_ok => true)
+      authenticate_client(node)
       node.db(TEST_DB).profiling_level = :off
     end
     # do a query on system.profile of the reader to see if it was used for the query

data/test/replica_set/insert_test.rb

@@ -18,7 +18,7 @@ class ReplicaSetInsertTest < Test::Unit::TestCase
 
   def setup
     ensure_cluster(:rs)
-    @client = MongoReplicaSetClient.new @rs.repl_set_seeds
+    @client = MongoReplicaSetClient.from_uri(@uri)
     @version = @client.server_version
     @db = @client.db(TEST_DB)
     @db.drop_collection("test-sets")

data/test/replica_set/max_values_test.rb

@@ -20,7 +20,7 @@ class MaxValuesTest < Test::Unit::TestCase
 
   def setup
     ensure_cluster(:rs)
-    @client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :name => @rs.repl_set_name)
+    @client = MongoReplicaSetClient.from_uri(@uri)
     @db = new_mock_db
     @client.stubs(:[]).returns(@db)
     @ismaster = {

data/test/replica_set/pinning_test.rb

@@ -17,7 +17,7 @@ require 'test_helper'
 class ReplicaSetPinningTest < Test::Unit::TestCase
   def setup
     ensure_cluster(:rs)
-    @client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :name => @rs.repl_set_name)
+    @client = MongoReplicaSetClient.from_uri(@uri)
     @db = @client.db(TEST_DB)
     @coll = @db.collection("test-sets")
     @coll.insert({:a => 1})

data/test/replica_set/query_test.rb

@@ -18,7 +18,7 @@ class ReplicaSetQueryTest < Test::Unit::TestCase
 
   def setup
     ensure_cluster(:rs)
-    @client = MongoReplicaSetClient.new @rs.repl_set_seeds
+    @client = MongoReplicaSetClient.from_uri(@uri)
     @db = @client.db(TEST_DB)
     @db.drop_collection("test-sets")
     @coll = @db.collection("test-sets")

data/test/replica_set/read_preference_test.rb

@@ -22,6 +22,7 @@ class ReadPreferenceTest < Test::Unit::TestCase
     # Insert data
     primary = @rs.primary
     conn = Connection.new(primary.host, primary.port)
+    authenticate_client(conn)
     db = conn.db(TEST_DB)
     coll = db.collection("test-sets")
     coll.save({:a => 20}, {:w => 2})
@@ -190,12 +191,15 @@ class ReadPreferenceTest < Test::Unit::TestCase
 
     # Setup direct connections
     @primary_direct = Connection.new(@rs.config['host'], @primary.read_pool.port)
+    authenticate_client(@primary_direct)
     @secondary_direct = Connection.new(@rs.config['host'], @secondary.read_pool.port, :slave_ok => true)
+    authenticate_client(@secondary_direct)
   end
 
   def make_connection(mode = :primary, opts = {})
     opts.merge!({:read => mode})
-    MongoReplicaSetClient.new(@rs.repl_set_seeds, opts)
+    client = MongoReplicaSetClient.new(@rs.repl_set_seeds, opts)
+    authenticate_client(client)
   end
 
   def query_count(connection)
@@ -204,6 +208,8 @@ class ReadPreferenceTest < Test::Unit::TestCase
 
   def assert_query_route(test_connection, expected_target)
     #puts "#{test_connection.read_pool.port} #{expected_target.read_pool.port}"
+    authenticate_client(test_connection)
+    authenticate_client(expected_target)
     queries_before = query_count(expected_target)
     assert_nothing_raised do
       test_connection[TEST_DB]['test-sets'].find_one

data/test/replica_set/refresh_test.rb

@@ -23,6 +23,7 @@ class ReplicaSetRefreshTest < Test::Unit::TestCase
   def test_connect_and_manual_refresh_with_secondary_down
     num_secondaries = @rs.secondaries.size
     client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :refresh_mode => false)
+    authenticate_client(client)
 
     assert_equal num_secondaries, client.secondaries.size
     assert client.connected?
@@ -57,6 +58,7 @@ class ReplicaSetRefreshTest < Test::Unit::TestCase
     num_secondaries = @rs.secondaries.size
     client = MongoReplicaSetClient.new(@rs.repl_set_seeds,
       :refresh_interval => 1, :refresh_mode => :sync, :read => :secondary_preferred)
+    authenticate_client(client)
 
     # Ensure secondaries are all recognized by client and client is connected
     assert_equal num_secondaries, client.secondaries.size
@@ -98,6 +100,7 @@ class ReplicaSetRefreshTest < Test::Unit::TestCase
     nthreads = factor * 10
     threads = []
     client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :refresh_mode => :sync, :refresh_interval => 1)
+    authenticate_client(client)
 
     nthreads.times do |i|
       threads << Thread.new do
@@ -123,21 +126,20 @@ class ReplicaSetRefreshTest < Test::Unit::TestCase
     end
   end
 
-
   def test_manager_recursive_locking
-    # See RUBY-775
-    # This tests that there isn't recursive locking when a pool manager reconnects
-    # to all replica set members. The bug in RUBY-775 occurred because the same lock
-    # acquired in order to connect the pool manager was used to read the pool manager's
-    # state.
-    client = MongoReplicaSetClient.new(@rs.repl_set_seeds)
+  # See RUBY-775
+  # This tests that there isn't recursive locking when a pool manager reconnects
+  # to all replica set members. The bug in RUBY-775 occurred because the same lock
+  # acquired in order to connect the pool manager was used to read the pool manager's
+  # state.
+    client = MongoReplicaSetClient.from_uri(@uri)
 
     cursor = client[TEST_DB]['rs-refresh-test'].find
     client.stubs(:receive_message).raises(ConnectionFailure)
     client.manager.stubs(:refresh_required?).returns(true)
     client.manager.stubs(:check_connection_health).returns(true)
     assert_raise ConnectionFailure do
-      cursor.next
+       cursor.next
     end
   end
 
@@ -145,6 +147,7 @@ class ReplicaSetRefreshTest < Test::Unit::TestCase
   def test_automated_refresh_with_removed_node
     client = MongoReplicaSetClient.new(@rs.repl_set_seeds,
       :refresh_interval => 1, :refresh_mode => :sync)
+    authenticate_client(client)
 
     num_secondaries = client.secondary_pools.length
     old_refresh_version = client.refresh_version

data/test/replica_set/replication_ack_test.rb

@@ -18,11 +18,12 @@ class ReplicaSetAckTest < Test::Unit::TestCase
 
   def setup
     ensure_cluster(:rs)
-    @client = MongoReplicaSetClient.new(@rs.repl_set_seeds)
+    @client = MongoReplicaSetClient.from_uri(@uri)
 
     @slave1 = MongoClient.new(
       @client.secondary_pools.first.host,
       @client.secondary_pools.first.port, :slave_ok => true)
+    authenticate_client(@slave1)
 
     assert !@slave1.read_primary?
 

data/test/sharded_cluster/basic_test.rb

@@ -29,7 +29,7 @@ class ShardedClusterBasicTest < Test::Unit::TestCase
 
   # TODO member.primary? ==> true
   def test_connect
-    @client = MongoShardedClient.new(@seeds)
+    @client = sharded_connection
     assert @client.connected?
     assert_equal(@seeds.size, @client.seeds.size)
     probe(@seeds.size)
@@ -54,39 +54,39 @@ class ShardedClusterBasicTest < Test::Unit::TestCase
   end
 
   def test_find_one_with_read_secondary
-    @client = MongoShardedClient.new(@seeds, { :read => :secondary })
+    @client = sharded_connection(:read => :secondary)
     @client[TEST_DB]["users"].insert([ @document ])
     assert_equal @client[TEST_DB]['users'].find_one["name"], "test_user"
   end
 
   def test_find_one_with_read_secondary_preferred
-    @client = MongoShardedClient.new(@seeds, { :read => :secondary_preferred })
+    @client = sharded_connection(:read => :secondary_preferred)
     @client[TEST_DB]["users"].insert([ @document ])
     assert_equal @client[TEST_DB]['users'].find_one["name"], "test_user"
   end
 
   def test_find_one_with_read_primary
-    @client = MongoShardedClient.new(@seeds, { :read => :primary })
+    @client = sharded_connection(:read => :primary)
     @client[TEST_DB]["users"].insert([ @document ])
     assert_equal @client[TEST_DB]['users'].find_one["name"], "test_user"
   end
 
   def test_find_one_with_read_primary_preferred
-    @client = MongoShardedClient.new(@seeds, { :read => :primary_preferred })
+    @client = sharded_connection(:read => :primary_preferred)
     @client[TEST_DB]["users"].insert([ @document ])
     assert_equal @client[TEST_DB]['users'].find_one["name"], "test_user"
   end
 
   def test_read_from_sharded_client
     tags = [{:dc => "mongolia"}]
-    @client = MongoShardedClient.new(@seeds, {:read => :secondary, :tag_sets => tags})
+    @client = sharded_connection(:read => :secondary, :tag_sets => tags)
     assert @client.connected?
     cursor = Cursor.new(@client[TEST_DB]['whatever'], {})
     assert_equal cursor.construct_query_spec['$readPreference'], {:mode => 'secondary', :tags => tags}
   end
 
   def test_hard_refresh
-    @client = MongoShardedClient.new(@seeds)
+    @client = sharded_connection
     assert @client.connected?
     @client.hard_refresh!
     assert @client.connected?
@@ -94,7 +94,7 @@ class ShardedClusterBasicTest < Test::Unit::TestCase
   end
 
   def test_reconnect
-    @client = MongoShardedClient.new(@seeds)
+    @client = sharded_connection
     assert @client.connected?
     router = @sc.servers(:routers).first
     router.stop
@@ -104,7 +104,7 @@ class ShardedClusterBasicTest < Test::Unit::TestCase
   end
 
   def test_mongos_failover
-    @client = MongoShardedClient.new(@seeds, :refresh_interval => 5, :refresh_mode => :sync)
+    @client = sharded_connection(:refresh_interval => 5, :refresh_mode => :sync)
     assert @client.connected?
     # do a find to pin a pool
     @client[TEST_DB]['test'].find_one
@@ -122,7 +122,7 @@ class ShardedClusterBasicTest < Test::Unit::TestCase
   end
 
   def test_all_down
-    @client = MongoShardedClient.new(@seeds)
+    @client = sharded_connection
     assert @client.connected?
     @sc.servers(:routers).each{|router| router.stop}
     assert_raises Mongo::ConnectionFailure do
@@ -133,7 +133,7 @@ class ShardedClusterBasicTest < Test::Unit::TestCase
   end
 
   def test_cycle
-    @client = MongoShardedClient.new(@seeds)
+    @client = sharded_connection
     assert @client.connected?
     routers = @sc.servers(:routers)
     while routers.size > 0 do
@@ -191,7 +191,13 @@ class ShardedClusterBasicTest < Test::Unit::TestCase
 
   private
 
+  def sharded_connection(opts={})
+    client = MongoShardedClient.new(@seeds, opts)
+    authenticate_client(client)
+  end
+
   def probe(size)
+    authenticate_client(@client)
     assert_equal(size, @client['config']['mongos'].find.to_a.size)
   end
 end

data/test/shared/authentication/basic_auth_shared.rb

@@ -15,67 +15,58 @@
 module BasicAuthTests
 
   def init_auth_basic
-    # enable authentication by creating and logging in as admin user
-    @admin = @client['admin']
-    @admin.add_user('admin', 'password', nil, :roles => ['readAnyDatabase',
-                                                         'readWriteAnyDatabase',
-                                                         'userAdminAnyDatabase',
-                                                         'dbAdminAnyDatabase',
-                                                         'clusterAdmin'])
-    @admin.authenticate('admin', 'password')
+    @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_basic
-    remove_all_users(@db, 'admin', 'cleanup')
-    remove_all_users(@admin, 'admin', 'password') if has_auth?(@admin.name)
-  end
+  def teardown
+    @client[TEST_DB].authenticate(TEST_USER, TEST_USER_PWD) unless has_auth?(TEST_DB, TEST_USER)
 
-  def remove_all_users(database, username, password)
-    database.authenticate(username, password) unless has_auth?(database.name)
     if @client.server_version < '2.5'
-      database['system.users'].remove
+      @db['system.users'].remove
     else
-      database.command(:dropAllUsersFromDatabase => 1)
+      @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)
-    @client.auths.any? { |a| a[:source] == db_name }
+  def has_auth?(db_name, username)
+    @client.auths.any? { |a| a[:source] == db_name && a[:username] == username }
   end
 
   def test_add_remove_user
     init_auth_basic
 
     # add user
-    silently { @db.add_user('bob','user') }
-    assert @db.authenticate('bob', 'user')
+    silently { @db.add_user(@test_user, @test_user_pwd) }
+    assert @db.authenticate(@test_user, @test_user_pwd)
 
     # remove user
-    assert @db.remove_user('bob')
-
-    teardown_basic
+    assert @db.remove_user(@test_user)
   end
 
   def test_update_user
     init_auth_basic
 
     # add user
-    silently { @db.add_user('bob', 'user') }
-    assert @db.authenticate('bob', '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('bob', 'updated') }
+    silently { @db.add_user(@test_user, 'updated') }
     assert_raise Mongo::AuthenticationError do
       @db.authenticate('bob', 'user')
     end
     assert @db.authenticate('bob', 'updated')
-
-    teardown_basic
   end
 
   def test_remove_non_existent_user
@@ -88,15 +79,12 @@ module BasicAuthTests
         assert @db.remove_user('joe')
       end
     end
-    teardown_basic
   end
 
   def test_authenticate
     init_auth_basic
-    silently { @db.add_user('peggy', 'user') }
-    assert @db.authenticate('peggy', 'user')
-    @db.remove_user('peggy')
-    teardown_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
@@ -104,47 +92,42 @@ module BasicAuthTests
     assert_raise Mongo::AuthenticationError do
       @db.authenticate('frank', 'thetank')
     end
-    teardown_basic
   end
 
   def test_logout
     init_auth_basic
-    silently { @db.add_user('peggy', 'user') }
-    assert @db.authenticate('peggy', 'user')
+    silently { @db.add_user(@test_user, @test_user_pwd) }
+    assert @db.authenticate(@test_user, @test_user_pwd)
     assert @db.logout
-    teardown_basic
   end
 
   def test_authenticate_with_special_characters
     init_auth_basic
     silently { assert @db.add_user('foo:bar','@foo') }
     assert @db.authenticate('foo:bar','@foo')
-    teardown_basic
   end
 
   def test_authenticate_read_only
     init_auth_basic
-    silently { @db.add_user('randy', 'readonly', true) }
-    assert @db.authenticate('randy', 'readonly')
-    teardown_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('eunice', 'uritest') }
+    silently { @db.add_user(@test_user, @test_user_pwd) }
 
-    uri    = "mongodb://eunice:uritest@#{@host_info}/#{@db.name}"
+    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[TEST_DB]['auth_test'].count
+    assert client[@db.name]['auth_test'].count
 
     auth = client.auths.first
     assert_equal @db.name, auth[:db_name]
-    assert_equal 'eunice', auth[:username]
-    assert_equal 'uritest', auth[:password]
-    teardown_basic
+    assert_equal @test_user, auth[:username]
+    assert_equal @test_user_pwd, auth[:password]
   end
 
   def test_socket_auths
@@ -177,28 +160,30 @@ module BasicAuthTests
 
     # clean-up
     db_b.authenticate('user_b', 'password')
-    remove_all_users(db_a, 'user_a', 'password')
-    remove_all_users(db_b, 'user_b', 'password')
-    remove_all_users(db_c, 'user_c', 'password')
-    teardown_basic
+    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
-    return unless @client.server_version >= '2.5.3'
     init_auth_basic
-    silently { @db.add_user('user', 'pass') }
-    silently { @db.authenticate('user', 'pass') }
-    info = @db.command(:usersInfo => 'user')['users'].first
-    assert_equal 'dbOwner', info['roles'].first['role']
+    @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
 
-    # read-only
-    silently { @db.add_user('ro-user', 'pass', true) }
-    @db.logout
-    @db.authenticate('ro-user', 'pass')
-    info = @db.command(:usersInfo => 'ro-user')['users'].first
-    assert_equal 'read', info['roles'].first['role']
-    @db.logout
-    teardown_basic
+    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
@@ -208,18 +193,18 @@ module BasicAuthTests
       # create user in test databases
       accounts = @client[TEST_DB + '_accounts']
       silently do
-        accounts.add_user('debbie', 'delegate')
-        @db.add_user('debbie', nil, nil, :roles => ['read'], :userSource => accounts.name)
+        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('debbie', 'delegate')
+        @db.authenticate('emily', 'password')
       end
 
       # validate delegated authentication
-      assert accounts.authenticate('debbie', 'delegate')
+      assert accounts.authenticate('emily', 'password')
       assert @db.collection_names
       accounts.logout
       assert_raise Mongo::OperationFailure do
@@ -227,49 +212,27 @@ module BasicAuthTests
       end
 
       # validate auth using source database
-      @db.authenticate('debbie', 'delegate', nil, accounts.name)
+      @db.authenticate('emily', 'password', nil, accounts.name)
       assert @db.collection_names
       accounts.logout
       assert_raise Mongo::OperationFailure do
         @db.collection_names
       end
 
-      # clean-up
-      @admin.authenticate('admin', 'password')
-      remove_all_users(accounts, 'debbie', 'delegate')
-      teardown_basic
+      remove_user(accounts, 'emily', 'password')
     end
   end
 
-  def test_non_admin_default_roles
-    return if @client.server_version < '2.5'
-    init_auth_basic
-
-    # add read-only user and verify that role is 'read'
-    @db.add_user('randy', 'password', nil, :roles => ['read'])
-    @db.authenticate('randy', 'password')
-    users = @db.command(:usersInfo => 'randy')['users']
-    assert_equal 'read', users.first['roles'].first['role']
-    @db.logout
-
-    # add dbOwner (default) user and verify role
-    silently { @db.add_user('emily', 'password') }
-    @db.authenticate('emily', 'password')
-    users = @db.command(:usersInfo => 'emily')['users']
-    assert_equal 'dbOwner', users.first['roles'].first['role']
-    teardown_basic
-  end
-
   def test_update_user_to_read_only
     with_auth(@client) do
       init_auth_basic
-      silently { @db.add_user('emily', 'password') }
+      silently { @db.add_user(@test_user, @test_user_pwd) }
       @admin.logout
-      @db.authenticate('emily', 'password')
+      @db.authenticate(@test_user, @test_user_pwd)
       @db['test'].insert({})
       @db.logout
 
-      @admin.authenticate('admin', 'password')
+      @admin.authenticate(TEST_USER, TEST_USER_PWD)
       silently { @db.add_user('emily', 'password', true) }
       @admin.logout
 
@@ -278,9 +241,7 @@ module BasicAuthTests
         @db['test'].insert({})
       end
       @db.logout
-      @admin.authenticate('admin', 'password')
-      teardown_basic
+      @admin.authenticate(TEST_USER, TEST_USER_PWD)
     end
   end
-
 end