mongo 1.3.0 → 1.12.5

data/test/unit/cursor_test.rb

@@ -1,13 +1,36 @@
-require './test/test_helper'
+# 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
 
-class CursorTest < Test::Unit::TestCase
   context "Cursor options" do
     setup do
       @logger     = mock()
       @logger.stubs(:debug)
-      @connection = stub(:class => Connection, :logger => @logger)
-      @db         = stub(:name => "testing", :slave_ok? => false, :connection => @connection)
-      @collection = stub(:db => @db, :name => "items")
+      @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
 
@@ -32,6 +55,18 @@ class CursorTest < Test::Unit::TestCase
       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
 
@@ -73,18 +108,154 @@ 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
+    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 => Connection, :logger => @logger)
-      @db = stub(:slave_ok? => true, :name => "testing", :connection => @connection)
-      @collection = stub(:db => @db, :name => "items")
+      @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
@@ -106,4 +277,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

@@ -1,4 +1,18 @@
-require './test/test_helper'
+# 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'
 
 def insert_message(db, documents)
   documents = [documents] unless documents.is_a?(Array)
@@ -9,14 +23,21 @@ def insert_message(db, documents)
   message = db.add_message_headers(Mongo::Constants::OP_INSERT, message)
 end
 
-class DBTest < Test::Unit::TestCase
+class DBUnitTest < Test::Unit::TestCase
   context "DBTest: " do
     context "DB commands" do
       setup do
-        @conn = stub()
-        @conn.stubs(:safe)
-        @db   = DB.new("testing", @conn)
+        @client = stub()
+        @client.stubs(:write_concern).returns({})
+        @client.stubs(:read).returns(:primary)
+        @client.stubs(:tag_sets)
+        @client.stubs(:acceptable_latency)
+        @client.stubs(:add_auth).returns({})
+        @db = DB.new("testing", @client)
         @db.stubs(:safe)
+        @db.stubs(:read)
+        @db.stubs(:tag_sets)
+        @db.stubs(:acceptable_latency)
         @collection = mock()
         @db.stubs(:system_command_collection).returns(@collection)
       end
@@ -35,10 +56,18 @@ class DBTest < Test::Unit::TestCase
         end
       end
 
+      should "not include named nil opts in selector" do
+        @cursor = mock(:next_document => {"ok" => 1})
+        Cursor.expects(:new).with(@collection, :limit => -1,
+          :selector => {:ping => 1}, :socket => nil).returns(@cursor)
+        command = {:ping => 1}
+        @db.command(command, :socket => nil)
+      end
+
       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}).returns(@cursor)
         command = {:buildinfo => 1}
         @db.command(command, :check_response => true)
       end
@@ -46,23 +75,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}).returns(@cursor)
         assert_raise OperationFailure do
           command = {:buildinfo => 1}
           @db.command(command, :check_response => true)
         end
       end
 
-      should "raise an error if logging out fails" do
-        @db.expects(:command).returns({})
-        @conn.expects(:pool_size).returns(1)
-        assert_raise Mongo::MongoDBError do
-          @db.logout
+      should "pass on the comment" do
+        @cursor = mock(:next_document => {"ok" => 0})
+        Cursor.expects(:new).with(@collection,
+          :limit => -1, :selector => {:buildinfo => 1},
+          :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 collection creation fails" do
-        @db.expects(:collection_names).returns([])
         @db.expects(:command).returns({'ok' => 0})
         assert_raise Mongo::MongoDBError do
           @db.create_collection("foo")
@@ -89,6 +120,17 @@ class DBTest < Test::Unit::TestCase
           @db.profiling_level = :slow_only
         end
       end
+
+      should "warn when save_auth is not nil" do
+        assert @db.expects(:warn).with(regexp_matches(/\[DEPRECATED\] Disabling the 'save_auth' option/))
+        @db.authenticate('foo', 'bar', false)
+      end
+
+      should "allow extra authentication options" do
+        extra_opts = { :service_name => 'example', :canonicalize_host_name => true }
+        assert @client.expects(:add_auth).with(@db.name, 'emily', nil, nil, 'GSSAPI', extra_opts)
+        @db.authenticate('emily', nil, nil, nil, 'GSSAPI', extra_opts)
+      end
     end
   end
 end

data/test/unit/grid_test.rb

@@ -1,49 +1,76 @@
-require './test/test_helper'
+# 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.
 
-class GridTest < Test::Unit::TestCase
+require 'test_helper'
+
+class GridUnitTest < Test::Unit::TestCase
 
   context "GridFS: " do
     setup do
-      @conn   = stub()
-      @conn.stubs(:safe)
-      @db     = DB.new("testing", @conn)
+      @client   = stub()
+      @client.stubs(:write_concern).returns({})
+      @client.stubs(:read).returns(:primary)
+      @client.stubs(:tag_sets)
+      @client.stubs(:acceptable_latency)
+      @db     = DB.new("testing", @client)
       @files  = mock()
       @chunks = mock()
 
-      @db.expects(:[]).with('fs.files').returns(@files)
-      @db.expects(:[]).with('fs.chunks').returns(@chunks)
+      @db.stubs(:[]).with('fs.files').returns(@files)
+      @db.stubs(:[]).with('fs.chunks').returns(@chunks)
       @db.stubs(:safe)
+      @db.stubs(:read).returns(:primary)
     end
 
-    context "Grid classe with standard connections" do
+    context "Grid classes with standard connections" do
       setup do
-        @conn.expects(:slave_ok?).returns(false)
+        @chunks.expects(:ensure_index)
       end
 
       should "create indexes for Grid" do
-        @chunks.expects(:create_index)
         Grid.new(@db)
       end
 
       should "create indexes for GridFileSystem" do
-        @files.expects(:create_index)
-        @chunks.expects(:create_index)
+        @files.expects(:ensure_index)
         GridFileSystem.new(@db)
       end
     end
 
     context "Grid classes with slave connection" do
       setup do
-        @conn.expects(:slave_ok?).returns(true)
+        @chunks.stubs(:ensure_index).raises(Mongo::ConnectionFailure)
+        @files.stubs(:ensure_index).raises(Mongo::ConnectionFailure)
       end
 
       should "not create indexes for Grid" do
-        Grid.new(@db)
+        grid = Grid.new(@db)
+        data = "hello world!"
+        assert_raise Mongo::ConnectionFailure do
+          grid.put(data)
+        end
       end
 
       should "not create indexes for GridFileSystem" do
-        GridFileSystem.new(@db)
+        gridfs = GridFileSystem.new(@db)
+        data = "hello world!"
+        assert_raise Mongo::ConnectionFailure do
+          gridfs.open('image.jpg', 'w') do |f|
+            f.write data
+          end
+        end
       end
     end
   end
-end
+end

data/test/unit/mongo_sharded_client_test.rb

@@ -0,0 +1,48 @@
+# 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 MongoShardedClientUnitTest < Test::Unit::TestCase
+  include Mongo
+
+  def test_initialize_with_single_mongos_uri
+    uri = "mongodb://localhost:27017"
+    with_preserved_env_uri(uri) do
+      client = MongoShardedClient.new(:connect => false)
+      assert_equal [[ "localhost", 27017 ]], client.seeds
+    end
+  end
+
+  def test_initialize_with_multiple_mongos_uris
+    uri = "mongodb://localhost:27017,localhost:27018"
+    with_preserved_env_uri(uri) do
+      client = MongoShardedClient.new(:connect => false)
+      assert_equal [[ "localhost", 27017 ], [ "localhost", 27018 ]], client.seeds
+    end
+  end
+
+  def test_from_uri_with_string
+    client = MongoShardedClient.from_uri("mongodb://localhost:27017,localhost:27018", :connect => false)
+    assert_equal [[ "localhost", 27017 ], [ "localhost", 27018 ]], client.seeds
+  end
+
+  def test_from_uri_with_env_variable
+    uri = "mongodb://localhost:27017,localhost:27018"
+    with_preserved_env_uri(uri) do
+      client = MongoShardedClient.from_uri(nil, :connect => false)
+      assert_equal [[ "localhost", 27017 ], [ "localhost", 27018 ]], client.seeds
+    end
+  end
+end

data/test/unit/node_test.rb

@@ -0,0 +1,93 @@
+# 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 NodeUnitTest < Test::Unit::TestCase
+
+  def setup
+    @client = stub()
+    manager = mock('pool_manager')
+    manager.stubs(:update_max_sizes)
+    @client.stubs(:local_manager).returns(manager)
+  end
+
+  should "refuse to connect to node without 'hosts' key" do
+    tcp = mock()
+    node = Node.new(@client, ['localhost', 27017])
+    tcp.stubs(:new).returns(new_mock_socket)
+    @client.stubs(:socket_class).returns(tcp)
+
+    admin_db = new_mock_db
+    admin_db.stubs(:command).returns({'ok' => 1, 'ismaster' => 1})
+    @client.stubs(:[]).with('admin').returns(admin_db)
+    @client.stubs(:op_timeout).returns(nil)
+    @client.stubs(:connect_timeout).returns(nil)
+    @client.expects(:log)
+    @client.expects(:mongos?).returns(false)
+    @client.stubs(:socket_opts)
+
+    assert node.connect
+    node.config
+  end
+
+  should "load a node from an array" do
+    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(@client, ['power.level.com'])
+    assert_equal 'power.level.com', node.host
+    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(@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(@client, '192.168.0.1')
+    assert_equal '192.168.0.1', node.host
+    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(@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(@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(@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(@client, '192.168.0.1').hash,
+      Node.new(@client, '1239.33.4.2393:29949').hash
+  end
+
+end