mongo 1.11.1 → 1.12.0.rc0

data/test/functional/db_api_test.rb

@@ -315,10 +315,25 @@ class DBAPITest < Test::Unit::TestCase
     cursor = @db.collections_info
     rows = cursor.to_a
     assert rows.length >= 1
-    row = rows.detect { |r| r['name'] == @coll_full_name }
+    if @client.server_version < '2.7.6'
+      row = rows.detect { |r| r['name'] == @coll_full_name }
+    else
+      row = rows.detect { |r| r['name'] == @coll.name }
+    end
     assert_not_nil row
   end
 
+  def test_collections_info_with_name
+    cursor = @db.collections_info(@coll.name)
+    info = cursor.to_a
+    assert_equal 1, info.length
+    if @client.server_version < '2.7.6'
+      assert_equal "#{@db.name}.#{@coll.name}", info.first['name']
+    else
+      assert_equal @coll.name, info.first['name']
+    end
+  end
+
   def test_collection_options
     @db.drop_collection('foobar')
     @db.strict = true

data/test/functional/pool_test.rb

@@ -43,19 +43,22 @@ class PoolTest < Test::Unit::TestCase
   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}}
-    @collection.insert(docs)
+    coll.insert(docs)
 
     threads = []
     threads << Thread.new do
-      @collection.find({"value" => {"$lt" => 100}}).each {|e| e}
+      coll.find({"value" => {"$lt" => 100}}).each {|e| e}
       Thread.pass
       sleep(0.125)
-      @collection.find({"value" => {"$gt" => 100}}).each {|e| e}
+      coll.find({"value" => {"$gt" => 100}}).each {|e| e}
     end
     threads << Thread.new do
-      @collection.find({'$where' => "function() {for(i=0;i<1000;i++) {this.value};}"}).each {|e| e}
+      coll.find({'$where' => "function() {for(i=0;i<500;i++) {this.value};}"}).each {|e| e}
     end
     threads.each(&:join)
   end
@@ -83,7 +86,6 @@ class PoolTest < Test::Unit::TestCase
         :username  => TEST_USER,
         :password  => TEST_USER_PWD,
         :source    => TEST_DB,
-        :mechanism => Mongo::Authentication::DEFAULT_MECHANISM,
         :extra     => {}
     }
     client.auths << creds
@@ -111,7 +113,6 @@ class PoolTest < Test::Unit::TestCase
         :username  => TEST_USER,
         :password  => TEST_USER_PWD,
         :source    => TEST_DB,
-        :mechanism => Mongo::Authentication::DEFAULT_MECHANISM,
         :extra     => {}
     }
     client.auths << creds

data/test/functional/uri_test.rb

@@ -31,6 +31,30 @@ class URITest < Test::Unit::TestCase
     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
@@ -89,6 +113,23 @@ class URITest < Test::Unit::TestCase
     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]
@@ -215,6 +256,11 @@ class URITest < Test::Unit::TestCase
     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
@@ -256,6 +302,34 @@ class URITest < Test::Unit::TestCase
     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)
@@ -288,11 +362,41 @@ class URITest < Test::Unit::TestCase
     parser = Mongo::URIParser.new("mongodb://user@localhost?authMechanism=MONGODB-X509")
     assert_equal 'MONGODB-X509', parser.authmechanism
 
-    assert_raise_error MongoArgumentError  do
+    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]
@@ -319,22 +423,22 @@ class URITest < Test::Unit::TestCase
 
 
     uri = "mongodb://foo%2Fbar%40example.net@localhost?authMechanism=GSSAPI;" +
-            "gssapiServiceName=mongodb;canonicalizeHostName=true"
+            "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][:gssapi_service_name]
+    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 gssapiservicename, authsource, replicaset, w should be case sensitive
-    uri = "mongodb://localhost?gssapiServiceName=MongoDB;" +
-            "authSource=FooBar;" +
+    # options authsource, replicaset, w should be case sensitive
+    uri = "mongodb://localhost?authSource=FooBar;" +
             "replicaSet=Foo;" +
             "w=Majority"
     parser = Mongo::URIParser.new(uri)
-    assert_equal 'MongoDB', parser.gssapiservicename
     assert_equal 'FooBar',  parser.authsource
     assert_equal 'Foo',     parser.replicaset
     assert_equal :Majority, parser.w

data/test/helpers/test_unit.rb

@@ -61,7 +61,7 @@ class Test::Unit::TestCase
 
     uri = "mongodb://#{TEST_USER}:#{TEST_USER_PWD}@" +
             "#{cluster_instance.members_uri}"
-    uri += "?replicaset=#{@rs.repl_set_name}" if cluster_instance.replica_set?
+    uri += "?replicaset=#{@rs.repl_set_name}&sockettimeoutms=60000" if cluster_instance.replica_set?
     instance_variable_set("@uri", uri)
   end
 
@@ -147,6 +147,7 @@ class Test::Unit::TestCase
     begin
       step_down_command = BSON::OrderedHash.new
       step_down_command[:replSetStepDown] = 30
+      step_down_command[:force] = true
       member['admin'].command(step_down_command)
     rescue Mongo::OperationFailure => e
       retry unless (Time.now - start) > timeout
@@ -176,6 +177,13 @@ class Test::Unit::TestCase
     Object.new
   end
 
+  def mock_pool(tags={}, ping_time=15)
+    mock('pool').tap do |pool|
+      pool.stubs(:tags).returns(tags)
+      pool.stubs(:ping_time).returns(ping_time)
+    end
+  end
+
   def assert_raise_error(klass, message=nil)
     begin
       yield
@@ -247,11 +255,17 @@ class Test::Unit::TestCase
   def with_default_journaling(client, &block)
     authenticate_client(client)
     cmd_line_args = client['admin'].command({ :getCmdLineOpts => 1 })['parsed']
-    unless client.server_version < "2.0" || cmd_line_args.include?('nojournal')
+    unless client.server_version < "2.0" || cmd_line_args.include?('nojournal') ||
+      using_heap1_storage_engine?(cmd_line_args)
       yield
     end
   end
 
+  def using_heap1_storage_engine?(cmd_line_args)
+    cmd_line_args.include?('storage') &&
+      cmd_line_args['storage']['engine'] == 'heap1'
+  end
+
   def with_no_replication(client, &block)
     if client.class == MongoClient
       yield
@@ -384,7 +398,7 @@ class Test::Unit::TestCase
         client = Mongo::MongoClient.new(TEST_HOST, TEST_PORT)
         db = client[TEST_DB]
         begin
-          db.authenticate(TEST_USER, TEST_USER_PWD)
+          db.authenticate(TEST_USER, TEST_USER_PWD, nil, 'admin')
         rescue Mongo::AuthenticationError => ex
           roles = [ 'dbAdminAnyDatabase',
                     'userAdminAnyDatabase',

data/test/replica_set/client_test.rb

@@ -216,6 +216,24 @@ class ReplicaSetClientTest < Test::Unit::TestCase
     end
   end
 
+  def test_read_pref_primary_with_tags
+    parser = Mongo::URIParser.new("mongodb://#{@rs.replicas[0].host_port},#{@rs.replicas[1].host_port}" +
+                                    "?replicaset=#{@rs.repl_set_name}&readPreference=primary&" +
+                                    "readPreferenceTags=dc:ny,rack:1")
+    assert_raise_error Mongo::MongoArgumentError do
+      parser.connection.read_pool
+    end
+  end
+
+  def test_read_pref_with_tags
+    parser = Mongo::URIParser.new("mongodb://#{@rs.replicas[0].host_port},#{@rs.replicas[1].host_port}" +
+                                    "?replicaset=#{@rs.repl_set_name}&" +
+                                    "readPreferenceTags=dc:ny,rack:1")
+    assert_raise_error Mongo::MongoArgumentError do
+      parser.connection.read_pool
+    end
+  end
+
   def test_connect_with_connection_string
     @client = MongoClient.from_uri("mongodb://#{@rs.replicas[0].host_port},#{@rs.replicas[1].host_port}?replicaset=#{@rs.repl_set_name}")
     assert !@client.nil?
@@ -344,4 +362,17 @@ class ReplicaSetClientTest < Test::Unit::TestCase
     )
     assert_equal true, collection.find_one({ 'a' => id }, :read => :primary)['processed']
   end
+
+  def test_op_timeout_option
+    client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :connect => false,
+                                                           :op_timeout => nil)
+    assert_equal nil, client.op_timeout
+
+    client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :connect => false,
+                                                           :op_timeout => 50)
+    assert_equal 50, client.op_timeout
+
+    client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :connect => false)
+    assert_equal Mongo::MongoClient::DEFAULT_OP_TIMEOUT, client.op_timeout
+  end
 end

data/test/replica_set/insert_test.rb

@@ -68,47 +68,64 @@ class ReplicaSetInsertTest < Test::Unit::TestCase
     end
 
     should "handle error with deferred write concern error - spec Merging Results" do
-      with_write_commands_and_operations(@db.connection) do |wire_version|
+      if @client.wire_version_feature?(MongoClient::MONGODB_2_8)
         @coll.remove
         @coll.ensure_index(BSON::OrderedHash[:a, Mongo::ASCENDING], {:unique => true})
         bulk = @coll.initialize_ordered_bulk_op
         bulk.insert({:a => 1})
         bulk.find({:a => 2}).upsert.update({'$set' => {:a => 2}})
         bulk.insert({:a => 1})
+        secondary = MongoClient.new(@rs.secondaries.first.host, @rs.secondaries.first.port)
+        cmd = BSON::OrderedHash[:configureFailPoint, 'rsSyncApplyStop', :mode, 'alwaysOn']
+        secondary['admin'].command(cmd)
         ex = assert_raise BulkWriteError do
-          bulk.execute({:w => 5, :wtimeout => 1})
+          bulk.execute({:w => @rs.servers.size, :wtimeout => 1})
+        end
+        cmd = BSON::OrderedHash[:configureFailPoint, 'rsSyncApplyStop', :mode, 'off']
+        secondary['admin'].command(cmd)
+      else
+        with_write_commands_and_operations(@db.connection) do |wire_version|
+          @coll.remove
+          @coll.ensure_index(BSON::OrderedHash[:a, Mongo::ASCENDING], {:unique => true})
+          bulk = @coll.initialize_ordered_bulk_op
+          bulk.insert({:a => 1})
+          bulk.find({:a => 2}).upsert.update({'$set' => {:a => 2}})
+          bulk.insert({:a => 1})
+          ex = assert_raise BulkWriteError do
+            bulk.execute({:w => 5, :wtimeout => 1})
+          end
         end
-        result = ex.result
-        assert_match_document(
-            {
-                "ok" => 1,
-                "n" => 2,
-                "writeErrors" => [
-                    {
-                        "index" => 2,
-                        "code" => 11000,
-                        "errmsg" => /duplicate key error/,
-                    }
-                ],
-                "writeConcernError" => [
-                    {
-                        "errmsg" => /waiting for replication timed out|timed out waiting for slaves|timeout/,
-                        "code" => 64,
-                        "errInfo" => {"wtimeout" => true},
-                        "index" => 0
-                    },
-                    {
-                        "errmsg" => /waiting for replication timed out|timed out waiting for slaves|timeout/,
-                        "code" => 64,
-                        "errInfo" => {"wtimeout" => true},
-                        "index" => 1
-                    }
-                ],
-                "code" => 65,
-                "errmsg" => "batch item errors occurred",
-                "nInserted" => 1
-            }, result, "wire_version:#{wire_version}")
       end
+      result = ex.result
+      assert_match_document(
+          {
+              "ok" => 1,
+              "n" => 2,
+              "writeErrors" => [
+                  {
+                      "index" => 2,
+                      "code" => 11000,
+                      "errmsg" => /duplicate key error/,
+                  }
+              ],
+              "writeConcernError" => [
+                  {
+                      "errmsg" => /waiting for replication timed out|timed out waiting for slaves|timeout/,
+                      "code" => 64,
+                      "errInfo" => {"wtimeout" => true},
+                      "index" => 0
+                  },
+                  {
+                      "errmsg" => /waiting for replication timed out|timed out waiting for slaves|timeout/,
+                      "code" => 64,
+                      "errInfo" => {"wtimeout" => true},
+                      "index" => 1
+                  }
+              ],
+              "code" => 65,
+              "errmsg" => "batch item errors occurred",
+              "nInserted" => 1
+          }, result)
       assert_equal 2, @coll.find.to_a.size
     end
 

data/test/replica_set/pinning_test.rb

@@ -52,4 +52,54 @@ class ReplicaSetPinningTest < Test::Unit::TestCase
     end
     threads.each(&:join)
   end
+
+  def test_aggregation_cursor_pinning
+    return unless @client.server_version >= '2.5.1'
+    @coll.drop
+
+    [10, 1000].each do |size|
+      @coll.drop
+      size.times {|i| @coll.insert({ :_id => i }) }
+      expected_sum = size.times.reduce(:+)
+
+      cursor = @coll.aggregate(
+          [{ :$project => {:_id => '$_id'}} ],
+          :cursor => { :batchSize => 1 }
+      )
+
+      assert_equal Mongo::Cursor, cursor.class
+
+      cursor_sum = cursor.reduce(0) do |sum, doc|
+        sum += doc['_id']
+      end
+
+      assert_equal expected_sum, cursor_sum
+    end
+    @coll.drop
+  end
+
+  def test_parallel_scan_pinning
+    return unless @client.server_version >= '2.5.5'
+    @coll.drop
+
+    8000.times { |i| @coll.insert({ :_id => i }) }
+
+    lock = Mutex.new
+    doc_ids = Set.new
+    threads = []
+    cursors = @coll.parallel_scan(3)
+    cursors.each_with_index do |cursor, i|
+      threads << Thread.new do
+        docs = cursor.to_a
+        lock.synchronize do
+          docs.each do |doc|
+            doc_ids << doc['_id']
+          end
+        end
+      end
+    end
+    threads.each(&:join)
+    assert_equal 8000, doc_ids.count
+    @coll.drop
+  end
 end