mongo 1.12.5 → 2.0.0.beta

data/test/functional/db_test.rb

@@ -1,348 +0,0 @@
-# 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'
-require 'digest/md5'
-require 'stringio'
-require 'logger'
-
-class TestPKFactory
-  def create_pk(row)
-    row['_id'] ||= BSON::ObjectId.new
-    row
-  end
-end
-
-class DBTest < Test::Unit::TestCase
-
-  include Mongo
-
-  def setup
-    @client  = standard_connection
-    @db      = @client.db(TEST_DB)
-    @version = @client.server_version
-  end
-
-  def test_close
-    @client.close
-    assert !@client.connected?
-    begin
-      @db.collection('test').insert('a' => 1)
-      fail "expected 'NilClass' exception"
-    rescue => ex
-      assert_match(/NilClass/, ex.to_s)
-    ensure
-      @db = standard_connection.db(TEST_DB)
-    end
-  end
-
-  def test_create_collection
-    col = @db.create_collection('foo')
-    assert_equal @db['foo'].name, col.name
-
-    col = @db.create_collection(:foo)
-    assert_equal @db['foo'].name, col.name
-
-    @db.drop_collection('foo')
-  end
-
-  def test_get_and_drop_collection
-    db = @client.db(TEST_DB, :strict => true)
-    db.create_collection('foo')
-    assert db.collection('foo')
-    assert db.drop_collection('foo')
-
-    db.create_collection(:foo)
-    assert db.collection(:foo)
-    # Use a string because of SERVER-16260
-    assert db.drop_collection('foo')
-  end
-
-  def test_logger
-    output = StringIO.new
-    logger = Logger.new(output)
-    logger.level = Logger::DEBUG
-    conn = standard_connection(:logger => logger)
-    assert_equal logger, conn.logger
-
-    conn.logger.debug 'testing'
-    assert output.string.include?('testing')
-  end
-
-  def test_full_coll_name
-    coll = @db.collection('test')
-    assert_equal "#{TEST_DB}.test", @db.full_collection_name(coll.name)
-  end
-
-  def test_collection_names
-    @db.collection("test").insert("foo" => 5)
-    @db.collection("test.mike").insert("bar" => 0)
-
-    colls = @db.collection_names()
-    assert colls.include?("test")
-    assert colls.include?("test.mike")
-    colls.each { |name|
-      assert !name.include?("$")
-    }
-  end
-
-  def test_collections
-    @db.collection("test.durran").insert("foo" => 5)
-    @db.collection("test.les").insert("bar" => 0)
-
-    colls = @db.collections()
-    assert_not_nil colls.select { |coll| coll.name == "test.durran" }
-    assert_not_nil colls.select { |coll| coll.name == "test.les" }
-    assert_equal [], colls.select { |coll| coll.name == "does_not_exist" }
-
-    assert_kind_of Collection, colls[0]
-  end
-
-  def test_pk_factory
-    db = standard_connection.db(TEST_DB, :pk => TestPKFactory.new)
-    coll = db.collection('test')
-    coll.remove
-
-    insert_id = coll.insert('name' => 'Fred', 'age' => 42)
-    # new id gets added to returned object
-    row = coll.find_one({'name' => 'Fred'})
-    oid = row['_id']
-    assert_not_nil oid
-    assert_equal insert_id, oid
-
-    oid = BSON::ObjectId.new
-    data = {'_id' => oid, 'name' => 'Barney', 'age' => 41}
-    coll.insert(data)
-    row = coll.find_one({'name' => data['name']})
-    db_oid = row['_id']
-    assert_equal oid, db_oid
-    assert_equal data, row
-
-    coll.remove
-  end
-
-  def test_pk_factory_reset
-    conn = standard_connection
-    db   = conn.db(TEST_DB)
-    db.pk_factory = Object.new # first time
-    begin
-      db.pk_factory = Object.new
-      fail "error: expected exception"
-    rescue => ex
-      assert_match(/Cannot change/, ex.to_s)
-    ensure
-      conn.close
-    end
-  end
-
-  def test_command
-    assert_raise OperationFailure do
-      @db.command({:non_command => 1}, :check_response => true)
-    end
-
-    result = @db.command({:non_command => 1}, :check_response => false)
-    assert !Mongo::Support.ok?(result)
-  end
-
-  def test_error
-    @db.reset_error_history
-    assert_nil @db.get_last_error['err']
-    assert !@db.error?
-    assert_nil @db.previous_error
-
-    @db.command({:forceerror => 1}, :check_response => false)
-    assert @db.error?
-    assert_not_nil @db.get_last_error['err']
-    assert_not_nil @db.previous_error
-
-    @db.command({:forceerror => 1}, :check_response => false)
-    assert @db.error?
-    assert @db.get_last_error['err']
-    prev_error = @db.previous_error
-    assert_equal 1, prev_error['nPrev']
-    assert_equal prev_error["err"], @db.get_last_error['err']
-
-    @db.collection('test').find_one
-    assert_nil @db.get_last_error['err']
-    assert !@db.error?
-    assert @db.previous_error
-    assert_equal 2, @db.previous_error['nPrev']
-
-    @db.reset_error_history
-    assert_nil @db.get_last_error['err']
-    assert !@db.error?
-    assert_nil @db.previous_error
-  end
-
-  def test_check_command_response
-    if @version >= "2.1.0"
-      command = {:create => "$$$$"}
-      expected_codes = [10356, 2]
-      expected_msg = "invalid"
-      raised = false
-      begin
-        @db.command(command)
-      rescue => ex
-        raised = true
-        assert ex.message.include?(expected_msg) ||
-                (ex.result.has_key?("assertion") &&
-                ex.result["assertion"].include?(expected_msg)),
-               "error message does not contain '#{expected_msg}'"
-        assert expected_codes.include?(ex.error_code)
-        assert expected_codes.include?(ex.result['code'])
-      ensure
-        assert raised, "No assertion raised!"
-      end
-    end
-  end
-
-  def test_arbitrary_command_opts
-    with_forced_timeout(@client) do
-      assert_raise ExecutionTimeout do
-        cmd = OrderedHash.new
-        cmd[:ping] = 1
-        cmd[:maxTimeMS] = 100
-        @db.command(cmd)
-      end
-    end
-  end
-
-  def test_command_with_bson
-    normal_response = @db.command({:buildInfo => 1})
-    bson = BSON::BSON_CODER.serialize({:buildInfo => 1}, false, false)
-    bson_response = @db.command({:bson => bson})
-    assert_equal normal_response, bson_response
-  end
-
-  def test_last_status
-    @db['test'].remove
-    @db['test'].save("i" => 1)
-
-    @db['test'].update({"i" => 1}, {"$set" => {"i" => 2}})
-    assert @db.get_last_error()["updatedExisting"]
-
-    @db['test'].update({"i" => 1}, {"$set" => {"i" => 500}})
-    assert !@db.get_last_error()["updatedExisting"]
-  end
-
-  def test_text_port_number_raises_no_errors
-    client = standard_connection
-    db   = client[TEST_DB]
-    db.collection('users').remove
-  end
-
-  def test_stored_function_management
-    grant_admin_user_eval_role(@client)
-    @db.add_stored_function("sum", "function (x, y) { return x + y; }")
-    assert_equal @db.eval("return sum(2,3);"), 5
-    assert @db.remove_stored_function("sum")
-    assert_raise OperationFailure do
-      @db.eval("return sum(2,3);")
-    end
-  end
-
-  def test_eval
-    grant_admin_user_eval_role(@client)
-    @db.eval("db.system.save({_id:'hello', value: function() { print('hello'); } })")
-    assert_equal 'hello', @db['system'].find_one['_id']
-  end
-
-  def test_eval_nook
-    grant_admin_user_eval_role(@client)
-    function = "db.system.save({_id:'hello', value: function(string) { print(string); } })"
-    @db.expects(:command).with do |selector, opts|
-      selector[:nolock] == true
-    end.returns({ 'ok' => 1, 'retval' => 1 })
-    @db.eval(function, 'hello', :nolock => true)
-  end
-
-  def test_default_admin_roles
-    return unless @version >= '2.5.3'
-    # admin user
-    @db.stubs(:command).returns({}, true)
-    @db.expects(:command).with do |command, cmd_opts|
-      command[:createUser] == TEST_USER
-      cmd_opts[:roles] == ['root'] if cmd_opts
-    end
-
-    silently { @db.add_user(TEST_USER, TEST_USER_PWD) }
-
-    @db.stubs(:command).returns({}, true)
-    @db.expects(:command).with do |command, cmd_opts|
-      command[:createUser] == TEST_USER
-      cmd_opts[:roles] == ['readAnyDatabase'] if cmd_opts
-    end
-
-    silently { @db.add_user(TEST_USER, TEST_USER_PWD, true) }
-  end
-
-  def test_db_stats
-    return unless @version >= "1.3.5"
-    stats = @db.stats
-    assert stats.has_key?('collections')
-    assert stats.has_key?('dataSize')
-  end
-
-  context "database profiling" do
-    setup do
-      @db  = @client[TEST_DB]
-      @coll = @db['test']
-      @coll.remove
-      @r1 = @coll.insert('a' => 1) # collection not created until it's used
-    end
-
-    should "set default profiling level" do
-      assert_equal :off, @db.profiling_level
-    end
-
-    should "change profiling level" do
-      @db.profiling_level = :slow_only
-      assert_equal :slow_only, @db.profiling_level
-      @db.profiling_level = :off
-      assert_equal :off, @db.profiling_level
-      @db.profiling_level = :all
-      assert_equal :all, @db.profiling_level
-      begin
-        @db.profiling_level = :medium
-        fail "shouldn't be able to do this"
-      rescue
-      end
-    end
-
-    should "return profiling info" do
-      if @version >= "2.2" && @version < "3.0"
-        @db.profiling_level = :all
-        @coll.find()
-        @db.profiling_level = :off
-
-        info = @db.profiling_info
-        assert_kind_of Array, info
-        assert info.length >= 1
-        first = info.first
-        assert_kind_of Time, first['ts']
-        assert_kind_of Numeric, first['millis']
-      end
-    end
-
-    should "validate collection" do
-      doc = @db.validate_collection(@coll.name)
-      if @version >= "1.9.1"
-        assert doc['valid']
-      else
-        assert doc['result']
-      end
-    end
-
-  end
-end

data/test/functional/grid_file_system_test.rb

@@ -1,285 +0,0 @@
-# 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 GridFileSystemTest < Test::Unit::TestCase
-  context "GridFileSystem:" do
-    setup do
-      @con = standard_connection
-      @db  = @con.db(TEST_DB)
-    end
-
-    teardown do
-      @db.drop_collection('fs.files')
-      @db.drop_collection('fs.chunks')
-    end
-
-    context "Initialization" do
-      setup do
-        @chunks_data = "CHUNKS" * 50000
-        @grid = GridFileSystem.new(@db)
-        @opts = {:w => 1}
-        @original_opts = @opts.dup
-        @grid.open('sample.file', 'w', @opts) do |f|
-          f.write @chunks_data
-        end
-      end
-
-      should "not modify original opts" do
-        assert_equal @original_opts, @opts
-      end
-    end
-
-    context "When reading:" do
-      setup do
-        @chunks_data = "CHUNKS" * 50000
-        @grid = GridFileSystem.new(@db)
-        @grid.open('sample.file', 'w') do |f|
-          f.write @chunks_data
-        end
-
-        @grid = GridFileSystem.new(@db)
-      end
-
-      should "return existence of the file" do
-        file = @grid.exist?(:filename => 'sample.file')
-        assert_equal 'sample.file', file['filename']
-      end
-
-      should "return nil if the file doesn't exist" do
-        assert_nil @grid.exist?(:filename => 'foo.file')
-      end
-
-      should "read sample data" do
-        data = @grid.open('sample.file', 'r') { |f| f.read }
-        assert_equal data.length, @chunks_data.length
-      end
-
-      should "have a unique index on chunks" do
-        assert @db['fs.chunks'].index_information['files_id_1_n_1']['unique']
-      end
-
-      should "have an index on filename" do
-        assert @db['fs.files'].index_information['filename_1_uploadDate_-1']
-      end
-
-      should "return an empty string if length is zero" do
-        data = @grid.open('sample.file', 'r') { |f| f.read(0) }
-        assert_equal '', data
-      end
-
-      should "return the first n bytes" do
-        data = @grid.open('sample.file', 'r') {|f| f.read(288888) }
-        assert_equal 288888, data.length
-        assert_equal @chunks_data[0...288888], data
-      end
-
-      should "return the first n bytes even with an offset" do
-        data = @grid.open('sample.file', 'r') do |f|
-          f.seek(1000)
-          f.read(288888)
-        end
-        assert_equal 288888, data.length
-        assert_equal @chunks_data[1000...289888], data
-      end
-    end
-
-    context "When writing:" do
-      setup do
-        @data   = "BYTES" * 50
-        @grid = GridFileSystem.new(@db)
-        @grid.open('sample', 'w') do |f|
-          f.write @data
-        end
-      end
-
-      should "read sample data" do
-        data = @grid.open('sample', 'r') { |f| f.read }
-        assert_equal data.length, @data.length
-      end
-
-      should "return the total number of bytes written" do
-        data = 'a' * 300000
-        assert_equal 300000, @grid.open('sample', 'w') {|f| f.write(data) }
-      end
-
-      should "more read sample data" do
-        data = @grid.open('sample', 'r') { |f| f.read }
-        assert_equal data.length, @data.length
-      end
-
-      should "raise exception if file not found" do
-        assert_raise GridFileNotFound do
-          @grid.open('io', 'r') { |f| f.write('hello') }
-        end
-      end
-
-      should "raise exception if not opened for write" do
-        assert_raise GridError do
-          @grid.open('sample', 'r') { |f| f.write('hello') }
-        end
-      end
-
-      context "and when overwriting the file" do
-        setup do
-          @old = @grid.open('sample', 'r')
-
-          @new_data = "DATA" * 10
-          @grid.open('sample', 'w') do |f|
-            f.write @new_data
-          end
-
-          @new = @grid.open('sample', 'r')
-        end
-
-        should "have a newer upload date" do
-          assert @new.upload_date > @old.upload_date, "New data is not greater than old date."
-        end
-
-        should "have a different files_id" do
-          assert_not_equal @new.files_id, @old.files_id
-        end
-
-        should "contain the new data" do
-          assert_equal @new_data, @new.read, "Expected DATA"
-        end
-
-        context "and on a second overwrite" do
-          setup do
-            @new_data = "NEW" * 1000
-            @grid.open('sample', 'w') do |f|
-              f.write @new_data
-            end
-
-            @ids = @db['fs.files'].find({'filename' => 'sample'}).map {|file| file['_id']}
-          end
-
-          should "write a third version of the file" do
-            assert_equal 3, @db['fs.files'].find({'filename' => 'sample'}).count
-            assert_equal 3, @db['fs.chunks'].find({'files_id' => {'$in' => @ids}}).count
-          end
-
-          should "remove all versions and their data on delete" do
-            @grid.delete('sample')
-            assert_equal 0, @db['fs.files'].find({'filename' => 'sample'}).count
-            assert_equal 0, @db['fs.chunks'].find({'files_id' => {'$in' => @ids}}).count
-          end
-
-          should "delete all versions which exceed the number of versions to keep specified by the option :versions" do
-            @versions = 1 + rand(4-1)
-            @grid.open('sample', 'w', :versions => @versions) do |f|
-              f.write @new_data
-            end
-            @new_ids = @db['fs.files'].find({'filename' => 'sample'}).map {|file| file['_id']}
-            assert_equal @versions, @new_ids.length
-            id = @new_ids.first
-            assert !@ids.include?(id)
-            assert_equal @versions, @db['fs.files'].find({'filename' => 'sample'}).count
-          end
-
-          should "delete old versions on write with :delete_old is passed in" do
-            @grid.open('sample', 'w', :delete_old => true) do |f|
-              f.write @new_data
-            end
-            @new_ids = @db['fs.files'].find({'filename' => 'sample'}).map {|file| file['_id']}
-            assert_equal 1, @new_ids.length
-            id = @new_ids.first
-            assert !@ids.include?(id)
-            assert_equal 1, @db['fs.files'].find({'filename' => 'sample'}).count
-            assert_equal 1, @db['fs.chunks'].find({'files_id' => id}).count
-          end
-        end
-      end
-    end
-
-    context "When writing chunks:" do
-      setup do
-        data   = "B" * 50000
-        @grid = GridFileSystem.new(@db)
-        @grid.open('sample', 'w', :chunk_size => 1000) do |f|
-          f.write data
-        end
-      end
-
-      should "write the correct number of chunks" do
-        file   = @db['fs.files'].find_one({:filename => 'sample'})
-        chunks = @db['fs.chunks'].find({'files_id' => file['_id']}).to_a
-        assert_equal 50, chunks.length
-      end
-    end
-
-    context "Positioning:" do
-      setup do
-        data = 'hello, world' + '1' * 5000 + 'goodbye!' + '2' * 1000 + '!'
-        @grid = GridFileSystem.new(@db)
-        @grid.open('hello', 'w', :chunk_size => 1000) do |f|
-          f.write data
-        end
-      end
-
-      should "seek within chunks" do
-        @grid.open('hello', 'r') do |f|
-          f.seek(0)
-          assert_equal 'h', f.read(1)
-          f.seek(7)
-          assert_equal 'w', f.read(1)
-          f.seek(4)
-          assert_equal 'o', f.read(1)
-          f.seek(0)
-          f.seek(7, IO::SEEK_CUR)
-          assert_equal 'w', f.read(1)
-          f.seek(-2, IO::SEEK_CUR)
-          assert_equal ' ', f.read(1)
-          f.seek(-4, IO::SEEK_CUR)
-          assert_equal 'l', f.read(1)
-          f.seek(3, IO::SEEK_CUR)
-          assert_equal 'w', f.read(1)
-        end
-      end
-
-      should "seek between chunks" do
-        @grid.open('hello', 'r') do |f|
-          f.seek(1000)
-          assert_equal '11111', f.read(5)
-
-          f.seek(5009)
-          assert_equal '111goodbye!222', f.read(14)
-
-          f.seek(-1, IO::SEEK_END)
-          assert_equal '!', f.read(1)
-          f.seek(-6, IO::SEEK_END)
-          assert_equal '2', f.read(1)
-        end
-      end
-
-      should "tell the current position" do
-        @grid.open('hello', 'r') do |f|
-          assert_equal 0, f.tell
-
-          f.seek(999)
-          assert_equal 999, f.tell
-        end
-      end
-
-      should "seek only in read mode" do
-        assert_raise GridError do
-          silently do
-            @grid.open('hello', 'w') { |f| f.seek(0) }
-          end
-        end
-      end
-    end
-  end
-end