mongo 1.9.2 → 1.10.0.rc0

data/test/unit/collection_test.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2013 10gen Inc.
+# Copyright (C) 2009-2013 MongoDB, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -14,43 +14,45 @@
 
 require 'test_helper'
 
-class CollectionTest < Test::Unit::TestCase
+module Mongo
+  class Collection
+    attr_reader :operation_writer,
+                :command_writer
+  end
+end
+
+class CollectionUnitTest < Test::Unit::TestCase
 
   context "Basic operations: " do
     setup do
       @logger = mock()
       @logger.stubs(:level => 0)
       @logger.expects(:debug)
+
+      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
+      @db     = @client[TEST_DB]
+      @coll   = @db.collection('collection-unit-test')
     end
 
     should "send update message" do
-      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @client['testing']
-      @coll = @db.collection('books')
       @client.expects(:send_message_with_gle).with do |op, msg, log|
         op == 2001
       end
-      @coll.stubs(:log_operation)
+      @coll.operation_writer.stubs(:log_operation)
       @coll.update({}, {:title => 'Moby Dick'})
     end
 
     should "send insert message" do
-      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @client['testing']
-      @coll = @db.collection('books')
       @client.expects(:send_message_with_gle).with do |op, msg, log|
         op == 2002
       end
-      @coll.expects(:log_operation).with do |name, payload|
-        (name == :insert) && payload[:documents][0][:title].include?('Moby')
+      @coll.operation_writer.expects(:log_operation).with do |name, payload|
+        (name == :insert) && payload[:documents][:title].include?('Moby')
       end
       @coll.insert({:title => 'Moby Dick'})
     end
 
     should "send sort data" do
-      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @client['testing']
-      @coll = @db.collection('books')
       @client.expects(:checkout_reader).returns(new_mock_socket)
       @client.expects(:receive_message).with do |op, msg, log, sock|
         op == 2004
@@ -60,60 +62,48 @@ class CollectionTest < Test::Unit::TestCase
     end
 
     should "not log binary data" do
-      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @client['testing']
-      @coll = @db.collection('books')
       data = BSON::Binary.new(("BINARY " * 1000).unpack("c*"))
       @client.expects(:send_message_with_gle).with do |op, msg, log|
         op == 2002
       end
-      @coll.expects(:log_operation).with do |name, payload|
-        (name == :insert) && payload[:documents][0][:data].inspect.include?('Binary')
+      @coll.operation_writer.expects(:log_operation).with do |name, payload|
+        (name == :insert) && payload[:documents][:data].inspect.include?('Binary')
       end
       @coll.insert({:data => data})
     end
 
     should "send safe update message" do
-      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @client['testing']
-      @coll = @db.collection('books')
       @client.expects(:send_message_with_gle).with do |op, msg, db_name, log|
         op == 2001
       end
-      @coll.expects(:log_operation).with do |name, payload|
-        (name == :update) && payload[:document][:title].include?('Moby')
+      @coll.operation_writer.expects(:log_operation).with do |name, payload|
+        (name == :update) && payload[:documents][:title].include?('Moby')
       end
       @coll.update({}, {:title => 'Moby Dick'})
     end
 
     should "send safe update message with legacy" do
-      @connection = Connection.new('localhost', 27017, :logger => @logger, :safe => true, :connect => false)
-      @db         = @connection['testing']
-      @coll       = @db.collection('books')
-      @connection.expects(:send_message_with_gle).with do |op, msg, db_name, log|
+      connection = Connection.new('localhost', 27017, :safe => true, :connect => false)
+      db         = connection[TEST_DB]
+      coll       = db.collection('collection-unit-test')
+      connection.expects(:send_message_with_gle).with do |op, msg, db_name, log|
         op == 2001
       end
-      @coll.expects(:log_operation).with do |name, payload|
-        (name == :update) && payload[:document][:title].include?('Moby')
+      coll.operation_writer.expects(:log_operation).with do |name, payload|
+        (name == :update) && payload[:documents][:title].include?('Moby')
       end
-      @coll.update({}, {:title => 'Moby Dick'})
+      coll.update({}, {:title => 'Moby Dick'})
     end
 
     should "send safe insert message" do
-      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @client['testing']
-      @coll = @db.collection('books')
       @client.expects(:send_message_with_gle).with do |op, msg, db_name, log|
         op == 2001
       end
-      @coll.stubs(:log_operation)
+      @coll.operation_writer.stubs(:log_operation)
       @coll.update({}, {:title => 'Moby Dick'})
     end
 
     should "not call insert for each ensure_index call" do
-      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @client['testing']
-      @coll = @db.collection('books')
       @coll.expects(:generate_indexes).once
 
       @coll.ensure_index [["x", Mongo::DESCENDING]]
@@ -121,21 +111,15 @@ class CollectionTest < Test::Unit::TestCase
     end
 
     should "call generate_indexes for a new type on the same field for ensure_index" do
-      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @client['testing']
-      @coll = @db.collection('books')
       @coll.expects(:generate_indexes).twice
 
       @coll.ensure_index [["x", Mongo::DESCENDING]]
       @coll.ensure_index [["x", Mongo::ASCENDING]]
-
     end
 
     should "call generate_indexes twice because the cache time is 0 seconds" do
-      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @client['testing']
       @db.cache_time = 0
-      @coll = @db.collection('books')
+      @coll = @db.collection('collection-unit-test')
       @coll.expects(:generate_indexes).twice
 
       @coll.ensure_index [["x", Mongo::DESCENDING]]
@@ -143,10 +127,8 @@ class CollectionTest < Test::Unit::TestCase
     end
 
     should "call generate_indexes for each key when calling ensure_indexes" do
-      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @client['testing']
       @db.cache_time = 300
-      @coll = @db.collection('books')
+      @coll = @db.collection('collection-unit-test')
       @coll.expects(:generate_indexes).once.with do |a, b, c|
         a == {"x"=>-1, "y"=>-1}
       end
@@ -155,10 +137,8 @@ class CollectionTest < Test::Unit::TestCase
     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')
+      @coll = @db.collection('collection-unit-test')
       oh = BSON::OrderedHash.new
       oh['x'] = Mongo::DESCENDING
       oh['y'] = Mongo::DESCENDING
@@ -176,11 +156,7 @@ class CollectionTest < Test::Unit::TestCase
       end
     end
 
-
     should "use the connection's logger" do
-      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @client['testing']
-      @coll = @db.collection('books')
       @logger.expects(:warn).with do |msg|
         msg == "MONGODB [WARNING] test warning"
       end

data/test/unit/connection_test.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2013 10gen Inc.
+# Copyright (C) 2009-2013 MongoDB, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -14,7 +14,7 @@
 
 require 'test_helper'
 
-class ConnectionTest < Test::Unit::TestCase
+class ConnectionUnitTest < Test::Unit::TestCase
   context "Mongo::MongoClient initialization " do
     context "given a single node" do
       setup do
@@ -66,22 +66,6 @@ class ConnectionTest < Test::Unit::TestCase
         connection.send(:initialize, *args)
       end
 
-      context "given a replica set" do
-
-        # 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 unix socket" do
@@ -100,11 +84,19 @@ class ConnectionTest < Test::Unit::TestCase
         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 "set auth source" do
+        @connection = Mongo::Connection.from_uri("mongodb://user:pass@localhost?authSource=foo", :connect => false)
+        assert_equal 'foo', @connection.auths.first[:source]
+      end
+
+      should "set auth mechanism" do
+        @connection = Mongo::Connection.from_uri("mongodb://user@localhost?authMechanism=MONGODB-X509", :connect => false)
+        assert_equal 'MONGODB-X509', @connection.auths.first[:mechanism]
+
+        assert_raise MongoArgumentError do
+          Mongo::Connection.from_uri("mongodb://localhost?authMechanism=INVALID", :connect => false)
+        end
+      end
 
       should "allow a complex host names" do
         host_name = "foo.bar-12345.org"
@@ -136,8 +128,15 @@ 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_port
-        auth_hash = { :db_name => 'db', :username => 'hyphen-user_name', :password => 'p-s_s' }
-        assert_equal auth_hash, @connection.auths[0]
+
+        auth_hash = {
+          :db_name   => 'db',
+          :username  => 'hyphen-user_name',
+          :password  => 'p-s_s',
+          :source    => 'db',
+          :mechanism => Authentication::DEFAULT_MECHANISM
+        }
+        assert_equal auth_hash, @connection.auths.first
       end
 
       should "attempt to connect" do
@@ -160,99 +159,163 @@ class ConnectionTest < Test::Unit::TestCase
         end
       end
 
-      should "require all of username, if password and db are specified" do
+      should "require password if using legacy auth and username present" do
         assert Mongo::Connection.from_uri("mongodb://kyle:jones@localhost/db", :connect => false)
 
         assert_raise MongoArgumentError do
-          Mongo::Connection.from_uri("mongodb://kyle:password@localhost", :connect => false)
+          Mongo::Connection.from_uri("mongodb://kyle:@localhost", :connect => false)
+        end
+
+        assert_raise MongoArgumentError do
+          Mongo::Connection.from_uri("mongodb://kyle@localhost", :connect => false)
         end
       end
     end
 
     context "initializing with ENV['MONGODB_URI']" do
-      setup do
-        @old_mongodb_uri = ENV['MONGODB_URI']
+      should "parse a simple uri" do
+        uri = "mongodb://localhost?connect=false"
+        with_preserved_env_uri(uri) do
+          @connection = Mongo::Connection.new
+          assert_equal ['localhost', 27017], @connection.host_port
+        end
       end
 
-      teardown do
-        ENV['MONGODB_URI'] = @old_mongodb_uri
+      should "set auth source" do
+        uri = "mongodb://user:pass@localhost?authSource=foo&connect=false"
+        with_preserved_env_uri(uri) do
+          @connection = Mongo::Connection.new
+          assert_equal 'foo', @connection.auths.first[:source]
+        end
       end
 
-      should "parse a simple uri" do
-        ENV['MONGODB_URI'] = "mongodb://localhost?connect=false"
-        @connection = Mongo::Connection.new
-        assert_equal ['localhost', 27017], @connection.host_port
+      should "set auth mechanism" do
+        uri = "mongodb://user@localhost?authMechanism=MONGODB-X509&connect=false"
+        with_preserved_env_uri(uri) do
+          @connection = Mongo::Connection.new
+          assert_equal 'MONGODB-X509', @connection.auths.first[:mechanism]
+
+          ENV['MONGODB_URI'] = "mongodb://user@localhost?authMechanism=INVALID&connect=false"
+          assert_raise MongoArgumentError do
+            Mongo::Connection.new
+          end
+        end
       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_port
+        uri = "mongodb://#{host_name}?connect=false"
+        with_preserved_env_uri(uri) do
+          @connection = Mongo::Connection.new
+          assert_equal [host_name, 27017], @connection.host_port
+        end
       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_port
+        uri = "mongodb://#{host_name}/foo?connect=false"
+        with_preserved_env_uri(uri) do
+          @connection = Mongo::Connection.new
+          assert_equal [host_name, 27017], @connection.host_port
+        end
       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}"
-        @connection = Mongo::Connection.new
-        assert_equal({:w => 2, :wtimeout => 1000, :fsync => true, :j => true}, @connection.safe)
+        uri = "mongodb://#{host_name}/foo?#{opts}"
+        with_preserved_env_uri(uri) do
+          @connection = Mongo::Connection.new
+          assert_equal({:w => 2, :wtimeout => 1000, :fsync => true, :j => true}, @connection.safe)
+        end
       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}"
-        @connection = Mongo::Connection.new
-        assert_equal 1, @connection.connect_timeout
-        assert_equal 5, @connection.op_timeout
+        uri = "mongodb://#{host_name}/foo?#{opts}"
+        with_preserved_env_uri(uri) do
+          @connection = Mongo::Connection.new
+          assert_equal 1, @connection.connect_timeout
+          assert_equal 5, @connection.op_timeout
+        end
       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"
-        @connection = Mongo::Connection.new
-        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]
+        uri = "mongodb://hyphen-user_name:p-s_s@localhost:27017/db?connect=false"
+        with_preserved_env_uri(uri) do
+          @connection = Mongo::Connection.new
+          assert_equal ['localhost', 27017], @connection.host_port
+
+          auth_hash = {
+            :db_name   => 'db',
+            :username  => 'hyphen-user_name',
+            :password  => 'p-s_s',
+            :source    => 'db',
+            :mechanism => Authentication::DEFAULT_MECHANISM
+          }
+          assert_equal auth_hash, @connection.auths.first
+        end
       end
 
       should "attempt to connect" do
         TCPSocket.stubs(:new).returns(new_mock_socket)
-        ENV['MONGODB_URI'] = "mongodb://localhost?connect=false" # connect=false ??
-        @connection = Mongo::Connection.new
-
-        admin_db = new_mock_db
-        admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1})
-        @connection.expects(:[]).with('admin').returns(admin_db)
-        @connection.connect
+        uri = "mongodb://localhost?connect=false"
+        with_preserved_env_uri(uri) do
+          @connection = Mongo::Connection.new
+
+          admin_db = new_mock_db
+          admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1})
+          @connection.expects(:[]).with('admin').returns(admin_db)
+          @connection.connect
+        end
       end
 
       should "raise an error on invalid uris" do
-        ENV['MONGODB_URI'] = "mongo://localhost"
-        assert_raise MongoArgumentError do
-          Mongo::Connection.new
+        uri = "mongo://localhost"
+        with_preserved_env_uri(uri) do
+          assert_raise MongoArgumentError do
+            Mongo::Connection.new
+          end
+
+          ENV['MONGODB_URI'] = "mongodb://localhost:abc"
+          assert_raise MongoArgumentError do
+            Mongo::Connection.new
+          end
         end
+      end
 
-        ENV['MONGODB_URI'] = "mongodb://localhost:abc"
-        assert_raise MongoArgumentError do
-          Mongo::Connection.new
+      should "require password if using legacy auth and username present" do
+        uri = "mongodb://kyle:jones@localhost/db?connect=false"
+        with_preserved_env_uri(uri) do
+          assert Mongo::Connection.new
+
+          ENV['MONGODB_URI'] = "mongodb://kyle:@localhost?connect=false"
+          assert_raise MongoArgumentError do
+            Mongo::Connection.new
+          end
+
+          ENV['MONGODB_URI'] = "mongodb://kyle@localhost?connect=false"
+          assert_raise MongoArgumentError do
+            Mongo::Connection.new
+          end
         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 Mongo::Connection.new
+      should "require password if using PLAIN auth and username present" do
+        uri = "mongodb://kyle:jones@localhost/db?connect=false&authMechanism=PLAIN"
+        with_preserved_env_uri(uri) do
+          assert Mongo::Connection.new
 
-        ENV['MONGODB_URI'] = "mongodb://kyle:password@localhost"
-        assert_raise MongoArgumentError do
-          Mongo::Connection.new
+          ENV['MONGODB_URI'] = "mongodb://kyle:@localhost?connect=false&authMechanism=PLAIN"
+          assert_raise MongoArgumentError do
+            Mongo::Connection.new
+          end
+
+          ENV['MONGODB_URI'] = "mongodb://kyle@localhost?connect=false&authMechanism=PLAIN"
+          assert_raise MongoArgumentError do
+            Mongo::Connection.new
+          end
         end
       end
     end