jmongo 1.0.3 → 1.1.0

data/test/db_connection_test.rb

@@ -0,0 +1,15 @@
+require './test/test_helper'
+
+class DBConnectionTest < Test::Unit::TestCase
+
+  include Mongo
+
+  def test_no_exceptions
+    host = ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost'
+    port = ENV['MONGO_RUBY_DRIVER_PORT'] || Connection::DEFAULT_PORT
+    db = Connection.new(host, port).db(MONGO_TEST_DB)
+    coll = db.collection('test')
+    coll.remove
+    db.get_last_error
+  end
+end

data/test/db_test.rb

@@ -0,0 +1,325 @@
+require './test/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
+
+  @@conn  = standard_connection
+  @@db    = @@conn.db(MONGO_TEST_DB)
+  @@users = @@db.collection('system.users')
+  @@version = @@conn.server_version
+
+  def test_close
+    @@conn.close
+    assert !@@conn.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(MONGO_TEST_DB)
+      @@users = @@db.collection('system.users')
+    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 = @@conn.db(MONGO_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)
+    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 "#{MONGO_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(MONGO_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(MONGO_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_authenticate
+    @@db.add_user('spongebob', 'squarepants')
+    assert_raise Mongo::AuthenticationError do
+      assert !@@db.authenticate('nobody', 'nopassword')
+    end
+    assert_raise Mongo::AuthenticationError do
+      assert !@@db.authenticate('spongebob' , 'squareliederhosen')
+    end
+    assert @@db.authenticate('spongebob', 'squarepants')
+    @@db.logout
+    @@db.remove_user('spongebob')
+  end
+
+  def test_authenticate_with_special_characters
+    assert @@db.add_user('foo:bar', '@foo')
+    assert @@db.authenticate('foo:bar', '@foo')
+    @@db.logout
+    @@db.remove_user('foo:bar')
+  end
+
+  def test_authenticate_with_connection_uri
+    @@db.add_user('spongebob', 'squarepants')
+    assert Mongo::Connection.from_uri("mongodb://spongebob:squarepants@#{host_port}/#{@@db.name}")
+
+    assert_raise Mongo::AuthenticationError do
+      con = Mongo::Connection.from_uri("mongodb://wrong:info@#{host_port}/#{@@db.name}")
+      con['test']['foo'].find_one
+    end
+  end
+
+  def test_logout
+    assert @@db.logout
+  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
+    command = {:forceerror => 1}
+    raised = false
+    begin
+      @@db.command(command)
+    rescue => ex
+      raised = true
+      assert ex.message.include?("forced error"),
+        "error message does not contain 'forced error'"
+      assert_equal 10038, ex.error_code
+      assert_equal 10038, ex.result['assertionCode']
+    ensure
+      assert raised, "No assertion raised!"
+    end
+  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
+    conn = standard_connection
+    db   = conn[MONGO_TEST_DB]
+    db.collection('users').remove
+  end
+
+  def test_user_management
+    @@db.add_user("bob", "secret")
+    assert @@db.authenticate("bob", "secret")
+    @@db.logout
+    assert @@db.remove_user("bob")
+    assert_raise Mongo::AuthenticationError do
+      @@db.authenticate("bob", "secret")
+    end
+  end
+
+  def test_remove_non_existant_user
+    assert !@@db.remove_user("joe")
+  end
+
+  def test_stored_function_management
+    @@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
+    @@db.eval("db.system.save({_id:'hello', value: function() { print('hello'); } })")
+    assert_equal 'hello', @@db['system'].find_one['_id']
+  end
+
+  if @@version >= "1.3.5"
+    def test_db_stats
+      stats = @@db.stats
+      assert stats.has_key?('collections')
+      assert stats.has_key?('dataSize')
+    end
+  end
+
+  context "database profiling" do
+    setup do
+      @db  = @@conn[MONGO_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
+      @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
+
+    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/grid_file_system_test.rb

@@ -0,0 +1,260 @@
+__END__
+require './test/test_helper'
+
+class GridFileSystemTest < Test::Unit::TestCase
+  context "GridFileSystem:" do
+    setup do
+      @con = standard_connection
+      @db  = @con.db(MONGO_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 = {:safe => true}
+        @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
+         sleep(2)
+         @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
+           sleep(2)
+           @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 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
+          @grid.open('hello', 'w') {|f| f.seek(0) }
+        end
+      end
+    end
+  end
+end