mongo 1.8.0 → 1.8.2

data/test/unit/client_test.rb

@@ -2,7 +2,7 @@ require 'test_helper'
 include Mongo
 
 class ClientTest < Test::Unit::TestCase
-  context "Mongo::MongoClient intialization " do
+  context "Mongo::MongoClient initialization " do
     context "given a single node" do
       setup do
         @client = MongoClient.new('localhost', 27017, :connect => false)
@@ -31,12 +31,12 @@ class ClientTest < Test::Unit::TestCase
         assert !@client.slave_ok?
       end
 
-      should "raise exception for invalid host or port" do
-        assert_raise MongoArgumentError do
-          MongoClient.new(:w => 1)
+      should "not raise error if no host or port is supplied" do
+        assert_nothing_raised do
+          MongoClient.new(:w => 1, :connect => false)
         end
-        assert_raise MongoArgumentError do
-          MongoClient.new('localhost', :w => 1)
+        assert_nothing_raised do
+          MongoClient.new('localhost', :w => 1, :connect=> false)
         end
       end
 
@@ -67,25 +67,47 @@ class ClientTest < Test::Unit::TestCase
           args = [['localhost:27017'], opts]
           client.send(:initialize, *args)
         end
+
+        should "throw error if superflous arguments are specified" do
+          assert_raise MongoArgumentError do
+            MongoReplicaSetClient.new(['localhost:27017'], ['localhost:27018'], {:connect => false})
+          end
+        end
+      end
+    end
+
+    context "initializing with a unix socket" do
+      setup do
+          @connection = Mongo::Connection.new('/tmp/mongod.sock', :safe => true, :connect => false)
+          UNIXSocket.stubs(:new).returns(new_mock_unix_socket)
+      end
+      should "parse a unix socket" do
+          assert_equal "/tmp/mongod.sock", @connection.host_port.first
       end
     end
 
     context "initializing with a mongodb uri" do
       should "parse a simple uri" do
         @client = MongoClient.from_uri("mongodb://localhost", :connect => false)
-        assert_equal ['localhost', 27017], @client.host_to_try
+        assert_equal ['localhost', 27017], @client.host_port
       end
 
+      #should "parse a unix socket" do
+      #  socket_address = "/tmp/mongodb-27017.sock"
+      #  @client = MongoClient.from_uri("mongodb://#{socket_address}")
+      #  assert_equal socket_address, @client.host_port.first
+      #end
+
       should "allow a complex host names" do
         host_name = "foo.bar-12345.org"
         @client = MongoClient.from_uri("mongodb://#{host_name}", :connect => false)
-        assert_equal [host_name, 27017], @client.host_to_try
+        assert_equal [host_name, 27017], @client.host_port
       end
 
       should "allow db without username and password" do
         host_name = "foo.bar-12345.org"
         @client = MongoClient.from_uri("mongodb://#{host_name}/foo", :connect => false)
-        assert_equal [host_name, 27017], @client.host_to_try
+        assert_equal [host_name, 27017], @client.host_port
       end
 
       should "set write concern options on connection" do
@@ -105,7 +127,7 @@ class ClientTest < Test::Unit::TestCase
 
       should "parse a uri with a hyphen & underscore in the username or password" do
         @client = MongoClient.from_uri("mongodb://hyphen-user_name:p-s_s@localhost:27017/db", :connect => false)
-        assert_equal ['localhost', 27017], @client.host_to_try
+        assert_equal ['localhost', 27017], @client.host_port
         auth_hash = { 'db_name' => 'db', 'username' => 'hyphen-user_name', "password" => 'p-s_s' }
         assert_equal auth_hash, @client.auths[0]
       end
@@ -151,21 +173,21 @@ class ClientTest < Test::Unit::TestCase
       should "parse a simple uri" do
         ENV['MONGODB_URI'] = "mongodb://localhost?connect=false"
         @client = MongoClient.new
-        assert_equal ['localhost', 27017], @client.host_to_try
+        assert_equal ['localhost', 27017], @client.host_port
       end
 
       should "allow a complex host names" do
         host_name = "foo.bar-12345.org"
         ENV['MONGODB_URI'] = "mongodb://#{host_name}?connect=false"
         @client = MongoClient.new
-        assert_equal [host_name, 27017], @client.host_to_try
+        assert_equal [host_name, 27017], @client.host_port
       end
 
       should "allow db without username and password" do
         host_name = "foo.bar-12345.org"
         ENV['MONGODB_URI'] = "mongodb://#{host_name}/foo?connect=false"
         @client = MongoClient.new
-        assert_equal [host_name, 27017], @client.host_to_try
+        assert_equal [host_name, 27017], @client.host_port
       end
 
       should "set write concern options on connection" do
@@ -188,7 +210,7 @@ class ClientTest < Test::Unit::TestCase
       should "parse a uri with a hyphen & underscore in the username or password" do
         ENV['MONGODB_URI'] = "mongodb://hyphen-user_name:p-s_s@localhost:27017/db?connect=false"
         @client = MongoClient.new
-        assert_equal ['localhost', 27017], @client.host_to_try
+        assert_equal ['localhost', 27017], @client.host_port
         auth_hash = { 'db_name' => 'db', 'username' => 'hyphen-user_name', "password" => 'p-s_s' }
         assert_equal auth_hash, @client.auths[0]
       end

data/test/unit/collection_test.rb

@@ -140,6 +140,29 @@ class CollectionTest < Test::Unit::TestCase
       @coll.ensure_index [["x", Mongo::DESCENDING], ["y", Mongo::DESCENDING]]
     end
 
+    should "call generate_indexes for each key when calling ensure_indexes with a hash" do
+      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
+      @db   = @client['testing']
+      @db.cache_time = 300
+      @coll = @db.collection('books')
+      oh = BSON::OrderedHash.new
+      oh['x'] = Mongo::DESCENDING
+      oh['y'] = Mongo::DESCENDING
+      @coll.expects(:generate_indexes).once.with do |a, b, c|
+        a == oh
+      end
+
+      if RUBY_VERSION > '1.9'
+          @coll.ensure_index({"x" => Mongo::DESCENDING, "y" => Mongo::DESCENDING})
+      else
+          ordered_hash = BSON::OrderedHash.new
+          ordered_hash['x'] = Mongo::DESCENDING
+          ordered_hash['y'] = Mongo::DESCENDING
+          @coll.ensure_index(ordered_hash)
+      end
+    end
+
+
     should "use the connection's logger" do
       @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
       @db   = @client['testing']

data/test/unit/connection_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 class ConnectionTest < Test::Unit::TestCase
-  context "Mongo::MongoClient intialization " do
+  context "Mongo::MongoClient initialization " do
     context "given a single node" do
       setup do
         @connection = Mongo::Connection.new('localhost', 27017, :safe => true, :connect => false)
@@ -30,12 +30,12 @@ class ConnectionTest < Test::Unit::TestCase
         assert !@connection.slave_ok?
       end
 
-      should "raise exception for invalid host or port" do
-        assert_raise MongoArgumentError do
-          Mongo::Connection.new(:safe => true)
+      should "not raise error if no host or port is supplied" do
+        assert_nothing_raised do
+          Mongo::Connection.new(:safe => true, :connect => false)
         end
-        assert_raise MongoArgumentError do
-          Mongo::Connection.new('localhost', :safe => true)
+        assert_nothing_raised do
+          Mongo::Connection.new('localhost', :safe => true, :connect => false)
         end
       end
 
@@ -70,22 +70,38 @@ class ConnectionTest < Test::Unit::TestCase
       end
     end
 
+    context "initializing with a unix socket" do
+      setup do
+          @connection = Mongo::Connection.new('/tmp/mongod.sock', :safe => true, :connect => false)
+          UNIXSocket.stubs(:new).returns(new_mock_unix_socket)
+      end
+      should "parse a unix socket" do
+          assert_equal "/tmp/mongod.sock", @connection.host_port.first
+      end
+    end
+
     context "initializing with a mongodb uri" do
       should "parse a simple uri" do
         @connection = Mongo::Connection.from_uri("mongodb://localhost", :connect => false)
-        assert_equal ['localhost', 27017], @connection.host_to_try
+        assert_equal ['localhost', 27017], @connection.host_port
       end
 
+      #should "parse a unix socket" do
+      #  socket_address = "/tmp/mongodb-27017.sock"
+      #  @client = MongoClient.from_uri("mongodb://#{socket_address}")
+      #  assert_equal socket_address, @client.host_port.first
+      #end
+
       should "allow a complex host names" do
         host_name = "foo.bar-12345.org"
         @connection = Mongo::Connection.from_uri("mongodb://#{host_name}", :connect => false)
-        assert_equal [host_name, 27017], @connection.host_to_try
+        assert_equal [host_name, 27017], @connection.host_port
       end
 
       should "allow db without username and password" do
         host_name = "foo.bar-12345.org"
         @connection = Mongo::Connection.from_uri("mongodb://#{host_name}/foo", :connect => false)
-        assert_equal [host_name, 27017], @connection.host_to_try
+        assert_equal [host_name, 27017], @connection.host_port
       end
 
       should "set safe options on connection" do
@@ -105,7 +121,7 @@ class ConnectionTest < Test::Unit::TestCase
 
       should "parse a uri with a hyphen & underscore in the username or password" do
         @connection = Mongo::Connection.from_uri("mongodb://hyphen-user_name:p-s_s@localhost:27017/db", :connect => false)
-        assert_equal ['localhost', 27017], @connection.host_to_try
+        assert_equal ['localhost', 27017], @connection.host_port
         auth_hash = { 'db_name' => 'db', 'username' => 'hyphen-user_name', "password" => 'p-s_s' }
         assert_equal auth_hash, @connection.auths[0]
       end
@@ -151,21 +167,21 @@ class ConnectionTest < Test::Unit::TestCase
       should "parse a simple uri" do
         ENV['MONGODB_URI'] = "mongodb://localhost?connect=false"
         @connection = Mongo::Connection.new
-        assert_equal ['localhost', 27017], @connection.host_to_try
+        assert_equal ['localhost', 27017], @connection.host_port
       end
 
       should "allow a complex host names" do
         host_name = "foo.bar-12345.org"
         ENV['MONGODB_URI'] = "mongodb://#{host_name}?connect=false"
         @connection = Mongo::Connection.new
-        assert_equal [host_name, 27017], @connection.host_to_try
+        assert_equal [host_name, 27017], @connection.host_port
       end
 
       should "allow db without username and password" do
         host_name = "foo.bar-12345.org"
         ENV['MONGODB_URI'] = "mongodb://#{host_name}/foo?connect=false"
         @connection = Mongo::Connection.new
-        assert_equal [host_name, 27017], @connection.host_to_try
+        assert_equal [host_name, 27017], @connection.host_port
       end
 
       should "set safe options on connection" do
@@ -188,7 +204,7 @@ class ConnectionTest < Test::Unit::TestCase
       should "parse a uri with a hyphen & underscore in the username or password" do
         ENV['MONGODB_URI'] = "mongodb://hyphen-user_name:p-s_s@localhost:27017/db?connect=false"
         @connection = Mongo::Connection.new
-        assert_equal ['localhost', 27017], @connection.host_to_try
+        assert_equal ['localhost', 27017], @connection.host_port
         auth_hash = { 'db_name' => 'db', 'username' => 'hyphen-user_name', "password" => 'p-s_s' }
         assert_equal auth_hash, @connection.auths[0]
       end

data/test/unit/cursor_test.rb

@@ -1,18 +1,22 @@
 require 'test_helper'
 
 class CursorTest < Test::Unit::TestCase
+  class Mongo::Cursor
+    public :construct_query_spec
+  end
+
   context "Cursor options" do
     setup do
       @logger     = mock()
       @logger.stubs(:debug)
       @connection = stub(:class => MongoClient, :logger => @logger,
-        :slave_ok? => false, :read_preference => :primary, :log_duration => false,
-        :tag_sets => {}, :acceptable_latency => 10)
+        :slave_ok? => false, :read => :primary, :log_duration => false,
+        :tag_sets => [], :acceptable_latency => 10)
       @db         = stub(:name => "testing", :slave_ok? => false,
-        :connection => @connection, :read_preference => :primary,
-        :tag_sets => {}, :acceptable_latency => 10)
-      @collection = stub(:db => @db, :name => "items", :read_preference => :primary,
-        :tag_sets => {}, :acceptable_latency => 10)
+        :connection => @connection, :read => :primary,
+        :tag_sets => [], :acceptable_latency => 10)
+      @collection = stub(:db => @db, :name => "items", :read => :primary,
+        :tag_sets => [], :acceptable_latency => 10)
       @cursor     = Cursor.new(@collection)
     end
 
@@ -107,6 +111,105 @@ class CursorTest < Test::Unit::TestCase
       @cursor.batch_size(100)
       assert_equal 100, @cursor.batch_size
     end
+
+    context "conected to mongos" do
+      setup do
+        @connection.stubs(:mongos?).returns(true)
+        @tag_sets = [{:dc => "ny"}]
+      end
+
+      should "set $readPreference" do
+        # secondary
+        cursor = Cursor.new(@collection, { :read => :secondary })
+
+        spec = cursor.construct_query_spec
+        assert spec.has_key?('$readPreference')
+        assert_equal :secondary, spec['$readPreference'][:mode]
+        assert !spec['$readPreference'].has_key?(:tags)
+
+        # secondary preferred with tags
+        cursor = Cursor.new(@collection, { :read => :secondary_preferred, :tag_sets => @tag_sets })
+
+        spec = cursor.construct_query_spec
+        assert spec.has_key?('$readPreference')
+        assert_equal :secondaryPreferred, spec['$readPreference'][:mode]
+        assert_equal @tag_sets, spec['$readPreference'][:tags]
+
+        # primary preferred
+        cursor = Cursor.new(@collection, { :read => :primary_preferred })
+
+        spec = cursor.construct_query_spec
+        assert spec.has_key?('$readPreference')
+        assert_equal :primaryPreferred, spec['$readPreference'][:mode]
+        assert !spec['$readPreference'].has_key?(:tags)
+
+        # primary preferred with tags
+        cursor = Cursor.new(@collection, { :read => :primary_preferred, :tag_sets => @tag_sets })
+
+        spec = cursor.construct_query_spec
+        assert spec.has_key?('$readPreference')
+        assert_equal :primaryPreferred, spec['$readPreference'][:mode]
+        assert_equal @tag_sets, spec['$readPreference'][:tags]
+
+        # nearest
+        cursor = Cursor.new(@collection, { :read => :nearest })
+
+        spec = cursor.construct_query_spec
+        assert spec.has_key?('$readPreference')
+        assert_equal :nearest, spec['$readPreference'][:mode]
+        assert !spec['$readPreference'].has_key?(:tags)
+
+        # nearest with tags
+        cursor = Cursor.new(@collection, { :read => :nearest, :tag_sets => @tag_sets })
+
+        spec = cursor.construct_query_spec
+        assert spec.has_key?('$readPreference')
+        assert_equal :nearest, spec['$readPreference'][:mode]
+        assert_equal @tag_sets, spec['$readPreference'][:tags]
+      end
+
+      should "not set $readPreference" do
+        # for primary
+        cursor = Cursor.new(@collection, { :read => :primary, :tag_sets => @tag_sets })
+        assert !cursor.construct_query_spec.has_key?('$readPreference')
+
+        # for secondary_preferred with no tags
+        cursor = Cursor.new(@collection, { :read => :secondary_preferred })
+        assert !cursor.construct_query_spec.has_key?('$readPreference')
+
+        cursor = Cursor.new(@collection, { :read => :secondary_preferred, :tag_sets => [] })
+        assert !cursor.construct_query_spec.has_key?('$readPreference')
+
+        cursor = Cursor.new(@collection, { :read => :secondary_preferred, :tag_sets => nil })
+        assert !cursor.construct_query_spec.has_key?('$readPreference')
+      end
+    end
+
+    context "not conected to mongos" do
+      setup do
+        @connection.stubs(:mongos?).returns(false)
+      end
+
+      should "not set $readPreference" do
+        cursor = Cursor.new(@collection, { :read => :primary })
+        assert !cursor.construct_query_spec.has_key?('$readPreference')
+
+        cursor = Cursor.new(@collection, { :read => :primary_preferred })
+        assert !cursor.construct_query_spec.has_key?('$readPreference')
+
+        cursor = Cursor.new(@collection, { :read => :secondary })
+        assert !cursor.construct_query_spec.has_key?('$readPreference')
+
+        cursor = Cursor.new(@collection, { :read => :secondary_preferred })
+        assert !cursor.construct_query_spec.has_key?('$readPreference')
+
+        cursor = Cursor.new(@collection, { :read => :nearest })
+        assert !cursor.construct_query_spec.has_key?('$readPreference')
+
+        cursor = Cursor.new(@collection, { :read => :secondary , :tag_sets => @tag_sets})
+        assert !cursor.construct_query_spec.has_key?('$readPreference')
+      end
+    end
   end
 
   context "Query fields" do
@@ -117,7 +220,7 @@ class CursorTest < Test::Unit::TestCase
         :log_duration => false, :tag_sets =>{}, :acceptable_latency => 10)
       @db = stub(:slave_ok? => true, :name => "testing", :connection => @connection,
         :tag_sets => {}, :acceptable_latency => 10)
-      @collection = stub(:db => @db, :name => "items", :read_preference => :primary,
+      @collection = stub(:db => @db, :name => "items", :read => :primary,
         :tag_sets => {}, :acceptable_latency => 10)
     end
 
@@ -140,4 +243,31 @@ class CursorTest < Test::Unit::TestCase
       assert_nil @cursor.fields
     end
   end
+
+  context "counts" do
+    setup do
+      @logger     = mock()
+      @logger.stubs(:debug)
+      @connection = stub(:class => Connection, :logger => @logger,
+        :slave_ok? => false, :read => :primary, :log_duration => false,
+        :tag_sets => {}, :acceptable_latency => 10)
+      @db         = stub(:name => "testing", :slave_ok? => false,
+        :connection => @connection, :read => :primary,
+        :tag_sets => {}, :acceptable_latency => 10)
+      @collection = stub(:db => @db, :name => "items", :read => :primary,
+        :tag_sets => {}, :acceptable_latency => 10)
+      @cursor     = Cursor.new(@collection)
+    end
+
+    should "pass the comment parameter" do
+      query = {:field => 7}
+      @db.expects(:command).with({ 'count' => "items",
+                                   'query' => query,
+                                   'fields' => nil},
+                                 { :read => :primary,
+                                   :comment => "my comment"}).
+        returns({'ok' => 1, 'n' => 1})
+      assert_equal(1, Cursor.new(@collection, :selector => query, :comment => 'my comment').count())
+    end
+  end
 end

data/test/unit/db_test.rb

@@ -15,12 +15,12 @@ class DBTest < Test::Unit::TestCase
       setup do
         @client = stub()
         @client.stubs(:write_concern).returns({})
-        @client.stubs(:read_preference)
+        @client.stubs(:read).returns(:primary)
         @client.stubs(:tag_sets)
         @client.stubs(:acceptable_latency)
         @db = DB.new("testing", @client)
         @db.stubs(:safe)
-        @db.stubs(:read_preference)
+        @db.stubs(:read)
         @db.stubs(:tag_sets)
         @db.stubs(:acceptable_latency)
         @collection = mock()
@@ -44,7 +44,8 @@ class DBTest < Test::Unit::TestCase
       should "create the proper cursor" do
         @cursor = mock(:next_document => {"ok" => 1})
         Cursor.expects(:new).with(@collection,
-          :limit => -1, :selector => {:buildinfo => 1}, :socket => nil).returns(@cursor)
+          :limit => -1, :selector => {:buildinfo => 1},
+          :socket => nil, :read => nil, :comment => nil).returns(@cursor)
         command = {:buildinfo => 1}
         @db.command(command, :check_response => true)
       end
@@ -52,13 +53,25 @@ class DBTest < Test::Unit::TestCase
       should "raise an error when the command fails" do
         @cursor = mock(:next_document => {"ok" => 0})
         Cursor.expects(:new).with(@collection,
-          :limit => -1, :selector => {:buildinfo => 1}, :socket => nil).returns(@cursor)
+          :limit => -1, :selector => {:buildinfo => 1},
+          :socket => nil, :read => nil, :comment => nil).returns(@cursor)
         assert_raise OperationFailure do
           command = {:buildinfo => 1}
           @db.command(command, :check_response => true)
         end
       end
 
+      should "pass on the comment" do
+        @cursor = mock(:next_document => {"ok" => 0})
+        Cursor.expects(:new).with(@collection,
+          :limit => -1, :selector => {:buildinfo => 1},
+          :socket => nil, :read => nil, :comment => "my comment").returns(@cursor)
+        assert_raise OperationFailure do
+          command = {:buildinfo => 1}
+          @db.command(command, :check_response => true, :comment => 'my comment')
+        end
+      end
+
       should "raise an error if logging out fails" do
         @db.expects(:command).returns({})
         @client.expects(:pool_size).returns(1)