mongo 1.1.5 → 1.3.0

data/test/connection_test.rb

@@ -22,12 +22,22 @@ class TestConnection < Test::Unit::TestCase
     end
   end
 
+  def test_host_port_accessors
+    assert_equal @conn.host, TEST_HOST
+    assert_equal @conn.port, TEST_PORT
+  end
+
   def test_server_info
     server_info = @conn.server_info
     assert server_info.keys.include?("version")
     assert Mongo::Support.ok?(server_info)
   end
 
+  def test_ping
+    ping = @conn.ping
+    assert ping['ok']
+  end
+
   def test_connection_uri
     con = Connection.from_uri("mongodb://#{host_port}")
     assert_equal mongo_host, con.primary_pool.host
@@ -35,7 +45,7 @@ class TestConnection < Test::Unit::TestCase
   end
 
   def test_server_version
-    assert_match /\d\.\d+(\.\d+)?/, @conn.server_version.to_s
+    assert_match(/\d\.\d+(\.\d+)?/, @conn.server_version.to_s)
   end
 
   def test_invalid_database_names
@@ -149,7 +159,7 @@ class TestConnection < Test::Unit::TestCase
     @conn.lock!
     assert @conn.locked?
     assert_equal 1, @conn['admin']['$cmd.sys.inprog'].find_one['fsyncLock'], "Not fsync-locked"
-    assert_equal "unlock requested", @conn.unlock!['info']
+    assert_match(/unlock/, @conn.unlock!['info'])
     unlocked = false
     counter  = 0
     while counter < 5
@@ -165,6 +175,62 @@ class TestConnection < Test::Unit::TestCase
     assert unlocked, "mongod failed to unlock"
   end
 
+  def test_max_bson_size_value
+    conn = standard_connection
+    if conn.server_version > "1.7.2"
+      assert_equal conn['admin'].command({:ismaster => 1})['maxBsonObjectSize'], conn.max_bson_size
+    end
+
+    conn.connect
+    assert_equal BSON::BSON_CODER.max_bson_size, conn.max_bson_size
+    doc = {'n' => 'a' * (BSON_CODER.max_bson_size - 11)}
+    assert_raise InvalidDocument do
+      assert BSON::BSON_CODER.serialize(doc)
+    end
+
+    limit = 7 * 1024 * 1024
+    conn.stubs(:max_bson_size).returns(limit)
+    conn.connect
+    assert_equal limit, conn.max_bson_size
+    assert_equal limit, BSON::BSON_CODER.max_bson_size
+    doc = {'n' => 'a' * ((limit) - 11)}
+    assert_raise_error InvalidDocument, "limited to #{limit}" do
+      assert BSON::BSON_CODER.serialize(doc)
+    end
+  end
+
+  def test_max_bson_size_with_old_mongod
+    conn = standard_connection(:connect => false)
+
+    admin_db = Object.new
+    admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1}).twice
+    conn.expects(:[]).with('admin').returns(admin_db).twice
+
+    conn.connect
+    assert_equal Mongo::DEFAULT_MAX_BSON_SIZE, BSON::BSON_CODER.max_bson_size
+  end
+
+  def test_connection_activity
+    conn = standard_connection
+    assert conn.active?
+
+    conn.primary_pool.close
+    assert !conn.active?
+
+    # Simulate a dropped connection.
+    dropped_socket = Mocha::Mock.new
+    dropped_socket.stubs(:read).raises(Errno::ECONNRESET)
+    dropped_socket.stubs(:send).raises(Errno::ECONNRESET)
+    dropped_socket.stub_everything
+
+    conn.primary_pool.host = 'localhost'
+    conn.primary_pool.port = Mongo::Connection::DEFAULT_PORT
+    conn.primary_pool.instance_variable_set("@pids", {dropped_socket => Process.pid})
+    conn.primary_pool.instance_variable_set("@sockets", [dropped_socket])
+
+    assert !conn.active?
+  end
+
   context "Saved authentications" do
     setup do
       @conn = standard_connection
@@ -229,5 +295,15 @@ class TestConnection < Test::Unit::TestCase
       end
       assert_equal 0, @con.primary_pool.checked_out.size
     end
+
+    should "show a proper exception message if an IOError is raised while closing a socket" do
+      fake_socket = Mocha::Mock.new
+      fake_socket.stubs(:close).raises(IOError.new)
+      fake_socket.stub_everything
+      TCPSocket.expects(:new).returns(fake_socket)
+
+      @con.primary_pool.checkout_new_socket
+      assert_equal [], @con.primary_pool.close
+    end
   end
 end

data/test/conversions_test.rb

@@ -1,7 +1,6 @@
 require './test/test_helper'
 require 'mongo/exceptions'
 require 'mongo/util/conversions'
-require 'bson/ordered_hash'
 
 class ConversionsTest < Test::Unit::TestCase
   include Mongo::Conversions
@@ -40,11 +39,11 @@ class ConversionsTest < Test::Unit::TestCase
   end
 
   def test_sort_value_when_value_is_negative_one
-    assert_equal -1, sort_value(-1)
+    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")
+    assert_equal(-1, sort_value("-1"))
   end
 
   def test_sort_value_when_value_is_ascending
@@ -80,35 +79,35 @@ class ConversionsTest < Test::Unit::TestCase
   end
 
   def test_sort_value_when_value_is_descending
-    assert_equal -1, sort_value("descending")
+    assert_equal(-1, sort_value("descending"))
   end
 
   def test_sort_value_when_value_is_desc
-    assert_equal -1, sort_value("desc")
+    assert_equal(-1, sort_value("desc"))
   end
 
   def test_sort_value_when_value_is_uppercase_descending
-    assert_equal -1, sort_value("DESCENDING")
+    assert_equal(-1, sort_value("DESCENDING"))
   end
 
   def test_sort_value_when_value_is_uppercase_desc
-    assert_equal -1, sort_value("DESC")
+    assert_equal(-1, sort_value("DESC"))
   end
 
   def test_sort_value_when_value_is_symbol_descending
-    assert_equal -1, sort_value(:descending)
+    assert_equal(-1, sort_value(:descending))
   end
 
   def test_sort_value_when_value_is_symbol_desc
-    assert_equal -1, sort_value(:desc)
+    assert_equal(-1, sort_value(:desc))
   end
 
   def test_sort_value_when_value_is_uppercase_symbol_descending
-    assert_equal -1, sort_value(:DESCENDING)
+    assert_equal(-1, sort_value(:DESCENDING))
   end
 
   def test_sort_value_when_value_is_uppercase_symbol_desc
-    assert_equal -1, sort_value(:DESC)
+    assert_equal(-1, sort_value(:DESC))
   end
 
   def test_sort_value_when_value_is_invalid

data/test/cursor_fail_test.rb

@@ -1,7 +1,7 @@
 require './test/test_helper'
 require 'logger'
 
-class CursorTest < Test::Unit::TestCase
+class CursorFailTest < Test::Unit::TestCase
 
   include Mongo
 

data/test/cursor_message_test.rb

@@ -1,7 +1,7 @@
 require './test/test_helper'
 require 'logger'
 
-class CursorTest < Test::Unit::TestCase
+class CursorMessageTest < Test::Unit::TestCase
 
   include Mongo
 

data/test/cursor_test.rb

@@ -120,7 +120,7 @@ class CursorTest < Test::Unit::TestCase
     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[1]['n'])
     assert_equal 1000000,    results[2]['n']
     assert_equal MaxKey.new, results[3]['n']
   end
@@ -171,8 +171,8 @@ class CursorTest < Test::Unit::TestCase
     cursor = Cursor.new(@@coll, :timeout => false)
     assert_equal false, cursor.timeout
 
-    @@coll.find({}, :timeout => false) do |cursor|
-      assert_equal false, cursor.timeout
+    @@coll.find({}, :timeout => false) do |c|
+      assert_equal false, c.timeout
     end
   end
 
@@ -395,10 +395,13 @@ class CursorTest < Test::Unit::TestCase
     end
 
     cursor = @@coll.find
+    n = 0
     while cursor.has_next?
-      assert cursor.next_document
+      assert cursor.next
+      n += 1
     end
 
+    assert_equal n, 200
     assert_equal false, cursor.has_next?
   end
 
@@ -451,4 +454,30 @@ class CursorTest < Test::Unit::TestCase
     assert_equal 100, cursor.map {|doc| doc }.length
   end
 
+  def test_transformer
+    transformer = Proc.new { |doc| doc }
+    cursor = Cursor.new(@@coll, :transformer => transformer)
+    assert_equal(transformer, cursor.transformer)
   end
+
+  def test_instance_transformation_with_next
+    klass       = Struct.new(:id, :a)
+    transformer = Proc.new { |doc| klass.new(doc['_id'], doc['a']) }
+    cursor      = Cursor.new(@@coll, :transformer => transformer)
+    instance    = cursor.next
+
+    assert_instance_of(klass, instance)
+    assert_instance_of(BSON::ObjectId, instance.id)
+    assert_equal(1, instance.a)
+  end
+
+  def test_instance_transformation_with_each
+    klass       = Struct.new(:id, :a)
+    transformer = Proc.new { |doc| klass.new(doc['_id'], doc['a']) }
+    cursor      = Cursor.new(@@coll, :transformer => transformer)
+
+    cursor.each do |instance|
+      assert_instance_of(klass, instance)
+    end
+  end
+end

data/test/db_api_test.rb

@@ -239,7 +239,7 @@ class DBAPITest < Test::Unit::TestCase
     names = @@db.collection_names
     assert names.length >= 2
     assert names.include?(@@coll.name)
-    assert names.include?('mongo-ruby-test.test2')
+    assert names.include?('test2')
   ensure
     @@db.drop_collection('test2')
   end
@@ -270,6 +270,17 @@ class DBAPITest < Test::Unit::TestCase
     end
   end
 
+  def test_collection_options_are_passed_to_the_existing_ones
+    @@db.drop_collection('foobar')
+
+    @@db.create_collection('foobar')
+
+    opts = {:safe => true}
+    coll = @@db.create_collection('foobar', opts)
+    assert_equal true, coll.safe
+  end
+
+
   def test_index_information
     assert_equal @@coll.index_information.length, 1
 
@@ -509,33 +520,37 @@ class DBAPITest < Test::Unit::TestCase
     @@db.drop_collection("test")
     test = @@db.collection("test")
 
-    assert_equal [], test.group([], {}, {"count" => 0}, "function (obj, prev) { prev.count++; }")
-    assert_equal [], test.group([], {}, {"count" => 0}, "function (obj, prev) { prev.count++; }")
+    assert_equal [], test.group(:initial => {"count" => 0}, :reduce => "function (obj, prev) { prev.count++; }")
+    assert_equal [], test.group(:initial => {"count" => 0}, :reduce => "function (obj, prev) { prev.count++; }")
 
     test.insert("a" => 2)
     test.insert("b" => 5)
     test.insert("a" => 1)
 
-    assert_equal 3, test.group([], {}, {"count" => 0}, "function (obj, prev) { prev.count++; }")[0]["count"]
-    assert_equal 3, test.group([], {}, {"count" => 0}, "function (obj, prev) { prev.count++; }")[0]["count"]
-    assert_equal 1, test.group([], {"a" => {"$gt" => 1}}, {"count" => 0}, "function (obj, prev) { prev.count++; }")[0]["count"]
-    assert_equal 1, test.group([], {"a" => {"$gt" => 1}}, {"count" => 0}, "function (obj, prev) { prev.count++; }")[0]["count"]
+    assert_equal 3, test.group(:initial => {"count" => 0},
+                      :reduce => "function (obj, prev) { prev.count++; }")[0]["count"]
+    assert_equal 3, test.group(:initial => {"count" => 0},
+                      :reduce => "function (obj, prev) { prev.count++; }")[0]["count"]
+    assert_equal 1, test.group(:cond => {"a" => {"$gt" => 1}},
+                      :initial => {"count" => 0}, :reduce => "function (obj, prev) { prev.count++; }")[0]["count"]
+    assert_equal 1, test.group(:cond => {"a" => {"$gt" => 1}},
+                      :initial => {"count" => 0}, :reduce => "function (obj, prev) { prev.count++; }")[0]["count"]
 
     finalize = "function (obj) { obj.f = obj.count - 1; }"
-    assert_equal 2, test.group([], {}, {"count" => 0}, "function (obj, prev) { prev.count++; }", finalize)[0]["f"]
+    assert_equal 2, test.group(:initial => {"count" => 0}, 
+                      :reduce => "function (obj, prev) { prev.count++; }", :finalize => finalize)[0]["f"]
 
     test.insert("a" => 2, "b" => 3)
     expected = [{"a" => 2, "count" => 2},
                 {"a" => nil, "count" => 1},
                 {"a" => 1, "count" => 1}]
-    assert_equal expected, test.group(["a"], {}, {"count" => 0}, "function (obj, prev) { prev.count++; }")
-    assert_equal expected, test.group(["a"], {}, {"count" => 0}, "function (obj, prev) { prev.count++; }", true)
+    assert_equal expected, test.group(:key => ["a"], :initial => {"count" => 0},
+                             :reduce => "function (obj, prev) { prev.count++; }")
+    assert_equal expected, test.group(:key => :a, :initial => {"count" => 0},
+                             :reduce => "function (obj, prev) { prev.count++; }")
 
     assert_raise OperationFailure do
-      test.group([], {}, {}, "5 ++ 5")
-    end
-    assert_raise OperationFailure do
-      test.group([], {}, {}, "5 ++ 5", true)
+      test.group(:initial => {}, :reduce => "5 ++ 5")
     end
   end
 
@@ -617,44 +632,7 @@ class DBAPITest < Test::Unit::TestCase
     assert_equal("mike", @@coll.find_one()["hello"])
   end
 
-  def test_invalid_key_names
-    @@coll.remove
-
-    @@coll.insert({"hello" => "world"})
-    @@coll.insert({"hello" => {"hello" => "world"}})
-
-    assert_raise BSON::InvalidKeyName do
-      @@coll.insert({"$hello" => "world"})
-    end
-
-    assert_raise BSON::InvalidKeyName do
-      @@coll.insert({"hello" => {"$hello" => "world"}})
-    end
-
-    @@coll.insert({"he$llo" => "world"})
-    @@coll.insert({"hello" => {"hell$o" => "world"}})
-
-    assert_raise BSON::InvalidKeyName do
-      @@coll.insert({".hello" => "world"})
-    end
-    assert_raise BSON::InvalidKeyName do
-      @@coll.insert({"hello" => {".hello" => "world"}})
-    end
-    assert_raise BSON::InvalidKeyName do
-      @@coll.insert({"hello." => "world"})
-    end
-    assert_raise BSON::InvalidKeyName do
-      @@coll.insert({"hello" => {"hello." => "world"}})
-    end
-    assert_raise BSON::InvalidKeyName do
-      @@coll.insert({"hel.lo" => "world"})
-    end
-    assert_raise BSON::InvalidKeyName do
-      @@coll.insert({"hello" => {"hel.lo" => "world"}})
-    end
-  end
-
-  def test_collection_names
+  def test_collection_names_errors
     assert_raise TypeError do
       @@db.collection(5)
     end

data/test/db_test.rb

@@ -26,7 +26,7 @@ class DBTest < Test::Unit::TestCase
       @@db.collection('test').insert('a' => 1)
       fail "expected 'NilClass' exception"
     rescue => ex
-      assert_match /NilClass/, ex.to_s
+      assert_match(/NilClass/, ex.to_s)
     ensure
       @@db = standard_connection.db(MONGO_TEST_DB)
       @@users = @@db.collection('system.users')
@@ -104,7 +104,7 @@ class DBTest < Test::Unit::TestCase
       db.pk_factory = Object.new
       fail "error: expected exception"
     rescue => ex
-      assert_match /Cannot change/, ex.to_s
+      assert_match(/Cannot change/, ex.to_s)
     ensure
       conn.close
     end
@@ -280,7 +280,7 @@ class DBTest < Test::Unit::TestCase
       assert_not_nil doc
       result = doc['result']
       assert_not_nil result
-      assert_match /firstExtent/, result
+      assert_match(/firstExtent/, result)
     end
 
   end

data/test/grid_file_system_test.rb

@@ -1,5 +1,4 @@
 require './test/test_helper'
-include Mongo
 
 class GridFileSystemTest < Test::Unit::TestCase
   context "GridFileSystem:" do

data/test/grid_io_test.rb

@@ -1,5 +1,4 @@
 require './test/test_helper'
-include Mongo
 
 class GridIOTest < Test::Unit::TestCase
 
@@ -33,6 +32,78 @@ class GridIOTest < Test::Unit::TestCase
       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 char = 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 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})
+        string = 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 "Seeking" do
       setup do
         @filename = 'test'

data/test/grid_test.rb

@@ -1,6 +1,22 @@
 require './test/test_helper'
 include Mongo
 
+def read_and_write_stream(filename, read_length, opts={})
+  io   = File.open(File.join(File.dirname(__FILE__), 'data', filename), 'r')
+  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
+  end
+  assert_equal data.length, read_data.length
+end
+
 class GridTest < Test::Unit::TestCase
   context "Tests:" do
     setup do
@@ -161,22 +177,6 @@ class GridTest < Test::Unit::TestCase
 
     context "Streaming: " do || {}
       setup do
-        def read_and_write_stream(filename, read_length, opts={})
-          io   = File.open(File.join(File.dirname(__FILE__), 'data', filename), 'r')
-          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
-          end
-          assert_equal data.length, read_data.length
-        end
-
         @grid = Grid.new(@db, 'test-fs')
       end
 

data/test/load/resque/load.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'lib', 'mongo')
+require 'logger'
+require 'rubygems'
+require 'resque'
+require 'sinatra'
+require File.join(File.dirname(__FILE__), 'processor')
+
+$con = Mongo::Connection.new
+$db = $con['foo']
+
+
+configure do
+  LOGGER = Logger.new("sinatra.log")
+  enable :logging, :dump_errors
+  set :raise_errors, true
+end
+
+get '/' do
+  Processor.perform(1)
+  true
+end

data/test/load/resque/processor.rb

@@ -0,0 +1,26 @@
+require 'logger'
+
+class Processor
+  @queue = :processor
+
+  def self.connection
+    @log ||= Logger.new(STDOUT)
+    @con ||= Mongo::Connection.new("localhost", 27017)
+  end
+
+  def self.perform(n)
+    begin
+    100.times do |n|
+      self.connection['resque']['docs'].insert({:n => n, :data => "0" * 1000}, :safe => true)
+    end
+
+    5.times do |n|
+      num = rand(100)
+      self.connection['resque']['docs'].find({:n => {"$gt" => num}}).limit(1).to_a
+    end
+    rescue => e
+      @log.warn(e.inspect)
+    end
+  end
+
+end

data/test/load/thin/load.rb

@@ -0,0 +1,24 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'lib', 'mongo')
+require 'logger'
+
+$con = Mongo::Connection.new
+$db = $con['foo']
+
+class Load < Sinatra::Base
+
+  configure do
+    LOGGER = Logger.new("sinatra.log")
+    enable :logging, :dump_errors
+    set :raise_errors, true
+  end
+
+  get '/' do
+    3.times do |n|
+      if (v=$db.eval("1 + #{n}")) != 1 + n
+        STDERR << "#{1 + n} expected but got #{v}"
+        raise StandardError, "#{1 + n} expected but got #{v}"
+      end
+    end
+  end
+
+end

data/test/load/unicorn/load.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'mongo')
+
+$con = Mongo::Connection.new
+$db = $con['foo']
+
+class Load < Sinatra::Base
+
+  configure do
+    LOGGER = Logger.new("sinatra.log")
+    enable :logging, :dump_errors
+    set :raise_errors, true
+  end
+
+  get '/' do
+    3.times do |n|
+      if (v=$db.eval("1 + #{n}")) != 1 + n
+        STDERR << "#{1 + n} expected but got #{v}"
+        raise StandardError, "#{1 + n} expected but got #{v}"
+      end
+    end
+  end
+
+end

data/test/load/unicorn/unicorn.rb

@@ -0,0 +1,29 @@
+# set path to app that will be used to configure unicorn, 
+# # note the trailing slash in this example
+@dir = "/home/kyle/work/10gen/ruby-driver/test/load/"
+
+worker_processes 10
+working_directory @dir
+
+preload_app true
+
+timeout 30
+
+# Specify path to socket unicorn listens to,
+# we will use this in our nginx.conf later
+listen "#{@dir}tmp/sockets/unicorn.sock", :backlog => 64
+
+# Set process id path
+pid "#{@dir}tmp/pids/unicorn.pid"
+
+# # Set log file paths
+stderr_path "#{@dir}log/unicorn.stderr.log"
+stdout_path "#{@dir}log/unicorn.stdout.log" 
+
+# NOTE: You need this when using forking web servers!
+after_fork do |server, worker|
+  $con.close if $con
+  $con = Mongo::Connection.new
+  $db = $con['foo']
+  STDERR << "FORKED #{server} #{worker}"
+end