mongo 1.3.0 → 1.12.5

data/test/{grid_io_test.rb → functional/grid_io_test.rb}

@@ -1,10 +1,24 @@
-require './test/test_helper'
+# 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
@@ -45,7 +59,7 @@ class GridIOTest < Test::Unit::TestCase
       should "read data character by character using" do
         bytes = 0
         file = GridIO.new(@files, @chunks, nil, "r", :query => {:_id => @file.files_id})
-        while char = file.getc
+        while file.getc
           bytes += 1
         end
         assert_equal bytes, 1_000_000
@@ -69,6 +83,24 @@ class GridIOTest < Test::Unit::TestCase
         assert_equal 10, string.length
       end
 
+      should "read to the end of the file one line at a time" do
+        file = GridIO.new(@files, @chunks, nil, "r", :query => {:_id => @file.files_id})
+        bytes = 0
+        while string = file.gets
+          bytes += string.length
+        end
+        assert_equal 1_000_000, bytes
+      end
+
+      should "read to the end of the file one multi-character separator at a time" do
+        file = GridIO.new(@files, @chunks, nil, "r", :query => {:_id => @file.files_id})
+        bytes = 0
+        while string = file.gets("45")
+          bytes += string.length
+        end
+        assert_equal 1_000_000, bytes
+      end
+
       should "read to a given separator" do
         file = GridIO.new(@files, @chunks, nil, "r", :query => {:_id => @file.files_id})
         string = file.gets("5")
@@ -93,7 +125,7 @@ class GridIOTest < Test::Unit::TestCase
 
       should "tell position, eof, and rewind" do
         file = GridIO.new(@files, @chunks, nil, "r", :query => {:_id => @file.files_id})
-        string = file.read(1000)
+        file.read(1000)
         assert_equal 1000, file.pos
         assert !file.eof?
         file.read
@@ -104,6 +136,35 @@ class GridIOTest < Test::Unit::TestCase
       end
     end
 
+    context "Writing" do
+      setup do
+        @filename = 'test'
+        @length = 50000
+        @times = 10
+      end
+
+      should "correctly write multiple chunks from mutiple writes" do
+        file = GridIO.new(@files, @chunks, @filename, 'w')
+
+        @times.times do
+          file.write("1" * @length)
+        end
+
+        file.close
+
+        file = GridIO.new(@files, @chunks, @filename, 'r')
+
+        total_size = 0
+        while !file.eof?
+          total_size += file.read(@length).length
+        end
+
+        file.close
+
+        assert_equal total_size, @times * @length
+      end
+    end
+
     context "Seeking" do
       setup do
         @filename = 'test'
@@ -139,24 +200,24 @@ class GridIOTest < Test::Unit::TestCase
 
     context "Grid MD5 check" do
       should "run in safe mode" do
-        file = GridIO.new(@files, @chunks, 'smallfile', 'w', :safe => true)
+        file = GridIO.new(@files, @chunks, 'smallfile', 'w')
         file.write("DATA" * 100)
         assert file.close
         assert_equal file.server_md5, file.client_md5
       end
 
       should "validate with a large file" do
-        io = File.open(File.join(File.dirname(__FILE__), 'data', 'sample_file.pdf'), 'r')
-        file = GridIO.new(@files, @chunks, 'bigfile', 'w', :safe => true)
+        io = File.open(File.join(TEST_DATA, 'sample_file.pdf'), 'r')
+        file = GridIO.new(@files, @chunks, 'bigfile', 'w')
         file.write(io)
         assert file.close
         assert_equal file.server_md5, file.client_md5
       end
 
       should "raise an exception when check fails" do
-        io = File.open(File.join(File.dirname(__FILE__), 'data', 'sample_file.pdf'), 'r')
+        io = File.open(File.join(TEST_DATA, 'sample_file.pdf'), 'r')
         @db.stubs(:command).returns({'md5' => '12345'})
-        file = GridIO.new(@files, @chunks, 'bigfile', 'w', :safe => true)
+        file = GridIO.new(@files, @chunks, 'bigfile', 'w')
         file.write(io)
         assert_raise GridMD5Failure do
           assert file.close

data/test/{grid_test.rb → functional/grid_test.rb}

@@ -1,8 +1,22 @@
-require './test/test_helper'
+# 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
 
 def read_and_write_stream(filename, read_length, opts={})
-  io   = File.open(File.join(File.dirname(__FILE__), 'data', filename), 'r')
+  io   = File.open(File.join(TEST_DATA, filename), 'r+b')
   id   = @grid.put(io, opts.merge!(:filename => filename + read_length.to_s))
   file = @grid.get(id)
   io.rewind
@@ -13,6 +27,7 @@ def read_and_write_stream(filename, read_length, opts={})
   read_data = ""
   while(chunk = file.read(read_length))
     read_data << chunk
+    break if chunk.empty?
   end
   assert_equal data.length, read_data.length
 end
@@ -20,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
@@ -30,6 +45,21 @@ class GridTest < Test::Unit::TestCase
       @chunks.remove
     end
 
+    context "A one-chunk grid-stored file" do
+      setup do
+        @data = "GRIDDATA" * 5
+        @grid = Grid.new(@db, 'test-fs')
+        @id   = @grid.put(@data, :filename => 'sample',
+                          :metadata => {'app' => 'photos'})
+      end
+
+      should "retrieve the file" do
+        data = @grid.get(@id).data
+        assert_equal @data, data
+      end
+
+    end
+
     context "A basic grid-stored file" do
       setup do
         @data = "GRIDDATA" * 50000
@@ -43,19 +73,13 @@ class GridTest < Test::Unit::TestCase
         assert_equal 'sample', file['filename']
       end
 
-      should "not be able to overwrite an exising file" do
-        assert_raise GridError do
-          @grid.put(@data, :filename => 'sample', :_id => @id, :safe => true)
-        end
-      end
-
       should "return nil if it doesn't exist" do
         assert_nil @grid.exist?(:metadata => 'foo')
       end
 
       should "retrieve the stored data" do
         data = @grid.get(@id).data
-        assert_equal @data, data
+        assert_equal @data.length, data.length
       end
 
       should "have a unique index on chunks" do
@@ -126,7 +150,9 @@ class GridTest < Test::Unit::TestCase
       end
 
       should "ignore special keys" do
-        id = @grid.put(@data, :file_length => 100, :phrase => "blimey")
+        id = silently do
+          @grid.put(@data, :file_length => 100, :phrase => "blimey")
+        end
         file = @grid.get(id)
 
         assert_equal "blimey", file['phrase']
@@ -137,8 +163,9 @@ class GridTest < Test::Unit::TestCase
     context "Storing data with a length of zero" do
       setup do
         @grid = Grid.new(@db, 'test-fs')
-        @id   = @grid.put('', :filename => 'sample',
-                          :metadata => {'app' => 'photos'})
+        @id = silently do
+          @grid.put('', :filename => 'sample', :metadata => {'app' => 'photos'})
+        end
       end
 
       should "return the zero length" do
@@ -151,7 +178,7 @@ class GridTest < Test::Unit::TestCase
       setup do
         @grid = Grid.new(@db, 'test-fs')
         filename = 'sample_data'
-        @io   = File.open(File.join(File.dirname(__FILE__), 'data', filename), 'r')
+        @io   = File.open(File.join(TEST_DATA, filename), 'r')
         id    = @grid.put(@io, :filename => filename)
         @file = @grid.get(id)
         @io.rewind
@@ -161,6 +188,46 @@ class GridTest < Test::Unit::TestCase
         end
       end
 
+      should "be equal in length" do
+        @io.rewind
+        assert_equal @io.read.length, @file.read.length
+      end
+
+      should "read the file" do
+        read_data = ""
+        @file.each do |chunk|
+          read_data << chunk
+        end
+        assert_equal @data.length, read_data.length
+      end
+
+      should "read the file if no block is given" do
+        read_data = @file.each
+        assert_equal @data.length, read_data.length
+      end
+    end
+
+    context "Grid streaming an empty file: " do
+      setup do
+        @grid = Grid.new(@db, 'test-fs')
+        filename = 'empty_data'
+        @io   = File.open(File.join(TEST_DATA, filename), 'r')
+        id = silently do
+          @grid.put(@io, :filename => filename)
+        end
+        @file = @grid.get(id)
+        @io.rewind
+        @data = @io.read
+        if @data.respond_to?(:force_encoding)
+          @data.force_encoding("binary")
+        end
+      end
+
+      should "be equal in length" do
+        @io.rewind
+        assert_equal @io.read.length, @file.read.length
+      end
+
       should "read the file" do
         read_data = ""
         @file.each do |chunk|
@@ -184,12 +251,18 @@ class GridTest < Test::Unit::TestCase
         read_and_write_stream('small_data.txt', 1, :chunk_size => 2)
       end
 
+      should "put and get an empty io object" do
+        silently do
+          read_and_write_stream('empty_data', 1)
+        end
+      end
+
       should "put and get a small io object" do
         read_and_write_stream('small_data.txt', 1)
       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

@@ -0,0 +1,136 @@
+# 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 PoolTest < Test::Unit::TestCase
+  include Mongo
+
+  def setup
+    @client    ||= standard_connection({:pool_size => 15, :pool_timeout => 5})
+    @db         = @client.db(TEST_DB)
+    @collection = @db.collection("pool_test")
+  end
+
+  def test_pool_affinity
+    pool = Pool.new(@client, TEST_HOST, TEST_PORT, :size => 5)
+
+    threads = []
+    10.times do
+      threads << Thread.new do
+        original_socket = pool.checkout
+        pool.checkin(original_socket)
+        500.times do
+          socket = pool.checkout
+          assert_equal original_socket, socket
+          pool.checkin(socket)
+        end
+      end
+    end
+
+    threads.each { |t| t.join }
+  end
+
+  def test_pool_affinity_max_size
+    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
+      coll.find({"value" => {"$lt" => 100}}).each {|e| e}
+      Thread.pass
+      sleep(0.125)
+      coll.find({"value" => {"$gt" => 100}}).each {|e| e}
+    end
+    threads << Thread.new do
+      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

@@ -0,0 +1,98 @@
+# 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
+
+class SafeTest < Test::Unit::TestCase
+  context "Safe mode propogation: " do
+    setup do
+      @connection = standard_connection({:safe => true}, true) # Legacy
+      @db         = @connection[TEST_DB]
+      @collection = @db['test-safe']
+      @collection.create_index([[:a, 1]], :unique => true)
+      @collection.remove
+    end
+
+    should "propogate safe option on insert" do
+      @collection.insert({:a => 1})
+
+      assert_raise_error(OperationFailure, "duplicate key") do
+        @collection.insert({:a => 1})
+      end
+    end
+
+    should "allow safe override on insert" do
+      @collection.insert({:a => 1})
+      @collection.insert({:a => 1}, :safe => false)
+    end
+
+    should "allow safe override on save" do
+      @collection.insert({:a => 1})
+      id = @collection.insert({:a => 2})
+      assert_nothing_raised do
+        @collection.save({:_id => id.to_s, :a => 1}, :safe => false)
+      end
+    end
+
+    should "propogate safe option on save" do
+      @collection.insert({:a => 1})
+      id = @collection.insert({:a => 2})
+      assert_raise(OperationFailure) do
+        @collection.save({:_id => id.to_s, :a => 1})
+      end
+    end
+
+    should "propogate safe option on update" do
+      @collection.insert({:a => 1})
+      @collection.insert({:a => 2})
+
+      assert_raise_error(OperationFailure, "duplicate key") do
+        @collection.update({:a => 2}, {:a => 1})
+      end
+    end
+
+    should "allow safe override on update" do
+      @collection.insert({:a => 1})
+      @collection.insert({:a => 2})
+      @collection.update({:a => 2}, {:a => 1}, :safe => false)
+    end
+  end
+
+  context "Safe error objects" do
+    setup do
+      @connection = standard_connection({:safe => true}, true) # Legacy
+      @db         = @connection[TEST_DB]
+      @collection = @db['test']
+      @collection.remove
+      @collection.insert({:a => 1})
+      @collection.insert({:a => 1})
+      @collection.insert({:a => 1})
+    end
+
+    should "return object on update" do
+      response = @collection.update({:a => 1}, {"$set" => {:a => 2}},
+                             :multi => true)
+
+      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
+      response = @collection.remove({})
+      assert_equal 3, response['n']
+    end
+  end
+
+end

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

@@ -0,0 +1,62 @@
+# 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
+
+  def test_command_response_succeeds
+    assert Support.ok?('ok' => 1)
+    assert Support.ok?('ok' => 1.0)
+    assert Support.ok?('ok' => true)
+  end
+
+  def test_command_response_fails
+    assert !Support.ok?('ok' => 0)
+    assert !Support.ok?('ok' => 0.0)
+    assert !Support.ok?('ok' => 0.0)
+    assert !Support.ok?('ok' => 'str')
+    assert !Support.ok?('ok' => false)
+  end
+
+  def test_array_of_pairs
+    hps = [["localhost", 27017], ["localhost", 27018], ["localhost", 27019]]
+    assert_equal [["localhost", 27017], ["localhost", 27018], ["localhost", 27019]], Support.normalize_seeds(hps)
+  end
+
+  def test_array_of_strings
+    hps = ["localhost:27017", "localhost:27018", "localhost:27019"]
+    assert_equal [["localhost", 27017], ["localhost", 27018], ["localhost", 27019]], Support.normalize_seeds(hps)
+  end
+
+  def test_single_string_with_host_port
+    hps = "localhost:27017"
+    assert_equal ["localhost", 27017], Support.normalize_seeds(hps)
+  end
+
+  def test_single_string_missing_port
+    hps = "localhost"
+    assert_equal ["localhost", 27017], Support.normalize_seeds(hps)
+  end
+
+  def test_single_element_array_missing_port
+    hps = ["localhost"]
+    assert_equal ["localhost", 27017], Support.normalize_seeds(hps)
+  end
+
+  def test_pair_doesnt_get_converted
+    hps = ["localhost", 27017]
+    assert_equal ["localhost", 27017], Support.normalize_seeds(hps)
+  end
+end