mongo 1.10.2 → 1.11.1

data/test/functional/db_connection_test.rb

@@ -17,9 +17,7 @@ require 'test_helper'
 class DBConnectionTest < Test::Unit::TestCase
 
   def test_no_exceptions
-    host = ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost'
-    port = ENV['MONGO_RUBY_DRIVER_PORT'] || MongoClient::DEFAULT_PORT
-    db = MongoClient.new(host, port).db(TEST_DB)
+    db = standard_connection.db(TEST_DB)
     coll = db.collection('test')
     coll.remove
     db.get_last_error

data/test/functional/db_test.rb

@@ -28,35 +28,37 @@ class DBTest < Test::Unit::TestCase
 
   include Mongo
 
-  @@client  = standard_connection
-  @@db    = @@client.db(TEST_DB)
-  @@version = @@client.server_version
+  def setup
+    @client  = standard_connection
+    @db      = @client.db(TEST_DB)
+    @version = @client.server_version
+  end
 
   def test_close
-    @@client.close
-    assert !@@client.connected?
+    @client.close
+    assert !@client.connected?
     begin
-      @@db.collection('test').insert('a' => 1)
+      @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)
+      @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
 
-    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')
+    @db.drop_collection('foo')
   end
 
   def test_get_and_drop_collection
-    db = @@client.db(TEST_DB, :strict => true)
+    db = @client.db(TEST_DB, :strict => true)
     db.create_collection('foo')
     assert db.collection('foo')
     assert db.drop_collection('foo')
@@ -78,15 +80,15 @@ class DBTest < Test::Unit::TestCase
   end
 
   def test_full_coll_name
-    coll = @@db.collection('test')
-    assert_equal "#{TEST_DB}.test", @@db.full_collection_name(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)
+    @db.collection("test").insert("foo" => 5)
+    @db.collection("test.mike").insert("bar" => 0)
 
-    colls = @@db.collection_names()
+    colls = @db.collection_names()
     assert colls.include?("test")
     assert colls.include?("test.mike")
     colls.each { |name|
@@ -95,10 +97,10 @@ class DBTest < Test::Unit::TestCase
   end
 
   def test_collections
-    @@db.collection("test.durran").insert("foo" => 5)
-    @@db.collection("test.les").insert("bar" => 0)
+    @db.collection("test.durran").insert("foo" => 5)
+    @db.collection("test.les").insert("bar" => 0)
 
-    colls = @@db.collections()
+    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" }
@@ -145,91 +147,92 @@ class DBTest < Test::Unit::TestCase
 
   def test_command
     assert_raise OperationFailure do
-      @@db.command({:non_command => 1}, :check_response => true)
+      @db.command({:non_command => 1}, :check_response => true)
     end
 
-    result = @@db.command({:non_command => 1}, :check_response => false)
+    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
+    @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
+    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") || ex.result.has_key?("assertion") && ex.result["assertion"].include?("forced error"),
-        "error message does not contain 'forced error'"
-      assert_equal 10038, ex.error_code
-
-      if @@version >= "2.1.0"
-        assert_equal 10038, ex.result['code']
-      else
-        assert_equal 10038, ex.result['assertionCode']
+    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
-    ensure
-      assert raised, "No assertion raised!"
     end
   end
 
   def test_arbitrary_command_opts
-    with_forced_timeout(@@client) do
+    with_forced_timeout(@client) do
       assert_raise ExecutionTimeout do
         cmd = OrderedHash.new
         cmd[:ping] = 1
         cmd[:maxTimeMS] = 100
-        @@db.command(cmd)
+        @db.command(cmd)
       end
     end
   end
 
   def test_command_with_bson
-    normal_response = @@db.command({:buildInfo => 1})
+    normal_response = @db.command({:buildInfo => 1})
     bson = BSON::BSON_CODER.serialize({:buildInfo => 1}, false, false)
-    bson_response = @@db.command({:bson => bson})
+    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'].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" => 2}})
+    assert @db.get_last_error()["updatedExisting"]
 
-    @@db['test'].update({"i" => 1}, {"$set" => {"i" => 500}})
-    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
@@ -239,62 +242,60 @@ class DBTest < Test::Unit::TestCase
   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")
+    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);")
+      @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']
+    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_nolock
+  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
+    @db.expects(:command).with do |selector, opts|
+      selector[:nolock] == true
     end.returns({ 'ok' => 1, 'retval' => 1 })
-    @@db.eval(function, 'hello', :nolock => true)
+    @db.eval(function, 'hello', :nolock => true)
   end
 
-  if @@version >= '2.5.3'
-    def test_default_admin_roles
-      # admin user
-      db = Mongo::MongoClient.new()['admin']
-      db.logout
-      silently { db.add_user('admin', 'pass') }
-      db.authenticate('admin', 'pass')
-      info = db.command(:usersInfo => 'admin')['users'].first
-      assert_equal 'root', info['roles'].first['role']
-
-      # read-only admin user
-      silently { db.add_user('ro-admin', 'pass', true) }
-      db.logout
-      db.authenticate('ro-admin', 'pass')
-      info = db.command(:usersInfo => 'ro-admin')['users'].first
-      assert_equal 'readAnyDatabase', info['roles'].first['role']
-      db.logout
-
-      db.authenticate('admin', 'pass')
-      db.command(:dropAllUsersFromDatabase => 1)
-      db.logout
+  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
-  end
 
-  if @@version >= "1.3.5"
-    def test_db_stats
-      stats = @@db.stats
-      assert stats.has_key?('collections')
-      assert stats.has_key?('dataSize')
+    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]
+      @db  = @client[TEST_DB]
       @coll = @db['test']
       @coll.remove
       @r1 = @coll.insert('a' => 1) # collection not created until it's used
@@ -319,7 +320,7 @@ class DBTest < Test::Unit::TestCase
     end
 
     should "return profiling info" do
-      if @@version >= "2.2"
+      if @version >= "2.2"
         @db.profiling_level = :all
         @coll.find()
         @db.profiling_level = :off
@@ -335,7 +336,7 @@ class DBTest < Test::Unit::TestCase
 
     should "validate collection" do
       doc = @db.validate_collection(@coll.name)
-      if @@version >= "1.9.1"
+      if @version >= "1.9.1"
         assert doc['valid']
       else
         assert doc['result']

data/test/functional/grid_file_system_test.rb

@@ -97,114 +97,114 @@ class GridFileSystemTest < Test::Unit::TestCase
     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   = "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)