mongo 1.8.4 → 1.8.5

data/test/functional/collection_test.rb

@@ -1272,7 +1272,6 @@ end
     should "create a geoHaystack index" do
       @geo.save({ "_id" => 100, "pos" => { "long" => 126.9, "lat" => 35.2 }, "type" => "restaurant"})
       @geo.create_index([['pos', Mongo::GEOHAYSTACK], ['type', Mongo::ASCENDING]], :bucket_size => 1)
-      puts @geo.index_information['loc_geoHaystack_type_1']
     end
 
     should "create a geo 2dsphere index" do

data/test/functional/connection_test.rb

@@ -309,7 +309,7 @@ class TestConnection < Test::Unit::TestCase
     conn.expects(:[]).with('admin').returns(admin_db)
 
     conn.connect
-    assert_equal Mongo::DEFAULT_MAX_MESSAGE_SIZE, conn.max_message_size
+    assert_equal Mongo::DEFAULT_MAX_BSON_SIZE * Mongo::MESSAGE_SIZE_FACTOR, conn.max_message_size
   end
 
   def test_connection_activity

data/test/functional/db_test.rb

@@ -131,47 +131,6 @@ class DBTest < Test::Unit::TestCase
     end
   end
 
-  def test_authenticate
-    @@db.add_user('spongebob', 'squarepants')
-    assert_raise Mongo::AuthenticationError do
-      assert !@@db.authenticate('nobody', 'nopassword')
-    end
-    assert_raise Mongo::AuthenticationError do
-      assert !@@db.authenticate('spongebob' , 'squareliederhosen')
-    end
-    assert @@db.authenticate('spongebob', 'squarepants')
-    @@db.logout
-    @@db.remove_user('spongebob')
-  end
-
-  def test_authenticate_with_special_characters
-    assert @@db.add_user('foo:bar', '@foo')
-    assert @@db.authenticate('foo:bar', '@foo')
-    @@db.logout
-    @@db.remove_user('foo:bar')
-  end
-
-  def test_authenticate_read_only
-    @@db.add_user('joebob', 'user', true) # read-only user
-    assert @@db.authenticate('joebob', 'user')
-    @@db.logout
-    @@db.remove_user('joebob')
-  end
-
-  def test_authenticate_with_connection_uri
-    @@db.add_user('spongebob', 'squarepants')
-    assert Mongo::MongoClient.from_uri("mongodb://spongebob:squarepants@#{host_port}/#{@@db.name}")
-
-    assert_raise Mongo::AuthenticationError do
-      client = Mongo::MongoClient.from_uri("mongodb://wrong:info@#{host_port}/#{@@db.name}")
-      client['test']['foo'].find_one
-    end
-  end
-
-  def test_logout
-    assert @@db.logout
-  end
-
   def test_command
     assert_raise OperationFailure do
       @@db.command({:non_command => 1}, :check_response => true)
@@ -249,25 +208,11 @@ class DBTest < Test::Unit::TestCase
     db.collection('users').remove
   end
 
-  def test_user_management
-    @@db.add_user("bob", "secret")
-    assert @@db.authenticate("bob", "secret")
-    @@db.logout
-    assert @@db.remove_user("bob")
-    assert_raise Mongo::AuthenticationError do
-      @@db.authenticate("bob", "secret")
-    end
-  end
-
-  def test_remove_non_existant_user
-    assert !@@db.remove_user("joe")
-  end
-
   def test_stored_function_management
     @@db.add_stored_function("sum", "function (x, y) { return x + y; }")
     assert_equal @@db.eval("return sum(2,3);"), 5
     assert @@db.remove_stored_function("sum")
-    assert_raise OperationFailure do 
+    assert_raise OperationFailure do
       @@db.eval("return sum(2,3);")
     end
   end

data/test/functional/support_test.rb

@@ -15,4 +15,34 @@ class SupportTest < Test::Unit::TestCase
     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

data/test/replica_set/authentication_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+require 'shared/authentication'
+
+class ReplicaSetAuthenticationTest < Test::Unit::TestCase
+  include Mongo
+  include AuthenticationTests
+
+  def setup
+    ensure_cluster(:rs)
+    @client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :name => @rs.repl_set_name, :connect_timeout => 60)
+    @db     = @client[MONGO_TEST_DB]
+  end
+
+  def teardown
+    @db['system.users'].remove
+  end
+
+  def test_authenticate_with_connection_uri
+    @db.add_user('eunice', 'uritest')
+    assert MongoReplicaSetClient.from_uri(
+      "mongodb://eunice:uritest@#{@rs.repl_set_seeds.join(',')}/#{@db.name}?replicaSet=#{@rs.repl_set_name}")
+  end
+end

data/test/replica_set/max_values_test.rb

@@ -0,0 +1,61 @@
+require 'test_helper'
+
+class MaxValuesTest < Test::Unit::TestCase
+
+  include Mongo
+
+  def setup
+    ensure_cluster(:rs)
+    @client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :name => @rs.repl_set_name)
+  end
+
+  def test_initial_max_sizes
+    assert @client.max_message_size
+    assert @client.max_bson_size
+  end
+
+  def test_updated_max_sizes_after_node_config_change
+    # stub max sizes for one member
+    @client.local_manager.members.each_with_index do |m, i|
+      if i % 2 == 0
+        m.stubs(:config).returns({'maxMessageSizeBytes' => 1024 * MESSAGE_SIZE_FACTOR, 'maxBsonObjectSize' => 1024})
+        m.set_config
+      end
+    end
+
+    assert_equal 1024, @client.max_bson_size
+    assert_equal 1024 * MESSAGE_SIZE_FACTOR, @client.max_message_size
+  end
+
+  def test_neither_max_sizes_in_config
+    @client.local_manager.members.each do |m|
+      m.stubs(:config).returns({})
+      m.set_config
+    end
+
+    assert_equal DEFAULT_MAX_BSON_SIZE, @client.max_bson_size
+    assert_equal DEFAULT_MAX_BSON_SIZE * MESSAGE_SIZE_FACTOR, @client.max_message_size
+  end
+
+  def test_only_bson_size_in_config
+    @client.local_manager.members.each do |m|
+      m.stubs(:config).returns({'maxBsonObjectSize' => 1024})
+      m.set_config
+    end
+    assert_equal 1024, @client.max_bson_size
+    assert_equal 1024 * MESSAGE_SIZE_FACTOR, @client.max_message_size
+  end
+
+  def test_both_sizes_in_config
+    @client.local_manager.members.each do |m|
+      m.stubs(:config).returns({'maxMessageSizeBytes' => 1024 * 2 * MESSAGE_SIZE_FACTOR,
+                                'maxBsonObjectSize' => 1024})
+      m.set_config
+    end
+
+    assert_equal 1024, @client.max_bson_size
+    assert_equal 1024 * 2 * MESSAGE_SIZE_FACTOR, @client.max_message_size
+  end
+
+end
+

data/test/sharded_cluster/basic_test.rb

@@ -89,6 +89,24 @@ class BasicTest < Test::Unit::TestCase
     @client.close
   end
 
+  def test_mongos_failover
+    @client = MongoShardedClient.new(@seeds, :refresh_interval => 5, :refresh_mode => :sync)
+    assert @client.connected?
+    # do a find to pin a pool
+    @client['MONGO_TEST_DB']['test'].find_one
+    original_primary = @client.manager.primary
+    # stop the pinned member
+    @sc.member_by_name("#{original_primary[0]}:#{original_primary[1]}").stop
+    # assert that the client fails over to the next available mongos
+    assert_nothing_raised do
+      @client['MONGO_TEST_DB']['test'].find_one
+    end
+
+    assert_not_equal original_primary, @client.manager.primary
+    assert @client.connected?
+    @client.close
+  end
+
   def test_all_down
     @client = MongoShardedClient.new(@seeds)
     assert @client.connected?

data/test/shared/authentication.rb

@@ -0,0 +1,49 @@
+module AuthenticationTests
+  def test_add_user
+    @db.add_user('bob','user')
+    assert @db['system.users'].find_one({:user => 'bob'})
+  end
+
+   def test_remove_user
+    @db.remove_user('bob')
+    assert_nil @db['system.users'].find_one({:user => 'bob'})
+  end
+
+  def test_remove_non_existent_user
+    assert_equal @db.remove_user('joe'), false
+  end
+
+  def test_authenticate
+    @db.add_user('peggy', 'user')
+    assert @db.authenticate('peggy', 'user')
+    @db.remove_user('peggy')
+    @db.logout
+  end
+
+  def test_authenticate_non_existent_user
+    assert_raise Mongo::AuthenticationError do
+      @db.authenticate('frank', 'thetank')
+    end
+  end
+
+  def test_logout
+    @db.add_user('peggy', 'user')
+    assert @db.authenticate('peggy', 'user')
+    assert @db.logout
+    @db.remove_user('peggy')
+  end
+
+  def test_authenticate_with_special_characters
+    assert @db.add_user('foo:bar','@foo')
+    assert @db.authenticate('foo:bar','@foo')
+    @db.remove_user('foo:bar')
+    @db.logout
+  end
+
+  def test_authenticate_read_only
+    @db.add_user('randy', 'readonly', true)
+    assert @db.authenticate('randy', 'readonly')
+    @db.remove_user('randy')
+    @db.logout
+  end
+end

data/test/tools/mongo_config.rb

@@ -24,7 +24,7 @@ end
 #
 module Mongo
   class Config
-    DEFAULT_BASE_OPTS = { :host => 'localhost', :dbpath => 'data', :logpath => 'data/log'}
+    DEFAULT_BASE_OPTS = { :host => 'localhost', :dbpath => 'data', :logpath => 'data/log' }
     DEFAULT_REPLICA_SET = DEFAULT_BASE_OPTS.merge( :replicas => 3, :arbiters => 0 )
     DEFAULT_SHARDED_SIMPLE = DEFAULT_BASE_OPTS.merge( :shards => 2, :configs => 1, :routers => 4 )
     DEFAULT_SHARDED_REPLICA = DEFAULT_SHARDED_SIMPLE.merge( :replicas => 3, :arbiters => 0)
@@ -80,51 +80,46 @@ module Mongo
     end
 
     def self.make_mongo(kind, opts)
-      dbpath = opts[:dbpath]
-      port = self.get_available_port
-      path = "#{dbpath}/#{kind}-#{port}"
+      dbpath  = opts[:dbpath]
+      port    = self.get_available_port
+      path    = "#{dbpath}/#{kind}-#{port}"
       logpath = "#{path}/#{kind}.log"
 
-      {
-        :host => opts[:host],
-        :port => port,
-        :logpath => logpath,
-        :logappend => true
-      }
+      { :host      => opts[:host],
+        :port      => port,
+        :logpath   => logpath,
+        :logappend => true }
     end
 
     def self.make_mongod(kind, opts)
       params = make_mongo('mongods', opts)
 
       mongod = ENV['MONGOD'] || 'mongod'
-      path = File.dirname(params[:logpath])
+      path   = File.dirname(params[:logpath])
 
       noprealloc = opts[:noprealloc] || true
       smallfiles = opts[:smallfiles] || true
       quiet      = opts[:quiet]      || true
       fast_sync  = opts[:fastsync]   || false
-
-      params.merge(
-        :command => mongod,
-        :dbpath => path,
-        :smallfiles => smallfiles,
-        :noprealloc => noprealloc,
-        :quiet => quiet,
-        :fastsync => fast_sync
-      )
+      auth       = opts[:auth]       || true
+
+      params.merge(:command    => mongod,
+                   :dbpath     => path,
+                   :smallfiles => smallfiles,
+                   :noprealloc => noprealloc,
+                   :quiet      => quiet,
+                   :fastsync   => fast_sync)
     end
 
     def self.make_replica(opts, count)
-      params = make_mongod('replicas', opts)
+      params     = make_mongod('replicas', opts)
 
       replSet    = opts[:replSet]    || 'ruby-driver-test'
       oplog_size = opts[:oplog_size] || 5
 
-      params.merge(
-        :_id => count,
-        :replSet => replSet,
-        :oplogSize => oplog_size
-      )
+      params.merge(:_id       => count,
+                   :replSet   => replSet,
+                   :oplogSize => oplog_size)
     end
 
     def self.make_config(opts)

data/test/unit/node_test.rb

@@ -4,6 +4,9 @@ class NodeTest < Test::Unit::TestCase
 
   def setup
     @client = stub()
+    manager = mock('pool_manager')
+    manager.stubs(:update_max_sizes)
+    @client.stubs(:local_manager).returns(manager)
   end
 
   should "refuse to connect to node without 'hosts' key" do

data/test/unit/pool_manager_test.rb

@@ -52,6 +52,7 @@ class PoolManagerTest < Test::Unit::TestCase
 
       seeds = [['localhost', 27017]]
       manager = Mongo::PoolManager.new(@client, seeds)
+      @client.stubs(:local_manager).returns(manager)
       manager.connect
 
       assert_equal ['localhost', 27017], manager.primary
@@ -77,7 +78,8 @@ class PoolManagerTest < Test::Unit::TestCase
       )
 
       seeds = [['localhost', 27017]]
-      manager = Mongo::PoolManager.new(@client, seeds)
+      manager = PoolManager.new(@client, seeds)
+      @client.stubs(:local_manager).returns(manager)
       manager.connect
 
       assert_equal ['localhost', 27018], manager.primary

data/test/unit/read_test.rb

@@ -106,6 +106,8 @@ class ReadTest < Test::Unit::TestCase
         sock = new_mock_socket
         read_pool = stub(:checkin => true)
         @client.stubs(:read_pool).returns(read_pool)
+        local_manager = PoolManager.new(@client, @client.seeds)
+        @client.stubs(:local_manager).returns(local_manager)
         primary_pool = stub(:checkin => true)
         sock.stubs(:pool).returns(primary_pool)
         @client.stubs(:primary_pool).returns(primary_pool)
@@ -120,6 +122,8 @@ class ReadTest < Test::Unit::TestCase
       should "allow override default value on query" do
         @cursor = @col.find({:a => 1}, :read => :primary)
         sock = new_mock_socket
+        local_manager = PoolManager.new(@client, @client.seeds)
+        @client.stubs(:local_manager).returns(local_manager)
         primary_pool = stub(:checkin => true)
         sock.stubs(:pool).returns(primary_pool)
         @client.stubs(:primary_pool).returns(primary_pool)

data/test/unit/sharding_pool_manager_test.rb

@@ -0,0 +1,88 @@
+require 'test_helper'
+include Mongo
+
+class ShardingPoolManagerTest < Test::Unit::TestCase
+
+  context "Initialization: " do
+
+    setup do
+      TCPSocket.stubs(:new).returns(new_mock_socket)
+      @db = new_mock_db
+
+      @client = stub("MongoShardedClient")
+      @client.stubs(:connect_timeout).returns(5)
+      @client.stubs(:op_timeout).returns(5)
+      @client.stubs(:pool_size).returns(2)
+      @client.stubs(:pool_timeout).returns(100)
+      @client.stubs(:socket_class).returns(TCPSocket)
+      @client.stubs(:mongos?).returns(true)
+      @client.stubs(:[]).returns(@db)
+
+      @client.stubs(:replica_set_name).returns(nil)
+      @client.stubs(:log)
+      @arbiters = ['localhost:27020']
+      @hosts = [
+        'localhost:27017',
+        'localhost:27018',
+        'localhost:27019'
+      ]
+
+      @ismaster = {
+        'hosts' => @hosts,
+        'arbiters' => @arbiters,
+        'maxMessageSizeBytes' => 1024 * 2.5,
+        'maxBsonObjectSize' => 1024
+      }
+    end
+
+    should "populate pools correctly" do
+
+      @db.stubs(:command).returns(
+        # First call to get a socket.
+        @ismaster.merge({'ismaster' => true}),
+
+        # Subsequent calls to configure pools.
+        @ismaster.merge({'ismaster' => true}),
+        @ismaster.merge({'secondary' => true, 'maxMessageSizeBytes' => 700}),
+        @ismaster.merge({'secondary' => true, 'maxBsonObjectSize' => 500}),
+        @ismaster.merge({'arbiterOnly' => true})
+      )
+
+      seed = ['localhost:27017']
+      manager = Mongo::ShardingPoolManager.new(@client, seed)
+      @client.stubs(:local_manager).returns(manager)
+      manager.connect
+
+      formatted_seed = ['localhost', 27017]
+
+      assert manager.seeds.include? formatted_seed
+      assert_equal 500, manager.max_bson_size
+      assert_equal 700 , manager.max_message_size
+    end
+
+    should "maintain seed format when checking connection health" do
+
+      @db.stubs(:command).returns(
+        # First call to get a socket.
+        @ismaster.merge({'ismaster' => true}),
+
+        # Subsequent calls to configure pools.
+        @ismaster.merge({'ismaster' => true}),
+        @ismaster.merge({'secondary' => true, 'maxMessageSizeBytes' => 700}),
+        @ismaster.merge({'secondary' => true, 'maxBsonObjectSize' => 500}),
+        @ismaster.merge({'arbiterOnly' => true})
+      )
+
+      config_db = new_mock_db
+      mongos_coll = mock('collection')
+      mongos_coll.stubs(:find).returns(@hosts.map{|h| {'_id' => h}})
+      config_db.stubs(:[]).with('mongos').returns(mongos_coll)
+      @client.stubs(:[]).with('config').returns(config_db)
+
+      manager = Mongo::ShardingPoolManager.new(@client, @hosts)
+      manager.check_connection_health
+
+      assert manager.seeds.all? {|s| s.is_a?(Array) && s[0].is_a?(String) && s[1].is_a?(Integer)}
+    end
+  end
+end