mongo 1.8.6 → 1.12.5

data/test/replica_set/cursor_test.rb

@@ -1,3 +1,17 @@
+# 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 ReplicaSetCursorTest < Test::Unit::TestCase
@@ -51,15 +65,17 @@ class ReplicaSetCursorTest < Test::Unit::TestCase
   def setup_client(read=:primary)
     route_read ||= read
     # Setup ReplicaSet Connection
-    @client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :read => read)
+    @client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :read => read, :op_timeout => TEST_OP_TIMEOUT)
+    authenticate_client(@client)
 
-    @db = @client.db(MONGO_TEST_DB)
+    @db = @client.db(TEST_DB)
     @db.drop_collection("cursor_tests")
     @coll = @db.collection("cursor_tests")
     insert_docs
 
     # Setup Direct Connections
     @primary = Mongo::MongoClient.new(*@client.manager.primary)
+    authenticate_client(@primary)
   end
 
   def insert_docs
@@ -79,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
@@ -93,24 +110,26 @@ class ReplicaSetCursorTest < Test::Unit::TestCase
     read_opts[:comment] = object_id
 
     # set profiling level to 2 on client and member to which the query will be routed
-    @client.db(MONGO_TEST_DB).profiling_level = :all
+    @client.db(TEST_DB).profiling_level = :all
     @client.secondaries.each do |node|
       node = Mongo::MongoClient.new(node[0], node[1], :slave_ok => true)
-      node.db(MONGO_TEST_DB).profiling_level = :all
+      authenticate_client(node)
+      node.db(TEST_DB).profiling_level = :all
     end
 
     @cursor = @coll.find({}, read_opts)
     @cursor.next
 
     # on client and other members set profiling level to 0
-    @client.db(MONGO_TEST_DB).profiling_level = :off
+    @client.db(TEST_DB).profiling_level = :off
     @client.secondaries.each do |node|
       node = Mongo::MongoClient.new(node[0], node[1], :slave_ok => true)
-      node.db(MONGO_TEST_DB).profiling_level = :off
+      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
-    profiled_queries = @read.db(MONGO_TEST_DB).collection('system.profile').find({
-      'ns' => "#{MONGO_TEST_DB}.cursor_tests", "query.$comment" => object_id })
+    profiled_queries = @read.db(TEST_DB).collection('system.profile').find({
+      'ns' => "#{TEST_DB}.cursor_tests", "query.$comment" => object_id })
 
     assert_equal 1, profiled_queries.count
   end
@@ -118,6 +137,7 @@ class ReplicaSetCursorTest < Test::Unit::TestCase
   # batch from send_initial_query is 101 documents
   # check that you get n_docs back from the query, with the same port
   def cursor_get_more_test(read=:primary)
+    return if subject_to_server_4754?(@client)
     set_read_client_and_tag(read)
     10.times do
       # assert that the query went to the correct member
@@ -138,6 +158,7 @@ class ReplicaSetCursorTest < Test::Unit::TestCase
 
   # batch from get_more can be huge, so close after send_initial_query
   def kill_cursor_test(read=:primary)
+    return if subject_to_server_4754?(@client)
     set_read_client_and_tag(read)
     10.times do
       # assert that the query went to the correct member
@@ -157,6 +178,7 @@ class ReplicaSetCursorTest < Test::Unit::TestCase
   end
 
   def assert_cursors_on_members(read=:primary)
+    return if subject_to_server_4754?(@client)
     set_read_client_and_tag(read)
     # assert that the query went to the correct member
     route_query(read)

data/test/replica_set/insert_test.rb

@@ -1,11 +1,26 @@
+# 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 ReplicaSetInsertTest < Test::Unit::TestCase
 
   def setup
     ensure_cluster(:rs)
-    @client = MongoReplicaSetClient.new @rs.repl_set_seeds
-    @db = @client.db(MONGO_TEST_DB)
+    @client = MongoReplicaSetClient.from_uri(@uri, :op_timeout => TEST_OP_TIMEOUT)
+    @version = @client.server_version
+    @db = @client.db(TEST_DB)
     @db.drop_collection("test-sets")
     @coll = @db.collection("test-sets")
   end
@@ -47,4 +62,96 @@ class ReplicaSetInsertTest < Test::Unit::TestCase
     end
   end
 
+  context "Bulk API CollectionView" do
+    setup do
+      setup
+    end
+
+    should "handle error with deferred write concern error - spec Merging Results" do
+      if @client.wire_version_feature?(MongoClient::MONGODB_3_0)
+        @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 => @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
+      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
+
+    should "handle unordered errors with deferred write concern error - spec Merging Results" do # TODO - spec review
+      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_unordered_bulk_op
+        bulk.insert({:a => 1})
+        bulk.find({:a => 2}).upsert.update({'$set' => {:a => 1}})
+        bulk.insert({:a => 3})
+        ex = assert_raise BulkWriteError do
+          bulk.execute({:w => 5, :wtimeout => 1})
+        end
+        result = ex.result # unordered varies, don't use assert_bulk_exception
+        assert_equal(1, result["ok"], "wire_version:#{wire_version}")
+        assert_equal(2, result["n"], "wire_version:#{wire_version}")
+        assert(result["nInserted"] >= 1, "wire_version:#{wire_version}")
+        assert_equal(65, result["code"], "wire_version:#{wire_version}")
+        assert_equal("batch item errors occurred", result["errmsg"], "wire_version:#{wire_version}")
+        assert(result["writeErrors"].size >= 1,  "wire_version:#{wire_version}")
+        assert(result["writeConcernError"].size >= 1, "wire_version:#{wire_version}") if wire_version >= 2
+        assert(@coll.size >= 1, "wire_version:#{wire_version}")
+      end
+    end
+
+  end
+
 end

data/test/replica_set/max_values_test.rb

@@ -1,3 +1,17 @@
+# 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 MaxValuesTest < Test::Unit::TestCase
@@ -6,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, :op_timeout => TEST_OP_TIMEOUT)
     @db = new_mock_db
     @client.stubs(:[]).returns(@db)
     @ismaster = {
@@ -15,25 +29,31 @@ class MaxValuesTest < Test::Unit::TestCase
     }
   end
 
-  def test_initial_max_sizes
-    assert @client.max_message_size
+  def test_initial_max_and_min_values
     assert @client.max_bson_size
+    assert @client.max_message_size
+    assert @client.max_wire_version
+    assert @client.min_wire_version
   end
 
-  def test_updated_max_sizes_after_node_config_change
+  def test_updated_max_and_min_sizes_after_node_config_change
     @db.stubs(:command).returns(
       @ismaster.merge({'ismaster' => true}),
       @ismaster.merge({'secondary' => true, 'maxMessageSizeBytes' => 1024 * MESSAGE_SIZE_FACTOR}),
-      @ismaster.merge({'secondary' => true, 'maxBsonObjectSize' => 1024})
+      @ismaster.merge({'secondary' => true, 'maxBsonObjectSize' => 1024}),
+      @ismaster.merge({'secondary' => true, 'maxWireVersion' => 0}),
+      @ismaster.merge({'secondary' => true, 'minWireVersion' => 0})
     )
     @client.local_manager.stubs(:refresh_required?).returns(true)
     @client.refresh
 
     assert_equal 1024, @client.max_bson_size
     assert_equal 1024 * MESSAGE_SIZE_FACTOR, @client.max_message_size
+    assert_equal 0, @client.max_wire_version
+    assert_equal 0, @client.min_wire_version
   end
 
-  def test_neither_max_sizes_in_config
+  def test_no_values_in_config
     @db.stubs(:command).returns(
       @ismaster.merge({'ismaster' => true}),
       @ismaster.merge({'secondary' => true}),
@@ -44,6 +64,8 @@ class MaxValuesTest < Test::Unit::TestCase
 
     assert_equal DEFAULT_MAX_BSON_SIZE, @client.max_bson_size
     assert_equal DEFAULT_MAX_BSON_SIZE * MESSAGE_SIZE_FACTOR, @client.max_message_size
+    assert_equal 0, @client.max_wire_version
+    assert_equal 0, @client.min_wire_version
   end
 
   def test_only_bson_size_in_config
@@ -57,20 +79,73 @@ class MaxValuesTest < Test::Unit::TestCase
 
     assert_equal 1024, @client.max_bson_size
     assert_equal 1024 * MESSAGE_SIZE_FACTOR, @client.max_message_size
+    assert_equal 0, @client.max_wire_version
+    assert_equal 0, @client.min_wire_version
   end
 
-  def test_both_sizes_in_config
+  def test_values_in_config
+    #ismaster is called three times on the first node
     @db.stubs(:command).returns(
-      @ismaster.merge({'ismaster' => true, 'maxMessageSizeBytes' => 1024 * 2 * MESSAGE_SIZE_FACTOR, 'maxBsonObjectSize' => 1024}),
-      @ismaster.merge({'secondary' => true, 'maxMessageSizeBytes' => 1024 * 2 * MESSAGE_SIZE_FACTOR, 'maxBsonObjectSize' => 1024}),
-      @ismaster.merge({'secondary' => true, 'maxMessageSizeBytes' => 1024 * 2 * MESSAGE_SIZE_FACTOR, 'maxBsonObjectSize' => 1024})
+      @ismaster.merge({'ismaster' => true, 'maxMessageSizeBytes' => 1024 * 2 * MESSAGE_SIZE_FACTOR,
+                       'maxBsonObjectSize' => 1024, 'maxWireVersion' => 2, 'minWireVersion' => 1}),
+      @ismaster.merge({'ismaster' => true, 'maxMessageSizeBytes' => 1024 * 2 * MESSAGE_SIZE_FACTOR,
+                       'maxBsonObjectSize' => 1024, 'maxWireVersion' => 2, 'minWireVersion' => 1}),
+      @ismaster.merge({'ismaster' => true, 'maxMessageSizeBytes' => 1024 * 2 * MESSAGE_SIZE_FACTOR,
+                       'maxBsonObjectSize' => 1024, 'maxWireVersion' => 2, 'minWireVersion' => 1}),
+      @ismaster.merge({'secondary' => true, 'maxMessageSizeBytes' => 1024 * 2 * MESSAGE_SIZE_FACTOR,
+                       'maxBsonObjectSize' => 1024, 'maxWireVersion' => 2, 'minWireVersion' => 0}),
+      @ismaster.merge({'secondary' => true, 'maxMessageSizeBytes' => 1024 * 2 * MESSAGE_SIZE_FACTOR,
+                       'maxBsonObjectSize' => 1024, 'maxWireVersion' => 1, 'minWireVersion' => 0})
     )
     @client.local_manager.stubs(:refresh_required?).returns(true)
     @client.refresh
 
     assert_equal 1024, @client.max_bson_size
     assert_equal 1024 * 2 * MESSAGE_SIZE_FACTOR, @client.max_message_size
+    assert_equal 1, @client.max_wire_version # minimum of all max_wire_version
+    assert_equal 1, @client.min_wire_version # maximum of all min_wire_version
+  end
+
+  def test_wire_version_not_in_range
+    min_wire_version, max_wire_version = [Mongo::MongoClient::MIN_WIRE_VERSION-1, Mongo::MongoClient::MIN_WIRE_VERSION-1]
+    #ismaster is called three times on the first node
+    @db.stubs(:command).returns(
+      @ismaster.merge({'ismaster' => true, 'maxWireVersion' => max_wire_version, 'minWireVersion' => min_wire_version}),
+      @ismaster.merge({'ismaster' => true, 'maxWireVersion' => max_wire_version, 'minWireVersion' => min_wire_version}),
+      @ismaster.merge({'ismaster' => true, 'maxWireVersion' => max_wire_version, 'minWireVersion' => min_wire_version}),
+      @ismaster.merge({'secondary' => true, 'maxWireVersion' => max_wire_version, 'minWireVersion' => min_wire_version}),
+      @ismaster.merge({'secondary' => true, 'maxWireVersion' => max_wire_version, 'minWireVersion' => min_wire_version})
+    )
+    @client.local_manager.stubs(:refresh_required?).returns(true)
+    assert_raises Mongo::ConnectionFailure do
+      @client.refresh
+    end
+  end
+
+  def test_use_write_command
+    with_write_commands(@client) do
+      assert_true @client.use_write_command?({:w => 1})
+      assert_false @client.use_write_command?({:w => 0})
+    end
+    with_write_operations(@client) do
+      assert_false @client.use_write_command?({:w => 1})
+      assert_false @client.use_write_command?({:w => 0})
+    end
+    @client.local_manager.primary_pool.node.expects(:wire_version_feature?).at_least_once.returns(true)
+    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
+
+  def test_max_write_batch_size_no_manager
+    # Simulate no local manager being set yet - RUBY-759
+    @client.stubs(:local_manager).returns(nil)
+    assert_equal Mongo::MongoClient::DEFAULT_MAX_WRITE_BATCH_SIZE, @client.max_write_batch_size
+  end
 end
 

data/test/replica_set/pinning_test.rb

@@ -1,10 +1,24 @@
+# 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 ReplicaSetPinningTest < Test::Unit::TestCase
   def setup
     ensure_cluster(:rs)
-    @client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :name => @rs.repl_set_name)
-    @db = @client.db(MONGO_TEST_DB)
+    @client = MongoReplicaSetClient.from_uri(@uri, :op_timeout => TEST_OP_TIMEOUT)
+    @db = @client.db(TEST_DB)
     @coll = @db.collection("test-sets")
     @coll.insert({:a => 1})
   end
@@ -38,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

data/test/replica_set/query_test.rb

@@ -1,17 +1,31 @@
+# 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 ReplicaSetQueryTest < Test::Unit::TestCase
 
   def setup
     ensure_cluster(:rs)
-    @client = MongoReplicaSetClient.new @rs.repl_set_seeds
-    @db = @client.db(MONGO_TEST_DB)
+    @client = MongoReplicaSetClient.from_uri(@uri, :op_timeout => TEST_OP_TIMEOUT)
+    @db = @client.db(TEST_DB)
     @db.drop_collection("test-sets")
     @coll = @db.collection("test-sets")
   end
 
   def teardown
-    @client.close if @conn
+    @client.close if @client
   end
 
   def test_query