mongo 1.12.5 → 2.0.0

data/test/functional/grid_io_test.rb

@@ -1,252 +0,0 @@
-# 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(TEST_DB)
-      @files  = @db.collection('fs.files')
-      @chunks = @db.collection('fs.chunks')
-      @chunks.create_index([['files_id', Mongo::ASCENDING], ['n', Mongo::ASCENDING]])
-    end
-
-    teardown do
-      @files.remove
-      @chunks.remove
-    end
-
-    context "Options" do
-      setup do
-        @filename = 'test'
-        @mode     = 'w'
-      end
-
-      should "set default 255k chunk size" do
-        file = GridIO.new(@files, @chunks, @filename, @mode)
-        assert_equal 255 * 1024, file.chunk_size
-      end
-
-      should "set chunk size" do
-        file = GridIO.new(@files, @chunks, @filename, @mode, :chunk_size => 1000)
-        assert_equal 1000, file.chunk_size
-      end
-    end
-
-    context "StringIO methods" do
-      setup do
-        @filename = 'test'
-        @mode     = 'w'
-        @data     = "012345678\n" * 100000
-        @file = GridIO.new(@files, @chunks, @filename, @mode)
-        @file.write(@data)
-        @file.close
-      end
-
-      should "read data character by character using" do
-        bytes = 0
-        file = GridIO.new(@files, @chunks, nil, "r", :query => {:_id => @file.files_id})
-        while file.getc
-          bytes += 1
-        end
-        assert_equal bytes, 1_000_000
-      end
-
-      should "read length is a length is given" do
-        file = GridIO.new(@files, @chunks, nil, "r", :query => {:_id => @file.files_id})
-        string = file.gets(1000)
-        assert_equal string.length, 1000
-        bytes = 0
-        bytes += string.length
-        while string = file.gets(1000)
-          bytes += string.length
-        end
-        assert_equal bytes, 1_000_000
-      end
-
-      should "read to the end of the line by default and assign to $_" do
-        file = GridIO.new(@files, @chunks, nil, "r", :query => {:_id => @file.files_id})
-        string = file.gets
-        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")
-        assert_equal 6, string.length
-      end
-
-      should "read a multi-character separator" do
-        file = GridIO.new(@files, @chunks, nil, "r", :query => {:_id => @file.files_id})
-        string = file.gets("45")
-        assert_equal 6, string.length
-        string = file.gets("45")
-        assert_equal "678\n012345", string
-        string = file.gets("\n01")
-        assert_equal "678\n01", string
-      end
-
-      should "read a mult-character separator with a length" do
-        file = GridIO.new(@files, @chunks, nil, "r", :query => {:_id => @file.files_id})
-        string = file.gets("45", 3)
-        assert_equal 3, string.length
-      end
-
-      should "tell position, eof, and rewind" do
-        file = GridIO.new(@files, @chunks, nil, "r", :query => {:_id => @file.files_id})
-        file.read(1000)
-        assert_equal 1000, file.pos
-        assert !file.eof?
-        file.read
-        assert file.eof?
-        file.rewind
-        assert_equal 0, file.pos
-        assert_equal 1_000_000, file.read.length
-      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'
-        @mode     = 'w'
-        @data     = "1" * 1024 * 1024
-        @file = GridIO.new(@files, @chunks, @filename, @mode)
-        @file.write(@data)
-        @file.close
-      end
-
-      should "read all data using read_length and then be able to seek" do
-        file = GridIO.new(@files, @chunks, nil, "r", :query => {:_id => @file.files_id})
-        assert_equal @data, file.read(1024 * 1024)
-        file.seek(0)
-        assert_equal @data, file.read
-      end
-
-      should "read all data using read_all and then be able to seek" do
-        file = GridIO.new(@files, @chunks, nil, "r", :query => {:_id => @file.files_id})
-        assert_equal @data, file.read
-        file.seek(0)
-        assert_equal @data, file.read
-        file.seek(1024 * 512)
-        assert_equal 524288, file.file_position
-        assert_equal @data.length / 2, file.read.length
-        assert_equal 1048576, file.file_position
-        assert_nil file.read
-        file.seek(1024 * 512)
-        assert_equal 524288, file.file_position
-      end
-
-    end
-
-    context "Grid MD5 check" do
-      should "run in safe mode" do
-        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(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(TEST_DATA, 'sample_file.pdf'), 'r')
-        @db.stubs(:command).returns({'md5' => '12345'})
-        file = GridIO.new(@files, @chunks, 'bigfile', 'w')
-        file.write(io)
-        assert_raise GridMD5Failure do
-          assert file.close
-        end
-        assert_not_equal file.server_md5, file.client_md5
-      end
-    end
-
-    context "Content types" do
-      if defined?(MIME)
-        should "determine common content types from the extension" do
-          file = GridIO.new(@files, @chunks, 'sample.pdf', 'w')
-          assert_equal 'application/pdf', file.content_type
-
-          file = GridIO.new(@files, @chunks, 'sample.txt', 'w')
-          assert_equal 'text/plain', file.content_type
-        end
-      end
-
-      should "default to binary/octet-stream when type is unknown" do
-        file = GridIO.new(@files, @chunks, 'sample.l33t', 'w')
-        assert_equal 'binary/octet-stream', file.content_type
-      end
-
-      should "use any provided content type by default" do
-        file = GridIO.new(@files, @chunks, 'sample.l33t', 'w', :content_type => 'image/jpg')
-        assert_equal 'image/jpg', file.content_type
-      end
-    end
-  end
-
-end

data/test/functional/grid_test.rb

@@ -1,273 +0,0 @@
-# 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(TEST_DATA, filename), 'r+b')
-  id   = @grid.put(io, opts.merge!(:filename => filename + read_length.to_s))
-  file = @grid.get(id)
-  io.rewind
-  data = io.read
-  if data.respond_to?(:force_encoding)
-    data.force_encoding("binary")
-  end
-  read_data = ""
-  while(chunk = file.read(read_length))
-    read_data << chunk
-    break if chunk.empty?
-  end
-  assert_equal data.length, read_data.length
-end
-
-class GridTest < Test::Unit::TestCase
-  context "Tests:" do
-    setup do
-      @db = standard_connection.db(TEST_DB)
-      @files  = @db.collection('test-fs.files')
-      @chunks = @db.collection('test-fs.chunks')
-    end
-
-    teardown do
-      @files.remove
-      @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
-        @grid = Grid.new(@db, 'test-fs')
-        @id   = @grid.put(@data, :filename => 'sample',
-                          :metadata => {'app' => 'photos'})
-      end
-
-      should "check existence" do
-        file = @grid.exist?(:filename => 'sample')
-        assert_equal 'sample', file['filename']
-      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.length, data.length
-      end
-
-      should "have a unique index on chunks" do
-        assert @chunks.index_information['files_id_1_n_1']['unique']
-      end
-
-      should "store the filename" do
-        file = @grid.get(@id)
-        assert_equal 'sample', file.filename
-      end
-
-      should "store any relevant metadata" do
-        file = @grid.get(@id)
-        assert_equal 'photos', file.metadata['app']
-      end
-
-      should "delete the file and any chunks" do
-        @grid.delete(@id)
-        assert_raise GridFileNotFound do
-          @grid.get(@id)
-        end
-        assert_equal nil, @db['test-fs']['chunks'].find_one({:files_id => @id})
-      end
-    end
-
-    context "Filename not required" do
-      setup do
-        @data = "GRIDDATA" * 50000
-        @grid = Grid.new(@db, 'test-fs')
-        @metadata = {'app' => 'photos'}
-      end
-
-      should "store the file with the old filename api" do
-        id = @grid.put(@data, :filename => 'sample', :metadata => @metadata)
-        file = @grid.get(id)
-        assert_equal 'sample', file.filename
-        assert_equal @metadata, file.metadata
-      end
-
-      should "store without a filename" do
-        id = @grid.put(@data, :metadata => @metadata)
-        file = @grid.get(id)
-        assert_nil file.filename
-        file_doc = @files.find_one({'_id' => id})
-        assert !file_doc.has_key?('filename')
-        assert_equal @metadata, file.metadata
-      end
-
-      should "store with filename and metadata with the new api" do
-        id = @grid.put(@data, :filename => 'sample', :metadata => @metadata)
-        file = @grid.get(id)
-        assert_equal 'sample', file.filename
-        assert_equal @metadata, file.metadata
-      end
-    end
-
-    context "Writing arbitrary data fields" do
-      setup do
-        @data = "GRIDDATA" * 50000
-        @grid = Grid.new(@db, 'test-fs')
-      end
-
-      should "write random keys to the files collection" do
-        id = @grid.put(@data, :phrases => ["blimey", "ahoy!"])
-        file = @grid.get(id)
-
-        assert_equal ["blimey", "ahoy!"], file['phrases']
-      end
-
-      should "ignore special keys" do
-        id = silently do
-          @grid.put(@data, :file_length => 100, :phrase => "blimey")
-        end
-        file = @grid.get(id)
-
-        assert_equal "blimey", file['phrase']
-        assert_equal 400_000, file.file_length
-      end
-    end
-
-    context "Storing data with a length of zero" do
-      setup do
-        @grid = Grid.new(@db, 'test-fs')
-        @id = silently do
-          @grid.put('', :filename => 'sample', :metadata => {'app' => 'photos'})
-        end
-      end
-
-      should "return the zero length" do
-        data = @grid.get(@id)
-        assert_equal 0, data.read.length
-      end
-    end
-
-    context "Grid streaming: " do
-      setup do
-        @grid = Grid.new(@db, 'test-fs')
-        filename = 'sample_data'
-        @io   = File.open(File.join(TEST_DATA, filename), 'r')
-        id    = @grid.put(@io, :filename => filename)
-        @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|
-          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|
-          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 "Streaming: " do || {}
-      setup do
-        @grid = Grid.new(@db, 'test-fs')
-      end
-
-      should "put and get a small io object with a small chunk size" do
-        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', 255 * 1024)
-      end
-
-      should "put and get a large io object if reading more than the chunk size" do
-        read_and_write_stream('sample_data', 300 * 1024)
-      end
-    end
-  end
-end

data/test/functional/pool_test.rb

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