mongo 1.10.0.rc0 → 1.10.0.rc1

data/test/functional/client_test.rb

@@ -334,12 +334,13 @@ class ClientTest < Test::Unit::TestCase
     conn = standard_connection(:connect => false)
 
     admin_db = Object.new
-    admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1, 'maxWireVersion' => 1, 'minWireVersion' => 1})
+    admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1, 'maxWireVersion' => 1, 'minWireVersion' => 1, 'maxWriteBatchSize' => 999})
     conn.expects(:[]).with('admin').returns(admin_db)
     conn.connect
 
     assert_equal 1, conn.max_wire_version
     assert_equal 1, conn.min_wire_version
+    assert_equal 999, conn.max_write_batch_size
   end
 
   def test_max_wire_version_and_min_wire_version_values_with_no_reported_values
@@ -352,6 +353,7 @@ class ClientTest < Test::Unit::TestCase
 
     assert_equal 0, conn.max_wire_version
     assert_equal 0, conn.min_wire_version
+    assert_equal Mongo::MongoClient::DEFAULT_MAX_WRITE_BATCH_SIZE, conn.max_write_batch_size
   end
 
   def test_wire_version_feature

data/test/functional/collection_test.rb

@@ -96,7 +96,265 @@ class CollectionTest < Test::Unit::TestCase
     end
   end
 
+  if @@version >= '2.5.4'
+
+    def test_single_delete_write_command
+      @@test.drop
+      @@test.insert([{ :a => 1 }, { :a => 1 }])
+
+      command = {
+        'delete' => @@test.name,
+        :deletes => [{ :q => { :a => 1 }, :limit => 1 }],
+        :writeConcern => { :w => 1 },
+        :ordered => false
+      }
+
+      result = @@db.command(command)
+      assert_equal 1, result['n']
+      assert_equal 1, result['ok']
+      assert_equal 1, @@test.count
+    end
+
+    def test_multi_ordered_delete_write_command
+      @@test.drop
+      @@test.insert([{ :a => 1 }, { :a => 1 }])
+
+      command = {
+        'delete' => @@test.name,
+        :deletes => [{ :q => { :a => 1 }, :limit => 0 }],
+        :writeConcern => { :w => 1 },
+        :ordered => true
+      }
+
+      result = @@db.command(command)
+      assert_equal 2, result['n']
+      assert_equal 1, result['ok']
+      assert_equal 0, @@test.count
+    end
+
+    def test_multi_unordered_delete_write_command
+      @@test.drop
+      @@test.insert([{ :a => 1 }, { :a => 1 }])
+
+      command = {
+        'delete' => @@test.name,
+        :deletes => [{ :q => { :a => 1 }, :limit => 0 }],
+        :writeConcern => { :w => 1 },
+        :ordered => false
+      }
+
+      result = @@db.command(command)
+      assert_equal 2, result['n']
+      assert_equal 1, result['ok']
+      assert_equal 0, @@test.count
+    end
+
+    def test_delete_write_command_with_no_concern
+      @@test.drop
+      @@test.insert([{ :a => 1 }, { :a => 1 }])
+
+      command = {
+        'delete' => @@test.name,
+        :deletes => [{ :q => { :a => 1 }, :limit => 0 }],
+        :ordered => false
+      }
+
+      result = @@db.command(command)
+      assert_equal 2, result['n']
+      assert_equal 1, result['ok']
+      assert_equal 0, @@test.count
+    end
+
+    def test_delete_write_command_with_error
+      @@test.drop
+      @@test.insert([{ :a => 1 }, { :a => 1 }])
+
+      command = {
+        'delete' => @@test.name,
+        :deletes => [{ :q => { '$set' => { :a => 1 }}, :limit => 0 }],
+        :writeConcern => { :w => 1 },
+        :ordered => false
+      }
+
+      assert_raise Mongo::OperationFailure do
+        @@db.command(command)
+      end
+    end
+
+    def test_single_insert_write_command
+      @@test.drop
+
+      command = {
+        'insert' => @@test.name,
+        :documents => [{ :a => 1 }],
+        :writeConcern => { :w => 1 },
+        :ordered => false
+      }
+
+      result = @@db.command(command)
+      assert_equal 1, result['ok']
+      assert_equal 1, @@test.count
+    end
+
+    def test_multi_ordered_insert_write_command
+      @@test.drop
+
+      command = {
+        'insert' => @@test.name,
+        :documents => [{ :a => 1 }, { :a => 2 }],
+        :writeConcern => { :w => 1 },
+        :ordered => true
+      }
+
+      result = @@db.command(command)
+      assert_equal 1, result['ok']
+      assert_equal 2, @@test.count
+    end
+
+    def test_multi_unordered_insert_write_command
+      @@test.drop
+
+      command = {
+        'insert' => @@test.name,
+        :documents => [{ :a => 1 }, { :a => 2 }],
+        :writeConcern => { :w => 1 },
+        :ordered => false
+      }
+
+      result = @@db.command(command)
+      assert_equal 1, result['ok']
+      assert_equal 2, @@test.count
+    end
+
+    def test_insert_write_command_with_no_concern
+      @@test.drop
+
+      command = {
+        'insert' => @@test.name,
+        :documents => [{ :a => 1 }, { :a => 2 }],
+        :ordered => false
+      }
+
+      result = @@db.command(command)
+      assert_equal 1, result['ok']
+      assert_equal 2, @@test.count
+    end
+
+    def test_insert_write_command_with_error
+      @@test.drop
+      @@test.ensure_index({ :a => 1 }, { :unique => true })
+
+      command = {
+        'insert' => @@test.name,
+        :documents => [{ :a => 1 }, { :a => 1 }],
+        :writeConcern => { :w => 1 },
+        :ordered => false
+      }
+
+      assert_raise Mongo::OperationFailure do
+        @@db.command(command)
+      end
+    end
+
+    def test_single_update_write_command
+      @@test.drop
+      @@test.insert([{ :a => 1 }, { :a => 2 }])
+
+      command = {
+        'update' => @@test.name,
+        :updates => [{ :q => { :a => 1 }, :u => { '$set' => { :a => 2 }}}],
+        :writeConcern => { :w => 1 }
+      }
+
+      result = @@db.command(command)
+      assert_equal 1, result['ok']
+      assert_equal 1, result['n']
+      assert_equal 2, @@test.find({ :a => 2 }).count
+    end
+
+    def test_multi_ordered_update_write_command
+      @@test.drop
+      @@test.insert([{ :a => 1 }, { :a => 3 }])
+
+      command = {
+        'update' => @@test.name,
+        :updates => [
+          { :q => { :a => 1 }, :u => { '$set' => { :a => 2 }}},
+          { :q => { :a => 3 }, :u => { '$set' => { :a => 4 }}}
+        ],
+        :writeConcern => { :w => 1 },
+        :ordered => true
+      }
+
+      result = @@db.command(command)
+      assert_equal 1, result['ok']
+      assert_equal 2, result['n']
+      assert_equal 1, @@test.find({ :a => 2 }).count
+      assert_equal 1, @@test.find({ :a => 4 }).count
+    end
+
+    def test_multi_unordered_update_write_command
+      @@test.drop
+      @@test.insert([{ :a => 1 }, { :a => 3 }])
+
+      command = {
+        'update' => @@test.name,
+        :updates => [
+          { :q => { :a => 1 }, :u => { '$set' => { :a => 2 }}},
+          { :q => { :a => 3 }, :u => { '$set' => { :a => 4 }}}
+        ],
+        :writeConcern => { :w => 1 },
+        :ordered => false
+      }
+
+      result = @@db.command(command)
+      assert_equal 1, result['ok']
+      assert_equal 2, result['n']
+      assert_equal 1, @@test.find({ :a => 2 }).count
+      assert_equal 1, @@test.find({ :a => 4 }).count
+    end
+
+    def test_update_write_command_with_no_concern
+      @@test.drop
+      @@test.insert([{ :a => 1 }, { :a => 3 }])
+
+      command = {
+        'update' => @@test.name,
+        :updates => [
+          { :q => { :a => 1 }, :u => { '$set' => { :a => 2 }}},
+          { :q => { :a => 3 }, :u => { '$set' => { :a => 4 }}}
+        ],
+        :ordered => false
+      }
+
+      result = @@db.command(command)
+      assert_equal 1, result['ok']
+      assert_equal 2, result['n']
+      assert_equal 1, @@test.find({ :a => 2 }).count
+      assert_equal 1, @@test.find({ :a => 4 }).count
+    end
+
+    def test_update_write_command_with_error
+      @@test.drop
+      @@test.ensure_index({ :a => 1 }, { :unique => true })
+      @@test.insert([{ :a => 1 }, { :a => 2 }])
+
+      command = {
+        'update' => @@test.name,
+        :updates => [
+          { :q => { :a => 2 }, :u => { '$set' => { :a => 1 }}}
+        ],
+        :ordered => false
+      }
+
+      assert_raise Mongo::OperationFailure do
+        @@db.command(command)
+      end
+    end
+  end
+
   if @@version >= '2.5.1'
+
     def test_aggregation_cursor
       [10, 1000].each do |size|
         @@test.drop
@@ -119,6 +377,16 @@ class CollectionTest < Test::Unit::TestCase
       @@test.drop
     end
 
+    def test_aggregation_array
+      @@test.drop
+      100.times {|i| @@test.insert({ :_id => i }) }
+      agg = @@test.aggregate([{ :$project => {:_id => '$_id'}} ])
+
+      assert agg.kind_of?(Array)
+
+      @@test.drop
+    end
+
     def test_aggregation_cursor_invalid_ops
       cursor = @@test.aggregate([], :cursor => {})
       assert_raise(Mongo::InvalidOperation) { cursor.rewind! }
@@ -134,13 +402,6 @@ class CollectionTest < Test::Unit::TestCase
   end
 
   if @@version >= '2.5.3'
-    def test_aggregation_allow_disk_usage
-      @@db.expects(:command).with do |selector, opts|
-        opts[:allowDiskUsage] == true
-      end.returns({ 'ok' => 1 })
-      @@test.aggregate([], :allowDiskUsage => true)
-    end
-
     def test_aggregation_supports_explain
       @@db.expects(:command).with do |selector, opts|
         opts[:explain] == true
@@ -613,6 +874,26 @@ class CollectionTest < Test::Unit::TestCase
     end
   end
 
+  if @@version < "2.5.3"
+    def test_jnote_raises_exception
+      with_no_journaling(@@client) do
+        ex = assert_raise Mongo::OperationFailure do
+          @@test.insert({:foo => 1}, :j => true)
+        end
+        result = ex.result
+        assert_true result.has_key?("jnote")
+      end
+    end
+
+    def test_wnote_raises_exception
+      ex = assert_raise Mongo::OperationFailure do
+        @@test.insert({:foo => 1}, :w => 2)
+      end
+      result = ex.result
+      assert_true result.has_key?("wnote")
+    end
+  end
+
   def test_update
     id1 = @@test.save("x" => 5)
     @@test.update({}, {"$inc" => {"x" => 1}})
@@ -780,7 +1061,7 @@ class CollectionTest < Test::Unit::TestCase
     end
   end
 
-  def test_defualt_timeout
+  def test_default_timeout
     cursor = @@test.find
     assert_equal true, cursor.timeout
   end
@@ -804,6 +1085,28 @@ class CollectionTest < Test::Unit::TestCase
     end
   end
 
+  if @@version >= '2.5.5'
+    def test_meta_field_projection
+      @@test.save({ :t => 'spam eggs and spam'})
+      @@test.save({ :t => 'spam'})
+      @@test.save({ :t => 'egg sausage and bacon'})
+
+      @@test.ensure_index([[:t, 'text']])
+      assert @@test.find_one({ :$text => { :$search => 'spam' }},
+                             { :fields => [:t, { :score => { :$meta => 'textScore' } }] })
+    end
+
+    def test_sort_by_meta
+      @@test.save({ :t => 'spam eggs and spam'})
+      @@test.save({ :t => 'spam'})
+      @@test.save({ :t => 'egg sausage and bacon'})
+
+      @@test.ensure_index([[:t, 'text']])
+      assert @@test.find({ :$text => { :$search => 'spam' }}).sort([:score, { '$meta' => 'textScore' }])
+      assert @@test.find({ :$text => { :$search => 'spam' }}).sort(:score => { '$meta' =>'textScore' })
+    end
+  end
+
   if @@version >= "1.5.1"
     def test_fields_with_slice
       @@test.save({:foo => [1, 2, 3, 4, 5, 6], :test => 'slice'})
@@ -1181,19 +1484,32 @@ class CollectionTest < Test::Unit::TestCase
   end
 
   if @@version >= '2.5.5'
+    def test_aggregation_allow_disk_use
+      @@db.expects(:command).with do |selector, opts|
+        opts[:allowDiskUse] == true
+      end.returns({ 'ok' => 1 })
+      @@test.aggregate([], :allowDiskUse => true)
+    end
+
     def test_parallel_scan
       8000.times { |i| @@test.insert({ :_id => i }) }
 
-      n_docs = {}
+      lock = Mutex.new
+      doc_ids = Set.new
       threads = []
       cursors = @@test.parallel_scan(3)
       cursors.each_with_index do |cursor, i|
         threads << Thread.new do
-          n_docs[i] = cursor.to_a.size
+          docs = cursor.to_a
+          lock.synchronize do
+            docs.each do |doc|
+              doc_ids << doc['_id']
+            end
+          end
         end
       end
       threads.each(&:join)
-      assert_equal @@test.count, n_docs.values.inject(0) { |sum, n| sum + n }
+      assert_equal 8000, doc_ids.count
     end
   end
 
@@ -1718,16 +2034,19 @@ end
     end
 
     should "generate indexes in the proper order" do
-      @collection.expects(:send_write) do |type, selector, documents, check_keys, opts, collection_name|
-        assert_equal 'b_1_a_1', selector[:name]
+      key = BSON::OrderedHash['b', 1, 'a', 1]
+      if @@version < '2.5.5'
+        @collection.expects(:send_write) do |type, selector, documents, check_keys, opts, collection_name|
+          assert_equal key, selector[:key]
+        end
+      else
+        @collection.db.expects(:command) do |selector|
+          assert_equal key, selector[:indexes].first[:key]
+        end
       end
       @collection.create_index([['b', 1], ['a', 1]])
     end
 
-    should "allow multiple calls to create_index" do
-
-    end
-
     should "allow creation of multiple indexes" do
       assert @collection.create_index([['a', 1]])
       assert @collection.create_index([['a', 1]])

data/test/functional/conversions_test.rb

@@ -27,6 +27,34 @@ class ConversionsTest < Test::Unit::TestCase
     assert_equal({ "field1" => 1, "field2" => -1 }, params)
   end
 
+  def test_array_as_sort_parameters_with_array_of_key_and_hash
+    params = array_as_sort_parameters(["score", {"$meta" => "textScore"}])
+    assert_equal({"score" => {"$meta" => "textScore"}}, params)
+  end
+
+  def test_array_as_sort_parameters_with_array_of_key_and_hashes
+    params = array_as_sort_parameters([["field1", :asc],["score", {"$meta" => "textScore"}]])
+    assert_equal({"field1" => 1, "score" => {"$meta" => "textScore"}}, params)
+  end
+
+  def test_hash_as_sort_parameters_with_string
+    sort = BSON::OrderedHash["field", "asc"]
+    params = hash_as_sort_parameters(sort)
+    assert_equal({"field" => 1}, params)
+  end
+
+  def test_hash_as_sort_parameters_with_hash
+    sort = BSON::OrderedHash["score", {"$meta" => "textScore"}]
+    params = hash_as_sort_parameters(sort)
+    assert_equal({"score" => {"$meta" => "textScore"}}, params)
+  end
+
+  def test_hash_as_sort_parameters_with_hash_and_string
+    sort = BSON::OrderedHash["score", {"$meta" => "textScore"}, "field", "asc"]
+    params = hash_as_sort_parameters(sort)
+    assert_equal({ "score" => {"$meta" => "textScore"}, "field" => 1 }, params)
+  end
+
   def test_string_as_sort_parameters_with_string
     params = string_as_sort_parameters("field")
     assert_equal({ "field" => 1 }, params)
@@ -122,6 +150,10 @@ class ConversionsTest < Test::Unit::TestCase
     assert_equal(-1, sort_value(:DESC))
   end
 
+  def test_sort_value_when_value_is_hash
+    assert_equal({"$meta" => "textScore"}, sort_value("$meta" => "textScore"))
+  end
+
   def test_sort_value_when_value_is_invalid
     assert_raise Mongo::InvalidSortValueError do
       sort_value(2)