mongo 1.3.0 → 1.12.5

data/test/functional/db_connection_test.rb

@@ -0,0 +1,25 @@
+# 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 DBConnectionTest < Test::Unit::TestCase
+
+  def test_no_exceptions
+    db = standard_connection.db(TEST_DB)
+    coll = db.collection('test')
+    coll.remove
+    db.get_last_error
+  end
+end

data/test/functional/db_test.rb

@@ -0,0 +1,348 @@
+# 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

@@ -0,0 +1,285 @@
+# 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