mongo 1.8.2 → 1.8.3.rc0

data/test/replica_set/z_cluster_shutdown.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+# mock test case to shutdown cluster for rake test:replica_set, must be last by file name sort order
+class ZClusterShutdownTest < Test::Unit::TestCase
+  def setup
+    ensure_cluster(:rs)
+  end
+
+  def test_cluster_shutdown
+    @@force_shutdown = true
+  end
+end
+

data/test/sharded_cluster/basic_test.rb

@@ -6,28 +6,24 @@ class Cursor
 end
 
 class BasicTest < Test::Unit::TestCase
-  
+
   def setup
     ensure_cluster(:sc)
-  end
-
-  def self.shutdown
-    @@cluster.stop
-    @@cluster.clobber
+    @document = { "name" => "test_user" }
+    @seeds = @sc.mongos_seeds
   end
 
   # TODO member.primary? ==> true
   def test_connect
-    seeds = @sc.mongos_seeds
-    @client = MongoShardedClient.new(seeds)
+    @client = MongoShardedClient.new(@seeds)
     assert @client.connected?
-    assert_equal(seeds.size, @client.seeds.size)
-    probe(seeds.size)
+    assert_equal(@seeds.size, @client.seeds.size)
+    probe(@seeds.size)
     @client.close
   end
 
   def test_connect_from_standard_client
-    mongos = @sc.mongos_seeds.first
+    mongos = @seeds.first
     @client = MongoClient.new(*mongos.split(':'))
     assert @client.connected?
     assert @client.mongos?
@@ -35,26 +31,48 @@ class BasicTest < Test::Unit::TestCase
   end
 
   def test_read_from_client
-    host, port = @sc.mongos_seeds.first.split(':')
-    tags = [{:dc => "mongolia"}] 
+    host, port = @seeds.first.split(':')
+    tags = [{:dc => "mongolia"}]
     @client = MongoClient.new(host, port, {:read => :secondary, :tag_sets => tags})
     assert @client.connected?
     cursor = Cursor.new(@client[MONGO_TEST_DB]['whatever'], {})
     assert_equal cursor.construct_query_spec['$readPreference'], {:mode => :secondary, :tags => tags}
   end
 
+  def test_find_one_with_read_secondary
+    @client = MongoShardedClient.new(@seeds, { :read => :secondary })
+    @client[MONGO_TEST_DB]["users"].insert([ @document ])
+    assert_equal @client[MONGO_TEST_DB]['users'].find_one["name"], "test_user"
+  end
+
+  def test_find_one_with_read_secondary_preferred
+    @client = MongoShardedClient.new(@seeds, { :read => :secondary_preferred })
+    @client[MONGO_TEST_DB]["users"].insert([ @document ])
+    assert_equal @client[MONGO_TEST_DB]['users'].find_one["name"], "test_user"
+  end
+
+  def test_find_one_with_read_primary
+    @client = MongoShardedClient.new(@seeds, { :read => :primary })
+    @client[MONGO_TEST_DB]["users"].insert([ @document ])
+    assert_equal @client[MONGO_TEST_DB]['users'].find_one["name"], "test_user"
+  end
+
+  def test_find_one_with_read_primary_preferred
+    @client = MongoShardedClient.new(@seeds, { :read => :primary_preferred })
+    @client[MONGO_TEST_DB]["users"].insert([ @document ])
+    assert_equal @client[MONGO_TEST_DB]['users'].find_one["name"], "test_user"
+  end
+
   def test_read_from_sharded_client
-    seeds = @sc.mongos_seeds
-    tags = [{:dc => "mongolia"}] 
-    @client = MongoShardedClient.new(seeds, {:read => :secondary, :tag_sets => tags})
+    tags = [{:dc => "mongolia"}]
+    @client = MongoShardedClient.new(@seeds, {:read => :secondary, :tag_sets => tags})
     assert @client.connected?
     cursor = Cursor.new(@client[MONGO_TEST_DB]['whatever'], {})
     assert_equal cursor.construct_query_spec['$readPreference'], {:mode => :secondary, :tags => tags}
   end
 
   def test_hard_refresh
-    seeds = @sc.mongos_seeds
-    @client = MongoShardedClient.new(seeds)
+    @client = MongoShardedClient.new(@seeds)
     assert @client.connected?
     @client.hard_refresh!
     assert @client.connected?
@@ -62,44 +80,41 @@ class BasicTest < Test::Unit::TestCase
   end
 
   def test_reconnect
-    seeds = @sc.mongos_seeds
-    @client = MongoShardedClient.new(seeds)
+    @client = MongoShardedClient.new(@seeds)
     assert @client.connected?
     router = @sc.servers(:routers).first
     router.stop
-    probe(seeds.size)
+    probe(@seeds.size)
     assert @client.connected?
     @client.close
   end
 
   def test_all_down
-    seeds = @sc.mongos_seeds
-    @client = MongoShardedClient.new(seeds)
+    @client = MongoShardedClient.new(@seeds)
     assert @client.connected?
     @sc.servers(:routers).each{|router| router.stop}
     assert_raises Mongo::ConnectionFailure do
-      probe(seeds.size)
+      probe(@seeds.size)
     end
     assert_false @client.connected?
     @client.close
   end
 
   def test_cycle
-    seeds = @sc.mongos_seeds
-    @client = MongoShardedClient.new(seeds)
+    @client = MongoShardedClient.new(@seeds)
     assert @client.connected?
     routers = @sc.servers(:routers)
     while routers.size > 0 do
       rescue_connection_failure do
-        probe(seeds.size)
+        probe(@seeds.size)
       end
-      probe(seeds.size)
+      probe(@seeds.size)
       router = routers.detect{|r| r.port == @client.manager.primary.last}
       routers.delete(router)
       router.stop
     end
     assert_raises Mongo::ConnectionFailure do
-      probe(seeds.size)
+      probe(@seeds.size)
     end
     assert_false @client.connected?
     routers = @sc.servers(:routers).reverse
@@ -107,9 +122,9 @@ class BasicTest < Test::Unit::TestCase
       r.start
       @client.hard_refresh!
       rescue_connection_failure do
-        probe(seeds.size)
+        probe(@seeds.size)
       end
-      probe(seeds.size)
+      probe(@seeds.size)
     end
     @client.close
   end
@@ -119,5 +134,4 @@ class BasicTest < Test::Unit::TestCase
   def probe(size)
     assert_equal(size, @client['config']['mongos'].find.to_a.size)
   end
-
 end

data/test/test_helper.rb

@@ -1,4 +1,16 @@
 require 'rubygems'
+# SimpleCov must load before our code - A coverage report summary line will print after each test suite
+if RUBY_VERSION >= '1.9.0' && RUBY_ENGINE == 'ruby'
+  if ENV.key?('COVERAGE')
+    require 'simplecov'
+    SimpleCov.start do
+      add_group "Mongo", 'lib/mongo'
+      add_group "BSON", 'lib/bson'
+      add_filter "/test/"
+    end
+  end
+end
+gem 'test-unit' # Do NOT remove this line - gem version is needed for Test::Unit::TestCase.shutdown
 require 'test/unit'
 require 'tools/mongo_config'
 
@@ -7,7 +19,7 @@ class Test::Unit::TestCase
   TEST_DATA = File.join(File.dirname(__FILE__), 'data')
 
   def ensure_cluster(kind=nil, opts={})
-    @@cluster ||= false
+    @@cluster ||= nil
 
     unless @@cluster
       if kind == :rs
@@ -25,6 +37,17 @@ class Test::Unit::TestCase
       config = Mongo::Config.cluster(cluster_opts)
       #debug 1, config
       @@cluster = Mongo::Config::ClusterManager.new(config)
+
+      Test::Unit::TestCase.class_eval do
+        @@force_shutdown = false
+
+        def self.shutdown
+          if @@force_shutdown || /rake_test_loader/ !~ $0
+            @@cluster.stop
+            @@cluster.clobber
+          end
+        end
+      end
     end
 
     @@cluster.start
@@ -143,6 +166,8 @@ class Test::Unit::TestCase
     socket.stubs(:setsockopt).with(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
     socket.stubs(:close)
     socket.stubs(:closed?)
+    socket.stubs(:checkin)
+    socket.stubs(:pool)
     socket
   end
 

data/test/threading/basic_test.rb

@@ -5,7 +5,7 @@ class TestThreading < Test::Unit::TestCase
   include Mongo
 
   def setup
-    @client = standard_connection(:pool_size => 50, :pool_timeout => 60)
+    @client = standard_connection(:pool_size => 10, :pool_timeout => 30)
     @db = @client.db(MONGO_TEST_DB)
     @coll = @db.collection('thread-test-collection')
     @coll.drop
@@ -58,22 +58,23 @@ class TestThreading < Test::Unit::TestCase
     threads.each {|thread| thread.join}
   end
 
-  def test_count
+  def test_concurrent_find
+    n_threads = 50
+
     1000.times do |i|
-      @coll.insert({ "x" => i })
+      @coll.insert({ "x" => "a" })
     end
 
     threads = []
-    10.times do |i|
+    n_threads.times do |i|
       threads << Thread.new do
         sum = 0
-        @coll.find().each do |document|
-          sum += document["x"]
-        end
-        assert_equal 499500, sum
+        @coll.find.to_a.size
       end
     end
 
-    threads.each {|thread| thread.join}
+    thread_values = threads.map(&:value)
+    assert thread_values.all?{|v| v == 1000}
+    assert_equal thread_values.size, n_threads
   end
 end

data/test/tools/mongo_config.rb

@@ -145,6 +145,7 @@ module Mongo
     def self.port_available?(port)
       ret = false
       socket = Socket.new(Socket::Constants::AF_INET, Socket::Constants::SOCK_STREAM, 0)
+      socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1)
       sockaddr = Socket.sockaddr_in(port, '0.0.0.0')
       begin
         socket.bind(sockaddr)
@@ -211,7 +212,10 @@ module Mongo
           false
         end
         # cleanup lock if unclean shutdown
-        File.delete(File.join(@config[:dbpath], 'mongod.lock')) if @config[:dbpath]
+        begin
+          File.delete(File.join(@config[:dbpath], 'mongod.lock')) if @config[:dbpath]
+        rescue Errno::ENOENT
+        end
       end
 
       def wait
@@ -550,7 +554,7 @@ module Mongo
       end
 
       def clobber
-        system "rm -fr #{@config[:dbpath]}/*"
+        FileUtils.rm_rf @config[:dbpath]
         self
       end
     end

data/test/unit/collection_test.rb

@@ -37,7 +37,7 @@ class CollectionTest < Test::Unit::TestCase
       @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
       @db   = @client['testing']
       @coll = @db.collection('books')
-      @client.expects(:checkout_reader).returns(mock(:pool))
+      @client.expects(:checkout_reader).returns(new_mock_socket)
       @client.expects(:receive_message).with do |op, msg, log, sock|
         op == 2004
       end.returns([[], 0, 0])

data/test/unit/grid_test.rb

@@ -13,43 +13,50 @@ class GridTest < Test::Unit::TestCase
       @files  = mock()
       @chunks = mock()
 
-      @db.expects(:[]).with('fs.files').returns(@files)
-      @db.expects(:[]).with('fs.chunks').returns(@chunks)
+      @db.stubs(:[]).with('fs.files').returns(@files)
+      @db.stubs(:[]).with('fs.chunks').returns(@chunks)
       @db.stubs(:safe)
       @db.stubs(:read).returns(:primary)
     end
 
-    context "Grid classe with standard connections" do
+    context "Grid classes with standard connections" do
       setup do
-        @client.expects(:class).returns(MongoClient)
-        @client.expects(:read_primary?).returns(true)
+        @chunks.expects(:ensure_index)
       end
 
       should "create indexes for Grid" do
-        @chunks.expects(:create_index)
         Grid.new(@db)
       end
 
       should "create indexes for GridFileSystem" do
-        @files.expects(:create_index)
-        @chunks.expects(:create_index)
+        @files.expects(:ensure_index)
         GridFileSystem.new(@db)
       end
     end
 
     context "Grid classes with slave connection" do
       setup do
-        @client.expects(:class).twice.returns(MongoClient)
-        @client.expects(:read_primary?).returns(false)
+        @chunks.stubs(:ensure_index).raises(Mongo::ConnectionFailure)
+        @files.stubs(:ensure_index).raises(Mongo::ConnectionFailure)
       end
 
       should "not create indexes for Grid" do
-        Grid.new(@db)
+        grid = Grid.new(@db)
+        data = "hello world!"
+        assert_raise Mongo::ConnectionFailure do
+          grid.put(data)
+        end
       end
 
       should "not create indexes for GridFileSystem" do
-        GridFileSystem.new(@db)
+        gridfs = GridFileSystem.new(@db)
+        data = "hello world!"
+        assert_raise Mongo::ConnectionFailure do
+          gridfs.open('image.jpg', 'w') do |f|
+            f.write data
+          end
+        end
       end
     end
   end
-end
+end

data/test/unit/mongo_sharded_client_test.rb

@@ -0,0 +1,32 @@
+require "test_helper"
+
+class MongoShardedClientTest < Test::Unit::TestCase
+  include Mongo
+
+  def setup
+    ENV["MONGODB_URI"] = nil
+  end
+
+  def test_initialize_with_single_mongos_uri
+    ENV["MONGODB_URI"] = "mongodb://localhost:27017"
+    client = MongoShardedClient.new
+    assert_equal [[ "localhost", 27017 ]], client.seeds
+  end
+
+  def test_initialize_with_multiple_mongos_uris
+    ENV["MONGODB_URI"] = "mongodb://localhost:27017,localhost:27018"
+    client = MongoShardedClient.new
+    assert_equal [[ "localhost", 27017 ], [ "localhost", 27018 ]], client.seeds
+  end
+
+  def test_from_uri_with_string
+    client = MongoShardedClient.from_uri("mongodb://localhost:27017,localhost:27018")
+    assert_equal [[ "localhost", 27017 ], [ "localhost", 27018 ]], client.seeds
+  end
+
+  def test_from_uri_with_env_variable
+    ENV["MONGODB_URI"] = "mongodb://localhost:27017,localhost:27018"
+    client = MongoShardedClient.from_uri
+    assert_equal [[ "localhost", 27017 ], [ "localhost", 27018 ]], client.seeds
+  end
+end

data/test/unit/pool_manager_test.rb

@@ -22,21 +22,33 @@ class PoolManagerTest < Test::Unit::TestCase
       @client.stubs(:replica_set_name).returns(nil)
       @client.stubs(:log)
       @arbiters = ['localhost:27020']
-      @hosts = ['localhost:27017', 'localhost:27018', 'localhost:27019',
-        'localhost:27020']
+      @hosts = [
+        'localhost:27017',
+        'localhost:27018',
+        'localhost:27019',
+        'localhost:27020'
+      ]
+
+      @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' => true, 'hosts' => @hosts, 'arbiters' => @arbiters},
+        @ismaster.merge({'ismaster' => true}),
 
         # Subsequent calls to configure pools.
-        {'ismaster' => true, 'hosts' => @hosts, 'arbiters' => @arbiters},
-        {'secondary' => true, 'hosts' => @hosts, 'arbiters' => @arbiters},
-        {'secondary' => true, 'hosts' => @hosts, 'arbiters' => @arbiters},
-        {'arbiterOnly' => true, 'hosts' => @hosts, 'arbiters' => @arbiters})
+        @ismaster.merge({'ismaster' => true}),
+        @ismaster.merge({'secondary' => true, 'maxMessageSizeBytes' => 700}),
+        @ismaster.merge({'secondary' => true, 'maxBsonObjectSize' => 500}),
+        @ismaster.merge({'arbiterOnly' => true})
+      )
 
       seeds = [['localhost', 27017]]
       manager = Mongo::PoolManager.new(@client, seeds)
@@ -45,22 +57,24 @@ class PoolManagerTest < Test::Unit::TestCase
       assert_equal ['localhost', 27017], manager.primary
       assert_equal 27017, manager.primary_pool.port
       assert_equal 2, manager.secondaries.length
-      assert_equal 27018, manager.secondary_pools[0].port
-      assert_equal 27019, manager.secondary_pools[1].port
+      assert_equal [27018, 27019], manager.secondary_pools.map(&:port).sort
       assert_equal [['localhost', 27020]], manager.arbiters
+      assert_equal 500, manager.max_bson_size
+      assert_equal 700 , manager.max_message_size
     end
 
     should "populate pools with single unqueryable seed" do
 
       @db.stubs(:command).returns(
         # First call to recovering node
-        {'ismaster' => false, 'secondary' => false, 'hosts' => @hosts, 'arbiters' => @arbiters},
+        @ismaster.merge({'ismaster' => false, 'secondary' => false}),
 
         # Subsequent calls to configure pools.
-        {'ismaster' => false, 'secondary' => false, 'hosts' => @hosts, 'arbiters' => @arbiters},
-        {'ismaster' => true, 'hosts' => @hosts, 'arbiters' => @arbiters},
-        {'secondary' => true, 'hosts' => @hosts, 'arbiters' => @arbiters},
-        {'arbiterOnly' => true, 'hosts' => @hosts, 'arbiters' => @arbiters})
+        @ismaster.merge({'ismaster' => false, 'secondary' => false}),
+        @ismaster.merge({'ismaster' => true}),
+        @ismaster.merge({'secondary' => true}),
+        @ismaster.merge({'arbiterOnly' => true})
+      )
 
       seeds = [['localhost', 27017]]
       manager = Mongo::PoolManager.new(@client, seeds)