mongo 1.4.0 → 1.5.0.rc0

data/lib/mongo/util/uri_parser.rb

@@ -20,7 +20,7 @@ module Mongo
   class URIParser
 
     DEFAULT_PORT = 27017
-    MONGODB_URI_MATCHER = /(([-.\w]+):([^@]+)@)?([-.\w]+)(:([\w]+))?(\/([-\w]+))?/
+    MONGODB_URI_MATCHER = /(([-.\w:]+):([^@,]+)@)?((?:(?:[-.\w]+)(?::(?:[\w]+))?,?)+)(\/([-\w]+))?/
     MONGODB_URI_SPEC = "mongodb://[username:password@]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/database]"
     SPEC_ATTRS = [:nodes, :auths]
     OPT_ATTRS  = [:connect, :replicaset, :slaveok, :safe, :w, :wtimeout, :fsync]
@@ -108,35 +108,43 @@ module Mongo
 
     private
 
-    def parse_hosts(hosts)
+    def parse_hosts(uri_without_proto)
       @nodes = []
       @auths = []
-      specs = hosts.split(',')
-      specs.each do |spec|
-        matches  = MONGODB_URI_MATCHER.match(spec)
-        if !matches
-          raise MongoArgumentError, "MongoDB URI must match this spec: #{MONGODB_URI_SPEC}"
-        end
 
-        uname = matches[2]
-        pwd   = matches[3]
-        host  = matches[4]
-        port  = matches[6] || DEFAULT_PORT
+      matches = MONGODB_URI_MATCHER.match(uri_without_proto)
+
+      if !matches
+        raise MongoArgumentError, "MongoDB URI must match this spec: #{MONGODB_URI_SPEC}"
+      end
+
+      uname    = matches[2]
+      pwd      = matches[3]
+      hosturis = matches[4].split(',')
+      db       = matches[6]
+
+      hosturis.each do |hosturi|
+        # If port is present, use it, otherwise use default port
+        host, port = hosturi.split(':') + [DEFAULT_PORT]
+
         if !(port.to_s =~ /^\d+$/)
           raise MongoArgumentError, "Invalid port #{port}; port must be specified as digits."
         end
-        port    = port.to_i
-        db      = matches[8]
-
-        if uname && pwd && db
-          auths << {'db_name' => db, 'username' => uname, 'password' => pwd}
-        elsif uname || pwd || db
-          raise MongoArgumentError, "MongoDB URI must include all three of username, password, " +
-            "and db if any one of these is specified."
-        end
+
+        port = port.to_i
 
         @nodes << [host, port]
       end
+
+      if uname && pwd && db
+        auths << {'db_name' => db, 'username' => uname, 'password' => pwd}
+      elsif uname || pwd
+        raise MongoArgumentError, "MongoDB URI must include username, password, "
+          "and db if username and password are specified."
+      end
+
+      # The auths are repeated for each host in a replica set
+      @auths *= hosturis.length
     end
 
     # This method uses the lambdas defined in OPT_VALID and OPT_CONV to validate

data/lib/mongo/version.rb

@@ -1,3 +1,3 @@
 module Mongo
-  VERSION = "1.4.0"
+  VERSION = "1.5.0.rc0"
 end

data/test/bson/binary_test.rb

@@ -2,14 +2,12 @@
 require './test/bson/test_helper'
 
 class BinaryTest < Test::Unit::TestCase
-  context "Inspecting" do
-    setup do
-      @data = ("THIS IS BINARY " * 50).unpack("c*")
-    end
+  def setup
+    @data = ("THIS IS BINARY " * 50).unpack("c*")
+  end
 
-    should "not display actual data" do
-      binary = BSON::Binary.new(@data)
-      assert_equal "<BSON::Binary:#{binary.object_id}>", binary.inspect
-    end
+  def test_do_not_display_binary_data
+    binary = BSON::Binary.new(@data)
+    assert_equal "<BSON::Binary:#{binary.object_id}>", binary.inspect
   end
 end

data/test/bson/bson_test.rb

@@ -9,6 +9,7 @@ end
 require 'bigdecimal'
 
 begin
+  require 'date'
   require 'tzinfo'
   require 'active_support/core_ext'
   Time.zone = "Pacific Time (US & Canada)"

data/test/bson/ordered_hash_test.rb

@@ -212,6 +212,8 @@ class OrderedHashTest < Test::Unit::TestCase
     assert @oh.keys.include?('z')
     @oh.delete_if { |k,v| k == 'z' }
     assert !@oh.keys.include?('z')
+    @oh.delete_if { |k, v| v > 0 }
+    assert @oh.keys.empty?
   end
 
   def test_reject

data/test/bson/test_helper.rb

@@ -10,23 +10,6 @@ def silently
   result
 end
 
-begin
-  require 'rubygems' if RUBY_VERSION < "1.9.0" && !ENV['C_EXT']
-  silently { require 'shoulda' }
-  silently { require 'mocha' }
-rescue LoadError
-  puts <<MSG
-
-This test suite requires shoulda and mocha.
-You can install them as follows:
-  gem install shoulda
-  gem install mocha
-
-MSG
-
-  exit
-end
-
 require 'bson_ext/cbson' if !(RUBY_PLATFORM =~ /java/) && ENV['C_EXT']
 
 class Test::Unit::TestCase

data/test/collection_test.rb

@@ -301,6 +301,7 @@ class TestCollection < Test::Unit::TestCase
     @conn = standard_connection
     @db   = @conn[MONGO_TEST_DB]
     @test = @db['test-safe-remove']
+    @test.remove
     @test.save({:a => 50})
     assert_equal 1, @test.remove({}, :safe => true)["n"]
     @test.drop
@@ -704,6 +705,26 @@ class TestCollection < Test::Unit::TestCase
     coll.ensure_index([['a', 1]])
   end
 
+
+  if @@version > '2.0.0'
+    def test_show_disk_loc
+      @@test.save({:a => 1})
+      @@test.save({:a => 2})
+      assert @@test.find({:a => 1}, :show_disk_loc => true).show_disk_loc
+      assert @@test.find({:a => 1}, :show_disk_loc => true).next['$diskLoc']
+      @@test.remove
+    end
+
+    def test_max_scan
+      1000.times do |n|
+        @@test.save({:a => n})
+      end
+      assert @@test.find({:a => 999}).next
+      assert !@@test.find({:a => 999}, :max_scan => 500).next
+      @@test.remove
+    end
+  end
+
   context "Grouping" do
     setup do
       @@test.remove
@@ -782,6 +803,7 @@ class TestCollection < Test::Unit::TestCase
   context "A collection with two records" do
     setup do
       @collection = @@db.collection('test-collection')
+      @collection.remove
       @collection.insert({:name => "Jones"})
       @collection.insert({:name => "Smith"})
     end

data/test/connection_test.rb

@@ -318,7 +318,7 @@ class TestConnection < Test::Unit::TestCase
       TCPSocket.stubs(:new).returns(fake_socket)
 
       @con.primary_pool.checkout_new_socket
-      assert_equal [], @con.primary_pool.close
+      assert @con.primary_pool.close
     end
   end
 end

data/test/cursor_test.rb

@@ -53,8 +53,8 @@ class CursorTest < Test::Unit::TestCase
   def test_exhaust
     if @@version >= "2.0"
       @@coll.remove
-      data = "1" * 100_000
-      10_000.times do |n|
+      data = "1" * 10_000
+      5000.times do |n|
         @@coll.insert({:n => n, :data => data})
       end
 
@@ -65,7 +65,7 @@ class CursorTest < Test::Unit::TestCase
 
       c = Cursor.new(@@coll)
       c.add_option(OP_QUERY_EXHAUST)
-      9999.times do
+      4999.times do
         c.next
       end
       assert c.has_next?

data/test/load/thin/load.rb

@@ -1,7 +1,7 @@
 require File.join(File.dirname(__FILE__), '..', '..', '..', 'lib', 'mongo')
 require 'logger'
 
-$con = Mongo::Connection.new
+$con = Mongo::ReplSetConnection.new(['localhost', 30000], ['localhost', 30001], :read => :secondary, :refresh_mode => :sync, :refresh_interval => 30)
 $db = $con['foo']
 
 class Load < Sinatra::Base
@@ -13,12 +13,9 @@ class Load < Sinatra::Base
   end
 
   get '/' do
-    3.times do |n|
-      if (v=$db.eval("1 + #{n}")) != 1 + n
-        STDERR << "#{1 + n} expected but got #{v}"
-        raise StandardError, "#{1 + n} expected but got #{v}"
-      end
-    end
+    $db['test'].insert({:a => rand(1000)})
+    $db['test'].find({:a => {'$gt' => rand(2)}}, :read => :secondary).limit(2).to_a
+    "ok"
   end
 
 end

data/test/replica_sets/basic_test.rb

@@ -0,0 +1,46 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require './test/replica_sets/rs_test_helper'
+
+class BasicTest < Test::Unit::TestCase
+  include ReplicaSetTest
+
+  def teardown
+    self.rs.restart_killed_nodes
+    @conn.close if defined?(@conn) && @conn
+  end
+
+  def test_connect
+    @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[1]], [self.rs.host, self.rs.ports[0]],
+      [self.rs.host, self.rs.ports[2]], :name => self.rs.name)
+    assert @conn.connected?
+
+    assert_equal self.rs.primary, @conn.primary
+    assert_equal self.rs.secondaries.sort, @conn.secondaries.sort
+    assert_equal self.rs.arbiters.sort, @conn.arbiters.sort
+
+    @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[1]], [self.rs.host, self.rs.ports[0]],
+      :name => self.rs.name)
+    assert @conn.connected?
+  end
+
+  def test_accessors
+    seeds = [[self.rs.host, self.rs.ports[0]], [self.rs.host, self.rs.ports[1]],
+      [self.rs.host, self.rs.ports[2]]]
+    args = seeds << {:name => self.rs.name}
+    @conn = ReplSetConnection.new(*args)
+
+    assert_equal @conn.host, self.rs.primary[0]
+    assert_equal @conn.port, self.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 self.rs.name, @conn.replica_set_name
+    assert @conn.secondary_pools.include?(@conn.read_pool)
+    assert_equal 5, @conn.tag_map.keys.length
+    assert_equal 90, @conn.refresh_interval
+    assert_equal @conn.refresh_mode, false
+  end
+end

data/test/replica_sets/connect_test.rb

@@ -1,111 +1,88 @@
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require './test/replica_sets/rs_test_helper'
 
-# NOTE: This test expects a replica set of three nodes to be running on RS.host,
-# on ports TEST_PORT, RS.ports[1], and TEST + 2.
 class ConnectTest < Test::Unit::TestCase
-  include Mongo
+  include ReplicaSetTest
 
   def teardown
-    RS.restart_killed_nodes
+    self.rs.restart_killed_nodes
     @conn.close if defined?(@conn) && @conn
   end
 
+  # TODO: test connect timeout.
+
   def test_connect_with_deprecated_multi
-    @conn = Connection.multi([[RS.host, RS.ports[0]], [RS.host, RS.ports[1]]], :name => RS.name)
+    @conn = Connection.multi([[self.rs.host, self.rs.ports[0]], [self.rs.host, self.rs.ports[1]]], :name => self.rs.name)
     assert @conn.is_a?(ReplSetConnection)
     assert @conn.connected?
   end
 
   def test_connect_bad_name
     assert_raise_error(ReplicaSetConnectionError, "-wrong") do
-      @conn = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
-        [RS.host, RS.ports[2]], :name => RS.name + "-wrong")
+      @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]], [self.rs.host, self.rs.ports[1]],
+        [self.rs.host, self.rs.ports[2]], :name => self.rs.name + "-wrong")
     end
   end
 
- # def test_connect_timeout
- #   passed = false
- #   timeout = 3
- #   begin
- #     t0 = Time.now
- #     @conn = ReplSetConnection.new(['192.169.169.1', 27017], :connect_timeout => timeout)
- #   rescue OperationTimeout
- #     passed = true
- #     t1 = Time.now
- #   end
-
- #   assert passed
- #   assert t1 - t0 < timeout + 1
- # end
-
-  def test_connect
-    @conn = ReplSetConnection.new([RS.host, RS.ports[1]], [RS.host, RS.ports[0]],
-      [RS.host, RS.ports[2]], :name => RS.name)
-    assert @conn.connected?
-
-    assert_equal RS.primary, @conn.primary
-    assert_equal RS.secondaries.sort, @conn.secondaries.sort
-    assert_equal RS.arbiters.sort, @conn.arbiters.sort
-
-    @conn = ReplSetConnection.new([RS.host, RS.ports[1]], [RS.host, RS.ports[0]],
-      :name => RS.name)
-    assert @conn.connected?
-  end
-
-  def test_host_port_accessors
-    @conn = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
-      [RS.host, RS.ports[2]], :name => RS.name)
-
-    assert_equal @conn.host, RS.primary[0]
-    assert_equal @conn.port, RS.primary[1]
-  end
-
   def test_connect_with_primary_node_killed
-    node = RS.kill_primary
+    node = self.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([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
-        [RS.host, RS.ports[2]])
+      @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]], [self.rs.host, self.rs.ports[1]],
+        [self.rs.host, self.rs.ports[2]])
     end
 
     # This allows the secondary to come up as a primary
     rescue_connection_failure do
-      @conn = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
-        [RS.host, RS.ports[2]])
+      @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]], [self.rs.host, self.rs.ports[1]],
+        [self.rs.host, self.rs.ports[2]])
     end
   end
 
   def test_connect_with_secondary_node_killed
-    node = RS.kill_secondary
+    node = self.rs.kill_secondary
 
     rescue_connection_failure do
-      @conn = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
-        [RS.host, RS.ports[2]])
+      @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]], [self.rs.host, self.rs.ports[1]],
+        [self.rs.host, self.rs.ports[2]])
     end
     assert @conn.connected?
   end
 
   def test_connect_with_third_node_killed
-    RS.kill(RS.get_node_from_port(RS.ports[2]))
+    self.rs.kill(self.rs.get_node_from_port(self.rs.ports[2]))
 
     rescue_connection_failure do
-      @conn = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
-        [RS.host, RS.ports[2]])
+      @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]], [self.rs.host, self.rs.ports[1]],
+        [self.rs.host, self.rs.ports[2]])
     end
     assert @conn.connected?
   end
 
   def test_connect_with_primary_stepped_down
-    RS.step_down_primary
+    self.rs.step_down_primary
 
     rescue_connection_failure do
-      @conn = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
-        [RS.host, RS.ports[2]])
+      @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]], [self.rs.host, self.rs.ports[1]],
+        [self.rs.host, self.rs.ports[2]])
     end
     assert @conn.connected?
   end
 
+  def test_connect_with_connection_string
+    @conn = Connection.from_uri("mongodb://#{self.rs.host}:#{self.rs.ports[0]},#{self.rs.host}:#{self.rs.ports[1]}?replicaset=#{self.rs.name}")
+    assert @conn.is_a?(ReplSetConnection)
+    assert @conn.connected?
+  end
+
+  def test_connect_with_full_connection_string
+    @conn = Connection.from_uri("mongodb://#{self.rs.host}:#{self.rs.ports[0]},#{self.rs.host}:#{self.rs.ports[1]}?replicaset=#{self.rs.name};safe=true;w=2;fsync=true;slaveok=true")
+    assert @conn.is_a?(ReplSetConnection)
+    assert @conn.connected?
+    assert_equal 2, @conn.safe[:w]
+    assert @conn.safe[:fsync]
+    assert @conn.read_pool
+  end
 end

data/test/replica_sets/count_test.rb

@@ -1,20 +1,22 @@
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require './test/replica_sets/rs_test_helper'
 
-# NOTE: This test expects a replica set of three nodes to be running
-# on the local host.
 class ReplicaSetCountTest < Test::Unit::TestCase
-  include Mongo
+  include ReplicaSetTest
 
   def setup
-    @conn = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]], [RS.host, RS.ports[2]])
+    @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]],
+                                  [self.rs.host, self.rs.ports[1]], [self.rs.host, self.rs.ports[2]],
+                                  :read => :secondary)
+    assert @conn.primary_pool
+    @primary = Connection.new(@conn.primary_pool.host, @conn.primary_pool.port)
     @db = @conn.db(MONGO_TEST_DB)
     @db.drop_collection("test-sets")
     @coll = @db.collection("test-sets")
   end
 
   def teardown
-    RS.restart_killed_nodes
+    self.rs.restart_killed_nodes
     @conn.close if @conn
   end
 
@@ -23,7 +25,7 @@ class ReplicaSetCountTest < Test::Unit::TestCase
     assert_equal 1, @coll.count
 
     # Kill the current master node
-    @node = RS.kill_primary
+    @node = self.rs.kill_primary
 
     rescue_connection_failure do
       @coll.insert({:a => 30}, :safe => true)
@@ -33,4 +35,11 @@ class ReplicaSetCountTest < Test::Unit::TestCase
     assert_equal 3, @coll.count, "Second count failed"
   end
 
+  def test_count_command_sent_to_primary
+    @coll.insert({:a => 20}, :safe => {:w => 2, :wtimeout => 10000})
+    count_before = @primary['admin'].command({:serverStatus => 1})['opcounters']['command']
+    assert_equal 1, @coll.count
+    count_after = @primary['admin'].command({:serverStatus => 1})['opcounters']['command']
+    assert_equal 2, count_after - count_before
+  end
 end