mongo 1.8.6 → 1.12.5

data/test/functional/grid_file_system_test.rb

@@ -1,10 +1,24 @@
+# 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(MONGO_TEST_DB)
+      @db  = @con.db(TEST_DB)
     end
 
     teardown do
@@ -73,7 +87,7 @@ class GridFileSystemTest < Test::Unit::TestCase
       end
 
       should "return the first n bytes even with an offset" do
-        data = @grid.open('sample.file', 'r') do |f| 
+        data = @grid.open('sample.file', 'r') do |f|
           f.seek(1000)
           f.read(288888)
         end
@@ -83,116 +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
-         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 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)

data/test/functional/grid_io_test.rb

@@ -1,10 +1,24 @@
+# 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 GridIOTest < Test::Unit::TestCase
 
   context "GridIO" do
     setup do
-      @db = standard_connection.db(MONGO_TEST_DB)
+      @db = standard_connection.db(TEST_DB)
       @files  = @db.collection('fs.files')
       @chunks = @db.collection('fs.chunks')
       @chunks.create_index([['files_id', Mongo::ASCENDING], ['n', Mongo::ASCENDING]])
@@ -21,9 +35,9 @@ class GridIOTest < Test::Unit::TestCase
         @mode     = 'w'
       end
 
-      should "set default 256k chunk size" do
+      should "set default 255k chunk size" do
         file = GridIO.new(@files, @chunks, @filename, @mode)
-        assert_equal 256 * 1024, file.chunk_size
+        assert_equal 255 * 1024, file.chunk_size
       end
 
       should "set chunk size" do

data/test/functional/grid_test.rb

@@ -1,3 +1,17 @@
+# 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'
 include Mongo
 
@@ -21,7 +35,7 @@ end
 class GridTest < Test::Unit::TestCase
   context "Tests:" do
     setup do
-      @db = standard_connection.db(MONGO_TEST_DB)
+      @db = standard_connection.db(TEST_DB)
       @files  = @db.collection('test-fs.files')
       @chunks = @db.collection('test-fs.chunks')
     end
@@ -248,7 +262,7 @@ class GridTest < Test::Unit::TestCase
       end
 
       should "put and get a large io object if reading less than the chunk size" do
-        read_and_write_stream('sample_data', 256 * 1024)
+        read_and_write_stream('sample_data', 255 * 1024)
       end
 
       should "put and get a large io object if reading more than the chunk size" do

data/test/functional/pool_test.rb

@@ -1,12 +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'
-require 'thread'
 
 class PoolTest < Test::Unit::TestCase
   include Mongo
 
   def setup
-    @client    ||= standard_connection({:pool_size => 500, :pool_timeout => 5})
-    @db         = @client.db(MONGO_TEST_DB)
+    @client    ||= standard_connection({:pool_size => 15, :pool_timeout => 5})
+    @db         = @client.db(TEST_DB)
     @collection = @db.collection("pool_test")
   end
 
@@ -18,7 +31,7 @@ class PoolTest < Test::Unit::TestCase
       threads << Thread.new do
         original_socket = pool.checkout
         pool.checkin(original_socket)
-        5000.times do
+        500.times do
           socket = pool.checkout
           assert_equal original_socket, socket
           pool.checkin(socket)
@@ -30,18 +43,94 @@ class PoolTest < Test::Unit::TestCase
   end
 
   def test_pool_affinity_max_size
-    8000.times {|x| @collection.insert({:value => x})}
+    client = standard_connection({:pool_size => 15, :pool_timeout => 5,
+                                  :op_timeout => nil})
+    coll = client[TEST_DB]['pool_test']
+    docs = []
+    8000.times {|x| docs << {:value => x}}
+    coll.insert(docs)
+
     threads = []
     threads << Thread.new do
-      @collection.find({"value" => {"$lt" => 100}}).each {|e| e}
+      coll.find({"value" => {"$lt" => 100}}).each {|e| e}
       Thread.pass
-      sleep(5)
-      @collection.find({"value" => {"$gt" => 100}}).each {|e| e}
+      sleep(0.125)
+      coll.find({"value" => {"$gt" => 100}}).each {|e| e}
     end
-    sleep(1)
     threads << Thread.new do
-      @collection.find({'$where' => "function() {for(i=0;i<8000;i++) {this.value};}"}).each {|e| e}
+      coll.find({'$where' => "function() {for(i=0;i<500;i++) {this.value};}"}).each {|e| e}
     end
     threads.each(&:join)
   end
+
+  def test_auth_network_error
+    # Make sure there's no semaphore leak if we get a network error
+    # when authenticating a new socket with cached credentials.
+
+    # Get a client with one socket so we detect if it's leaked.
+    client = MongoClient.new(TEST_HOST, TEST_PORT, :pool_size => 1, :pool_timeout => 1)
+    assert_equal 1, client.pool_size
+
+    # Set up the client with a pool
+    client[TEST_DB].command(:ping => 1)
+
+    # Close the one socket in the pool
+    pool = client.primary_pool
+    socket = pool.instance_variable_get(:@sockets).first
+    socket.close
+
+    # Simulate an authenticate() call on a different socket.
+    # Cache the creds on the client.
+    creds = {
+        :db_name   => TEST_DB,
+        :username  => TEST_USER,
+        :password  => TEST_USER_PWD,
+        :source    => TEST_DB,
+        :extra     => {}
+    }
+    client.auths << creds
+
+    # The client authenticates its socket with the
+    # new credential, but gets a socket.error.
+    client[TEST_DB]['ruby-test'].find_one
+
+    # # No semaphore leak, the pool is allowed to make a new socket.
+    assert_equal 1, pool.instance_variable_get(:@sockets).size
+  end
+
+  def test_socket_cleanup
+    # Get a client with one socket so we detect if it's leaked.
+    client = MongoClient.new(TEST_HOST, TEST_PORT, :pool_size => 1, :pool_timeout => 1)
+    assert_equal 1, client.pool_size
+
+    # Set up the client with a pool
+    client[TEST_DB].command(:ping => 1)
+
+    # Simulate an authenticate() call on a different socket.
+    # Cache the creds on the client.
+    creds = {
+        :db_name   => TEST_DB,
+        :username  => TEST_USER,
+        :password  => TEST_USER_PWD,
+        :source    => TEST_DB,
+        :extra     => {}
+    }
+    client.auths << creds
+
+    # Mock the socket to raise a ConnectionFailure when applying auths
+    pool   = client.primary_pool
+    socket = pool.instance_variable_get(:@sockets).first
+    socket.expects(:send).raises(ConnectionFailure)
+
+    # Checkout a socket from the pool to force it to get a new socket
+    pool.checkout
+    new_socket = pool.instance_variable_get(:@sockets).first
+
+    # Make sure the pool is cleaned up properly
+    assert_not_equal socket, new_socket
+    assert_equal 1, pool.instance_variable_get(:@sockets).size
+    assert_equal 1, pool.instance_variable_get(:@thread_ids_to_sockets).size
+    assert !pool.instance_variable_get(:@checked_out).include?(socket)
+    assert !pool.instance_variable_get(:@sockets).include?(socket)
+  end
 end

data/test/functional/safe_test.rb

@@ -1,3 +1,17 @@
+# 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'
 include Mongo
 
@@ -5,7 +19,7 @@ class SafeTest < Test::Unit::TestCase
   context "Safe mode propogation: " do
     setup do
       @connection = standard_connection({:safe => true}, true) # Legacy
-      @db         = @connection[MONGO_TEST_DB]
+      @db         = @connection[TEST_DB]
       @collection = @db['test-safe']
       @collection.create_index([[:a, 1]], :unique => true)
       @collection.remove
@@ -59,7 +73,7 @@ class SafeTest < Test::Unit::TestCase
   context "Safe error objects" do
     setup do
       @connection = standard_connection({:safe => true}, true) # Legacy
-      @db         = @connection[MONGO_TEST_DB]
+      @db         = @connection[TEST_DB]
       @collection = @db['test']
       @collection.remove
       @collection.insert({:a => 1})
@@ -71,8 +85,8 @@ class SafeTest < Test::Unit::TestCase
       response = @collection.update({:a => 1}, {"$set" => {:a => 2}},
                              :multi => true)
 
-      assert response['updatedExisting']
-      assert_equal 3, response['n']
+      assert(response['updatedExisting'] || @db.connection.wire_version_feature?(Mongo::MongoClient::BATCH_COMMANDS)) # TODO - review new write command return values
+      assert(response['n'] == 3 || @db.connection.wire_version_feature?(Mongo::MongoClient::BATCH_COMMANDS)) # TODO - update command top pending
     end
 
     should "return object on remove" do

data/test/functional/ssl_test.rb

@@ -0,0 +1,29 @@
+# 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 'shared/ssl_shared'
+
+class SSLTest < Test::Unit::TestCase
+  include Mongo
+  include SSLTests
+
+  def setup
+    @client_class     = MongoClient
+    @uri_info         = 'server'
+    @connect_info     = ['server', 27017]
+    @bad_connect_info = ['localhost', 27017]
+  end
+
+end

data/test/functional/support_test.rb

@@ -1,3 +1,17 @@
+# 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 SupportTest < Test::Unit::TestCase

data/test/functional/timeout_test.rb

@@ -1,26 +1,43 @@
+# 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 TestTimeout < Test::Unit::TestCase
+class TimeoutTest < Test::Unit::TestCase
+
   def test_op_timeout
-    connection = standard_connection(:op_timeout => 1)
+    grant_admin_user_eval_role(standard_connection)
+    connection = standard_connection(:op_timeout => 0.5)
 
     admin = connection.db('admin')
 
-    command = {:eval => "sleep(500)"}
+    command = {:eval => "sleep(100)"}
     # Should not timeout
     assert admin.command(command)
 
     # Should timeout
-    command = {:eval => "sleep(1500)"}
+    command = {:eval => "sleep(1000)"}
     assert_raise Mongo::OperationTimeout do
       admin.command(command)
     end
   end
 
   def test_external_timeout_does_not_leave_socket_in_bad_state
-    client = Mongo::MongoClient.new
-    db = client[MONGO_TEST_DB]
-    coll = db['timeout-tests']
+    client = standard_connection
+    db     = client[TEST_DB]
+    coll   = db['timeout-tests']
+    grant_admin_user_eval_role(client)
 
     # prepare the database
     coll.drop
@@ -28,10 +45,10 @@ class TestTimeout < Test::Unit::TestCase
 
     # use external timeout to mangle socket
     begin
-      Timeout::timeout(1) do
-        db.command({:eval => "sleep(1500)"})
+      Timeout::timeout(0.5) do
+        db.command({:eval => "sleep(1000)"})
       end
-    rescue Timeout::Error => ex
+    rescue Timeout::Error
       #puts "Thread timed out and has now mangled the socket"
     end
 
@@ -40,21 +57,4 @@ class TestTimeout < Test::Unit::TestCase
     end
   end
 
-=begin
-  def test_ssl_op_timeout
-    connection = standard_connection(:op_timeout => 1, :ssl => true)
-
-    coll = connection.db(MONGO_TEST_DB).collection("test")
-    coll.insert({:a => 1})
-    # Should not timeout
-    assert coll.find_one({"$where" => "sleep(100); return true;"})
-
-    # Should timeout
-    assert_raise Mongo::OperationTimeout do
-      coll.find_one({"$where" => "sleep(5 * 1000); return true;"})
-    end
-
-    coll.remove
-  end
-=end
 end