mongo 1.7.1 → 1.8.0

data/test/unit/pool_manager_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path("../../test_helper", __FILE__)
+require 'test_helper'
 include Mongo
 
 class PoolManagerTest < Test::Unit::TestCase
@@ -9,17 +9,17 @@ class PoolManagerTest < Test::Unit::TestCase
       TCPSocket.stubs(:new).returns(new_mock_socket)
       @db = new_mock_db
 
-      @connection = stub("Connection")
-      @connection.stubs(:connect_timeout).returns(5)
-      @connection.stubs(:op_timeout).returns(5)
-      @connection.stubs(:pool_size).returns(2)
-      @connection.stubs(:pool_timeout).returns(100)
-      @connection.stubs(:seeds).returns(['localhost:30000'])
-      @connection.stubs(:socket_class).returns(TCPSocket)
-      @connection.stubs(:[]).returns(@db)
-
-      @connection.stubs(:replica_set_name).returns(nil)
-      @connection.stubs(:log)
+      @client = stub("MongoClient")
+      @client.stubs(:connect_timeout).returns(5)
+      @client.stubs(:op_timeout).returns(5)
+      @client.stubs(:pool_size).returns(2)
+      @client.stubs(:pool_timeout).returns(100)
+      @client.stubs(:seeds).returns(['localhost:30000'])
+      @client.stubs(:socket_class).returns(TCPSocket)
+      @client.stubs(:[]).returns(@db)
+
+      @client.stubs(:replica_set_name).returns(nil)
+      @client.stubs(:log)
       @arbiters = ['localhost:27020']
       @hosts = ['localhost:27017', 'localhost:27018', 'localhost:27019',
         'localhost:27020']
@@ -35,7 +35,7 @@ class PoolManagerTest < Test::Unit::TestCase
         {'arbiterOnly' => true, 'hosts' => @hosts, 'arbiters' => @arbiters})
 
       seeds = [['localhost', 27017]]
-      manager = Mongo::PoolManager.new(@connection, seeds)
+      manager = Mongo::PoolManager.new(@client, seeds)
       manager.connect
 
       assert_equal ['localhost', 27017], manager.primary

data/test/unit/pool_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path("../../test_helper", __FILE__)
+require 'test_helper'
 include Mongo
 
 class PoolTest < Test::Unit::TestCase

data/test/unit/read_test.rb

@@ -1,11 +1,11 @@
-require File.expand_path("../../test_helper", __FILE__)
+require 'test_helper'
 
 class ReadTest < Test::Unit::TestCase
 
   context "Read mode on standard connection: " do
     setup do
       @read_preference = :secondary
-      @con = Mongo::Connection.new('localhost', 27017, :read => @read_preference, :connect => false)
+      @client = MongoClient.new('localhost', 27017, :read => @read_preference, :connect => false)
     end
 
   end
@@ -16,7 +16,7 @@ class ReadTest < Test::Unit::TestCase
       @acceptable_latency = 100
       @tags = {"dc" => "Tyler", "rack" => "Brock"}
       @bad_tags = {"wow" => "cool"}
-      @con = Mongo::ReplSetConnection.new(
+      @client = MongoReplicaSetClient.new(
         ['localhost:27017'],
         :read => @read_preference,
         :tag_sets => @tags,
@@ -25,36 +25,36 @@ class ReadTest < Test::Unit::TestCase
       )
     end
 
-    should "store read preference on Connection" do
-      assert_equal @read_preference, @con.read_preference
-      assert_equal @tags, @con.tag_sets
-      assert_equal @acceptable_latency, @con.acceptable_latency
+    should "store read preference on MongoClient" do
+      assert_equal @read_preference, @client.read_preference
+      assert_equal @tags, @client.tag_sets
+      assert_equal @acceptable_latency, @client.acceptable_latency
     end
 
     should "propogate to DB" do
-      db = @con['foo']
+      db = @client['foo']
       assert_equal @read_preference, db.read_preference
       assert_equal @tags, db.tag_sets
       assert_equal @acceptable_latency, db.acceptable_latency
 
-      db = @con.db('foo')
+      db = @client.db('foo')
       assert_equal @read_preference, db.read_preference
       assert_equal @tags, db.tag_sets
       assert_equal @acceptable_latency, db.acceptable_latency
 
-      db = DB.new('foo', @con)
+      db = DB.new('foo', @client)
       assert_equal @read_preference, db.read_preference
       assert_equal @tags, db.tag_sets
       assert_equal @acceptable_latency, db.acceptable_latency
     end
 
     should "allow db override" do
-      db = DB.new('foo', @con, :read => :primary, :tag_sets => @bad_tags, :acceptable_latency => 25)
+      db = DB.new('foo', @client, :read => :primary, :tag_sets => @bad_tags, :acceptable_latency => 25)
       assert_equal :primary, db.read_preference
       assert_equal @bad_tags, db.tag_sets
       assert_equal 25, db.acceptable_latency
 
-      db = @con.db('foo', :read => :primary, :tag_sets => @bad_tags, :acceptable_latency => 25)
+      db = @client.db('foo', :read => :primary, :tag_sets => @bad_tags, :acceptable_latency => 25)
       assert_equal :primary, db.read_preference
       assert_equal @bad_tags, db.tag_sets
       assert_equal 25, db.acceptable_latency
@@ -62,7 +62,7 @@ class ReadTest < Test::Unit::TestCase
 
     context "on DB: " do
       setup do
-        @db = @con['foo']
+        @db = @client['foo']
       end
 
       should "propogate to collection" do
@@ -97,7 +97,7 @@ class ReadTest < Test::Unit::TestCase
 
     context "on read mode ops" do
       setup do
-        @col = @con['foo']['bar']
+        @col = @client['foo']['bar']
         @mock_socket = new_mock_socket
       end
 
@@ -105,12 +105,12 @@ class ReadTest < Test::Unit::TestCase
         @cursor = @col.find({:a => 1})
         sock = new_mock_socket
         read_pool = stub(:checkin => true)
-        @con.stubs(:read_pool).returns(read_pool)
+        @client.stubs(:read_pool).returns(read_pool)
         primary_pool = stub(:checkin => true)
         sock.stubs(:pool).returns(primary_pool)
-        @con.stubs(:primary_pool).returns(primary_pool)
-        @con.expects(:checkout_reader).returns(sock)
-        @con.expects(:receive_message).with do |o, m, l, s, c, r|
+        @client.stubs(:primary_pool).returns(primary_pool)
+        @client.expects(:checkout_reader).returns(sock)
+        @client.expects(:receive_message).with do |o, m, l, s, c, r|
           r == nil
         end.returns([[], 0, 0])
 
@@ -122,9 +122,9 @@ class ReadTest < Test::Unit::TestCase
         sock = new_mock_socket
         primary_pool = stub(:checkin => true)
         sock.stubs(:pool).returns(primary_pool)
-        @con.stubs(:primary_pool).returns(primary_pool)
-        @con.expects(:checkout_reader).returns(sock)
-        @con.expects(:receive_message).with do |o, m, l, s, c, r|
+        @client.stubs(:primary_pool).returns(primary_pool)
+        @client.expects(:checkout_reader).returns(sock)
+        @client.expects(:receive_message).with do |o, m, l, s, c, r|
           r == nil
         end.returns([[], 0, 0])
 
@@ -132,11 +132,6 @@ class ReadTest < Test::Unit::TestCase
       end
 
       should "allow override alternate value on query" do
-        # TODO: enable this test once we enable reading from tags.
-        # @con.expects(:receive_message).with do |o, m, l, s, c, r|
-        #   tags = {:dc => "ny"}
-        # end.returns([[], 0, 0])
-
         assert_raise MongoArgumentError do
           @col.find_one({:a => 1}, :read => {:dc => "ny"})
         end

data/test/unit/safe_test.rb

@@ -1,65 +1,65 @@
-require File.expand_path("../../test_helper", __FILE__)
+require 'test_helper'
 
 class SafeTest < Test::Unit::TestCase
 
-  context "Safe mode on connection: " do
+  context "Write-Concern modes on Mongo::Connection " do
     setup do
-      @safe_value = {:w => 7}
-      @con = Mongo::Connection.new('localhost', 27017, :safe => @safe_value, :connect => false)
+      @safe_value = {:w => 7, :j => false, :fsync => false, :wtimeout => false}
+      @connection = Mongo::Connection.new('localhost', 27017, :safe => @safe_value, :connect => false)
     end
 
     should "propogate to DB" do
-      db = @con['foo']
-      assert_equal @safe_value, db.safe
+      db = @connection['foo']
+      assert_equal @safe_value[:w], db.write_concern[:w]
 
 
-      db = @con.db('foo')
-      assert_equal @safe_value, db.safe
+      db = @connection.db('foo')
+      assert_equal @safe_value[:w], db.write_concern[:w]
 
-      db = DB.new('foo', @con)
-      assert_equal @safe_value, db.safe
+      db = DB.new('foo', @connection)
+      assert_equal @safe_value[:w], db.write_concern[:w]
     end
 
     should "allow db override" do
-      db = DB.new('foo', @con, :safe => false)
-      assert_equal false, db.safe
+      db = DB.new('foo', @connection, :safe => false)
+      assert_equal 0, db.write_concern[:w]
 
-      db = @con.db('foo', :safe => false)
-      assert_equal false, db.safe
+      db = @connection.db('foo', :safe => false)
+      assert_equal 0, db.write_concern[:w]
     end
 
     context "on DB: " do
       setup do
-        @db = @con['foo']
+        @db = @connection['foo']
       end
 
       should "propogate to collection" do
         col = @db.collection('bar')
-        assert_equal @safe_value, col.safe
+        assert_equal @safe_value, col.write_concern
 
         col = @db['bar']
-        assert_equal @safe_value, col.safe
+        assert_equal @safe_value, col.write_concern
 
         col = Collection.new('bar', @db)
-        assert_equal @safe_value, col.safe
+        assert_equal @safe_value, col.write_concern
       end
 
       should "allow override on collection" do
         col = @db.collection('bar', :safe => false)
-        assert_equal false, col.safe
+        assert_equal 0, col.write_concern[:w]
 
         col = Collection.new('bar', @db, :safe => false)
-        assert_equal false, col.safe
+        assert_equal 0, col.write_concern[:w]
       end
     end
 
     context "on operations supporting safe mode" do
       setup do
-        @col = @con['foo']['bar']
+        @col = @connection['foo']['bar']
       end
 
       should "use default value on insert" do
-        @con.expects(:send_message_with_safe_check).with do |op, msg, log, n, safe|
+        @connection.expects(:send_message_with_gle).with do |op, msg, log, n, safe|
           safe == @safe_value
         end
 
@@ -67,20 +67,20 @@ class SafeTest < Test::Unit::TestCase
       end
 
       should "allow override alternate value on insert" do
-        @con.expects(:send_message_with_safe_check).with do |op, msg, log, n, safe|
-          safe == {:w => 100}
+        @connection.expects(:send_message_with_gle).with do |op, msg, log, n, safe|
+          safe == {:w => 100, :j => false, :fsync => false, :wtimeout => false}
         end
 
         @col.insert({:a => 1}, :safe => {:w => 100})
       end
 
       should "allow override to disable on insert" do
-        @con.expects(:send_message)
+        @connection.expects(:send_message)
         @col.insert({:a => 1}, :safe => false)
       end
 
       should "use default value on update" do
-        @con.expects(:send_message_with_safe_check).with do |op, msg, log, n, safe|
+        @connection.expects(:send_message_with_gle).with do |op, msg, log, n, safe|
           safe == @safe_value
         end
 
@@ -88,20 +88,39 @@ class SafeTest < Test::Unit::TestCase
       end
 
       should "allow override alternate value on update" do
-        @con.expects(:send_message_with_safe_check).with do |op, msg, log, n, safe|
-          safe == {:w => 100}
+        @connection.expects(:send_message_with_gle).with do |op, msg, log, n, safe|
+          safe == {:w => 100, :j => false, :fsync => false, :wtimeout => false}
         end
 
         @col.update({:a => 1}, {:a => 2}, :safe => {:w => 100})
       end
 
       should "allow override to disable on update" do
-        @con.expects(:send_message)
+        @connection.expects(:send_message)
         @col.update({:a => 1}, {:a => 2}, :safe => false)
       end
 
+      should "use default value on save" do
+        @connection.expects(:send_message_with_gle).with do |op, msg, log, n, safe|
+          safe == @safe_value
+        end
+        @col.save({:a => 1})
+      end
+
+      should "allow override alternate value on save" do
+        @connection.expects(:send_message_with_gle).with do |op, msg, log, n, safe|
+          safe == @safe_value.merge(:w => 1)
+        end
+        @col.save({:a => 1}, :safe => true)
+      end
+
+      should "allow override to disable on save" do
+        @connection.expects(:send_message)
+        @col.save({:a => 1}, :safe => false)
+      end
+
       should "use default value on remove" do
-        @con.expects(:send_message_with_safe_check).with do |op, msg, log, n, safe|
+        @connection.expects(:send_message_with_gle).with do |op, msg, log, n, safe|
           safe == @safe_value
         end
 
@@ -109,15 +128,15 @@ class SafeTest < Test::Unit::TestCase
       end
 
       should "allow override alternate value on remove" do
-        @con.expects(:send_message_with_safe_check).with do |op, msg, log, n, safe|
-          safe == {:w => 100}
+        @connection.expects(:send_message_with_gle).with do |op, msg, log, n, safe|
+          safe == {:w => 100, :j => false, :fsync => false, :wtimeout => false}
         end
 
         @col.remove({}, :safe => {:w => 100})
       end
 
       should "allow override to disable on remove" do
-        @con.expects(:send_message)
+        @connection.expects(:send_message)
         @col.remove({}, :safe => false)
       end
     end

data/test/unit/util_test.rb

@@ -0,0 +1,55 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+class UtilTest < Test::Unit::TestCase
+  context "Support" do
+    context ".secondary_ok?" do
+      should "return false for mapreduces with a string for out" do
+        assert_equal false, Mongo::Support.secondary_ok?(BSON::OrderedHash[
+            'mapreduce', 'test-collection',
+            'out', 'new-test-collection'
+          ])
+      end
+
+      should "return false for mapreduces replacing a collection" do
+        assert_equal false, Mongo::Support.secondary_ok?(BSON::OrderedHash[
+            'mapreduce', 'test-collection',
+            'out', BSON::OrderedHash['replace', 'new-test-collection']
+          ])
+      end
+
+      should "return false for mapreduces replacing the inline collection" do
+        assert_equal false, Mongo::Support.secondary_ok?(BSON::OrderedHash[
+            'mapreduce', 'test-collection',
+            'out', 'inline'
+          ])
+      end
+
+      should "return true for inline output mapreduces when inline is a symbol" do
+        assert_equal true, Mongo::Support.secondary_ok?(BSON::OrderedHash[
+            'mapreduce', 'test-collection',
+            'out', BSON::OrderedHash[:inline, 'true']
+          ])
+      end
+
+      should "return true for inline output mapreduces when inline is a string" do
+        assert_equal true, Mongo::Support.secondary_ok?(BSON::OrderedHash[
+            'mapreduce', 'test-collection',
+            'out', BSON::OrderedHash['inline', 'true']
+          ])
+      end
+
+      should 'return true for count' do
+        assert_equal true, Mongo::Support.secondary_ok?(BSON::OrderedHash[
+            'count', 'test-collection',
+            'query', BSON::OrderedHash['a', 'b']
+          ])
+      end
+
+      should 'return false for serverStatus' do
+        assert_equal false, Mongo::Support.secondary_ok?(BSON::OrderedHash[
+            'serverStatus', 1
+          ])
+      end
+    end
+  end
+end

data/test/unit/write_concern_test.rb

@@ -0,0 +1,161 @@
+require 'test_helper'
+
+class WriteConcernTest < Test::Unit::TestCase
+
+  context "Write-Concern modes on Mongo::MongoClient " do
+    setup do
+      @write_concern = {
+        :w        => 7,
+        :j        => false,
+        :fsync    => false,
+        :wtimeout => false
+      }
+
+      class Mongo::MongoClient
+        public :build_get_last_error_message, :build_command_message
+      end
+
+      @client =
+        MongoClient.new('localhost', 27017, 
+          @write_concern.merge({:connect => false}))
+    end
+
+    should "propogate to DB" do
+      db = @client['foo']
+      assert_equal @write_concern, db.write_concern
+
+
+      db = @client.db('foo')
+      assert_equal @write_concern, db.write_concern
+
+      db = DB.new('foo', @client)
+      assert_equal @write_concern, db.write_concern
+    end
+
+    should "allow db override" do
+      db = DB.new('foo', @client, :w => 0)
+      assert_equal 0, db.write_concern[:w]
+
+      db = @client.db('foo', :w => 0)
+      assert_equal 0, db.write_concern[:w]
+    end
+
+    context "on DB: " do
+      setup do
+        @db = @client['foo']
+      end
+
+      should "propogate to collection" do
+        collection = @db.collection('bar')
+        assert_equal @write_concern, collection.write_concern
+
+        collection = @db['bar']
+        assert_equal @write_concern, collection.write_concern
+
+        collection = Collection.new('bar', @db)
+        assert_equal @write_concern, collection.write_concern
+      end
+
+      should "allow override on collection" do
+        collection = @db.collection('bar', :w => 0)
+        assert_equal 0, collection.write_concern[:w]
+
+        collection = Collection.new('bar', @db, :w => 0)
+        assert_equal 0, collection.write_concern[:w]
+      end
+    end
+
+    context "on operations supporting 'gle' mode" do
+      setup do
+        @collection = @client['foo']['bar']
+      end
+
+      should "not send w = 1 to the server" do
+        gle = @client.build_get_last_error_message("fake", {:w => 1})
+        assert_equal gle, @client.build_command_message("fake", {:getlasterror => 1})
+      end
+
+      should "use default value on insert" do
+        @client.expects(:send_message_with_gle).with do |op, msg, log, n, wc|
+          wc == @write_concern
+        end
+
+        @collection.insert({:a => 1})
+      end
+
+      should "allow override alternate value on insert" do
+        @client.expects(:send_message_with_gle).with do |op, msg, log, n, wc|
+          wc == {:w => 100, :j => false, :fsync => false, :wtimeout => false}
+        end
+
+        @collection.insert({:a => 1}, {:w => 100})
+      end
+
+      should "allow override to disable on insert" do
+        @client.expects(:send_message)
+        @collection.insert({:a => 1}, :w => 0)
+      end
+
+      should "use default value on update" do
+        @client.expects(:send_message_with_gle).with do |op, msg, log, n, wc|
+          wc == @write_concern
+        end
+
+        @collection.update({:a => 1}, {:a => 2})
+      end
+
+      should "allow override alternate value on update" do
+        @client.expects(:send_message_with_gle).with do |op, msg, log, n, wc|
+          wc == {:w => 100, :j => false, :fsync => false, :wtimeout => false}
+        end
+
+        @collection.update({:a => 1}, {:a => 2}, {:w => 100})
+      end
+
+      should "allow override to disable on update" do
+        @client.expects(:send_message)
+        @collection.update({:a => 1}, {:a => 2}, :w => 0)
+      end
+
+      should "use default value on save" do
+        @client.expects(:send_message_with_gle).with do |op, msg, log, n, wc|
+          wc == @write_concern
+        end
+        @collection.save({:a => 1})
+      end
+
+      should "allow override alternate value on save" do
+        @client.expects(:send_message_with_gle).with do |op, msg, log, n, wc|
+          wc == @write_concern.merge(:w => 1)
+        end
+        @collection.save({:a => 1}, :w => 1)
+      end
+
+      should "allow override to disable on save" do
+        @client.expects(:send_message)
+        @collection.save({:a => 1}, :w => 0)
+      end
+
+      should "use default value on remove" do
+        @client.expects(:send_message_with_gle).with do |op, msg, log, n, wc|
+          wc == @write_concern
+        end
+
+        @collection.remove
+      end
+
+      should "allow override alternate value on remove" do
+        @client.expects(:send_message_with_gle).with do |op, msg, log, n, wc|
+          wc == {:w => 100, :j => false, :fsync => false, :wtimeout => false}
+        end
+
+        @collection.remove({}, {:w => 100})
+      end
+
+      should "allow override to disable on remove" do
+        @client.expects(:send_message)
+        @collection.remove({}, :w => 0)
+      end
+    end
+  end
+end