mongo 1.10.0.rc0 → 1.10.0.rc1

data/test/functional/cursor_test.rb

@@ -103,7 +103,7 @@ class CursorTest < Test::Unit::TestCase
     end
   end
 
-  def test_server_op_timeout_error
+  def test_max_time_ms_error
     cursor = @@coll.find
     cursor.stubs(:send_initial_query).returns(true)
 
@@ -117,10 +117,10 @@ class CursorTest < Test::Unit::TestCase
     end
   end
 
-  def test_server_op_timeout
+  def test_max_time_ms
     with_forced_timeout(@@connection) do
       assert_raise ExecutionTimeout do
-        cursor = @@coll.find.server_op_timeout(100)
+        cursor = @@coll.find.max_time_ms(100)
         cursor.to_a
       end
     end

data/test/functional/db_api_test.rb

@@ -325,11 +325,11 @@ class DBAPITest < Test::Unit::TestCase
     @@db.strict = true
 
     begin
-      coll = @@db.create_collection('foobar', :capped => true, :size => 1024)
+      coll = @@db.create_collection('foobar', :capped => true, :size => 4096)
       options = coll.options
       assert_equal 'foobar', options['create'] if @@client.server_version < '2.5.5'
       assert_equal true, options['capped']
-      assert_equal 1024, options['size']
+      assert_equal 4096, options['size']
     rescue => ex
       @@db.drop_collection('foobar')
       fail "did not expect exception \"#{ex.inspect}\""

data/test/functional/db_test.rb

@@ -260,6 +260,30 @@ class DBTest < Test::Unit::TestCase
     @@db.eval(function, 'hello', :nolock => true)
   end
 
+  if @@version >= '2.5.3'
+    def test_default_admin_roles
+      # admin user
+      db = Mongo::MongoClient.new()['admin']
+      db.logout
+      silently { db.add_user('admin', 'pass') }
+      db.authenticate('admin', 'pass')
+      info = db.command(:usersInfo => 'admin')['users'].first
+      assert_equal 'root', info['roles'].first['role']
+
+      # read-only admin user
+      silently { db.add_user('ro-admin', 'pass', true) }
+      db.logout
+      db.authenticate('ro-admin', 'pass')
+      info = db.command(:usersInfo => 'ro-admin')['users'].first
+      assert_equal 'readAnyDatabase', info['roles'].first['role']
+      db.logout
+
+      db.authenticate('admin', 'pass')
+      db.command(:dropAllUsersFromDatabase => 1)
+      db.logout
+    end
+  end
+
   if @@version >= "1.3.5"
     def test_db_stats
       stats = @@db.stats

data/test/functional/uri_test.rb

@@ -31,39 +31,39 @@ class URITest < Test::Unit::TestCase
     assert_equal 27018, parser.nodes[0][1]
   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
+    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]
 
-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
+    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')
@@ -310,4 +310,21 @@ end
       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;" +
+            "gssapiServiceName=mongodb;canonicalizeHostName=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][:gssapi_service_name]
+    assert_equal true, parser.auths.first[:extra][:canonicalize_host_name]
+  end
+
 end

data/test/helpers/test_unit.rb

@@ -233,6 +233,11 @@ class Test::Unit::TestCase
     end
   end
 
+  def with_auth(client, &block)
+    cmd_line_args = client['admin'].command({ :getCmdLineOpts => 1 })['parsed']
+    yield if cmd_line_args.include?('auth')
+  end
+
   def with_default_journaling(client, &block)
     cmd_line_args = client['admin'].command({ :getCmdLineOpts => 1 })['parsed']
     unless client.server_version < "2.0" || cmd_line_args.include?('nojournal')
@@ -298,6 +303,9 @@ class Test::Unit::TestCase
     with_write_operations(client, &block)
   end
 
+  def batch_commands?(wire_version)
+    wire_version >= Mongo::MongoClient::BATCH_COMMANDS
+  end
 end
 
 # Before and after hooks for the entire test run

data/test/replica_set/authentication_test.rb

@@ -15,17 +15,21 @@
 require 'test_helper'
 require 'shared/authentication/basic_auth_shared'
 require 'shared/authentication/sasl_plain_shared'
+require 'shared/authentication/bulk_api_auth_shared'
+require 'shared/authentication/gssapi_shared'
 
 class ReplicaSetAuthenticationTest < Test::Unit::TestCase
   include Mongo
   include BasicAuthTests
   include SASLPlainTests
+  include BulkAPIAuthTests
+  include GSSAPITests
 
   def setup
     ensure_cluster(:rs)
     @client    = MongoReplicaSetClient.new(@rs.repl_set_seeds)
+    @version   = @client.server_version
     @db        = @client[TEST_DB]
     @host_info = @rs.repl_set_seeds.join(',')
-    init_auth
   end
 end

data/test/replica_set/client_test.rb

@@ -329,12 +329,13 @@ class ReplicaSetClientTest < Test::Unit::TestCase
   def test_find_and_modify_with_secondary_read_preference
     @client = MongoReplicaSetClient.new @rs.repl_set_seeds
     collection = @client[TEST_DB].collection('test', :read => :secondary)
-    collection << { :a => 1, :processed => false}
+    id = BSON::ObjectId.new
+    collection << { :a => id, :processed => false }
 
     collection.find_and_modify(
-      :query => {},
-      :update => {"$set" => {:processed => true}}
+      :query => { 'a' => id },
+      :update => { "$set" => { :processed => true }}
     )
-    assert_equal collection.find_one({}, :fields => {:_id => 0}, :read => :primary), {'a' => 1, 'processed' => true}
+    assert_equal true, collection.find_one({ 'a' => id }, :read => :primary)['processed']
   end
 end

data/test/replica_set/max_values_test.rb

@@ -135,5 +135,11 @@ class MaxValuesTest < Test::Unit::TestCase
     assert_true @client.use_write_command?({:w => 1})
     assert_false @client.use_write_command?({:w => 0})
   end
+
+  def test_max_write_batch_size
+    assert_equal Mongo::MongoClient::DEFAULT_MAX_WRITE_BATCH_SIZE, @client.max_write_batch_size
+    @client.local_manager.primary_pool.node.stubs(:max_write_batch_size).returns(999)
+    assert_equal 999, @client.max_write_batch_size
+  end
 end
 

data/test/shared/authentication/basic_auth_shared.rb

@@ -14,7 +14,7 @@
 
 module BasicAuthTests
 
-  def init_auth
+  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',
@@ -28,7 +28,7 @@ module BasicAuthTests
     @db.add_user('admin', 'cleanup', nil, :roles => [])
   end
 
-  def teardown
+  def teardown_basic
     remove_all_users(@db, 'admin', 'cleanup')
     remove_all_users(@admin, 'admin', 'password') if has_auth?(@admin.name)
   end
@@ -48,15 +48,21 @@ module BasicAuthTests
   end
 
   def test_add_remove_user
+    init_auth_basic
+
     # add user
     silently { @db.add_user('bob','user') }
     assert @db.authenticate('bob', 'user')
 
     # remove user
     assert @db.remove_user('bob')
+
+    teardown_basic
   end
 
   def test_update_user
+    init_auth_basic
+
     # add user
     silently { @db.add_user('bob', 'user') }
     assert @db.authenticate('bob', 'user')
@@ -68,9 +74,13 @@ module BasicAuthTests
       @db.authenticate('bob', 'user')
     end
     assert @db.authenticate('bob', 'updated')
+
+    teardown_basic
   end
 
   def test_remove_non_existent_user
+    init_auth_basic
+
     if @client.server_version < '2.5'
       assert_equal false, @db.remove_user('joe')
     else
@@ -78,37 +88,49 @@ 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
   end
 
   def test_authenticate_non_existent_user
+    init_auth_basic
     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')
     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
   end
 
   def test_authenticate_with_connection_uri
+    init_auth_basic
     silently { @db.add_user('eunice', 'uritest') }
 
     uri    = "mongodb://eunice:uritest@#{@host_info}/#{@db.name}"
@@ -122,9 +144,11 @@ module BasicAuthTests
     assert_equal @db.name, auth[:db_name]
     assert_equal 'eunice', auth[:username]
     assert_equal 'uritest', auth[:password]
+    teardown_basic
   end
 
   def test_socket_auths
+    init_auth_basic
     # setup
     db_a = @client[TEST_DB + '_a']
     silently { db_a.add_user('user_a', 'password') }
@@ -156,47 +180,70 @@ module BasicAuthTests
     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
+  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']
+
+    # 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
   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('debbie', 'delegate')
+        @db.add_user('debbie', nil, nil, :roles => ['read'], :userSource => accounts.name)
+      end
+      @admin.logout
 
-    # 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)
-    end
-    @admin.logout
+      # validate that direct authentication is not allowed
+      assert_raise Mongo::AuthenticationError do
+        @db.authenticate('debbie', 'delegate')
+      end
 
-    # validate that direct authentication is not allowed
-    assert_raise Mongo::AuthenticationError do
-      @db.authenticate('debbie', 'delegate')
-    end
+      # validate delegated authentication
+      assert accounts.authenticate('debbie', 'delegate')
+      assert @db.collection_names
+      accounts.logout
+      assert_raise Mongo::OperationFailure do
+        @db.collection_names
+      end
 
-    # validate delegated authentication
-    assert accounts.authenticate('debbie', 'delegate')
-    assert @db.collection_names
-    accounts.logout
-    assert_raise Mongo::OperationFailure do
-      @db.collection_names
-    end
+      # validate auth using source database
+      @db.authenticate('debbie', 'delegate', nil, accounts.name)
+      assert @db.collection_names
+      accounts.logout
+      assert_raise Mongo::OperationFailure do
+        @db.collection_names
+      end
 
-    # validate auth using source database
-    @db.authenticate('debbie', 'delegate', nil, accounts.name)
-    assert @db.collection_names
-    accounts.logout
-    assert_raise Mongo::OperationFailure do
-      @db.collection_names
+      # clean-up
+      @admin.authenticate('admin', 'password')
+      remove_all_users(accounts, 'debbie', 'delegate')
+      teardown_basic
     end
-
-    # clean-up
-    @admin.authenticate('admin', 'password')
-    remove_all_users(accounts, 'debbie', 'delegate')
   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'])
@@ -210,6 +257,30 @@ module BasicAuthTests
     @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') }
+      @admin.logout
+      @db.authenticate('emily', 'password')
+      @db['test'].insert({})
+      @db.logout
+
+      @admin.authenticate('admin', 'password')
+      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('admin', 'password')
+      teardown_basic
+    end
   end
 
 end