mongo 1.6.4 → 1.7.0.rc0

data/test/connection_test.rb

@@ -58,6 +58,12 @@ class TestConnection < Test::Unit::TestCase
     assert_equal mongo_port, con.primary_pool.port
   end
 
+  def test_uri_with_extra_opts
+    con = Connection.from_uri("mongodb://#{host_port}", :pool_size => 10, :slave_ok => true)
+    assert_equal 10, con.pool_size
+    assert_true con.slave_ok?
+  end
+
   def test_env_mongodb_uri
     begin
       old_mongodb_uri = ENV['MONGODB_URI']
@@ -82,6 +88,46 @@ class TestConnection < Test::Unit::TestCase
     end
   end
 
+  def test_db_from_uri_exists_no_options
+    begin
+      db_name = "_database"
+
+      old_mongodb_uri = ENV['MONGODB_URI']
+      ENV['MONGODB_URI'] = "mongodb://#{host_port}/#{db_name}"
+      con = Connection.from_uri
+      db = con.db
+      assert_equal db.name, db_name
+    ensure
+      ENV['MONGODB_URI'] = old_mongodb_uri
+    end
+  end
+
+  def test_db_from_uri_exists_options
+    begin
+      db_name = "_database"
+
+      old_mongodb_uri = ENV['MONGODB_URI']
+      ENV['MONGODB_URI'] = "mongodb://#{host_port}/#{db_name}?"
+      con = Connection.from_uri
+      db = con.db
+      assert_equal db.name, db_name
+    ensure
+      ENV['MONGODB_URI'] = old_mongodb_uri
+    end
+  end
+
+  def test_db_from_uri_exists_no_db_name
+    begin
+      old_mongodb_uri = ENV['MONGODB_URI']
+      ENV['MONGODB_URI'] = "mongodb://#{host_port}/"
+      con = Connection.from_uri
+      db = con.db
+      assert_equal db.name, Mongo::Connection::DEFAULT_DB_NAME
+    ensure
+      ENV['MONGODB_URI'] = old_mongodb_uri
+    end
+  end
+
   def test_server_version
     assert_match(/\d\.\d+(\.\d+)?/, @conn.server_version.to_s)
   end
@@ -207,7 +253,7 @@ class TestConnection < Test::Unit::TestCase
     assert !@conn.locked?
     @conn.lock!
     assert @conn.locked?
-    assert_equal 1, @conn['admin']['$cmd.sys.inprog'].find_one['fsyncLock'], "Not fsync-locked"
+    assert [1, true].include?(@conn['admin']['$cmd.sys.inprog'].find_one['fsyncLock'])
     assert_match(/unlock/, @conn.unlock!['info'])
     unlocked = false
     counter  = 0
@@ -339,7 +385,7 @@ class TestConnection < Test::Unit::TestCase
       end
 
       should "close the connection on receive_message for major exceptions" do
-        @con.expects(:checkout_writer).raises(SystemStackError)
+        @con.expects(:checkout_reader).raises(SystemStackError)
         @con.expects(:close)
         begin
           @coll.find.next
@@ -375,11 +421,11 @@ class TestConnection < Test::Unit::TestCase
 
     should "release connection if an exception is raised on receive_message" do
       @con.stubs(:receive).raises(ConnectionFailure)
-      assert_equal 0, @con.primary_pool.checked_out.size
+      assert_equal 0, @con.read_pool.checked_out.size
       assert_raise ConnectionFailure do
         @coll.find.to_a
       end
-      assert_equal 0, @con.primary_pool.checked_out.size
+      assert_equal 0, @con.read_pool.checked_out.size
     end
 
     should "show a proper exception message if an IOError is raised while closing a socket" do

data/test/db_api_test.rb

@@ -429,9 +429,9 @@ class DBAPITest < Test::Unit::TestCase
   end
 
   def test_array
-    @@coll.remove
-    @@coll.insert({'b' => [1, 2, 3]})
-    @@coll.insert({'b' => [1, 2, 3]})
+    @@coll.remove({'$atomic' => true}, :safe => true)
+    @@coll.insert({'b' => [1, 2, 3]}, :safe => true)
+    @@coll.insert({'b' => [1, 2, 3]}, :safe => true)
     rows = @@coll.find({}, {:fields => ['b']}).to_a
     assert_equal 2, rows.length
     assert_equal [1, 2, 3], rows[1]['b']

data/test/db_test.rb

@@ -221,7 +221,12 @@ class DBTest < Test::Unit::TestCase
       assert ex.message.include?("forced error"),
         "error message does not contain 'forced error'"
       assert_equal 10038, ex.error_code
-      assert_equal 10038, ex.result['assertionCode']
+
+      if @@version >= "2.1.0"
+        assert_equal 10038, ex.result['code']
+      else
+        assert_equal 10038, ex.result['assertionCode']
+      end
     ensure
       assert raised, "No assertion raised!"
     end

data/test/replica_sets/basic_test.rb

@@ -47,21 +47,18 @@ class BasicTest < Test::Unit::TestCase
     seeds = build_seeds(3)
     args = {:name => @rs.name}
     @conn = ReplSetConnection.new(seeds, args)
-    @major_version = @rs.version.first
 
     assert_equal @conn.host, @rs.primary[0]
     assert_equal @conn.port, @rs.primary[1]
     assert_equal @conn.host, @conn.primary_pool.host
     assert_equal @conn.port, @conn.primary_pool.port
-    #assert_equal @conn.nodes.sort, @conn.seeds.sort
     assert_equal 2, @conn.secondaries.length
     assert_equal 0, @conn.arbiters.length
     assert_equal 2, @conn.secondary_pools.length
     assert_equal @rs.name, @conn.replica_set_name
-    assert @conn.secondary_pools.include?(@conn.read_pool)
+    assert @conn.secondary_pools.include?(@conn.read_pool(:secondary))
     assert_equal 90, @conn.refresh_interval
     assert_equal @conn.refresh_mode, false
-    assert_equal 5, @conn.tag_map.keys.length unless @major_version < 2
   end
 
   context "Socket pools" do
@@ -92,10 +89,10 @@ class BasicTest < Test::Unit::TestCase
       end
 
       should "close the connection on receive_message for major exceptions" do
-        @con.expects(:checkout_writer).raises(SystemStackError)
+        @con.expects(:checkout_reader).raises(SystemStackError)
         @con.expects(:close)
         begin
-          @coll.find.next
+          @coll.find({}, :read => :primary).next
         rescue SystemStackError
         end
       end

data/test/replica_sets/complex_connect_test.rb

@@ -21,6 +21,8 @@ class ComplexConnectTest < Test::Unit::TestCase
       "#{@rs.host}:#{@rs.ports[0]}",
     ])
 
+    version = @conn.server_version
+
     @conn['test']['foo'].insert({:a => 1})
     assert @conn['test']['foo'].find_one
 
@@ -34,11 +36,21 @@ class ComplexConnectTest < Test::Unit::TestCase
       primary['admin'].command({:replSetReconfig => config})
     end
     @rs.ensure_up
+
+    force_stepdown = BSON::OrderedHash.new
+    force_stepdown[:replSetStepDown] = 1
+    force_stepdown[:force] = true
+
     assert_raise ConnectionFailure do
-      primary['admin'].command({:replSetStepDown => 1})
+      primary['admin'].command(force_stepdown)
     end
 
-    rescue_connection_failure do
+    # isMaster is currently broken in 2.1+ when called on removed nodes
+    if version < "2.1"
+      rescue_connection_failure do
+        assert @conn['test']['foo'].find_one
+      end
+
       assert @conn['test']['foo'].find_one
     end
   end

data/test/replica_sets/complex_read_preference_test.rb

@@ -0,0 +1,237 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require './test/replica_sets/rs_test_helper'
+require 'logger'
+
+# Tags for members:
+# 0 => {"dc" => "ny", "rack" => "a", "db" => "main"}
+# 1 => {"dc" => "ny", "rack" => "b", "db" => "main"}
+# 2 => {"dc" => "sf", "rack" => "a", "db" => "main"}
+
+class ComplexReadPreferenceTest < Test::Unit::TestCase
+  def setup
+    ensure_rs
+
+    # Insert data
+    conn = Connection.new(@rs.host, @rs.primary[1])
+    db = conn.db(MONGO_TEST_DB)
+    coll = db.collection("test-sets")
+    coll.save({:a => 20}, :safe => {:w => 2})
+  end
+
+  def test_primary_with_tags
+    # Test specifying a tag set with default read preference of primary throws and error
+    conn = make_connection({:tag_sets => {"rack" => "a"}})
+    assert_raise_error MongoArgumentError, "Read preferecy :primary cannot be combined with tags" do
+      conn.read_pool
+    end
+  end
+
+  def test_tags
+    return true if @rs.version < "2.1"
+
+    assert_read_pool(:primary, {}, 0)
+    assert_read_pool(:primary_preferred, {}, 0)
+    assert_read_pool(:secondary, {}, [1,2])
+    assert_read_pool(:secondary_preferred, {}, [1,2])
+
+    # Test tag_sets are ignored on primary
+    assert_read_pool(:primary_preferred,
+      {"rack" => "b"}, 0)
+
+    # Test single tag
+    assert_read_pool(:secondary,
+      {"rack" => "a"}, 2)
+    assert_read_pool(:secondary,
+      {"rack" => "b"}, 1)
+    assert_read_pool(:secondary,
+      {"db" => "main"}, [1, 2])
+
+    # Test multiple tags
+    assert_read_pool(:secondary,
+      {"db" => "main", "rack" => "a"}, 2)
+    assert_read_pool(:secondary,
+      {"dc" => "ny", "rack" => "b", "db" => "main"}, 1)
+
+    # Test multiple tags failing
+    assert_fail_pool(:secondary,
+      {"dc" => "ny", "rack" => "a"})
+    assert_fail_pool(:secondary,
+      {"dc" => "ny", "rack" => "b", "db" => "main", "xtra" => "?"})
+
+    # Test symbol is converted to string for key
+    assert_read_pool(:secondary,
+      {:db => "main", "rack" => "b"}, 1)
+    assert_read_pool(:secondary,
+      {:db => "main", :rack => "b"}, 1)
+    assert_read_pool(:secondary,
+      {"db" => "main", :rack => "b"}, 1)
+
+    # Test secondary_preferred
+    assert_read_pool(:secondary_preferred,
+      {"dc" => "ny"}, 1)
+    assert_read_pool(:secondary_preferred,
+      {"dc" => "sf"}, 2)
+    assert_read_pool(:secondary_preferred,
+      {"dc" => "china"}, 0)
+
+    # Test secondary_preferred with no matching member
+    assert_read_pool(:secondary_preferred,
+      {"dc" => "bad"}, 0)
+    assert_read_pool(:secondary_preferred,
+      {"db" => "main", "dc" => "china"}, 0)
+    assert_read_pool(:secondary_preferred,
+      {"db" => "ny", "rack" => "a"}, 0)
+  end
+
+  def test_tag_sets
+    return true if @rs.version < "2.1"
+
+    # Test primary_preferred overrides any tags when primary is available
+    assert_read_pool(:primary_preferred, [
+      {"dc" => "sf"}
+    ], 0)
+
+    # Test first tag_set takes priority over the second
+    assert_read_pool(:secondary, [
+      {"dc" => "sf"},
+      {"dc" => "ny"}
+    ], 2)
+    assert_read_pool(:secondary, [
+      {"dc" => "ny"},
+      {"dc" => "sf"}
+    ], 1)
+    assert_read_pool(:secondary_preferred, [
+      {"dc" => "sf"},
+      {"dc" => "ny"}
+    ], 2)
+    assert_read_pool(:secondary_preferred, [
+      {"dc" => "ny"},
+      {"dc" => "sf"}
+    ], 1)
+
+    # Test tags not matching any member throw an error
+    assert_fail_pool(:secondary, [
+      {"dc" => "ny", "rack" => "a"},
+      {"dc" => "sf", "rack" => "b"},
+    ])
+
+    # Test bad tags get skipped over
+    assert_read_pool(:secondary_preferred, [
+      {"bad" => "tag"},
+      {"dc" => "sf"}
+    ], 2)
+
+    # Test less selective tags
+    assert_read_pool(:secondary, [
+      {"dc" => "ny", "rack" => "b", "db" => "alt"},
+      {"dc" => "ny", "rack" => "a"},
+      {"dc" => "sf"}
+    ], 2)
+    assert_read_pool(:secondary_preferred, [
+      {"dc" => "ny", "rack" => "b", "db" => "alt"},
+      {"dc" => "ny", "rack" => "a"},
+      {"dc" => "sf"}
+    ], 2)
+    assert_read_pool(:secondary_preferred, [
+      {"dc" => "ny", "rack" => "a"},
+      {"dc" => "sf", "rack" => "b"},
+      {"db" => "main"}
+    ], [1,2])
+
+    # Test secondary preferred gives primary if no tags match
+    assert_read_pool(:secondary_preferred, [
+      {"dc" => "ny", "rack" => "a"},
+      {"dc" => "sf", "rack" => "b"}
+    ], 0)
+    assert_read_pool(:secondary_preferred, [
+      {"dc" => "ny", "rack" => "a"},
+      {"dc" => "sf", "rack" => "b"},
+      {"dc" => "ny", "rack" => "b"},
+    ], 1)
+
+    # Basic nearest test
+    assert_read_pool(:nearest, [
+      {"dc" => "ny", "rack" => "a"},
+      {"dc" => "sf", "rack" => "b"},
+      {"db" => "main"}
+    ], [0,1,2])
+  end
+
+  def test_nearest
+    # Test refresh happens on connection after interval has passed
+    conn = make_connection(
+      :read => :secondary_preferred,
+      :refresh_mode => :sync,
+      :refresh_interval => 1,
+      :secondary_acceptable_latency_ms => 10
+    )
+    pools = conn.manager.pools
+
+    # Connection should select node with 110 ping every time
+    set_pings(pools, [100,110,130])
+    sleep(2)
+
+    assert conn.read_pool == pools[1]
+
+    # Connection should select node with 100 ping every time
+    set_pings(pools, [100,120,100])
+    sleep(2)
+
+    assert conn.read_pool == pools[2]
+  end
+
+  def test_tags_and_nearest
+    return true if @rs.version < "2.1"
+
+    # Test connection's read pool matches tags
+    assert_read_pool(:secondary_preferred, {"dc" => "sf"}, 2, [100,110,130])
+
+    # Test connection's read pool picks near pool (both match tags)
+    assert_read_pool(:secondary_preferred, {"db" => "main"}, 1, [100,110,130])
+    assert_read_pool(:secondary_preferred, {"db" => "main"}, 2, [100,130,110])
+    assert_read_pool(:secondary_preferred, {"db" => "fake"}, 0, [100,130,110])
+  end
+
+  private
+
+  def set_pings(pools, pings)
+    pools.sort! { |a,b| a.port <=> b.port }
+    pools.each_with_index do |pool, index|
+      pool.stubs(:ping_time).returns(pings[index])
+    end
+  end
+
+  def make_connection(opts = {})
+    ReplSetConnection.new(build_seeds(3), opts)
+  end
+
+  def assert_read_pool(mode=:primary, tags=[], node_nums=[0], pings=[], latency=10)
+    if pings.empty?
+      conn = make_connection({:read => mode, :tag_sets => tags})
+    else
+      conn = make_connection({
+        :read => mode,
+        :tag_sets => tags,
+        :refresh_mode => :sync,
+        :refresh_interval => 1,
+        :secondary_acceptable_latency_ms => latency
+      })
+
+      set_pings(conn.manager.pools, pings)
+      sleep(2)
+    end
+
+    assert conn[MONGO_TEST_DB]['test-sets'].find_one
+
+    target_ports = [*node_nums].collect {|num| @rs.ports[num]}
+
+    assert target_ports.member?(conn.read_pool.port)
+  end
+
+  def assert_fail_pool(mode=:primary, tags={})
+    assert_raise_error ConnectionFailure, "No replica set member available for query " +
+      "with read preference matching mode #{mode} and tags matching #{tags}." do
+      make_connection({:read => mode, :tag_sets => tags}).read_pool
+    end
+  end
+end

data/test/replica_sets/connect_test.rb

@@ -3,12 +3,22 @@ require './test/replica_sets/rs_test_helper'
 
 class ConnectTest < Test::Unit::TestCase
   def setup
+    @old_mongodb_uri = ENV['MONGODB_URI']
     ensure_rs
   end
 
   def teardown
     @rs.restart_killed_nodes
     @conn.close if defined?(@conn) && @conn
+    ENV['MONGODB_URI'] = @old_mongodb_uri
+  end
+
+  def step_down_command
+    # Adding force=true to avoid 'no secondaries within 10 seconds of my optime' errors
+    step_down_command = BSON::OrderedHash.new
+    step_down_command[:replSetStepDown] = 60
+    step_down_command[:force]           = true
+    step_down_command
   end
 
   # TODO: test connect timeout.
@@ -27,21 +37,6 @@ class ConnectTest < Test::Unit::TestCase
     end
   end
 
-  def test_connect_with_primary_node_killed
-    @rs.kill_primary
-
-    # Becuase we're killing the primary and trying to connect right away,
-    # this is going to fail right away.
-    assert_raise_error(ConnectionFailure, "Failed to connect to primary node") do
-      @conn = ReplSetConnection.new build_seeds(3)
-    end
-
-    # This allows the secondary to come up as a primary
-    rescue_connection_failure do
-      @conn = ReplSetConnection.new build_seeds(3)
-    end
-  end
-
   def test_connect_with_secondary_node_killed
     @rs.kill_secondary
 
@@ -67,13 +62,9 @@ class ConnectTest < Test::Unit::TestCase
 
     primary = Mongo::Connection.new(@conn.primary_pool.host, @conn.primary_pool.port)
     assert_raise Mongo::ConnectionFailure do
-      primary['admin'].command({:replSetStepDown => 60})
+      primary['admin'].command(step_down_command)
     end
     assert @conn.connected?
-    assert_raise Mongo::ConnectionFailure do
-      @conn[MONGO_TEST_DB]['bar'].find_one
-    end
-    assert !@conn.connected?
 
     rescue_connection_failure do
       @conn[MONGO_TEST_DB]['bar'].find_one
@@ -84,11 +75,6 @@ class ConnectTest < Test::Unit::TestCase
     @conn = ReplSetConnection.new build_seeds(3)
 
     primary = Mongo::Connection.new(@conn.primary_pool.host, @conn.primary_pool.port)
-
-    # Adding force=true to avoid 'no secondaries within 10 seconds of my optime' errors
-    step_down_command = BSON::OrderedHash.new
-    step_down_command[:replSetStepDown] = 60
-    step_down_command[:force]           = true
     assert_raise Mongo::ConnectionFailure do
       primary['admin'].command(step_down_command)
     end
@@ -99,39 +85,34 @@ class ConnectTest < Test::Unit::TestCase
   end
 
   def test_connect_with_connection_string
-    silently do
-      @conn = Connection.from_uri("mongodb://#{@rs.host}:#{@rs.ports[0]},#{@rs.host}:#{@rs.ports[1]}?replicaset=#{@rs.name}")
-    end
+    @conn = Connection.from_uri("mongodb://#{@rs.host}:#{@rs.ports[0]},#{@rs.host}:#{@rs.ports[1]}?replicaset=#{@rs.name}")
     assert @conn.is_a?(ReplSetConnection)
     assert @conn.connected?
   end
 
   def test_connect_with_connection_string_in_env_var
-    begin
-      old_mongodb_uri = ENV['MONGODB_URI']
-      ENV['MONGODB_URI'] = "mongodb://#{@rs.host}:#{@rs.ports[0]},#{@rs.host}:#{@rs.ports[1]}?replicaset=#{@rs.name}"
-      silently do
-        @conn = ReplSetConnection.new
-      end
-      assert @conn.is_a?(ReplSetConnection)
-      assert @conn.connected?
-    ensure
-      ENV['MONGODB_URI'] = old_mongodb_uri
-    end
+    ENV['MONGODB_URI'] = "mongodb://#{@rs.host}:#{@rs.ports[0]},#{@rs.host}:#{@rs.ports[1]}?replicaset=#{@rs.name}"
+    @conn = ReplSetConnection.new
+    assert @conn.is_a?(ReplSetConnection)
+    assert_equal 2, @conn.seeds.length
+    assert_equal @rs.host, @conn.seeds[0][0]
+    assert_equal @rs.host, @conn.seeds[1][0]
+    assert_equal @rs.ports[0], @conn.seeds[0][1]
+    assert_equal @rs.ports[1], @conn.seeds[1][1]
+    assert @conn.connected?
   end
 
   def test_connect_with_connection_string_in_implicit_mongodb_uri
-    begin
-      old_mongodb_uri = ENV['MONGODB_URI']
-      ENV['MONGODB_URI'] = "mongodb://#{@rs.host}:#{@rs.ports[0]},#{@rs.host}:#{@rs.ports[1]}?replicaset=#{@rs.name}"
-      silently do
-        @conn = Connection.from_uri
-      end
-      assert @conn.is_a?(ReplSetConnection)
-      assert @conn.connected?
-    ensure
-      ENV['MONGODB_URI'] = old_mongodb_uri
-    end
+    ENV['MONGODB_URI'] = "mongodb://#{@rs.host}:#{@rs.ports[0]},#{@rs.host}:#{@rs.ports[1]}?replicaset=#{@rs.name}"
+    @conn = Connection.from_uri
+    assert @conn.is_a?(ReplSetConnection)
+    assert_equal 2, @conn.seeds.length
+    assert_equal @rs.host, @conn.seeds[0][0]
+    assert_equal @rs.host, @conn.seeds[1][0]
+    assert_equal @rs.ports[0], @conn.seeds[0][1]
+    assert_equal @rs.ports[1], @conn.seeds[1][1]
+    assert_equal @rs.name, @conn.replica_set_name
+    assert @conn.connected?
   end
   
   def test_connect_with_new_seed_format
@@ -147,9 +128,7 @@ class ConnectTest < Test::Unit::TestCase
   end
 
   def test_connect_with_full_connection_string
-    silently do
-      @conn = Connection.from_uri("mongodb://#{@rs.host}:#{@rs.ports[0]},#{@rs.host}:#{@rs.ports[1]}?replicaset=#{@rs.name};safe=true;w=2;fsync=true;slaveok=true")
-    end
+    @conn = Connection.from_uri("mongodb://#{@rs.host}:#{@rs.ports[0]},#{@rs.host}:#{@rs.ports[1]}?replicaset=#{@rs.name};safe=true;w=2;fsync=true;slaveok=true")
     assert @conn.is_a?(ReplSetConnection)
     assert @conn.connected?
     assert_equal 2, @conn.safe[:w]
@@ -158,19 +137,20 @@ class ConnectTest < Test::Unit::TestCase
   end
 
   def test_connect_with_full_connection_string_in_env_var
-    begin
-      old_mongodb_uri = ENV['MONGODB_URI']
-      ENV['MONGODB_URI'] = "mongodb://#{@rs.host}:#{@rs.ports[0]},#{@rs.host}:#{@rs.ports[1]}?replicaset=#{@rs.name};safe=true;w=2;fsync=true;slaveok=true"
-      silently do
-        @conn = ReplSetConnection.new
-      end
-      assert @conn.is_a?(ReplSetConnection)
-      assert @conn.connected?
-      assert_equal 2, @conn.safe[:w]
-      assert @conn.safe[:fsync]
-      assert @conn.read_pool
-    ensure
-      ENV['MONGODB_URI'] = old_mongodb_uri
-    end
+    ENV['MONGODB_URI'] = "mongodb://#{@rs.host}:#{@rs.ports[0]},#{@rs.host}:#{@rs.ports[1]}?replicaset=#{@rs.name};safe=true;w=2;fsync=true;slaveok=true"
+    @conn = ReplSetConnection.new
+    assert @conn.is_a?(ReplSetConnection)
+    assert @conn.connected?
+    assert_equal 2, @conn.safe[:w]
+    assert @conn.safe[:fsync]
+    assert @conn.read_pool
+  end
+
+  def test_connect_options_override_env_var
+    ENV['MONGODB_URI'] = "mongodb://#{@rs.host}:#{@rs.ports[0]},#{@rs.host}:#{@rs.ports[1]}?replicaset=#{@rs.name};safe=true;w=2;fsync=true;slaveok=true"
+    @conn = ReplSetConnection.new({:safe => false})
+    assert @conn.is_a?(ReplSetConnection)
+    assert @conn.connected?
+    assert_equal @conn.safe, false
   end
 end