jmongo 1.0.3 → 1.1.0

data/test/unit/node_test.rb

@@ -0,0 +1,73 @@
+require './test/test_helper'
+
+class NodeTest < Test::Unit::TestCase
+
+  def setup
+    @connection = stub()
+  end
+
+  should "refuse to connect to node without 'hosts' key" do
+    tcp = mock()
+    node = Node.new(@connection, ['localhost', 27017])
+    tcp.stubs(:new).returns(new_mock_socket)
+    @connection.stubs(:socket_class).returns(tcp)
+
+    admin_db = new_mock_db
+    admin_db.stubs(:command).returns({'ok' => 1, 'ismaster' => 1})
+    @connection.stubs(:[]).with('admin').returns(admin_db)
+    @connection.stubs(:connect_timeout).returns(nil)
+    @connection.expects(:log)
+
+    assert node.connect
+    node.set_config
+  end
+
+  should "load a node from an array" do
+    node = Node.new(@connection, ['power.level.com', 9001])
+    assert_equal 'power.level.com', node.host
+    assert_equal 9001, node.port
+    assert_equal 'power.level.com:9001', node.address
+  end
+
+  should "should default the port for an array" do
+    node = Node.new(@connection, ['power.level.com'])
+    assert_equal 'power.level.com', node.host
+    assert_equal Connection::DEFAULT_PORT, node.port
+    assert_equal "power.level.com:#{Connection::DEFAULT_PORT}", node.address
+  end
+
+  should "load a node from a string" do
+    node = Node.new(@connection, 'localhost:1234')
+    assert_equal 'localhost', node.host
+    assert_equal 1234, node.port
+    assert_equal 'localhost:1234', node.address
+  end
+
+  should "should default the port for a string" do
+    node = Node.new(@connection, '192.168.0.1')
+    assert_equal '192.168.0.1', node.host
+    assert_equal Connection::DEFAULT_PORT, node.port
+    assert_equal "192.168.0.1:#{Connection::DEFAULT_PORT}", node.address
+  end
+
+  should "two nodes with the same address should be equal" do
+    assert_equal Node.new(@connection, '192.168.0.1'),
+      Node.new(@connection, ['192.168.0.1', Connection::DEFAULT_PORT])
+  end
+
+  should "two nodes with the same address should have the same hash" do
+    assert_equal Node.new(@connection, '192.168.0.1').hash,
+      Node.new(@connection, ['192.168.0.1', Connection::DEFAULT_PORT]).hash
+  end
+
+  should "two nodes with different addresses should not be equal" do
+    assert_not_equal Node.new(@connection, '192.168.0.2'),
+      Node.new(@connection, ['192.168.0.1', Connection::DEFAULT_PORT])
+  end
+
+  should "two nodes with the same address should have the same hash negate" do
+    assert_not_equal Node.new(@connection, '192.168.0.1').hash,
+      Node.new(@connection, '1239.33.4.2393:29949').hash
+  end
+
+end

data/test/unit/pool_manager_test.rb

@@ -0,0 +1,47 @@
+require './test/test_helper'
+include Mongo
+
+class PoolManagerTest < Test::Unit::TestCase
+
+  context "Initialization: " do
+
+    should "populate pools correctly" do
+      TCPSocket.stubs(:new).returns(new_mock_socket)
+      @db = new_mock_db
+
+      @connection = stub("Connection")
+      @connection.stubs(:connect_timeout).returns(5000)
+      @connection.stubs(:pool_size).returns(2)
+      @connection.stubs(:socket_class).returns(TCPSocket)
+      @connection.stubs(:[]).returns(@db)
+
+      @connection.stubs(:replica_set_name).returns(nil)
+      @connection.stubs(:log)
+      @arbiters = ['localhost:27020']
+      @hosts = ['localhost:27017', 'localhost:27018', 'localhost:27019',
+        'localhost:27020']
+
+      @db.stubs(:command).returns(
+        # First call to get a socket.
+        {'ismaster' => true, 'hosts' => @hosts, 'arbiters' => @arbiters},
+
+        # 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})
+
+      seeds = [['localhost', 27017]]
+      manager = Mongo::PoolManager.new(@connection, seeds)
+      manager.connect
+
+      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 [['localhost', 27020]], manager.arbiters
+    end
+
+  end
+
+end

data/test/unit/pool_test.rb

@@ -0,0 +1,9 @@
+require './test/test_helper'
+include Mongo
+
+class PoolTest < Test::Unit::TestCase
+  context "Initialization: " do
+    should "do" do
+    end
+  end
+end

data/test/unit/read_test.rb

@@ -0,0 +1,101 @@
+require './test/test_helper'
+
+class ReadTest < Test::Unit::TestCase
+
+  context "Read mode on standard connection: " do
+    setup do
+      @read_preference = :secondary
+      @con = Mongo::Connection.new('localhost', 27017, :read => @read_preference, :connect => false)
+    end
+
+  end
+
+  context "Read mode on connection: " do
+    setup do
+      @read_preference = :secondary
+      @con = Mongo::ReplSetConnection.new(['localhost', 27017], :read => @read_preference, :connect => false)
+    end
+
+    should "store read preference on Connection" do
+      assert_equal @read_preference, @con.read_preference
+    end
+
+    should "propogate to DB" do
+      db = @con['foo']
+      assert_equal @read_preference, db.read_preference
+
+      db = @con.db('foo')
+      assert_equal @read_preference, db.read_preference
+
+      db = DB.new('foo', @con)
+      assert_equal @read_preference, db.read_preference
+    end
+
+    should "allow db override" do
+      db = DB.new('foo', @con, :read => :primary)
+      assert_equal :primary, db.read_preference
+
+      db = @con.db('foo', :read => :primary)
+      assert_equal :primary, db.read_preference
+    end
+
+    context "on DB: " do
+      setup do
+        @db = @con['foo']
+      end
+
+      should "propogate to collection" do
+        col = @db.collection('bar')
+        assert_equal @read_preference, col.read_preference
+
+        col = @db['bar']
+        assert_equal @read_preference, col.read_preference
+
+        col = Collection.new('bar', @db)
+        assert_equal @read_preference, col.read_preference
+      end
+
+      should "allow override on collection" do
+        col = @db.collection('bar', :read => :primary)
+        assert_equal :primary, col.read_preference
+
+        col = Collection.new('bar', @db, :read => :primary)
+        assert_equal :primary, col.read_preference
+      end
+    end
+
+    context "on read mode ops" do
+      setup do
+        @col = @con['foo']['bar']
+        @mock_socket = stub()
+      end
+
+      should "use default value on query" do
+        @con.expects(:receive_message).with do |o, m, l, s, c, r|
+          r == :secondary
+        end.returns([[], 0, 0])
+
+        @col.find_one({:a => 1})
+      end
+
+      should "allow override default value on query" do
+        @con.expects(:receive_message).with do |o, m, l, s, c, r|
+          r == :primary
+        end.returns([[], 0, 0])
+
+        @col.find_one({:a => 1}, :read => :primary)
+      end
+
+      should "allow override alternate value on query" do
+        # TODO: enable this test once we enable reading from tags.
+        # @con.expects(:receive_message).with do |o, m, l, s, c, r|
+        #   tags = {:dc => "ny"}
+        # end.returns([[], 0, 0])
+
+        assert_raise MongoArgumentError do
+          @col.find_one({:a => 1}, :read => {:dc => "ny"})
+        end
+      end
+    end
+  end
+end

data/test/unit/safe_test.rb

@@ -0,0 +1,125 @@
+require './test/test_helper'
+
+class SafeTest < Test::Unit::TestCase
+
+  context "Safe mode on connection: " do
+    setup do
+      @safe_value = {:w => 7}
+      @con = Mongo::Connection.new('localhost', 27017, :safe => @safe_value, :connect => false)
+    end
+
+    should "propogate to DB" do
+      db = @con['foo']
+      assert_equal @safe_value, db.safe
+
+
+      db = @con.db('foo')
+      assert_equal @safe_value, db.safe
+
+      db = DB.new('foo', @con)
+      assert_equal @safe_value, db.safe
+    end
+
+    should "allow db override" do
+      db = DB.new('foo', @con, :safe => false)
+      assert_equal false, db.safe
+
+      db = @con.db('foo', :safe => false)
+      assert_equal false, db.safe
+    end
+
+    context "on DB: " do
+      setup do
+        @db = @con['foo']
+      end
+
+      should "propogate to collection" do
+        col = @db.collection('bar')
+        assert_equal @safe_value, col.safe
+
+        col = @db['bar']
+        assert_equal @safe_value, col.safe
+
+        col = Collection.new('bar', @db)
+        assert_equal @safe_value, col.safe
+      end
+
+      should "allow override on collection" do
+        col = @db.collection('bar', :safe => false)
+        assert_equal false, col.safe
+
+        col = Collection.new('bar', @db, :safe => false)
+        assert_equal false, col.safe
+      end
+    end
+
+    context "on operations supporting safe mode" do
+      setup do
+        @col = @con['foo']['bar']
+      end
+
+      should "use default value on insert" do
+        @con.expects(:send_message_with_safe_check).with do |op, msg, log, n, safe|
+          safe == @safe_value
+        end
+
+        @col.insert({:a => 1})
+      end
+
+      should "allow override alternate value on insert" do
+        @con.expects(:send_message_with_safe_check).with do |op, msg, log, n, safe|
+          safe == {:w => 100}
+        end
+
+        @col.insert({:a => 1}, :safe => {:w => 100})
+      end
+
+      should "allow override to disable on insert" do
+        @con.expects(:send_message)
+        @col.insert({:a => 1}, :safe => false)
+      end
+
+      should "use default value on update" do
+        @con.expects(:send_message_with_safe_check).with do |op, msg, log, n, safe|
+          safe == @safe_value
+        end
+
+        @col.update({:a => 1}, {:a => 2})
+      end
+
+      should "allow override alternate value on update" do
+        @con.expects(:send_message_with_safe_check).with do |op, msg, log, n, safe|
+          safe == {:w => 100}
+        end
+
+        @col.update({:a => 1}, {:a => 2}, :safe => {:w => 100})
+      end
+
+      should "allow override to disable on update" do
+        @con.expects(:send_message)
+        @col.update({:a => 1}, {:a => 2}, :safe => false)
+      end
+
+      should "use default value on remove" do
+        @con.expects(:send_message_with_safe_check).with do |op, msg, log, n, safe|
+          safe == @safe_value
+        end
+
+        @col.remove
+      end
+
+      should "allow override alternate value on remove" do
+        @con.expects(:send_message_with_safe_check).with do |op, msg, log, n, safe|
+          safe == {:w => 100}
+        end
+
+        @col.remove({}, :safe => {:w => 100})
+      end
+
+      should "allow override to disable on remove" do
+        @con.expects(:send_message)
+        @col.remove({}, :safe => false)
+      end
+    end
+  end
+end

data/test/uri_test.rb

@@ -0,0 +1,92 @@
+__END__
+require './test/test_helper'
+
+class TestThreading < Test::Unit::TestCase
+  include Mongo
+
+  def test_uri_without_port
+    parser = Mongo::URIParser.new('mongodb://localhost')
+    assert_equal 1, parser.nodes.length
+    assert_equal 'localhost', parser.nodes[0][0]
+    assert_equal 27017, parser.nodes[0][1]
+  end
+
+  def test_basic_uri
+    parser = Mongo::URIParser.new('mongodb://localhost:27018')
+    assert_equal 1, parser.nodes.length
+    assert_equal 'localhost', parser.nodes[0][0]
+    assert_equal 27018, parser.nodes[0][1]
+  end
+
+  def test_multiple_uris
+    parser = Mongo::URIParser.new('mongodb://a.example.com:27018,b.example.com')
+    assert_equal 2, parser.nodes.length
+    assert_equal 'a.example.com', parser.nodes[0][0]
+    assert_equal 27018, parser.nodes[0][1]
+    assert_equal 'b.example.com', parser.nodes[1][0]
+    assert_equal 27017, parser.nodes[1][1]
+  end
+
+  def test_complex_passwords
+    parser = Mongo::URIParser.new('mongodb://bob:secret.word@a.example.com:27018/test')
+    assert_equal "bob", parser.auths[0]["username"]
+    assert_equal "secret.word", parser.auths[0]["password"]
+
+    parser = Mongo::URIParser.new('mongodb://bob:s-_3#%R.t@a.example.com:27018/test')
+    assert_equal "bob", parser.auths[0]["username"]
+    assert_equal "s-_3#%R.t", parser.auths[0]["password"]
+  end
+
+  def test_passwords_contain_no_commas
+    assert_raise MongoArgumentError do
+      Mongo::URIParser.new('mongodb://bob:a,b@a.example.com:27018/test')
+    end
+  end
+
+  def test_multiple_uris_with_auths
+    parser = Mongo::URIParser.new('mongodb://bob:secret@a.example.com:27018/test,joe:secret2@b.example.com/test2')
+    assert_equal 2, parser.nodes.length
+    assert_equal 'a.example.com', parser.nodes[0][0]
+    assert_equal 27018, parser.nodes[0][1]
+    assert_equal 'b.example.com', parser.nodes[1][0]
+    assert_equal 27017, parser.nodes[1][1]
+    assert_equal 2, parser.auths.length
+    assert_equal "bob", parser.auths[0]["username"]
+    assert_equal "secret", parser.auths[0]["password"]
+    assert_equal "test", parser.auths[0]["db_name"]
+    assert_equal "joe", parser.auths[1]["username"]
+    assert_equal "secret2", parser.auths[1]["password"]
+    assert_equal "test2", parser.auths[1]["db_name"]
+  end
+
+  def test_opts_basic
+    parser = Mongo::URIParser.new('mongodb://localhost:27018?connect=direct;slaveok=true;safe=true')
+    assert_equal 'direct', parser.connect
+    assert parser.slaveok
+    assert parser.safe
+  end
+
+  def test_opts_with_amp_separator
+    parser = Mongo::URIParser.new('mongodb://localhost:27018?connect=direct&slaveok=true&safe=true')
+    assert_equal 'direct', parser.connect
+    assert parser.slaveok
+    assert parser.safe
+  end
+
+  def test_opts_safe
+    parser = Mongo::URIParser.new('mongodb://localhost:27018?safe=true;w=2;wtimeout=200;fsync=true')
+    assert parser.safe
+    assert_equal 2, parser.w
+    assert_equal 200, parser.wtimeout
+    assert parser.fsync
+  end
+
+  def test_opts_replica_set
+    assert_raise_error MongoArgumentError, "specify that connect=replicaset" do
+      Mongo::URIParser.new('mongodb://localhost:27018?replicaset=foo')
+    end
+    parser = Mongo::URIParser.new('mongodb://localhost:27018?connect=replicaset;replicaset=foo')
+    assert_equal 'foo', parser.replicaset
+    assert_equal 'replicaset', parser.connect
+  end
+end