mongo-find_replace 0.18.3

data/test/test_connection.rb

@@ -0,0 +1,160 @@
+require 'test/test_helper'
+require 'logger'
+require 'stringio'
+require 'thread'
+
+# NOTE: assumes Mongo is running
+class TestConnection < Test::Unit::TestCase
+
+  include Mongo
+
+  def setup
+    @host = ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost'
+    @port = ENV['MONGO_RUBY_DRIVER_PORT'] || Connection::DEFAULT_PORT
+    @mongo = Connection.new(@host, @port)
+  end
+
+  def teardown
+    @mongo.db('ruby-mongo-test').error
+  end
+
+  def test_server_info
+    server_info = @mongo.server_info
+    assert server_info.keys.include?("version")
+    assert_equal 1.0, server_info["ok"]
+  end
+
+  def test_server_version
+    assert_match /\d\.\d+(\.\d+)?/, @mongo.server_version.to_s
+  end
+
+  def test_invalid_database_names
+    assert_raise TypeError do @mongo.db(4) end
+
+    assert_raise InvalidName do @mongo.db('') end
+    assert_raise InvalidName do @mongo.db('te$t') end
+    assert_raise InvalidName do @mongo.db('te.t') end
+    assert_raise InvalidName do @mongo.db('te\\t') end
+    assert_raise InvalidName do @mongo.db('te/t') end
+    assert_raise InvalidName do @mongo.db('te st') end
+  end
+
+  def test_database_info
+    @mongo.drop_database('ruby-mongo-info-test')
+    @mongo.db('ruby-mongo-info-test').collection('info-test').insert('a' => 1)
+
+    info = @mongo.database_info
+    assert_not_nil info
+    assert_kind_of Hash, info
+    assert_not_nil info['ruby-mongo-info-test']
+    assert info['ruby-mongo-info-test'] > 0
+
+    @mongo.drop_database('ruby-mongo-info-test')
+  end
+
+  def test_copy_database
+    @mongo.db('old').collection('copy-test').insert('a' => 1)
+    @mongo.copy_database('old', 'new')
+    old_object = @mongo.db('old').collection('copy-test').find.next_document
+    new_object = @mongo.db('new').collection('copy-test').find.next_document
+    assert_equal old_object, new_object
+  end
+
+  def test_database_names
+    @mongo.drop_database('ruby-mongo-info-test')
+    @mongo.db('ruby-mongo-info-test').collection('info-test').insert('a' => 1)
+
+    names = @mongo.database_names
+    assert_not_nil names
+    assert_kind_of Array, names
+    assert names.length >= 1
+    assert names.include?('ruby-mongo-info-test')
+
+    @mongo.drop_database('ruby-mongo-info-test')
+  end
+
+  def test_logging
+    output = StringIO.new
+    logger = Logger.new(output)
+    logger.level = Logger::DEBUG
+    db = Connection.new(@host, @port, :logger => logger).db('ruby-mongo-test')
+    assert output.string.include?("admin.$cmd.find")
+  end
+  
+  def test_connection_logger
+    output = StringIO.new
+    logger = Logger.new(output)
+    logger.level = Logger::DEBUG
+    connection = Connection.new(@host, @port, :logger => logger)
+    assert_equal logger, connection.logger
+    
+    connection.logger.debug 'testing'
+    assert output.string.include?('testing')
+  end
+
+  def test_drop_database
+    db = @mongo.db('ruby-mongo-will-be-deleted')
+    coll = db.collection('temp')
+    coll.remove
+    coll.insert(:name => 'temp')
+    assert_equal 1, coll.count()
+    assert @mongo.database_names.include?('ruby-mongo-will-be-deleted')
+
+    @mongo.drop_database('ruby-mongo-will-be-deleted')
+    assert !@mongo.database_names.include?('ruby-mongo-will-be-deleted')
+  end
+
+  def test_nodes
+    db = Connection.new({:left => ['foo', 123]}, nil, :connect => false)
+    nodes = db.nodes
+    assert_equal 2, db.nodes.length
+    assert_equal ['foo', 123], nodes[0]
+    assert_equal ['localhost', Connection::DEFAULT_PORT], nodes[1]
+
+    db = Connection.new({:right => 'bar'}, nil, :connect => false)
+    nodes = db.nodes
+    assert_equal 2, nodes.length
+    assert_equal ['localhost', Connection::DEFAULT_PORT], nodes[0]
+    assert_equal ['bar', Connection::DEFAULT_PORT], nodes[1]
+
+    db = Connection.new({:right => ['foo', 123], :left => 'bar'}, nil, :connect => false)
+    nodes = db.nodes
+    assert_equal 2, nodes.length
+    assert_equal ['bar', Connection::DEFAULT_PORT], nodes[0]
+    assert_equal ['foo', 123], nodes[1]
+  end
+
+  context "Connection exceptions" do
+    setup do
+      @conn = Mongo::Connection.new('localhost', 27017, :pool_size => 10, :timeout => 10)
+      @coll = @conn['mongo-ruby-test']['test-connection-exceptions']
+    end
+
+    should "release connection if an exception is raised on send_message" do
+      @conn.stubs(:send_message_on_socket).raises(ConnectionFailure)
+      assert_equal 0, @conn.checked_out.size
+      assert_raise ConnectionFailure do
+        @coll.insert({:test => "insert"})
+      end
+      assert_equal 0, @conn.checked_out.size
+    end
+
+    should "release connection if an exception is raised on send_with_safe_check" do
+      @conn.stubs(:receive).raises(ConnectionFailure)
+      assert_equal 0, @conn.checked_out.size
+      assert_raise ConnectionFailure do
+        @coll.insert({:test => "insert"}, :safe => true)
+      end
+      assert_equal 0, @conn.checked_out.size
+    end
+
+    should "release connection if an exception is raised on receive_message" do
+      @conn.stubs(:receive).raises(ConnectionFailure)
+      assert_equal 0, @conn.checked_out.size
+      assert_raise ConnectionFailure do
+        @coll.find.to_a
+      end
+      assert_equal 0, @conn.checked_out.size
+    end
+  end
+end

data/test/test_conversions.rb

@@ -0,0 +1,120 @@
+require 'test/test_helper'
+require 'mongo/exceptions'
+require 'mongo/util/conversions'
+require 'mongo/util/ordered_hash'
+
+class ConversionsTest < Test::Unit::TestCase
+  include Mongo::Conversions
+
+  def test_array_as_sort_parameters_with_array_of_key_and_value
+    params = array_as_sort_parameters(["field1", "asc"])
+    assert_equal({"field1" => 1}, params)
+  end
+
+  def test_array_as_sort_parameters_with_array_of_string_and_values
+    params = array_as_sort_parameters([["field1", :asc], ["field2", :desc]])
+    assert_equal({ "field1" => 1, "field2" => -1 }, params)
+  end
+
+  def test_string_as_sort_parameters_with_string
+    params = string_as_sort_parameters("field")
+    assert_equal({ "field" => 1 }, params)
+  end
+
+  def test_string_as_sort_parameters_with_empty_string
+    params = string_as_sort_parameters("")
+    assert_equal({}, params)
+  end
+
+  def test_symbol_as_sort_parameters
+    params = string_as_sort_parameters(:field)
+    assert_equal({ "field" => 1 }, params)
+  end
+
+  def test_sort_value_when_value_is_one
+    assert_equal 1, sort_value(1)
+  end
+
+  def test_sort_value_when_value_is_one_as_a_string
+    assert_equal 1, sort_value("1")
+  end
+
+  def test_sort_value_when_value_is_negative_one
+    assert_equal -1, sort_value(-1)
+  end
+
+  def test_sort_value_when_value_is_negative_one_as_a_string
+    assert_equal -1, sort_value("-1")
+  end
+
+  def test_sort_value_when_value_is_ascending
+    assert_equal 1, sort_value("ascending")
+  end
+
+  def test_sort_value_when_value_is_asc
+    assert_equal 1, sort_value("asc")
+  end
+
+  def test_sort_value_when_value_is_uppercase_ascending
+    assert_equal 1, sort_value("ASCENDING")
+  end
+
+  def test_sort_value_when_value_is_uppercase_asc
+    assert_equal 1, sort_value("ASC")
+  end
+
+  def test_sort_value_when_value_is_symbol_ascending
+    assert_equal 1, sort_value(:ascending)
+  end
+
+  def test_sort_value_when_value_is_symbol_asc
+    assert_equal 1, sort_value(:asc)
+  end
+
+  def test_sort_value_when_value_is_symbol_uppercase_ascending
+    assert_equal 1, sort_value(:ASCENDING)
+  end
+
+  def test_sort_value_when_value_is_symbol_uppercase_asc
+    assert_equal 1, sort_value(:ASC)
+  end
+
+  def test_sort_value_when_value_is_descending
+    assert_equal -1, sort_value("descending")
+  end
+
+  def test_sort_value_when_value_is_desc
+    assert_equal -1, sort_value("desc")
+  end
+
+  def test_sort_value_when_value_is_uppercase_descending
+    assert_equal -1, sort_value("DESCENDING")
+  end
+
+  def test_sort_value_when_value_is_uppercase_desc
+    assert_equal -1, sort_value("DESC")
+  end
+
+  def test_sort_value_when_value_is_symbol_descending
+    assert_equal -1, sort_value(:descending)
+  end
+
+  def test_sort_value_when_value_is_symbol_desc
+    assert_equal -1, sort_value(:desc)
+  end
+
+  def test_sort_value_when_value_is_uppercase_symbol_descending
+    assert_equal -1, sort_value(:DESCENDING)
+  end
+
+  def test_sort_value_when_value_is_uppercase_symbol_desc
+    assert_equal -1, sort_value(:DESC)
+  end
+
+  def test_sort_value_when_value_is_invalid
+    assert_raise Mongo::InvalidSortValueError do
+      sort_value(2)
+    end
+  end
+
+end

data/test/test_cursor.rb

@@ -0,0 +1,386 @@
+require 'test/test_helper'
+require 'logger'
+
+# NOTE: assumes Mongo is running
+class CursorTest < Test::Unit::TestCase
+
+  include Mongo
+
+  @@connection = Connection.new(ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost',
+                        ENV['MONGO_RUBY_DRIVER_PORT'] || Connection::DEFAULT_PORT)
+  @@db   = @@connection.db('ruby-mongo-test')
+  @@coll = @@db.collection('test')
+  @@version = @@connection.server_version
+
+  def setup
+    @@coll.remove
+    @@coll.insert('a' => 1)     # collection not created until it's used
+    @@coll_full_name = 'ruby-mongo-test.test'
+  end
+
+  def test_explain
+    cursor = @@coll.find('a' => 1)
+    explaination = cursor.explain
+    assert_not_nil explaination['cursor']
+    assert_kind_of Numeric, explaination['n']
+    assert_kind_of Numeric, explaination['millis']
+    assert_kind_of Numeric, explaination['nscanned']
+  end
+
+  def test_count
+    @@coll.remove
+
+    assert_equal 0, @@coll.find().count()
+
+    10.times do |i|
+      @@coll.save("x" => i)
+    end
+
+    assert_equal 10, @@coll.find().count()
+    assert_kind_of Integer, @@coll.find().count()
+    assert_equal 10, @@coll.find({}, :limit => 5).count()
+    assert_equal 10, @@coll.find({}, :skip => 5).count()
+
+    assert_equal 1, @@coll.find({"x" => 1}).count()
+    assert_equal 5, @@coll.find({"x" => {"$lt" => 5}}).count()
+
+    a = @@coll.find()
+    b = a.count()
+    a.each do |doc|
+      break
+    end
+    assert_equal b, a.count()
+
+    assert_equal 0, @@db['acollectionthatdoesn'].count()
+  end
+
+  def test_next_object_deprecation
+    @@coll.remove
+    @@coll.insert({"a" => 1})
+
+    assert_equal 1, @@coll.find().next_object["a"]
+  end
+
+  def test_sort
+    @@coll.remove
+    5.times{|x| @@coll.insert({"age" => x}) }
+
+    assert_kind_of Cursor, @@coll.find().sort(:age, 1)
+
+    assert_equal 0, @@coll.find().sort(:age, 1).next_document["age"]
+    assert_equal 4, @@coll.find().sort(:age, -1).next_document["age"]
+    assert_equal 0, @@coll.find().sort([["age", :asc]]).next_document["age"]
+
+    assert_kind_of Cursor, @@coll.find().sort([[:age, -1], [:b, 1]])
+
+    assert_equal 4, @@coll.find().sort(:age, 1).sort(:age, -1).next_document["age"]
+    assert_equal 0, @@coll.find().sort(:age, -1).sort(:age, 1).next_document["age"]
+
+    assert_equal 4, @@coll.find().sort([:age, :asc]).sort(:age, -1).next_document["age"]
+    assert_equal 0, @@coll.find().sort([:age, :desc]).sort(:age, 1).next_document["age"]
+
+    cursor = @@coll.find()
+    cursor.next_document
+    assert_raise InvalidOperation do
+      cursor.sort(["age"])
+    end
+
+    assert_raise InvalidSortValueError do
+      @@coll.find().sort(:age, 25).next_document
+    end
+
+    assert_raise InvalidSortValueError do
+      @@coll.find().sort(25).next_document
+    end
+  end
+
+  def test_sort_date
+    @@coll.remove
+    5.times{|x| @@coll.insert({"created_at" => Time.utc(2000 + x)}) }
+
+    assert_equal 2000, @@coll.find().sort(:created_at, :asc).next_document["created_at"].year
+    assert_equal 2004, @@coll.find().sort(:created_at, :desc).next_document["created_at"].year
+
+    assert_equal 2000, @@coll.find().sort([:created_at, :asc]).next_document["created_at"].year
+    assert_equal 2004, @@coll.find().sort([:created_at, :desc]).next_document["created_at"].year
+
+    assert_equal 2000, @@coll.find().sort([[:created_at, :asc]]).next_document["created_at"].year
+    assert_equal 2004, @@coll.find().sort([[:created_at, :desc]]).next_document["created_at"].year
+  end
+
+  def test_sort_min_max_keys
+    @@coll.remove
+    @@coll.insert({"n" => 1000000})
+    @@coll.insert({"n" => -1000000})
+    @@coll.insert({"n" => MaxKey.new})
+    @@coll.insert({"n" => MinKey.new})
+
+    results = @@coll.find.sort([:n, :asc]).to_a
+
+    assert_equal MinKey.new, results[0]['n']
+    assert_equal -1000000,   results[1]['n']
+    assert_equal 1000000,    results[2]['n']
+    assert_equal MaxKey.new, results[3]['n']
+  end
+
+  def test_id_range_queries
+    @@coll.remove
+
+    t1 = Time.now
+    t1_id = ObjectID.from_time(t1)
+    @@coll.save({:t => 't1'})
+    @@coll.save({:t => 't1'})
+    @@coll.save({:t => 't1'})
+    sleep(2)
+    t2 = Time.now
+    t2_id = ObjectID.from_time(t2)
+    @@coll.save({:t => 't2'})
+    @@coll.save({:t => 't2'})
+    @@coll.save({:t => 't2'})
+
+    assert_equal 3, @@coll.find({'_id' => {'$gt' => t1_id}, '_id' => {'$lt' => t2_id}}).count
+    @@coll.find({'_id' => {'$gt' => t2_id}}).each do |doc|
+      assert_equal 't2', doc['t']
+    end
+  end
+
+  def test_limit
+    @@coll.remove
+
+    10.times do |i|
+      @@coll.save("x" => i)
+    end
+    assert_equal 10, @@coll.find().count()
+
+    results = @@coll.find().limit(5).to_a
+    assert_equal 5, results.length
+  end
+
+  def test_limit_exceptions
+    assert_raise ArgumentError do
+      cursor = @@coll.find().limit('not-an-integer')
+    end
+
+    cursor      = @@coll.find()
+    firstResult = cursor.next_document
+    assert_raise InvalidOperation, "Cannot modify the query once it has been run or closed." do
+      cursor.limit(1)
+    end
+
+    cursor = @@coll.find()
+    cursor.close
+    assert_raise InvalidOperation, "Cannot modify the query once it has been run or closed." do
+      cursor.limit(1)
+    end
+  end
+
+  def test_skip
+    @@coll.remove
+
+    10.times do |i|
+      @@coll.save("x" => i)
+    end
+    assert_equal 10, @@coll.find().count()
+
+    all_results    = @@coll.find().to_a
+    skip_results = @@coll.find().skip(2).to_a
+    assert_equal 10, all_results.length
+    assert_equal 8,  skip_results.length
+
+    assert_equal all_results.slice(2...10), skip_results
+  end
+
+  def test_skip_exceptions
+    assert_raise ArgumentError do
+      cursor = @@coll.find().skip('not-an-integer')
+    end
+
+    cursor      = @@coll.find()
+    firstResult = cursor.next_document
+    assert_raise InvalidOperation, "Cannot modify the query once it has been run or closed." do
+      cursor.skip(1)
+    end
+
+    cursor = @@coll.find()
+    cursor.close
+    assert_raise InvalidOperation, "Cannot modify the query once it has been run or closed." do
+      cursor.skip(1)
+    end
+  end
+
+  def test_limit_skip_chaining
+    @@coll.remove
+    10.times do |i|
+      @@coll.save("x" => i)
+    end
+
+    all_results = @@coll.find().to_a
+    limited_skip_results = @@coll.find().limit(5).skip(3).to_a
+
+    assert_equal all_results.slice(3...8), limited_skip_results
+  end
+
+  def test_close_no_query_sent
+    begin
+      cursor = @@coll.find('a' => 1)
+      cursor.close
+      assert cursor.closed?
+    rescue => ex
+      fail ex.to_s
+    end
+  end
+
+  def test_refill_via_get_more
+    assert_equal 1, @@coll.count
+    1000.times { |i|
+      assert_equal 1 + i, @@coll.count
+      @@coll.insert('a' => i)
+    }
+
+    assert_equal 1001, @@coll.count
+    count = 0
+    @@coll.find.each { |obj|
+      count += obj['a']
+    }
+    assert_equal 1001, @@coll.count
+
+    # do the same thing again for debugging
+    assert_equal 1001, @@coll.count
+    count2 = 0
+    @@coll.find.each { |obj|
+      count2 += obj['a']
+    }
+    assert_equal 1001, @@coll.count
+
+    assert_equal count, count2
+    assert_equal 499501, count
+  end
+
+  def test_refill_via_get_more_alt_coll
+    coll = @@db.collection('test-alt-coll')
+    coll.remove
+    coll.insert('a' => 1)     # collection not created until it's used
+    assert_equal 1, coll.count
+
+    1000.times { |i|
+      assert_equal 1 + i, coll.count
+      coll.insert('a' => i)
+    }
+
+    assert_equal 1001, coll.count
+    count = 0
+    coll.find.each { |obj|
+      count += obj['a']
+    }
+    assert_equal 1001, coll.count
+
+    # do the same thing again for debugging
+    assert_equal 1001, coll.count
+    count2 = 0
+    coll.find.each { |obj|
+      count2 += obj['a']
+    }
+    assert_equal 1001, coll.count
+
+    assert_equal count, count2
+    assert_equal 499501, count
+  end
+
+  def test_close_after_query_sent
+    begin
+      cursor = @@coll.find('a' => 1)
+      cursor.next_document
+      cursor.close
+      assert cursor.closed?
+    rescue => ex
+      fail ex.to_s
+    end
+  end
+
+  def test_kill_cursors
+    @@coll.drop
+
+    client_cursors = @@db.command("cursorInfo" => 1)["clientCursors_size"]
+    by_location = @@db.command("cursorInfo" => 1)["byLocation_size"]
+
+    10000.times do |i|
+      @@coll.insert("i" => i)
+    end
+
+    assert_equal(client_cursors,
+                 @@db.command("cursorInfo" => 1)["clientCursors_size"])
+    assert_equal(by_location,
+                 @@db.command("cursorInfo" => 1)["byLocation_size"])
+
+    10.times do |i|
+      @@coll.find_one()
+    end
+
+    assert_equal(client_cursors,
+                 @@db.command("cursorInfo" => 1)["clientCursors_size"])
+    assert_equal(by_location,
+                 @@db.command("cursorInfo" => 1)["byLocation_size"])
+
+    10.times do |i|
+      a = @@coll.find()
+      a.next_document
+      a.close()
+    end
+
+    assert_equal(client_cursors,
+                 @@db.command("cursorInfo" => 1)["clientCursors_size"])
+    assert_equal(by_location,
+                 @@db.command("cursorInfo" => 1)["byLocation_size"])
+
+    a = @@coll.find()
+    a.next_document
+
+    assert_not_equal(client_cursors,
+                     @@db.command("cursorInfo" => 1)["clientCursors_size"])
+    assert_not_equal(by_location,
+                     @@db.command("cursorInfo" => 1)["byLocation_size"])
+
+    a.close()
+
+    assert_equal(client_cursors,
+                 @@db.command("cursorInfo" => 1)["clientCursors_size"])
+    assert_equal(by_location,
+                 @@db.command("cursorInfo" => 1)["byLocation_size"])
+
+    a = @@coll.find({}, :limit => 10).next_document
+
+    assert_equal(client_cursors,
+                 @@db.command("cursorInfo" => 1)["clientCursors_size"])
+    assert_equal(by_location,
+                 @@db.command("cursorInfo" => 1)["byLocation_size"])
+
+    @@coll.find() do |cursor|
+      cursor.next_document
+    end
+
+    assert_equal(client_cursors,
+                 @@db.command("cursorInfo" => 1)["clientCursors_size"])
+    assert_equal(by_location,
+                 @@db.command("cursorInfo" => 1)["byLocation_size"])
+
+    @@coll.find() { |cursor|
+      cursor.next_document
+    }
+
+    assert_equal(client_cursors,
+                 @@db.command("cursorInfo" => 1)["clientCursors_size"])
+    assert_equal(by_location,
+                 @@db.command("cursorInfo" => 1)["byLocation_size"])
+  end
+
+  def test_count_with_fields
+    @@coll.remove
+    @@coll.save("x" => 1)
+
+    if @@version < "1.1.3"
+      assert_equal(0, @@coll.find({}, :fields => ["a"]).count())
+    else
+      assert_equal(1, @@coll.find({}, :fields => ["a"]).count())
+    end
+  end
+end