mongo 1.1.2 → 1.1.3

data/lib/mongo/cursor.rb

@@ -23,7 +23,7 @@ module Mongo
 
     attr_reader :collection, :selector, :fields,
       :order, :hint, :snapshot, :timeout,
-      :full_collection_name, :batch_size
+      :full_collection_name
 
     # Create a new cursor.
     #
@@ -50,20 +50,26 @@ module Mongo
       @explain    = options[:explain]
       @socket     = options[:socket]
       @tailable   = options[:tailable] || false
+      @closed       = false
+      @query_run    = false
       batch_size(options[:batch_size] || 0)
 
       @full_collection_name = "#{@collection.db.name}.#{@collection.name}"
       @cache        = []
-      @closed       = false
-      @query_run    = false
       @returned     = 0
+
+      if @collection.name =~ /^\$cmd/ || @collection.name =~ /^system/
+        @command = true
+      else
+        @command = false
+      end
     end
 
     # Get the next document specified the cursor options.
     #
     # @return [Hash, Nil] the next document or Nil if no documents remain.
     def next_document
-      refresh if @cache.length == 0#empty?# num_remaining == 0
+      refresh if @cache.length == 0
       doc = @cache.shift
 
       if doc && doc['$err']
@@ -104,14 +110,21 @@ module Mongo
 
     # Get the size of the result set for this query.
     #
-    # @return [Integer] the number of objects in the result set for this query. Does
-    #   not take limit and skip into account. 
+    # @param [Boolean] whether of not to take notice of skip and limit
+    #
+    # @return [Integer] the number of objects in the result set for this query.
     #
     # @raise [OperationFailure] on a database error.
-    def count
-      command = BSON::OrderedHash["count",  @collection.name,
-                            "query",  @selector,
-                            "fields", @fields]
+    def count(skip_and_limit = false)
+      command = BSON::OrderedHash["count",  @collection.name, "query",  @selector]
+
+      if skip_and_limit
+        command.merge!(BSON::OrderedHash["limit", @limit]) if @limit != 0
+        command.merge!(BSON::OrderedHash["skip", @skip]) if @skip != 0
+      end
+
+      command.merge!(BSON::OrderedHash["fields", @fields])
+
       response = @db.command(command)
       return response['n'].to_i if Mongo::Support.ok?(response)
       return 0 if response['errmsg'] == "ns missing"
@@ -156,7 +169,6 @@ module Mongo
     def limit(number_to_return=nil)
       return @limit unless number_to_return
       check_modifiable
-      raise ArgumentError, "limit requires an integer" unless number_to_return.is_a? Integer
 
       @limit = number_to_return
       self
@@ -174,7 +186,6 @@ module Mongo
     def skip(number_to_skip=nil)
       return @skip unless number_to_skip
       check_modifiable
-      raise ArgumentError, "skip requires an integer" unless number_to_skip.is_a? Integer
 
       @skip = number_to_skip
       self
@@ -354,8 +365,8 @@ module Mongo
       # Cursor id.
       message.put_long(@cursor_id)
       @logger.debug("MONGODB cursor.refresh() for cursor #{@cursor_id}") if @logger
-      results, @n_received, @cursor_id = @connection.receive_message(Mongo::Constants::OP_GET_MORE,
-                                                                     message, nil, @socket)
+      results, @n_received, @cursor_id = @connection.receive_message(
+          Mongo::Constants::OP_GET_MORE, message, nil, @socket, @command)
       @returned += @n_received
       @cache += results
       close_cursor_if_query_complete
@@ -368,7 +379,8 @@ module Mongo
       else
         message = construct_query_message
         @logger.debug query_log_message if @logger
-        results, @n_received, @cursor_id = @connection.receive_message(Mongo::Constants::OP_QUERY, message, nil, @socket)
+        results, @n_received, @cursor_id = @connection.receive_message(
+          Mongo::Constants::OP_QUERY, message, nil, @socket, @command)
         @returned += @n_received
         @cache += results
         @query_run = true

data/lib/mongo/db.rb

@@ -51,6 +51,9 @@ module Mongo
     # The Mongo::Connection instance connecting to the MongoDB server.
     attr_reader :connection
 
+    # The length of time that Collection.ensure_index should cache index calls
+    attr_accessor :cache_time
+
     # Instances of DB are normally obtained by calling Mongo#db.
     #
     # @param [String] db_name the database name.
@@ -70,6 +73,7 @@ module Mongo
     #   value is provided, the default value set on this instance's Connection object will be used. This
     #   default can be overridden upon instantiation of any collection by explicity setting a :safe value
     #   on initialization
+    # @option options [Integer] :cache_time (300) Set the time that all ensure_index calls should cache the command.
     #
     # @core databases constructor_details
     def initialize(db_name, connection, options={})
@@ -78,6 +82,7 @@ module Mongo
       @strict     = options[:strict]
       @pk_factory = options[:pk]
       @safe       = options.has_key?(:safe) ? options[:safe] : @connection.safe
+      @cache_time = options[:cache_time] || 300 #5 minutes.
     end
 
     # Authenticate with the given username and password. Note that mongod

data/lib/mongo/gridfs/grid.rb

@@ -65,7 +65,7 @@ module Mongo
     #
     # @return [Mongo::ObjectId] the file's id.
     def put(data, opts={})
-      filename = opts[:filename]
+      filename = opts.delete :filename
       opts.merge!(default_grid_io_opts)
       file = GridIO.new(@files, @chunks, filename, 'w', opts=opts)
       file.write(data)

data/lib/mongo/util/pool.rb

@@ -18,11 +18,17 @@
 module Mongo
   class Pool
 
-    def initialize(host, port, socket, options={})
+    attr_accessor :host, :port, :size, :timeout, :safe, :checked_out
+
+    # Create a new pool of connections.
+    #
+    def initialize(connection, host, port, options={})
+      @connection  = connection
+
       @host, @port = host, port
 
       # Pool size and timeout.
-      @size      = options[:pool_size] || 1
+      @size      = options[:size] || 1
       @timeout   = options[:timeout]   || 5.0
 
       # Mutex for synchronizing pool access
@@ -43,6 +49,12 @@ module Mongo
     end
 
     def close
+      @sockets.each do |sock|
+        sock.close
+      end
+      @host = @port = nil
+      @sockets.clear
+      @checked_out.clear
     end
 
     # Return a socket to the pool.
@@ -84,7 +96,7 @@ module Mongo
     # pool size has not been exceeded. Otherwise, wait for the next
     # available socket.
     def checkout
-      connect if !connected?
+      @connection.connect if !@connection.connected?
       start_time = Time.now
       loop do
         if (Time.now - start_time) > @timeout

data/test/bson/object_id_test.rb

@@ -127,4 +127,9 @@ class ObjectIdTest < Test::Unit::TestCase
     id = ObjectId.new
     assert_equal "{\"$oid\": \"#{id}\"}", id.to_json
   end
+  
+  def test_as_json
+    id = ObjectId.new
+    assert_equal({"$oid" => id.to_s}, id.as_json)
+  end
 end

data/test/collection_test.rb

@@ -67,6 +67,17 @@ class TestCollection < Test::Unit::TestCase
     assert_equal 5, @@db.collection("test.foo").find_one()["x"]
   end
 
+  def test_rename_collection
+    @@db.drop_collection('foo1')
+    @@db.drop_collection('bar1')
+
+    @col = @@db.create_collection('foo1')
+    assert_equal 'foo1', @col.name
+
+    @col.rename('bar1')
+    assert_equal 'bar1', @col.name
+  end
+
   def test_nil_id
     assert_equal 5, @@test.insert({"_id" => 5, "foo" => "bar"}, {:safe => true})
     assert_equal 5, @@test.save({"_id" => 5, "foo" => "baz"}, {:safe => true})
@@ -555,8 +566,40 @@ class TestCollection < Test::Unit::TestCase
     assert_equal 1, x
   end
 
+
+  def test_ensure_index
+    @@test.drop_indexes
+    @@test.insert("x" => "hello world")
+    assert_equal 1, @@test.index_information.keys.count #default index
+
+    @@test.ensure_index([["x", Mongo::DESCENDING]], {})
+    assert_equal 2, @@test.index_information.keys.count
+    assert @@test.index_information.keys.include? "x_-1"
+
+    @@test.ensure_index([["x", Mongo::ASCENDING]])
+    assert @@test.index_information.keys.include? "x_1"
+
+    @@test.drop_index("x_1")
+    assert_equal 2, @@test.index_information.keys.count
+    @@test.drop_index("x_-1")
+    assert_equal 1, @@test.index_information.keys.count
+
+    @@test.ensure_index([["x", Mongo::DESCENDING]], {}) #should work as not cached.
+    assert_equal 2, @@test.index_information.keys.count
+    assert @@test.index_information.keys.include? "x_-1"
+
+    # Make sure that drop_index expires cache properly
+    @@test.ensure_index([['a', 1]])
+    assert @@test.index_information.keys.include?("a_1")
+    @@test.drop_index("a_1")
+    assert !@@test.index_information.keys.include?("a_1")
+    @@test.ensure_index([['a', 1]])
+    assert @@test.index_information.keys.include?("a_1")
+    @@test.drop_index("a_1")
+  end
+
   context "Grouping" do
-    setup do 
+    setup do
       @@test.remove
       @@test.save("a" => 1)
       @@test.save("b" => 1)
@@ -576,6 +619,23 @@ class TestCollection < Test::Unit::TestCase
     end
   end
 
+  context "Grouping with key" do
+    setup do
+      @@test.remove
+      @@test.save("a" => 1, "pop" => 100)
+      @@test.save("a" => 1, "pop" => 100)
+      @@test.save("a" => 2, "pop" => 100)
+      @@test.save("a" => 2, "pop" => 100)
+      @initial = {"count" => 0, "foo" => 1}
+      @reduce_function = "function (obj, prev) { prev.count += obj.pop; }"
+    end
+
+    should "group" do
+      result = @@test.group([:a], {}, @initial, @reduce_function, nil)
+      assert result.all? { |r| r['count'] == 200 }
+    end
+  end
+
   context "Grouping with a key function" do
     setup do 
       @@test.remove
@@ -699,6 +759,15 @@ class TestCollection < Test::Unit::TestCase
       @collection.create_index([['b', 1], ['a', 1]])
     end
 
+    should "allow multiple calls to create_index" do
+
+    end
+
+    should "allow creation of multiple indexes" do
+      assert @collection.create_index([['a', 1]])
+      assert @collection.create_index([['a', 1]])
+    end
+
     context "with an index created" do
       setup do
         @collection.create_index([['b', 1], ['a', 1]])

data/test/connection_test.rb

@@ -24,8 +24,8 @@ class TestConnection < Test::Unit::TestCase
 
   def test_connection_uri
     con = Connection.from_uri("mongodb://#{host_port}")
-    assert_equal mongo_host, con.host
-    assert_equal mongo_port, con.port
+    assert_equal mongo_host, con.primary_pool.host
+    assert_equal mongo_port, con.primary_pool.port
   end
 
   def test_server_version
@@ -44,8 +44,8 @@ class TestConnection < Test::Unit::TestCase
   end
 
   def test_replica_set_connection_name
-    assert_raise_error(Mongo::ReplicaSetConnectionError, "replSet") do
-      standard_connection(:name => "replica-set-foo")
+    assert_raise Mongo::ReplicaSetConnectionError do
+      standard_connection(:rs_name => "replica-set-wrong-name")
     end
   end
 
@@ -144,12 +144,6 @@ class TestConnection < Test::Unit::TestCase
     assert_equal ['bar', 27018], nodes[1]
   end
 
-  def test_slave_ok_with_multiple_nodes
-    assert_raise MongoArgumentError do
-      Connection.multi([['foo', 27017], ['bar', 27018]], :connect => false, :slave_ok => true)
-    end
-  end
-
   def test_fsync_lock
     assert !@conn.locked?
     @conn.lock!
@@ -211,29 +205,29 @@ class TestConnection < Test::Unit::TestCase
 
     should "release connection if an exception is raised on send_message" do
       @con.stubs(:send_message_on_socket).raises(ConnectionFailure)
-      assert_equal 0, @con.checked_out.size
+      assert_equal 0, @con.primary_pool.checked_out.size
       assert_raise ConnectionFailure do
         @coll.insert({:test => "insert"})
       end
-      assert_equal 0, @con.checked_out.size
+      assert_equal 0, @con.primary_pool.checked_out.size
     end
 
     should "release connection if an exception is raised on send_with_safe_check" do
       @con.stubs(:receive).raises(ConnectionFailure)
-      assert_equal 0, @con.checked_out.size
+      assert_equal 0, @con.primary_pool.checked_out.size
       assert_raise ConnectionFailure do
         @coll.insert({:test => "insert"}, :safe => true)
       end
-      assert_equal 0, @con.checked_out.size
+      assert_equal 0, @con.primary_pool.checked_out.size
     end
 
     should "release connection if an exception is raised on receive_message" do
       @con.stubs(:receive).raises(ConnectionFailure)
-      assert_equal 0, @con.checked_out.size
+      assert_equal 0, @con.primary_pool.checked_out.size
       assert_raise ConnectionFailure do
         @coll.find.to_a
       end
-      assert_equal 0, @con.checked_out.size
+      assert_equal 0, @con.primary_pool.checked_out.size
     end
   end
 end

data/test/cursor_test.rb

@@ -46,6 +46,10 @@ class CursorTest < Test::Unit::TestCase
     assert_equal 10, @@coll.find({}, :limit => 5).count()
     assert_equal 10, @@coll.find({}, :skip => 5).count()
 
+    assert_equal 5, @@coll.find({}, :limit => 5).count(true)
+    assert_equal 5, @@coll.find({}, :skip => 5).count(true)
+    assert_equal 2, @@coll.find({}, :skip => 5, :limit => 2).count(true)
+
     assert_equal 1, @@coll.find({"x" => 1}).count()
     assert_equal 5, @@coll.find({"x" => {"$lt" => 5}}).count()
 
@@ -182,10 +186,6 @@ class CursorTest < Test::Unit::TestCase
   end
 
   def test_limit_exceptions
-    assert_raise ArgumentError do
-      cursor = @@coll.find().limit('not-an-integer')
-    end
-
     cursor      = @@coll.find()
     firstResult = cursor.next_document
     assert_raise InvalidOperation, "Cannot modify the query once it has been run or closed." do
@@ -216,10 +216,6 @@ class CursorTest < Test::Unit::TestCase
   end
 
   def test_skip_exceptions
-    assert_raise ArgumentError do
-      cursor = @@coll.find().skip('not-an-integer')
-    end
-
     cursor      = @@coll.find()
     firstResult = cursor.next_document
     assert_raise InvalidOperation, "Cannot modify the query once it has been run or closed." do

data/test/db_api_test.rb

@@ -364,15 +364,12 @@ class DBAPITest < Test::Unit::TestCase
   end
 
   def test_array
-    @@coll << {'b' => [1, 2, 3]}
+    @@coll.remove
+    @@coll.insert({'b' => [1, 2, 3]})
+    @@coll.insert({'b' => [1, 2, 3]})
     rows = @@coll.find({}, {:fields => ['b']}).to_a
-    if @@version < "1.1.3"
-      assert_equal 1, rows.length
-      assert_equal [1, 2, 3], rows[0]['b']
-    else
-      assert_equal 2, rows.length
-      assert_equal [1, 2, 3], rows[1]['b']
-    end
+    assert_equal 2, rows.length
+    assert_equal [1, 2, 3], rows[1]['b']
   end
 
   def test_regex
@@ -713,16 +710,7 @@ class DBAPITest < Test::Unit::TestCase
 
     a.rename("bar")
 
-    assert_equal 0, a.count()
-    assert_equal 2, b.count()
-
-    assert_equal 1, b.find().to_a()[0]["x"]
-    assert_equal 2, b.find().to_a()[1]["x"]
-
-    b.rename(:foo)
-
     assert_equal 2, a.count()
-    assert_equal 0, b.count()
   end
 
   # doesn't really test functionality, just that the option is set correctly

data/test/replica_sets/query_secondaries.rb

@@ -0,0 +1,40 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'mongo'
+require 'test/unit'
+require './test/test_helper'
+
+# NOTE: This test expects a replica set of three nodes to be running
+# on the local host.
+class ReplicaSetQuerySecondariesTest < Test::Unit::TestCase
+  include Mongo
+
+  def setup
+    @conn = Mongo::Connection.multi([['localhost', 27018]], :read_secondaries => true)
+    @db = @conn.db(MONGO_TEST_DB)
+    @db.drop_collection("test-sets")
+    @coll = @db.collection("test-sets", :safe => {:w => 2, :wtimeout => 100})
+  end
+
+  def test_query
+    @coll.save({:a => 20})
+    @coll.save({:a => 30})
+    @coll.save({:a => 40})
+    results = []
+    @coll.find.each {|r| results << r["a"]}
+    assert results.include?(20)
+    assert results.include?(30)
+    assert results.include?(40)
+
+    puts "Please disconnect the current master."
+    gets
+
+    results = []
+    rescue_connection_failure do
+      @coll.find.each {|r| results << r}
+      [20, 30, 40].each do |a|
+        assert results.any? {|r| r['a'] == a}, "Could not find record for a => #{a}"
+      end
+    end
+  end
+
+end