mongo 1.7.1 → 1.8.0

data/test/tools/mongo_config_test.rb

@@ -0,0 +1,146 @@
+require 'test_helper'
+
+class MongoConfig < Test::Unit::TestCase
+
+  def startup
+    @sys_proc = nil
+  end
+
+  def shutdown
+    @sys_proc.stop if @sys_proc && @sys_proc.running?
+  end
+
+  test "config defaults" do
+    [ Mongo::Config::DEFAULT_BASE_OPTS,
+      Mongo::Config::DEFAULT_REPLICA_SET,
+      Mongo::Config::DEFAULT_SHARDED_SIMPLE,
+      Mongo::Config::DEFAULT_SHARDED_REPLICA
+    ].each do |params|
+      config = Mongo::Config.cluster(params)
+      assert(config.size > 0)
+    end
+  end
+
+  test "get available port" do
+    assert_not_nil(Mongo::Config.get_available_port)
+  end
+
+  test "SysProc start" do
+    cmd = "true"
+    @sys_proc = Mongo::Config::SysProc.new(cmd)
+    assert_equal(cmd, @sys_proc.cmd)
+    assert_nil(@sys_proc.pid)
+    start_and_assert_running?(@sys_proc)
+  end
+
+  test "SysProc wait" do
+    @sys_proc = Mongo::Config::SysProc.new("true")
+    start_and_assert_running?(@sys_proc)
+    assert(@sys_proc.running?)
+    @sys_proc.wait
+    assert(!@sys_proc.running?)
+  end
+
+  test "SysProc kill" do
+    @sys_proc = Mongo::Config::SysProc.new("true")
+    start_and_assert_running?(@sys_proc)
+    @sys_proc.kill
+    @sys_proc.wait
+    assert(!@sys_proc.running?)
+  end
+
+  test "SysProc stop" do
+    @sys_proc = Mongo::Config::SysProc.new("true")
+    start_and_assert_running?(@sys_proc)
+    @sys_proc.stop
+    assert(!@sys_proc.running?)
+  end
+
+  test "SysProc zombie respawn" do
+    @sys_proc = Mongo::Config::SysProc.new("true")
+    start_and_assert_running?(@sys_proc)
+    prev_pid = @sys_proc.pid
+    @sys_proc.kill
+    # don't wait, leaving a zombie
+    assert(@sys_proc.running?)
+    start_and_assert_running?(@sys_proc)
+    assert(prev_pid && @sys_proc.pid && prev_pid != @sys_proc.pid, 'SysProc#start should spawn a new process after a zombie')
+    @sys_proc.stop
+    assert(!@sys_proc.running?)
+  end
+
+  test "Server" do
+    server = Mongo::Config::Server.new('a cmd', 'host', 1234)
+    assert_equal('a cmd', server.cmd)
+    assert_equal('host', server.host)
+    assert_equal(1234, server.port)
+  end
+
+  test "DbServer" do
+    config = Mongo::Config::DEFAULT_BASE_OPTS
+    server = Mongo::Config::DbServer.new(config)
+    assert_equal(config, server.config)
+    assert_equal("mongod --dbpath data --logpath data/log", server.cmd)
+    assert_equal(config[:host], server.host)
+    assert_equal(config[:port], server.port)
+  end
+
+  def cluster_test(opts)
+    #debug 1, opts.inspect
+    config =  Mongo::Config.cluster(opts)
+    #debug 1, config.inspect
+    manager = Mongo::Config::ClusterManager.new(config)
+    assert_equal(config, manager.config)
+    manager.start
+    yield manager
+    manager.stop
+    manager.servers.each{|s| assert(!s.running?)}
+    manager.clobber
+  end
+
+  test "cluster manager base" do
+    cluster_test(Mongo::Config::DEFAULT_BASE_OPTS) do |manager|
+
+    end
+  end
+
+  test "cluster manager replica set" do
+    cluster_test(Mongo::Config::DEFAULT_REPLICA_SET) do |manager|
+      servers = manager.servers
+      servers.each do |server|    
+        assert_not_nil(Mongo::MongoClient.new(server.host, server.port))
+        assert_match(/oplogSize/, server.cmd, '--oplogSize option should be specified')
+        assert_match(/smallfiles/, server.cmd, '--smallfiles option should be specified')
+        assert_no_match(/nojournal/, server.cmd, '--nojournal option should not be specified')
+        assert_match(/noprealloc/, server.cmd, '--noprealloc option should be specified')
+      end
+    end
+  end
+
+  test "cluster manager sharded simple" do
+    cluster_test(Mongo::Config::DEFAULT_SHARDED_SIMPLE) do |manager|
+      servers = manager.shards + manager.configs
+      servers.each do |server|
+        assert_not_nil(Mongo::MongoClient.new(server.host, server.port))
+        assert_match(/oplogSize/, server.cmd, '--oplogSize option should be specified')
+        assert_match(/smallfiles/, server.cmd, '--smallfiles option should be specified')
+        assert_no_match(/nojournal/, server.cmd, '--nojournal option should not be specified')
+        assert_match(/noprealloc/, server.cmd, '--noprealloc option should be specified')
+      end
+    end
+  end
+
+  test "cluster manager sharded replica" do
+    #cluster_test(Mongo::Config::DEFAULT_SHARDED_REPLICA) # not yet supported by ClusterManager
+  end
+
+  private
+
+  def start_and_assert_running?(sys_proc)
+    assert_not_nil(sys_proc.start(0))
+    assert_not_nil(sys_proc.pid)
+    assert(sys_proc.running?)
+  end
+
+end
+

data/test/unit/client_test.rb

@@ -0,0 +1,230 @@
+require 'test_helper'
+include Mongo
+
+class ClientTest < Test::Unit::TestCase
+  context "Mongo::MongoClient intialization " do
+    context "given a single node" do
+      setup do
+        @client = MongoClient.new('localhost', 27017, :connect => false)
+        TCPSocket.stubs(:new).returns(new_mock_socket)
+
+        admin_db = new_mock_db
+        admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1})
+        @client.expects(:[]).with('admin').returns(admin_db)
+        @client.connect
+      end
+
+      should "gle writes by default" do
+        assert_equal 1, @client.write_concern[:w]
+      end
+
+      should "set localhost and port to master" do
+        assert_equal 'localhost', @client.primary_pool.host
+        assert_equal 27017, @client.primary_pool.port
+      end
+
+      should "set connection pool to 1" do
+        assert_equal 1, @client.primary_pool.size
+      end
+
+      should "default slave_ok to false" do
+        assert !@client.slave_ok?
+      end
+
+      should "raise exception for invalid host or port" do
+        assert_raise MongoArgumentError do
+          MongoClient.new(:w => 1)
+        end
+        assert_raise MongoArgumentError do
+          MongoClient.new('localhost', :w => 1)
+        end
+      end
+
+      should "warn if invalid options are specified" do
+        client = MongoClient.allocate
+        opts = {:connect => false}
+
+        MongoReplicaSetClient::REPL_SET_OPTS.each do |opt|
+          client.expects(:warn).with("#{opt} is not a valid option for #{client.class}")
+          opts[opt] = true
+        end
+
+        args = ['localhost', 27017, opts]
+        client.send(:initialize, *args)
+      end
+
+      context "given a replica set" do
+
+        should "warn if invalid options are specified" do
+          client = MongoReplicaSetClient.allocate
+          opts = {:connect => false}
+
+          MongoClient::CLIENT_ONLY_OPTS.each do |opt|
+            client.expects(:warn).with("#{opt} is not a valid option for #{client.class}")
+            opts[opt] = true
+          end
+
+          args = [['localhost:27017'], opts]
+          client.send(:initialize, *args)
+        end
+      end
+    end
+
+    context "initializing with a mongodb uri" do
+      should "parse a simple uri" do
+        @client = MongoClient.from_uri("mongodb://localhost", :connect => false)
+        assert_equal ['localhost', 27017], @client.host_to_try
+      end
+
+      should "allow a complex host names" do
+        host_name = "foo.bar-12345.org"
+        @client = MongoClient.from_uri("mongodb://#{host_name}", :connect => false)
+        assert_equal [host_name, 27017], @client.host_to_try
+      end
+
+      should "allow db without username and password" do
+        host_name = "foo.bar-12345.org"
+        @client = MongoClient.from_uri("mongodb://#{host_name}/foo", :connect => false)
+        assert_equal [host_name, 27017], @client.host_to_try
+      end
+
+      should "set write concern options on connection" do
+        host_name = "localhost"
+        opts = "w=2&wtimeoutMS=1000&fsync=true&journal=true"
+        @client = MongoClient.from_uri("mongodb://#{host_name}/foo?#{opts}", :connect => false)
+        assert_equal({:w => 2, :wtimeout => 1000, :fsync => true, :j => true}, @client.write_concern)
+      end
+
+      should "set timeout options on connection" do
+        host_name = "localhost"
+        opts = "connectTimeoutMS=1000&socketTimeoutMS=5000"
+        @client = MongoClient.from_uri("mongodb://#{host_name}/foo?#{opts}", :connect => false)
+        assert_equal 1, @client.connect_timeout
+        assert_equal 5, @client.op_timeout
+      end
+
+      should "parse a uri with a hyphen & underscore in the username or password" do
+        @client = MongoClient.from_uri("mongodb://hyphen-user_name:p-s_s@localhost:27017/db", :connect => false)
+        assert_equal ['localhost', 27017], @client.host_to_try
+        auth_hash = { 'db_name' => 'db', 'username' => 'hyphen-user_name', "password" => 'p-s_s' }
+        assert_equal auth_hash, @client.auths[0]
+      end
+
+      should "attempt to connect" do
+        TCPSocket.stubs(:new).returns(new_mock_socket)
+        @client = MongoClient.from_uri("mongodb://localhost", :connect => false)
+
+        admin_db = new_mock_db
+        admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1})
+        @client.expects(:[]).with('admin').returns(admin_db)
+        @client.connect
+      end
+
+      should "raise an error on invalid uris" do
+        assert_raise MongoArgumentError do
+          MongoClient.from_uri("mongo://localhost", :connect => false)
+        end
+
+        assert_raise MongoArgumentError do
+          MongoClient.from_uri("mongodb://localhost:abc", :connect => false)
+        end
+      end
+
+      should "require all of username, if password and db are specified" do
+        assert MongoClient.from_uri("mongodb://kyle:jones@localhost/db", :connect => false)
+
+        assert_raise MongoArgumentError do
+          MongoClient.from_uri("mongodb://kyle:password@localhost", :connect => false)
+        end
+      end
+    end
+
+    context "initializing with ENV['MONGODB_URI']" do
+      setup do
+        @old_mongodb_uri = ENV['MONGODB_URI']
+      end
+
+      teardown do
+        ENV['MONGODB_URI'] = @old_mongodb_uri
+      end
+
+      should "parse a simple uri" do
+        ENV['MONGODB_URI'] = "mongodb://localhost?connect=false"
+        @client = MongoClient.new
+        assert_equal ['localhost', 27017], @client.host_to_try
+      end
+
+      should "allow a complex host names" do
+        host_name = "foo.bar-12345.org"
+        ENV['MONGODB_URI'] = "mongodb://#{host_name}?connect=false"
+        @client = MongoClient.new
+        assert_equal [host_name, 27017], @client.host_to_try
+      end
+
+      should "allow db without username and password" do
+        host_name = "foo.bar-12345.org"
+        ENV['MONGODB_URI'] = "mongodb://#{host_name}/foo?connect=false"
+        @client = MongoClient.new
+        assert_equal [host_name, 27017], @client.host_to_try
+      end
+
+      should "set write concern options on connection" do
+        host_name = "localhost"
+        opts = "w=2&wtimeoutMS=1000&fsync=true&journal=true&connect=false"
+        ENV['MONGODB_URI'] = "mongodb://#{host_name}/foo?#{opts}"
+        @client = MongoClient.new
+        assert_equal({:w => 2, :wtimeout => 1000, :fsync => true, :j => true}, @client.write_concern)
+      end
+
+      should "set timeout options on connection" do
+        host_name = "localhost"
+        opts = "connectTimeoutMS=1000&socketTimeoutMS=5000&connect=false"
+        ENV['MONGODB_URI'] = "mongodb://#{host_name}/foo?#{opts}"
+        @client = MongoClient.new
+        assert_equal 1, @client.connect_timeout
+        assert_equal 5, @client.op_timeout
+      end
+
+      should "parse a uri with a hyphen & underscore in the username or password" do
+        ENV['MONGODB_URI'] = "mongodb://hyphen-user_name:p-s_s@localhost:27017/db?connect=false"
+        @client = MongoClient.new
+        assert_equal ['localhost', 27017], @client.host_to_try
+        auth_hash = { 'db_name' => 'db', 'username' => 'hyphen-user_name', "password" => 'p-s_s' }
+        assert_equal auth_hash, @client.auths[0]
+      end
+
+      should "attempt to connect" do
+        TCPSocket.stubs(:new).returns(new_mock_socket)
+        ENV['MONGODB_URI'] = "mongodb://localhost?connect=false" # connect=false ??
+        @client = MongoClient.new
+
+        admin_db = new_mock_db
+        admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1})
+        @client.expects(:[]).with('admin').returns(admin_db)
+        @client.connect
+      end
+
+      should "raise an error on invalid uris" do
+        ENV['MONGODB_URI'] = "mongo://localhost"
+        assert_raise MongoArgumentError do
+          MongoClient.new
+        end
+
+        ENV['MONGODB_URI'] = "mongodb://localhost:abc"
+        assert_raise MongoArgumentError do
+          MongoClient.new
+        end
+      end
+
+      should "require all of username, if password and db are specified" do
+        ENV['MONGODB_URI'] = "mongodb://kyle:jones@localhost/db?connect=false"
+        assert MongoClient.new
+
+        ENV['MONGODB_URI'] = "mongodb://kyle:password@localhost"
+        assert_raise MongoArgumentError do
+          MongoClient.new
+        end
+      end
+    end
+  end
+end

data/test/unit/collection_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path("../../test_helper", __FILE__)
+require 'test_helper'
 
 class CollectionTest < Test::Unit::TestCase
 
@@ -10,10 +10,10 @@ class CollectionTest < Test::Unit::TestCase
     end
 
     should "send update message" do
-      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @conn['testing']
+      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
+      @db   = @client['testing']
       @coll = @db.collection('books')
-      @conn.expects(:send_message).with do |op, msg, log|
+      @client.expects(:send_message_with_gle).with do |op, msg, log|
         op == 2001
       end
       @coll.stubs(:log_operation)
@@ -21,10 +21,10 @@ class CollectionTest < Test::Unit::TestCase
     end
 
     should "send insert message" do
-      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @conn['testing']
+      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
+      @db   = @client['testing']
       @coll = @db.collection('books')
-      @conn.expects(:send_message).with do |op, msg, log|
+      @client.expects(:send_message_with_gle).with do |op, msg, log|
         op == 2002
       end
       @coll.expects(:log_operation).with do |name, payload|
@@ -34,11 +34,11 @@ class CollectionTest < Test::Unit::TestCase
     end
 
     should "send sort data" do
-      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @conn['testing']
+      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
+      @db   = @client['testing']
       @coll = @db.collection('books')
-      @conn.expects(:checkout_reader).returns(mock(:pool))
-      @conn.expects(:receive_message).with do |op, msg, log, sock|
+      @client.expects(:checkout_reader).returns(mock(:pool))
+      @client.expects(:receive_message).with do |op, msg, log, sock|
         op == 2004
       end.returns([[], 0, 0])
       @logger.expects(:debug)
@@ -46,11 +46,11 @@ class CollectionTest < Test::Unit::TestCase
     end
 
     should "not log binary data" do
-      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @conn['testing']
+      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
+      @db   = @client['testing']
       @coll = @db.collection('books')
       data = BSON::Binary.new(("BINARY " * 1000).unpack("c*"))
-      @conn.expects(:send_message).with do |op, msg, log|
+      @client.expects(:send_message_with_gle).with do |op, msg, log|
         op == 2002
       end
       @coll.expects(:log_operation).with do |name, payload|
@@ -60,32 +60,45 @@ class CollectionTest < Test::Unit::TestCase
     end
 
     should "send safe update message" do
-      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @conn['testing']
+      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
+      @db   = @client['testing']
       @coll = @db.collection('books')
-      @conn.expects(:send_message_with_safe_check).with do |op, msg, db_name, log|
+      @client.expects(:send_message_with_gle).with do |op, msg, db_name, log|
         op == 2001
       end
       @coll.expects(:log_operation).with do |name, payload|
         (name == :update) && payload[:document][:title].include?('Moby')
       end
-      @coll.update({}, {:title => 'Moby Dick'}, :safe => true)
+      @coll.update({}, {:title => 'Moby Dick'})
+    end
+
+    should "send safe update message with legacy" do
+      @connection = Connection.new('localhost', 27017, :logger => @logger, :safe => true, :connect => false)
+      @db         = @connection['testing']
+      @coll       = @db.collection('books')
+      @connection.expects(:send_message_with_gle).with do |op, msg, db_name, log|
+        op == 2001
+      end
+      @coll.expects(:log_operation).with do |name, payload|
+        (name == :update) && payload[:document][:title].include?('Moby')
+      end
+      @coll.update({}, {:title => 'Moby Dick'})
     end
 
     should "send safe insert message" do
-      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @conn['testing']
+      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
+      @db   = @client['testing']
       @coll = @db.collection('books')
-      @conn.expects(:send_message_with_safe_check).with do |op, msg, db_name, log|
+      @client.expects(:send_message_with_gle).with do |op, msg, db_name, log|
         op == 2001
       end
       @coll.stubs(:log_operation)
-      @coll.update({}, {:title => 'Moby Dick'}, :safe => true)
+      @coll.update({}, {:title => 'Moby Dick'})
     end
 
     should "not call insert for each ensure_index call" do
-      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @conn['testing']
+      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
+      @db   = @client['testing']
       @coll = @db.collection('books')
       @coll.expects(:generate_indexes).once
 
@@ -94,8 +107,8 @@ class CollectionTest < Test::Unit::TestCase
     end
 
     should "call generate_indexes for a new direction on the same field for ensure_index" do
-      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @conn['testing']
+      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
+      @db   = @client['testing']
       @coll = @db.collection('books')
       @coll.expects(:generate_indexes).twice
 
@@ -105,8 +118,8 @@ class CollectionTest < Test::Unit::TestCase
     end
 
     should "call generate_indexes twice because the cache time is 0 seconds" do
-      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @conn['testing']
+      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
+      @db   = @client['testing']
       @db.cache_time = 0
       @coll = @db.collection('books')
       @coll.expects(:generate_indexes).twice
@@ -116,8 +129,8 @@ class CollectionTest < Test::Unit::TestCase
     end
 
     should "call generate_indexes for each key when calling ensure_indexes" do
-      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @conn['testing']
+      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
+      @db   = @client['testing']
       @db.cache_time = 300
       @coll = @db.collection('books')
       @coll.expects(:generate_indexes).once.with do |a, b, c|
@@ -128,8 +141,8 @@ class CollectionTest < Test::Unit::TestCase
     end
 
     should "use the connection's logger" do
-      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @conn['testing']
+      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
+      @db   = @client['testing']
       @coll = @db.collection('books')
       @logger.expects(:warn).with do |msg|
         msg == "MONGODB [WARNING] test warning"