mongo 1.7.1 → 1.8.0

data/test/unit/connection_test.rb

@@ -1,132 +1,140 @@
-require File.expand_path("../../test_helper", __FILE__)
-include Mongo
+require 'test_helper'
 
 class ConnectionTest < Test::Unit::TestCase
-  context "Initialization: " do
+  context "Mongo::MongoClient intialization " do
     context "given a single node" do
       setup do
-        @conn = Connection.new('localhost', 27017, :connect => false)
+        @connection = Mongo::Connection.new('localhost', 27017, :safe => true, :connect => false)
         TCPSocket.stubs(:new).returns(new_mock_socket)
 
         admin_db = new_mock_db
         admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1})
-        @conn.expects(:[]).with('admin').returns(admin_db)
-        @conn.connect
+        @connection.expects(:[]).with('admin').returns(admin_db)
+        @connection.connect
+      end
+
+      should "set safe mode true" do
+        assert_equal true, @connection.safe
       end
 
       should "set localhost and port to master" do
-        assert_equal 'localhost', @conn.primary_pool.host
-        assert_equal 27017, @conn.primary_pool.port
+        assert_equal 'localhost', @connection.primary_pool.host
+        assert_equal 27017, @connection.primary_pool.port
       end
 
       should "set connection pool to 1" do
-        assert_equal 1, @conn.primary_pool.size
+        assert_equal 1, @connection.primary_pool.size
       end
 
       should "default slave_ok to false" do
-        assert !@conn.slave_ok?
+        assert !@connection.slave_ok?
+      end
+
+      should "raise exception for invalid host or port" do
+        assert_raise MongoArgumentError do
+          Mongo::Connection.new(:safe => true)
+        end
+        assert_raise MongoArgumentError do
+          Mongo::Connection.new('localhost', :safe => true)
+        end
       end
 
       should "warn if invalid options are specified" do
-        conn = Connection.allocate
+        connection = Mongo::Connection.allocate
         opts = {:connect => false}
 
-        ReplSetConnection::REPL_SET_OPTS.each do |opt|
-          conn.expects(:warn).with("#{opt} is not a valid option for #{conn.class}")
+        Mongo::ReplSetConnection::REPL_SET_OPTS.each do |opt|
+          connection.expects(:warn).with("#{opt} is not a valid option for #{connection.class}")
           opts[opt] = true
         end
 
         args = ['localhost', 27017, opts]
-        conn.send(:initialize, *args)
+        connection.send(:initialize, *args)
       end
 
       context "given a replica set" do
-        #should "enforce a minimum refresh_interval" do
-        #  @conn = ReplSetConnection.new(['localhost:27017'],
-        #    :connect => false, :refresh_mode => :sync, :refresh_interval => 10)
-        #  assert_equal 60, @conn.refresh_interval
-        #end
-
-        should "warn if invalid options are specified" do
-          conn = ReplSetConnection.allocate
-          opts = {:connect => false}
-
-          Connection::CONNECTION_OPTS.each do |opt|
-            conn.expects(:warn).with("#{opt} is not a valid option for #{conn.class}")
-            opts[opt] = true
-          end
-
-          args = [['localhost:27017'], opts]
-          conn.send(:initialize, *args)
-        end
+
+        # should "warn if invalid options are specified" do
+        #   connection = Mongo::ReplSetConnection.allocate
+        #   opts = {:connect => false}
+
+        #   # Mongo::Connection::CLIENT_ONLY_OPTS.each do |opt|
+        #     connection.expects(:warn).with("#{:slave_ok} is not a valid option for #{connection.class}")
+        #     opts[:slave_ok] = true
+        #   # end
+
+        #   args = [['localhost:27017'], opts]
+        #   connection.send(:initialize, *args)
+        # end
+
       end
     end
 
     context "initializing with a mongodb uri" do
       should "parse a simple uri" do
-        @conn = Connection.from_uri("mongodb://localhost", :connect => false)
-        assert_equal ['localhost', 27017], @conn.host_to_try
+        @connection = Mongo::Connection.from_uri("mongodb://localhost", :connect => false)
+        assert_equal ['localhost', 27017], @connection.host_to_try
       end
 
       should "allow a complex host names" do
         host_name = "foo.bar-12345.org"
-        @conn = Connection.from_uri("mongodb://#{host_name}", :connect => false)
-        assert_equal [host_name, 27017], @conn.host_to_try
+        @connection = Mongo::Connection.from_uri("mongodb://#{host_name}", :connect => false)
+        assert_equal [host_name, 27017], @connection.host_to_try
       end
 
       should "allow db without username and password" do
         host_name = "foo.bar-12345.org"
-        @conn = Connection.from_uri("mongodb://#{host_name}/foo", :connect => false)
-        assert_equal [host_name, 27017], @conn.host_to_try
+        @connection = Mongo::Connection.from_uri("mongodb://#{host_name}/foo", :connect => false)
+        assert_equal [host_name, 27017], @connection.host_to_try
       end
 
       should "set safe options on connection" do
         host_name = "localhost"
         opts = "safe=true&w=2&wtimeoutMS=1000&fsync=true&journal=true"
-        @conn = Connection.from_uri("mongodb://#{host_name}/foo?#{opts}", :connect => false)
-        assert_equal({:w => 2, :wtimeout => 1000, :fsync => true, :j => true}, @conn.safe)
+        @connection = Mongo::Connection.from_uri("mongodb://#{host_name}/foo?#{opts}", :connect => false)
+        assert_equal({:w => 2, :wtimeout => 1000, :fsync => true, :j => true}, @connection.write_concern)
       end
 
       should "set timeout options on connection" do
         host_name = "localhost"
         opts = "connectTimeoutMS=1000&socketTimeoutMS=5000"
-        @conn = Connection.from_uri("mongodb://#{host_name}/foo?#{opts}", :connect => false)
-        assert_equal 1, @conn.connect_timeout
-        assert_equal 5, @conn.op_timeout
+        @connection = Mongo::Connection.from_uri("mongodb://#{host_name}/foo?#{opts}", :connect => false)
+        assert_equal 1, @connection.connect_timeout
+        assert_equal 5, @connection.op_timeout
       end
 
       should "parse a uri with a hyphen & underscore in the username or password" do
-        @conn = Connection.from_uri("mongodb://hyphen-user_name:p-s_s@localhost:27017/db", :connect => false)
-        assert_equal ['localhost', 27017], @conn.host_to_try
+        @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
         auth_hash = { 'db_name' => 'db', 'username' => 'hyphen-user_name', "password" => 'p-s_s' }
-        assert_equal auth_hash, @conn.auths[0]
+        assert_equal auth_hash, @connection.auths[0]
       end
 
       should "attempt to connect" do
         TCPSocket.stubs(:new).returns(new_mock_socket)
-        @conn = Connection.from_uri("mongodb://localhost", :connect => false)
+        @connection = Mongo::Connection.from_uri("mongodb://localhost", :connect => false)
 
         admin_db = new_mock_db
         admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1})
-        @conn.expects(:[]).with('admin').returns(admin_db)
-        @conn.connect
+        @connection.expects(:[]).with('admin').returns(admin_db)
+        @connection.connect
       end
 
       should "raise an error on invalid uris" do
         assert_raise MongoArgumentError do
-          Connection.from_uri("mongo://localhost", :connect => false)
+          Mongo::Connection.from_uri("mongo://localhost", :connect => false)
         end
 
         assert_raise MongoArgumentError do
-          Connection.from_uri("mongodb://localhost:abc", :connect => false)
+          Mongo::Connection.from_uri("mongodb://localhost:abc", :connect => false)
         end
       end
 
       should "require all of username, if password and db are specified" do
-        assert Connection.from_uri("mongodb://kyle:jones@localhost/db", :connect => false)
+        assert Mongo::Connection.from_uri("mongodb://kyle:jones@localhost/db", :connect => false)
 
         assert_raise MongoArgumentError do
-          Connection.from_uri("mongodb://kyle:password@localhost", :connect => false)
+          Mongo::Connection.from_uri("mongodb://kyle:password@localhost", :connect => false)
         end
       end
     end
@@ -142,79 +150,79 @@ class ConnectionTest < Test::Unit::TestCase
 
       should "parse a simple uri" do
         ENV['MONGODB_URI'] = "mongodb://localhost?connect=false"
-        @conn = Connection.new
-        assert_equal ['localhost', 27017], @conn.host_to_try
+        @connection = Mongo::Connection.new
+        assert_equal ['localhost', 27017], @connection.host_to_try
       end
 
       should "allow a complex host names" do
         host_name = "foo.bar-12345.org"
         ENV['MONGODB_URI'] = "mongodb://#{host_name}?connect=false"
-        @conn = Connection.new
-        assert_equal [host_name, 27017], @conn.host_to_try
+        @connection = Mongo::Connection.new
+        assert_equal [host_name, 27017], @connection.host_to_try
       end
 
       should "allow db without username and password" do
         host_name = "foo.bar-12345.org"
         ENV['MONGODB_URI'] = "mongodb://#{host_name}/foo?connect=false"
-        @conn = Connection.new
-        assert_equal [host_name, 27017], @conn.host_to_try
+        @connection = Mongo::Connection.new
+        assert_equal [host_name, 27017], @connection.host_to_try
       end
 
       should "set safe options on connection" do
         host_name = "localhost"
         opts = "safe=true&w=2&wtimeoutMS=1000&fsync=true&journal=true&connect=false"
         ENV['MONGODB_URI'] = "mongodb://#{host_name}/foo?#{opts}"
-        @conn = Connection.new
-        assert_equal({:w => 2, :wtimeout => 1000, :fsync => true, :j => true}, @conn.safe)
+        @connection = Mongo::Connection.new
+        assert_equal({:w => 2, :wtimeout => 1000, :fsync => true, :j => true}, @connection.safe)
       end
 
       should "set timeout options on connection" do
         host_name = "localhost"
         opts = "connectTimeoutMS=1000&socketTimeoutMS=5000&connect=false"
         ENV['MONGODB_URI'] = "mongodb://#{host_name}/foo?#{opts}"
-        @conn = Connection.new
-        assert_equal 1, @conn.connect_timeout
-        assert_equal 5, @conn.op_timeout
+        @connection = Mongo::Connection.new
+        assert_equal 1, @connection.connect_timeout
+        assert_equal 5, @connection.op_timeout
       end
 
       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"
-        @conn = Connection.new
-        assert_equal ['localhost', 27017], @conn.host_to_try
+        @connection = Mongo::Connection.new
+        assert_equal ['localhost', 27017], @connection.host_to_try
         auth_hash = { 'db_name' => 'db', 'username' => 'hyphen-user_name', "password" => 'p-s_s' }
-        assert_equal auth_hash, @conn.auths[0]
+        assert_equal auth_hash, @connection.auths[0]
       end
 
       should "attempt to connect" do
         TCPSocket.stubs(:new).returns(new_mock_socket)
         ENV['MONGODB_URI'] = "mongodb://localhost?connect=false" # connect=false ??
-        @conn = Connection.new
+        @connection = Mongo::Connection.new
 
         admin_db = new_mock_db
         admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1})
-        @conn.expects(:[]).with('admin').returns(admin_db)
-        @conn.connect
+        @connection.expects(:[]).with('admin').returns(admin_db)
+        @connection.connect
       end
 
       should "raise an error on invalid uris" do
         ENV['MONGODB_URI'] = "mongo://localhost"
         assert_raise MongoArgumentError do
-          Connection.new
+          Mongo::Connection.new
         end
 
         ENV['MONGODB_URI'] = "mongodb://localhost:abc"
         assert_raise MongoArgumentError do
-          Connection.new
+          Mongo::Connection.new
         end
       end
 
       should "require all of username, if password and db are specified" do
         ENV['MONGODB_URI'] = "mongodb://kyle:jones@localhost/db?connect=false"
-        assert Connection.new
+        assert Mongo::Connection.new
 
         ENV['MONGODB_URI'] = "mongodb://kyle:password@localhost"
         assert_raise MongoArgumentError do
-          Connection.new
+          Mongo::Connection.new
         end
       end
     end

data/test/unit/cursor_test.rb

@@ -1,11 +1,11 @@
-require File.expand_path("../../test_helper", __FILE__)
+require 'test_helper'
 
 class CursorTest < Test::Unit::TestCase
   context "Cursor options" do
     setup do
       @logger     = mock()
       @logger.stubs(:debug)
-      @connection = stub(:class => Connection, :logger => @logger,
+      @connection = stub(:class => MongoClient, :logger => @logger,
         :slave_ok? => false, :read_preference => :primary, :log_duration => false,
         :tag_sets => {}, :acceptable_latency => 10)
       @db         = stub(:name => "testing", :slave_ok? => false,
@@ -78,23 +78,31 @@ class CursorTest < Test::Unit::TestCase
       assert_equal "name", @cursor.query_options_hash[:hint]
     end
 
+    should "set comment" do
+      assert_nil @cursor.comment
+
+      @cursor = Cursor.new(@collection, :comment => "comment")
+      assert_equal "comment", @cursor.comment
+      assert_equal "comment", @cursor.query_options_hash[:comment]
+    end
+
     should "cache full collection name" do
       assert_equal "testing.items", @cursor.full_collection_name
     end
-    
+
     should "raise error when batch_size is 1" do
       e = assert_raise ArgumentError do
         @cursor.batch_size(1)
         end
         assert_equal "Invalid value for batch_size 1; must be 0 or > 1.", e.message
     end
-    
+
     should "use the limit for batch size when it's smaller than the specified batch_size" do
       @cursor.limit(99)
       @cursor.batch_size(100)
       assert_equal 99, @cursor.batch_size
       end
-      
+
     should "use the specified batch_size" do
       @cursor.batch_size(100)
       assert_equal 100, @cursor.batch_size
@@ -105,7 +113,7 @@ class CursorTest < Test::Unit::TestCase
     setup do
       @logger     = mock()
       @logger.stubs(:debug)
-      @connection = stub(:class => Connection, :logger => @logger, :slave_ok? => false,
+      @connection = stub(:class => MongoClient, :logger => @logger, :slave_ok? => false,
         :log_duration => false, :tag_sets =>{}, :acceptable_latency => 10)
       @db = stub(:slave_ok? => true, :name => "testing", :connection => @connection,
         :tag_sets => {}, :acceptable_latency => 10)

data/test/unit/db_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path("../../test_helper", __FILE__)
+require 'test_helper'
 
 def insert_message(db, documents)
   documents = [documents] unless documents.is_a?(Array)
@@ -13,12 +13,12 @@ class DBTest < Test::Unit::TestCase
   context "DBTest: " do
     context "DB commands" do
       setup do
-        @conn = stub()
-        @conn.stubs(:safe)
-        @conn.stubs(:read_preference)
-        @conn.stubs(:tag_sets)
-        @conn.stubs(:acceptable_latency)
-        @db   = DB.new("testing", @conn)
+        @client = stub()
+        @client.stubs(:write_concern).returns({})
+        @client.stubs(:read_preference)
+        @client.stubs(:tag_sets)
+        @client.stubs(:acceptable_latency)
+        @db = DB.new("testing", @client)
         @db.stubs(:safe)
         @db.stubs(:read_preference)
         @db.stubs(:tag_sets)
@@ -61,7 +61,7 @@ class DBTest < Test::Unit::TestCase
 
       should "raise an error if logging out fails" do
         @db.expects(:command).returns({})
-        @conn.expects(:pool_size).returns(1)
+        @client.expects(:pool_size).returns(1)
         assert_raise Mongo::MongoDBError do
           @db.logout
         end

data/test/unit/grid_test.rb

@@ -1,15 +1,15 @@
-require File.expand_path("../../test_helper", __FILE__)
+require 'test_helper'
 
 class GridTest < Test::Unit::TestCase
 
   context "GridFS: " do
     setup do
-      @conn   = stub()
-      @conn.stubs(:safe)
-      @conn.stubs(:read_preference)
-      @conn.stubs(:tag_sets)
-      @conn.stubs(:acceptable_latency)
-      @db     = DB.new("testing", @conn)
+      @client   = stub()
+      @client.stubs(:write_concern).returns({})
+      @client.stubs(:read_preference)
+      @client.stubs(:tag_sets)
+      @client.stubs(:acceptable_latency)
+      @db     = DB.new("testing", @client)
       @files  = mock()
       @chunks = mock()
 
@@ -21,8 +21,8 @@ class GridTest < Test::Unit::TestCase
 
     context "Grid classe with standard connections" do
       setup do
-        @conn.expects(:class).returns(Connection)
-        @conn.expects(:read_primary?).returns(true)
+        @client.expects(:class).returns(MongoClient)
+        @client.expects(:read_primary?).returns(true)
       end
 
       should "create indexes for Grid" do
@@ -39,8 +39,8 @@ class GridTest < Test::Unit::TestCase
 
     context "Grid classes with slave connection" do
       setup do
-        @conn.expects(:class).twice.returns(Connection)
-        @conn.expects(:read_primary?).returns(false)
+        @client.expects(:class).twice.returns(MongoClient)
+        @client.expects(:read_primary?).returns(false)
       end
 
       should "not create indexes for Grid" do

data/test/unit/node_test.rb

@@ -1,74 +1,74 @@
-require File.expand_path("../../test_helper", __FILE__)
+require 'test_helper'
 
 class NodeTest < Test::Unit::TestCase
 
   def setup
-    @connection = stub()
+    @client = stub()
   end
 
   should "refuse to connect to node without 'hosts' key" do
     tcp = mock()
-    node = Node.new(@connection, ['localhost', 27017])
+    node = Node.new(@client, ['localhost', 27017])
     tcp.stubs(:new).returns(new_mock_socket)
-    @connection.stubs(:socket_class).returns(tcp)
+    @client.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(:op_timeout).returns(nil)
-    @connection.stubs(:connect_timeout).returns(nil)
-    @connection.expects(:log)
+    @client.stubs(:[]).with('admin').returns(admin_db)
+    @client.stubs(:op_timeout).returns(nil)
+    @client.stubs(:connect_timeout).returns(nil)
+    @client.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])
+    node = Node.new(@client, ['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'])
+    node = Node.new(@client, ['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
+    assert_equal MongoClient::DEFAULT_PORT, node.port
+    assert_equal "power.level.com:#{MongoClient::DEFAULT_PORT}", node.address
   end
 
   should "load a node from a string" do
-    node = Node.new(@connection, 'localhost:1234')
+    node = Node.new(@client, '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')
+    node = Node.new(@client, '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
+    assert_equal MongoClient::DEFAULT_PORT, node.port
+    assert_equal "192.168.0.1:#{MongoClient::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])
+    assert_equal Node.new(@client, '192.168.0.1'),
+      Node.new(@client, ['192.168.0.1', MongoClient::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
+    assert_equal Node.new(@client, '192.168.0.1').hash,
+      Node.new(@client, ['192.168.0.1', MongoClient::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])
+    assert_not_equal Node.new(@client, '192.168.0.2'),
+      Node.new(@client, ['192.168.0.1', MongoClient::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
+    assert_not_equal Node.new(@client, '192.168.0.1').hash,
+      Node.new(@client, '1239.33.4.2393:29949').hash
   end
 
 end