mongo 1.3.0 → 1.12.5

data/test/replica_set/cursor_test.rb

@@ -0,0 +1,220 @@
+# 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
+
+  def setup
+    ensure_cluster(:rs)
+  end
+
+  def test_get_more_primary
+    setup_client(:primary)
+    cursor_get_more_test(:primary)
+  end
+
+  def test_get_more_secondary
+    setup_client(:secondary)
+    cursor_get_more_test(:secondary)
+  end
+
+  def test_close_primary
+    setup_client(:primary)
+    kill_cursor_test(:primary)
+  end
+
+  def test_close_secondary
+    setup_client(:secondary)
+    kill_cursor_test(:secondary)
+  end
+
+  def test_cursors_get_closed
+    setup_client
+    assert_cursors_on_members
+  end
+
+  def test_cursors_get_closed_secondary
+    setup_client(:secondary)
+    assert_cursors_on_members(:secondary)
+  end
+
+  def test_cursors_get_closed_secondary_query
+    setup_client(:primary)
+    assert_cursors_on_members(:secondary)
+  end
+
+  def test_intervening_query_secondary
+    setup_client(:primary)
+    refresh_while_iterating(:secondary)
+  end
+
+  private
+
+  def setup_client(read=:primary)
+    route_read ||= read
+    # Setup ReplicaSet Connection
+    @client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :read => read, :op_timeout => TEST_OP_TIMEOUT)
+    authenticate_client(@client)
+
+    @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
+    @n_docs = 102 # batch size is 101
+    @n_docs.times do |i|
+      @coll.insert({ "x" => i }, :w => 3)
+    end
+  end
+
+  def set_read_client_and_tag(read)
+    read_opts = {:read => read}
+    @tag = (0...3).map{|i|i.to_s}.detect do |tag|
+      begin
+        read_opts[:tag_sets] = [{:node => tag}] unless read == :primary
+        cursor = @coll.find({}, read_opts)
+        cursor.next
+        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
+      end
+    end
+  end
+
+  def route_query(read)
+    read_opts = {:read => read}
+    read_opts[:tag_sets] = [{:node => @tag}] unless read == :primary
+    object_id = BSON::ObjectId.new
+    read_opts[:comment] = object_id
+
+    # set profiling level to 2 on client and member to which the query will be routed
+    @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
+
+    @cursor = @coll.find({}, read_opts)
+    @cursor.next
+
+    # on client and other members set profiling level to 0
+    @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
+    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
+
+  # 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
+      route_query(read)
+      docs_count = 1
+      port = @cursor.instance_variable_get(:@pool).port
+      assert @cursor.alive?
+      while @cursor.has_next?
+        docs_count += 1
+        @cursor.next
+        assert_equal port, @cursor.instance_variable_get(:@pool).port
+      end
+      assert !@cursor.alive?
+      assert_equal @n_docs, docs_count
+      @cursor.close #cursor is already closed
+    end
+  end
+
+  # 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
+      route_query(read)
+      cursor_id = @cursor.cursor_id
+      cursor_clone = @cursor.clone
+      assert_equal cursor_id, cursor_clone.cursor_id
+      assert @cursor.instance_variable_get(:@pool)
+      # .next was called once already and leave one for get more
+      (@n_docs-2).times { @cursor.next }
+      @cursor.close
+      # an exception confirms the cursor has indeed been closed
+      assert_raise Mongo::OperationFailure do
+        cursor_clone.next
+      end
+    end
+  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)
+    cursor_id = @cursor.cursor_id
+    cursor_clone = @cursor.clone
+    assert_equal cursor_id, cursor_clone.cursor_id
+    assert @cursor.instance_variable_get(:@pool)
+    port = @cursor.instance_variable_get(:@pool).port
+    while @cursor.has_next?
+      @cursor.next
+      assert_equal port, @cursor.instance_variable_get(:@pool).port
+    end
+    # an exception confirms the cursor has indeed been closed after query
+    assert_raise Mongo::OperationFailure do
+      cursor_clone.next
+    end
+  end
+
+  def refresh_while_iterating(read)
+    set_read_client_and_tag(read)
+
+    read_opts = {:read => read}
+    read_opts[:tag_sets] = [{:node => @tag}]
+    read_opts[:batch_size] = 2
+    cursor = @coll.find({}, read_opts)
+
+    2.times { cursor.next }
+    port = cursor.instance_variable_get(:@pool).port
+    host = cursor.instance_variable_get(:@pool).host
+    # Refresh connection
+    @client.refresh
+    assert_nothing_raised do
+      cursor.next
+    end
+
+    assert_equal port, cursor.instance_variable_get(:@pool).port
+    assert_equal host, cursor.instance_variable_get(:@pool).host
+  end
+end

data/test/replica_set/insert_test.rb

@@ -0,0 +1,157 @@
+# 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.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
+
+  def teardown
+    @client.close if @conn
+  end
+
+  def test_insert
+    @coll.save({:a => 20}, :w => 3)
+
+    @rs.primary.stop
+
+    rescue_connection_failure do
+      @coll.save({:a => 30}, :w => 1)
+    end
+
+    @coll.save({:a => 40}, :w => 1)
+    @coll.save({:a => 50}, :w => 1)
+    @coll.save({:a => 60}, :w => 1)
+    @coll.save({:a => 70}, :w => 1)
+
+    # Restart the old master and wait for sync
+    @rs.start
+    sleep(5)
+    results = []
+
+    rescue_connection_failure do
+      @coll.find.each {|r| results << r}
+      [20, 30, 40, 50, 60, 70].each do |a|
+        assert results.any? {|r| r['a'] == a}, "Could not find record for a => #{a}"
+      end
+    end
+
+    @coll.save({:a => 80}, :w => 3)
+    @coll.find.each {|r| results << r}
+    [20, 30, 40, 50, 60, 70, 80].each do |a|
+      assert results.any? {|r| r['a'] == a}, "Could not find record for a => #{a} on second find"
+    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

@@ -0,0 +1,151 @@
+# 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
+
+  include Mongo
+
+  def setup
+    ensure_cluster(:rs)
+    @client = MongoReplicaSetClient.from_uri(@uri, :op_timeout => TEST_OP_TIMEOUT)
+    @db = new_mock_db
+    @client.stubs(:[]).returns(@db)
+    @ismaster = {
+      'hosts' => @client.local_manager.hosts.to_a,
+      'arbiters' => @client.local_manager.arbiters
+    }
+  end
+
+  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_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, '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_no_values_in_config
+    @db.stubs(:command).returns(
+      @ismaster.merge({'ismaster' => true}),
+      @ismaster.merge({'secondary' => true}),
+      @ismaster.merge({'secondary' => true})
+    )
+    @client.local_manager.stubs(:refresh_required?).returns(true)
+    @client.refresh
+
+    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
+    @db.stubs(:command).returns(
+      @ismaster.merge({'ismaster' => true}),
+      @ismaster.merge({'secondary' => true}),
+      @ismaster.merge({'secondary' => true, 'maxBsonObjectSize' => 1024})
+    )
+    @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_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, '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

@@ -0,0 +1,105 @@
+# 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.from_uri(@uri, :op_timeout => TEST_OP_TIMEOUT)
+    @db = @client.db(TEST_DB)
+    @coll = @db.collection("test-sets")
+    @coll.insert({:a => 1})
+  end
+
+  def test_unpinning
+    # pin primary
+    @coll.find_one
+    assert_equal @client.pinned_pool[:pool], @client.primary_pool
+
+    # pin secondary
+    @coll.find_one({}, :read => :secondary_preferred)
+    assert @client.secondary_pools.include? @client.pinned_pool[:pool]
+
+    # repin primary
+    @coll.find_one({}, :read => :primary_preferred)
+    assert_equal @client.pinned_pool[:pool], @client.primary_pool
+  end
+
+  def test_pinned_pool_is_local_to_thread
+    threads = []
+    30.times do |i|
+      threads << Thread.new do
+        if i % 2 == 0
+          @coll.find_one({}, :read => :secondary_preferred)
+          assert @client.secondary_pools.include? @client.pinned_pool[:pool]
+        else
+          @coll.find_one({}, :read => :primary_preferred)
+          assert_equal @client.pinned_pool[:pool], @client.primary_pool
+        end
+      end
+    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