mongo 1.12.5 → 2.0.0

data/test/unit/connection_test.rb

@@ -1,335 +0,0 @@
-# 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.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'test_helper'
-
-class ConnectionUnitTest < Test::Unit::TestCase
-  context "Mongo::MongoClient initialization " do
-    context "given a single node" do
-      setup do
-        @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})
-        @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', @connection.primary_pool.host
-        assert_equal 27017, @connection.primary_pool.port
-      end
-
-      should "set connection pool to 1" do
-        assert_equal 1, @connection.primary_pool.size
-      end
-
-      should "default slave_ok to false" do
-        assert !@connection.slave_ok?
-      end
-
-      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_nothing_raised do
-          Mongo::Connection.new('localhost', :safe => true, :connect => false)
-        end
-      end
-
-      should "warn if invalid options are specified" do
-        connection = Mongo::Connection.allocate
-        opts = {:connect => false}
-
-        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]
-        connection.send(:initialize, *args)
-      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 unix socket in uri" do
-      setup do
-          @connection = Mongo::Connection.from_uri("mongodb:///tmp/mongod.sock", :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_port
-      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"
-        @connection = Mongo::Connection.from_uri("mongodb://#{host_name}", :connect => false)
-        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_port
-      end
-
-      should "set safe options on connection" do
-        host_name = "localhost"
-        opts = "safe=true&w=2&wtimeoutMS=1000&fsync=true&journal=true"
-        @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"
-        @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
-        @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',
-          :extra=>{},
-          :username  => 'hyphen-user_name',
-          :password  => 'p-s_s',
-          :source    => 'db',
-          :mechanism => nil
-        }
-        assert_equal auth_hash, @connection.auths.first
-      end
-
-      should "attempt to connect" do
-        TCPSocket.stubs(:new).returns(new_mock_socket)
-        @connection = Mongo::Connection.from_uri("mongodb://localhost", :connect => false)
-
-        admin_db = new_mock_db
-        admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1})
-        @connection.expects(:[]).with('admin').returns(admin_db)
-        @connection.connect
-      end
-
-      should "raise an error on invalid uris" do
-        assert_raise MongoArgumentError do
-          Mongo::Connection.from_uri("mongo://localhost", :connect => false)
-        end
-
-        assert_raise MongoArgumentError do
-          Mongo::Connection.from_uri("mongodb://localhost:abc", :connect => false)
-        end
-      end
-
-      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:@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
-      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
-
-      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 "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"
-        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"
-        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"
-        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"
-        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
-        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',
-            :extra=>{},
-            :username  => 'hyphen-user_name',
-            :password  => 'p-s_s',
-            :source    => 'db',
-            :mechanism => nil
-          }
-          assert_equal auth_hash, @connection.auths.first
-        end
-      end
-
-      should "attempt to connect" do
-        TCPSocket.stubs(:new).returns(new_mock_socket)
-        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
-        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
-
-      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 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:@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
-  end
-end

data/test/unit/cursor_test.rb

@@ -1,307 +0,0 @@
-# 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.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'test_helper'
-
-class CursorUnitTest < 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 => :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 "set timeout" do
-      assert @cursor.timeout
-      assert @cursor.query_options_hash[:timeout]
-    end
-
-    should "set selector" do
-      assert_equal({}, @cursor.selector)
-
-      @cursor = Cursor.new(@collection, :selector => {:name => "Jones"})
-      assert_equal({:name => "Jones"}, @cursor.selector)
-      assert_equal({:name => "Jones"}, @cursor.query_options_hash[:selector])
-    end
-
-    should "set fields" do
-      assert_nil @cursor.fields
-
-      @cursor = Cursor.new(@collection, :fields => [:name, :date])
-      assert_equal({:name => 1, :date => 1}, @cursor.fields)
-      assert_equal({:name => 1, :date => 1}, @cursor.query_options_hash[:fields])
-    end
-
-    should "allow $meta projection operator" do
-      assert_nil @cursor.fields
-
-      @cursor = Cursor.new(@collection, :fields => [{ :score => { :$meta => 'textScore' } }])
-      assert_equal({ :score  => { :$meta => 'textScore' } }, @cursor.fields)
-      assert_equal({ :score  => { :$meta => 'textScore' } }, @cursor.query_options_hash[:fields])
-
-      @cursor = Cursor.new(@collection, :fields => [:name, { :score => { :$meta => 'textScore' } }])
-      assert_equal({ :name => 1, :score => { :$meta => 'textScore' } }, @cursor.fields)
-      assert_equal({ :name => 1, :score => { :$meta => 'textScore' } }, @cursor.query_options_hash[:fields])
-    end
-
-    should "set mix fields 0 and 1" do
-      assert_nil @cursor.fields
-
-      @cursor = Cursor.new(@collection, :fields => {:name => 1, :date => 0})
-      assert_equal({:name => 1, :date => 0}, @cursor.fields)
-      assert_equal({:name => 1, :date => 0}, @cursor.query_options_hash[:fields])
-    end
-
-    should "set limit" do
-      assert_equal 0, @cursor.limit
-
-      @cursor = Cursor.new(@collection, :limit => 10)
-      assert_equal 10, @cursor.limit
-      assert_equal 10, @cursor.query_options_hash[:limit]
-    end
-
-
-    should "set skip" do
-      assert_equal 0, @cursor.skip
-
-      @cursor = Cursor.new(@collection, :skip => 5)
-      assert_equal 5, @cursor.skip
-      assert_equal 5, @cursor.query_options_hash[:skip]
-    end
-
-    should "set sort order" do
-      assert_nil @cursor.order
-
-      @cursor = Cursor.new(@collection, :order => "last_name")
-      assert_equal "last_name", @cursor.order
-      assert_equal "last_name", @cursor.query_options_hash[:order]
-    end
-
-    should "set hint" do
-      assert_nil @cursor.hint
-
-      @cursor = Cursor.new(@collection, :hint => "name")
-      assert_equal "name", @cursor.hint
-      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
-    end
-
-    context 'when an alternate namespace is specified' do
-
-      should 'use the alternate namespace' do
-        cursor = Cursor.new(@collection, :ns => 'other_db.other_collection')
-        assert_equal('other_db.other_collection', cursor.full_collection_name)
-      end
-    end
-
-    context "connected 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 connected 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
-    setup do
-      @logger     = mock()
-      @logger.stubs(:debug)
-      @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)
-      @collection = stub(:db => @db, :name => "items", :read => :primary,
-        :tag_sets => {}, :acceptable_latency => 10)
-    end
-
-    should "when an array should return a hash with each key" do
-      @cursor = Cursor.new(@collection, :fields => [:name, :age])
-      result  = @cursor.fields
-      assert_equal result.keys.sort{|a,b| a.to_s <=> b.to_s}, [:age, :name].sort{|a,b| a.to_s <=> b.to_s}
-      assert result.values.all? {|v| v == 1}
-    end
-
-    should "when a string, return a hash with just the key" do
-      @cursor = Cursor.new(@collection, :fields => "name")
-      result  = @cursor.fields
-      assert_equal result.keys.sort, ["name"]
-      assert result.values.all? {|v| v == 1}
-    end
-
-    should "return nil when neither hash nor string nor symbol" do
-      @cursor = Cursor.new(@collection, :fields => 1234567)
-      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