mongo 1.1.5 → 1.3.0

data/test/async/cursor_test.rb

@@ -0,0 +1,162 @@
+require 'test/test_helper'
+require 'logger'
+
+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(MONGO_TEST_DB)
+  @@coll = @@db.collection('test')
+  @@version = @@connection.server_version
+
+  def wait_for_async
+    sleep 0.2
+  end
+
+  def setup
+    @@coll.remove
+    @@coll.insert('a' => 1)     # collection not created until it's used
+    @@coll_full_name = "#{MONGO_TEST_DB}.test"
+  end
+
+  def test_async_explain
+    failsafe = mock('failsafe will get called in block', :call => true)
+
+    cursor = @@coll.find('a' => 1)
+
+    cursor.explain(:async => true) do |error, result|
+      assert_not_nil result['cursor']
+      assert_kind_of Numeric, result['n']
+      assert_kind_of Numeric, result['millis']
+      assert_kind_of Numeric, result['nscanned']
+      failsafe.call
+    end
+    wait_for_async
+  end
+
+  def test_async_count
+    failsafe = mock('failsafe will get called in block')
+    failsafe.expects(:call).times(3)
+
+    @@coll.remove
+
+    @@coll.find.count(:async => true) do |error, count|
+      assert_equal 0, count
+      failsafe.call
+    end
+    wait_for_async
+
+    10.times do |i|
+      @@coll.save("x" => i)
+    end
+
+    @@coll.find.count(:async => true) do |error, count|
+      assert_equal 10, count
+      failsafe.call
+    end
+    wait_for_async
+
+    @@coll.find({"x" => 1}).count(:async => true) do |error, count|
+      assert_equal 1, count
+      failsafe.call
+    end
+    wait_for_async
+  end
+
+  def test_async_close
+    failsafe = mock('failsafe will get called in block', :call => true)
+
+    @@coll.remove
+    cursor = @@coll.find
+    
+    cursor.close(:async => true) do |error, result|
+      assert_nil error
+      assert result
+      assert cursor.closed?
+      failsafe.call
+    end
+    wait_for_async
+  end
+
+  def test_async_has_next
+    failsafe = mock('failsafe will get called in block', :call => true)
+
+    @@coll.remove
+    200.times do |n|
+      @@coll.save("x" => n)
+    end
+
+    cursor = @@coll.find
+    cursor.has_next?(:async => true) do |error, result|
+      assert_nil error
+      assert result
+      failsafe.call
+    end
+    wait_for_async
+  end
+
+  def test_async_next_document
+    failsafe = mock('failsafe will get called in block')
+    failsafe.expects(:call).times(2)
+
+    @@coll.remove
+    200.times do |n|
+      @@coll.save("x" => n)
+    end
+
+    cursor = @@coll.find
+    cursor.next_document(:async => true) do |error, result|
+      assert_nil error
+      assert result
+      failsafe.call
+    end
+    wait_for_async
+
+    callback = Proc.new do |error, result| 
+      assert_nil error
+      assert result
+      failsafe.call
+    end
+
+    cursor.next_document(:async => true, :callback => callback)
+    wait_for_async
+  end
+
+  def test_async_to_a
+    failsafe = mock('failsafe will get called in block')
+    failsafe.expects(:call)
+
+    @@coll.remove
+    total = 200
+    total.times do |n|
+      @@coll.save("x" => n)
+    end
+
+    cursor = @@coll.find
+    cursor.to_a(:async => true) do |error, result|
+      assert_nil error
+      assert_equal total, result.size
+      failsafe.call
+    end
+    wait_for_async
+  end
+
+  def test_async_each
+    @@coll.remove
+    total = 200
+    total.times do |n|
+      @@coll.save("x" => n)
+    end
+
+    cursor = @@coll.find
+    count = 0
+    cursor.each(:async => true) do |error, result|
+      count += 1
+    end
+    wait_for_async
+    
+    assert_equal total, count
+  end
+end

data/test/async/worker_pool_test.rb

@@ -0,0 +1,99 @@
+require 'test/test_helper'
+include Mongo
+
+class WorkerPoolTest < Test::Unit::TestCase
+  context "Initialization: " do
+
+    def wait_for_async
+      sleep 0.2
+    end
+
+    setup do
+      def new_mock_queue
+        stub_everything('queue')
+      end
+
+      def new_mock_thread
+        stub_everything('thread')
+      end
+    end
+
+    context "given a size" do
+      setup do
+        @size = 5
+      end
+
+      should "allocate a Thread 'size' times" do
+        Queue.stubs(:new).returns(new_mock_queue)
+        Thread.expects(:new).times(@size).returns(new_mock_thread)
+        Async::WorkerPool.new @size
+      end
+
+      should "set 'abort_on_exception' for each current thread" do
+        Queue.stubs(:new).returns(new_mock_queue)
+        thread = new_mock_thread
+        Thread.stubs(:new).returns(thread)
+
+        thread.expects(:abort_on_exception=).with(true).times(@size)
+
+        Async::WorkerPool.new @size
+      end
+
+      should "save each thread into the workers queue" do
+        assert_equal @size, Async::WorkerPool.new(@size).workers.size
+      end
+
+    end # context 'given a size'
+
+
+    context "given a job" do
+      setup do
+        @pool = Async::WorkerPool.new 1
+        @command = stub_everything('command')
+        @cmd_args = stub_everything('command args')
+        @callback = stub_everything('callback')
+      end
+
+      should "remove nils from the command args array and pass the results to the callback" do
+        args = [nil, @cmd_args]
+        @command.expects(:call).with(@cmd_args).returns(2)
+        @callback.expects(:call).with(nil, 2)
+
+        @pool.enqueue @command, args, @callback
+        wait_for_async
+      end
+
+      should "execute the original command with args and pass the results to the callback" do
+        @cmd_args.expects(:compact).returns(@cmd_args)
+        @command.expects(:call).with(@cmd_args).returns(2)
+        @callback.expects(:call).with(nil, 2)
+
+        @pool.enqueue @command, @cmd_args, @callback
+        wait_for_async
+      end
+
+      should "capture any exceptions and pass them to the callback" do
+        args = [@cmd_args]
+        error = StandardError.new
+        @command.expects(:call).with(@cmd_args).raises(error)
+        @callback.expects(:call).with(error, nil)
+
+        @pool.enqueue @command, args, @callback
+        wait_for_async
+      end
+
+      should "abort the thread when the callback raises an exception" do
+        args = [@cmd_args]
+        error = StandardError.new
+        @callback.expects(:call).raises(error)
+
+        assert_raises(StandardError) do
+          @pool.enqueue @command, args, @callback
+          wait_for_async
+        end
+      end
+    end # context 'given a job'
+
+
+  end
+end

data/test/auxillary/fork_test.rb

@@ -0,0 +1,30 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'mongo'
+require 'test/unit'
+require './test/test_helper'
+
+class ForkTest < Test::Unit::TestCase
+  include Mongo
+
+  def setup
+    @conn = standard_connection
+  end
+
+  def test_fork
+    # Now insert some data
+    10.times do |n|
+      @conn[MONGO_TEST_DB]['nums'].insert({:a => n})
+    end
+
+    # Now fork. You'll almost always see an exception here.
+    if !Kernel.fork
+      10.times do
+        assert @conn[MONGO_TEST_DB]['nums'].find_one
+      end
+    else
+      10.times do
+        assert @conn[MONGO_TEST_DB]['nums'].find_one
+      end
+    end
+  end
+end

data/test/auxillary/repl_set_auth_test.rb

@@ -0,0 +1,58 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require './test/test_helper'
+require './test/tools/auth_repl_set_manager'
+
+class AuthTest < Test::Unit::TestCase
+  include Mongo
+
+  def setup
+    @manager = AuthReplSetManager.new(:start_port => 40000)
+    @manager.start_set
+  end
+
+  def teardown
+    @manager.cleanup_set
+  end
+
+  def test_repl_set_auth
+    @conn = ReplSetConnection.new([@manager.host, @manager.ports[0]], [@manager.host, @manager.ports[1]],
+      [@manager.host, @manager.ports[2]], :name => @manager.name)
+
+    # Add an admin user
+    @conn['admin'].add_user("me", "secret")
+
+    # Ensure that insert fails
+    assert_raise_error Mongo::OperationFailure, "unauthorized" do
+      @conn['foo']['stuff'].insert({:a => 2}, :safe => {:w => 3})
+    end
+
+    # Then authenticate
+    assert @conn['admin'].authenticate("me", "secret")
+
+    # Insert should succeed now
+    assert @conn['foo']['stuff'].insert({:a => 2}, :safe => {:w => 3})
+
+    # So should a query
+    assert @conn['foo']['stuff'].find_one
+
+    # But not when we logout
+    @conn['admin'].logout
+
+    assert_raise_error Mongo::OperationFailure, "unauthorized" do
+      @conn['foo']['stuff'].find_one
+    end
+
+    # Same should apply to a random secondary
+    @slave1 = Connection.new(@conn.secondary_pools[0].host,
+      @conn.secondary_pools[0].port, :slave_ok => true)
+
+    # Find should fail
+    assert_raise_error Mongo::OperationFailure, "unauthorized" do
+      @slave1['foo']['stuff'].find_one
+    end
+
+    # But not when authenticated
+    @slave1['admin'].authenticate("me", "secret")
+    assert @slave1['foo']['stuff'].find_one
+  end
+end

data/test/auxillary/threaded_authentication_test.rb

@@ -0,0 +1,101 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'mongo'
+require 'thread'
+require 'test/unit'
+require './test/test_helper'
+
+# NOTE: This test requires bouncing the server.
+# It also requires that a user exists on the admin database.
+class AuthenticationTest < Test::Unit::TestCase
+  include Mongo
+
+  def setup
+    @conn = standard_connection(:pool_size => 10)
+    @db1 = @conn.db('mongo-ruby-test-auth1')
+    @db2 = @conn.db('mongo-ruby-test-auth2')
+    @admin = @conn.db('admin')
+  end
+
+  def teardown
+    @db1.authenticate('user1', 'secret')
+    @db2.authenticate('user2', 'secret')
+    @conn.drop_database('mongo-ruby-test-auth1')
+    @conn.drop_database('mongo-ruby-test-auth2')
+  end
+
+  def threaded_exec
+    threads = []
+
+    100.times do
+      threads << Thread.new do
+        yield
+      end
+    end
+
+    100.times do |n|
+      threads[n].join
+    end
+  end
+
+  def test_authenticate
+    @admin.authenticate('bob', 'secret')
+    @db1.add_user('user1', 'secret')
+    @db2.add_user('user2', 'secret')
+    @admin.logout
+
+    threaded_exec do
+      assert_raise Mongo::OperationFailure do
+        @db1['stuff'].insert({:a => 2}, :safe => true)
+      end
+    end
+
+    threaded_exec do
+      assert_raise Mongo::OperationFailure do
+        @db2['stuff'].insert({:a => 2}, :safe => true)
+      end
+    end
+
+    @db1.authenticate('user1', 'secret')
+    @db2.authenticate('user2', 'secret')
+
+    threaded_exec do
+      assert @db1['stuff'].insert({:a => 2}, :safe => true)
+    end
+
+    threaded_exec do
+      assert @db2['stuff'].insert({:a => 2}, :safe => true)
+    end
+
+    puts "Please bounce the server."
+    gets
+
+    # Here we reconnect.
+    begin
+      @db1['stuff'].find.to_a
+      rescue Mongo::ConnectionFailure
+    end
+
+    threaded_exec do
+      assert @db1['stuff'].insert({:a => 2}, :safe => true)
+    end
+
+    threaded_exec do
+      assert @db2['stuff'].insert({:a => 2}, :safe => true)
+    end
+
+    @db1.logout
+    threaded_exec do
+      assert_raise Mongo::OperationFailure do
+        @db1['stuff'].insert({:a => 2}, :safe => true)
+      end
+    end
+
+    @db2.logout
+    threaded_exec do
+      assert_raise Mongo::OperationFailure do
+        assert @db2['stuff'].insert({:a => 2}, :safe => true)
+      end
+    end
+  end
+
+end