mongo 1.7.1 → 1.8.0

data/mongo.gemspec

@@ -1,34 +1,23 @@
-require File.expand_path('../lib/mongo/version', __FILE__)
-
 Gem::Specification.new do |s|
-  s.name = 'mongo'
-
-  s.version = Mongo::VERSION
-
-  s.platform = Gem::Platform::RUBY
-  s.summary = 'Ruby driver for MongoDB'
-  s.description = 'A Ruby driver for MongoDB. For more information about Mongo, see http://www.mongodb.org.'
-
-  s.require_paths = ['lib']
-
-  s.files  = ['README.md', 'Rakefile', 'mongo.gemspec', 'LICENSE.txt']
-  s.files += ['lib/mongo.rb'] + Dir['lib/mongo/**/*.rb']
-  s.files += Dir['docs/**/*.md'] + Dir['examples/**/*.rb'] + Dir['bin/**/*.rb']
-  s.files += Dir['bin/mongo_console']
-  s.test_files = Dir['test/**/*.rb']
-
-  s.executables = ['mongo_console']
-
-  s.has_rdoc = true
-  s.test_files = Dir['test/**/*.rb']
-
-  s.has_rdoc = true
-  s.rdoc_options = ['--main', 'README.md', '--inline-source']
-  s.extra_rdoc_files = ['README.md']
-
-  s.authors = ['Jim Menard', 'Mike Dirolf', 'Kyle Banker', 'Tyler Brock']
-  s.email = 'mongodb-dev@googlegroups.com'
-  s.homepage = 'http://www.mongodb.org'
-
-  s.add_dependency('bson', "~> #{Mongo::VERSION}")
+  s.name              = 'mongo'
+
+  s.version           = File.read(File.join(File.dirname(__FILE__), 'VERSION'))
+  s.platform          = Gem::Platform::RUBY
+  s.authors           = ['Tyler Brock', 'Gary Murakami', 'Emily Stolfo', 'Brandon Black']
+  s.email             = 'mongodb-dev@googlegroups.com'
+  s.homepage          = 'http://www.mongodb.org'
+  s.summary           = 'Ruby driver for MongoDB'
+  s.description       = 'A Ruby driver for MongoDB. For more information about Mongo, see http://www.mongodb.org.'
+  s.rubyforge_project = 'mongo'
+
+  s.files             = ['mongo.gemspec', 'LICENSE', 'VERSION']
+  s.files             += ['README.md', 'Rakefile', 'bin/mongo_console']
+  s.files             += ['lib/mongo.rb'] + Dir['lib/mongo/**/*.rb'] + Dir['examples/**/*.rb']
+
+  s.test_files        = Dir['test/**/*.rb']
+  s.executables       = ['mongo_console']
+  s.require_paths     = ['lib']
+  s.has_rdoc          = 'yard'
+
+  s.add_dependency('bson', "~> #{s.version}")
 end

data/test/auxillary/{1.4_features.rb → 1.4_feature_test.rb}

@@ -1,15 +1,14 @@
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'test_helper'
 require 'mongo'
-require 'test/unit'
-require File.expand_path("../../test_helper", __FILE__)
+
 
 # Demonstrate features in MongoDB 1.4
 class Features14Test < Test::Unit::TestCase
 
   context "MongoDB 1.4" do
     setup do
-      @con = Mongo::Connection.new
-      @db  = @con['mongo-ruby-test']
+      @client = MongoClient.new
+      @db  = @client['mongo-ruby-test']
       @col = @db['new-features']
     end
 

data/test/auxillary/authentication_test.rb

@@ -1,7 +1,5 @@
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'test_helper'
 require 'mongo'
-require 'test/unit'
-require File.expand_path("../../test_helper", __FILE__)
 
 # NOTE: This test requires bouncing the server.
 # It also requires that a user exists on the admin database.
@@ -9,17 +7,17 @@ class AuthenticationTest < Test::Unit::TestCase
   include Mongo
 
   def setup
-    @conn = Mongo::Connection.new
-    @db1 = @conn.db('mongo-ruby-test-auth1')
-    @db2 = @conn.db('mongo-ruby-test-auth2')
-    @admin = @conn.db('admin')
+    @client = MongoClient.new
+    @db1 = @client.db('mongo-ruby-test-auth1')
+    @db2 = @client.db('mongo-ruby-test-auth2')
+    @admin = @client.db('admin')
   end
 
   def teardown
     @db1.authenticate('user1', 'secret')
     @db2.authenticate('user2', 'secret')
-    @conn.drop_database('mongo-ruby-test-auth1')
-    @conn.drop_database('mongo-ruby-test-auth2')
+    @client.drop_database('mongo-ruby-test-auth1')
+    @client.drop_database('mongo-ruby-test-auth2')
   end
 
   def test_authenticate
@@ -30,18 +28,18 @@ class AuthenticationTest < Test::Unit::TestCase
     @admin.logout
 
     assert_raise Mongo::OperationFailure do
-      @db1['stuff'].insert({:a => 2}, :safe => true)
+      @db1['stuff'].insert({:a => 2})
     end
 
     assert_raise Mongo::OperationFailure do
-      @db2['stuff'].insert({:a => 2}, :safe => true)
+      @db2['stuff'].insert({:a => 2})
     end
 
     @db1.authenticate('user1', 'secret')
     @db2.authenticate('user2', 'secret')
 
-    assert @db1['stuff'].insert({:a => 2}, :safe => true)
-    assert @db2['stuff'].insert({:a => 2}, :safe => true)
+    assert @db1['stuff'].insert({:a => 2})
+    assert @db2['stuff'].insert({:a => 2})
 
     puts "Please bounce the server."
     gets
@@ -52,24 +50,24 @@ class AuthenticationTest < Test::Unit::TestCase
       rescue Mongo::ConnectionFailure
     end
 
-    assert @db1['stuff'].insert({:a => 2}, :safe => true)
-    assert @db2['stuff'].insert({:a => 2}, :safe => true)
-    assert @db2['stuff'].find(:safe => true)
+    assert @db1['stuff'].insert({:a => 2})
+    assert @db2['stuff'].insert({:a => 2})
+    assert @db2['stuff'].find({})
 
     @db1.logout
     assert_raise Mongo::OperationFailure do
-      @db1['stuff'].insert({:a => 2}, :safe => true)
+      @db1['stuff'].insert({:a => 2})
     end
 
     @db2.logout
     assert_raise Mongo::OperationFailure do
-      assert @db2['stuff'].insert({:a => 2}, :safe => true)
+      assert @db2['stuff'].insert({:a => 2})
     end
 
     @db2.authenticate('userRO', 'secret')
-    assert @db2['stuff'].find(:safe => true)
+    assert @db2['stuff'].find({})
     assert_raise Mongo::OperationFailure do
-      assert @db2['stuff'].insert({:a => 2}, :safe => true)
+      assert @db2['stuff'].insert({:a => 2})
     end
   end
 

data/test/auxillary/autoreconnect_test.rb

@@ -1,15 +1,13 @@
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'test_helper'
 require 'mongo'
-require 'test/unit'
-require File.expand_path("../../test_helper", __FILE__)
 
 # NOTE: This test requires bouncing the server
 class AutoreconnectTest < Test::Unit::TestCase
   include Mongo
 
   def setup
-    @conn = Mongo::Connection.new
-    @db = @conn.db('mongo-ruby-test')
+    @client = MongoClient.new
+    @db = @client.db('mongo-ruby-test')
     @db.drop_collection("test-connect")
     @coll = @db.collection("test-connect")
   end

data/test/auxillary/fork_test.rb

@@ -1,29 +1,27 @@
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'test_helper'
 require 'mongo'
-require 'test/unit'
-require File.expand_path("../../test_helper", __FILE__)
 
 class ForkTest < Test::Unit::TestCase
   include Mongo
 
   def setup
-    @conn = standard_connection
+    @client = standard_connection
   end
 
   def test_fork
     # Now insert some data
     10.times do |n|
-      @conn[MONGO_TEST_DB]['nums'].insert({:a => n})
+      @client[MONGO_TEST_DB]['nums'].insert({:a => n})
     end
 
     # Now fork. You'll almost always see an exception here.
     if !Kernel.fork
       10.times do
-        assert @conn[MONGO_TEST_DB]['nums'].find_one
+        assert @client[MONGO_TEST_DB]['nums'].find_one
       end
     else
       10.times do
-        assert @conn[MONGO_TEST_DB]['nums'].find_one
+        assert @client[MONGO_TEST_DB]['nums'].find_one
       end
     end
   end

data/test/auxillary/repl_set_auth_test.rb

@@ -1,7 +1,5 @@
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require File.expand_path("../../test_helper", __FILE__)
-require './test/tools/auth_repl_set_manager'
-require './test/replica_sets/rs_test_helper'
+require 'test_helper'
+require 'mongo'
 
 class AuthTest < Test::Unit::TestCase
   include Mongo
@@ -16,35 +14,35 @@ class AuthTest < Test::Unit::TestCase
   end
 
   def test_repl_set_auth
-    @conn = ReplSetConnection.new(build_seeds(3), :name => @rs.name)
+    @client = MongoReplicaSetClient.new(build_seeds(3), :name => @rs.name)
 
     # Add an admin user
-    @conn['admin'].add_user("me", "secret")
+    @client['admin'].add_user("me", "secret")
 
     # Ensure that insert fails
     assert_raise_error Mongo::OperationFailure, "unauthorized" do
-      @conn['foo']['stuff'].insert({:a => 2}, :safe => {:w => 3})
+      @client['foo']['stuff'].insert({:a => 2}, {:w => 3})
     end
 
     # Then authenticate
-    assert @conn['admin'].authenticate("me", "secret")
+    assert @client['admin'].authenticate("me", "secret")
 
     # Insert should succeed now
-    assert @conn['foo']['stuff'].insert({:a => 2}, :safe => {:w => 3})
+    assert @client['foo']['stuff'].insert({:a => 2}, {:w => 3})
 
     # So should a query
-    assert @conn['foo']['stuff'].find_one
+    assert @client['foo']['stuff'].find_one
 
     # But not when we logout
-    @conn['admin'].logout
+    @client['admin'].logout
 
     assert_raise_error Mongo::OperationFailure, "unauthorized" do
-      @conn['foo']['stuff'].find_one
+      @client['foo']['stuff'].find_one
     end
 
     # Same should apply to a random secondary
-    @slave1 = Connection.new(@conn.secondary_pools[0].host,
-      @conn.secondary_pools[0].port, :slave_ok => true)
+    @slave1 = MongoClient.new(@client.secondary_pools[0].host,
+      @client.secondary_pools[0].port, :slave_ok => true)
 
     # Find should fail
     assert_raise_error Mongo::OperationFailure, "unauthorized" do
@@ -56,7 +54,7 @@ class AuthTest < Test::Unit::TestCase
     assert @slave1['foo']['stuff'].find_one
 
     # Same should apply when using :secondary_only
-    @second_only = ReplSetConnection.new(build_seeds(3), 
+    @second_only = MongoReplicaSetClient.new(build_seeds(3), 
       :require_primary => false, :read => :secondary_only)
 
     # Find should fail

data/test/auxillary/slave_connection_test.rb

@@ -1,4 +1,5 @@
-require File.expand_path("../../test_helper", __FILE__)
+require 'test_helper'
+require 'mongo'
 
 # NOTE: these tests are run only if we can connect to a single MongoDB in slave mode.
 class SlaveConnectionTest < Test::Unit::TestCase
@@ -6,8 +7,8 @@ class SlaveConnectionTest < Test::Unit::TestCase
 
   def self.connect_to_slave
     @@host = ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost'
-    @@port = ENV['MONGO_RUBY_DRIVER_PORT'] || Connection::DEFAULT_PORT
-    conn = Connection.new(@@host, @@port, :slave_ok => true)
+    @@port = ENV['MONGO_RUBY_DRIVER_PORT'] || MongoClient::DEFAULT_PORT
+    conn = MongoClient.new(@@host, @@port, :slave_ok => true)
     response = conn['admin'].command(:ismaster => 1)
     Mongo::Support.ok?(response) && response['ismaster'] != 1
   end
@@ -17,20 +18,20 @@ class SlaveConnectionTest < Test::Unit::TestCase
 
     def test_connect_to_slave
       assert_raise Mongo::ConnectionFailure do
-        @db = Connection.new(@@host, @@port, :slave_ok => false).db('ruby-mongo-demo')
+        @db = MongoClient.new(@@host, @@port, :slave_ok => false).db('ruby-mongo-demo')
       end
     end
 
     def test_slave_ok_sent_to_queries
-      @con = Connection.new(@@host, @@port, :slave_ok => true)
+      @con = MongoClient.new(@@host, @@port, :slave_ok => true)
       assert_equal true, @con.slave_ok?
     end
   else
     puts "Not connected to slave; skipping slave connection tests."
 
     def test_slave_ok_false_on_queries
-      @conn = Connection.new(@@host, @@port)
-      assert !@conn.slave_ok?
+      @client = MongoClient.new(@@host, @@port)
+      assert !@client.slave_ok?
     end
   end
 end

data/test/auxillary/threaded_authentication_test.rb

@@ -1,8 +1,6 @@
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'test_helper'
 require 'mongo'
 require 'thread'
-require 'test/unit'
-require File.expand_path("../../test_helper", __FILE__)
 
 # NOTE: This test requires bouncing the server.
 # It also requires that a user exists on the admin database.
@@ -10,17 +8,17 @@ class AuthenticationTest < Test::Unit::TestCase
   include Mongo
 
   def setup
-    @conn = standard_connection(:pool_size => 10)
-    @db1 = @conn.db('mongo-ruby-test-auth1')
-    @db2 = @conn.db('mongo-ruby-test-auth2')
-    @admin = @conn.db('admin')
+    @client = standard_connection(:pool_size => 10)
+    @db1 = @client.db('mongo-ruby-test-auth1')
+    @db2 = @client.db('mongo-ruby-test-auth2')
+    @admin = @client.db('admin')
   end
 
   def teardown
     @db1.authenticate('user1', 'secret')
     @db2.authenticate('user2', 'secret')
-    @conn.drop_database('mongo-ruby-test-auth1')
-    @conn.drop_database('mongo-ruby-test-auth2')
+    @client.drop_database('mongo-ruby-test-auth1')
+    @client.drop_database('mongo-ruby-test-auth2')
   end
 
   def threaded_exec
@@ -45,13 +43,13 @@ class AuthenticationTest < Test::Unit::TestCase
 
     threaded_exec do
       assert_raise Mongo::OperationFailure do
-        @db1['stuff'].insert({:a => 2}, :safe => true)
+        @db1['stuff'].insert({:a => 2})
       end
     end
 
     threaded_exec do
       assert_raise Mongo::OperationFailure do
-        @db2['stuff'].insert({:a => 2}, :safe => true)
+        @db2['stuff'].insert({:a => 2})
       end
     end
 
@@ -59,11 +57,11 @@ class AuthenticationTest < Test::Unit::TestCase
     @db2.authenticate('user2', 'secret')
 
     threaded_exec do
-      assert @db1['stuff'].insert({:a => 2}, :safe => true)
+      assert @db1['stuff'].insert({:a => 2})
     end
 
     threaded_exec do
-      assert @db2['stuff'].insert({:a => 2}, :safe => true)
+      assert @db2['stuff'].insert({:a => 2})
     end
 
     puts "Please bounce the server."
@@ -76,24 +74,24 @@ class AuthenticationTest < Test::Unit::TestCase
     end
 
     threaded_exec do
-      assert @db1['stuff'].insert({:a => 2}, :safe => true)
+      assert @db1['stuff'].insert({:a => 2})
     end
 
     threaded_exec do
-      assert @db2['stuff'].insert({:a => 2}, :safe => true)
+      assert @db2['stuff'].insert({:a => 2})
     end
 
     @db1.logout
     threaded_exec do
       assert_raise Mongo::OperationFailure do
-        @db1['stuff'].insert({:a => 2}, :safe => true)
+        @db1['stuff'].insert({:a => 2})
       end
     end
 
     @db2.logout
     threaded_exec do
       assert_raise Mongo::OperationFailure do
-        assert @db2['stuff'].insert({:a => 2}, :safe => true)
+        assert @db2['stuff'].insert({:a => 2})
       end
     end
   end

data/test/bson/binary_test.rb

@@ -1,5 +1,5 @@
 # encoding:utf-8
-require File.expand_path("../test_helper", __FILE__)
+require 'test_helper'
 
 class BinaryTest < Test::Unit::TestCase
   def setup

data/test/bson/bson_test.rb

@@ -1,5 +1,5 @@
 # encoding:utf-8
-require File.expand_path("../test_helper", __FILE__)
+require 'test_helper'
 require 'set'
 
 if RUBY_VERSION < '1.9'
@@ -27,6 +27,18 @@ rescue LoadError
   Zone = ActiveSupport::TimeWithZone.new(Time.now.utc, 'EST')
 end
 
+begin
+  require 'active_support/multibyte/chars'
+rescue LoadError
+  warn 'Mocking ActiveSupport::Multibyte::Chars'
+  module ActiveSupport
+    module Multibyte
+      class Chars < String
+      end
+    end
+  end
+end
+
 class BSONTest < Test::Unit::TestCase
 
   include BSON
@@ -70,6 +82,17 @@ class BSONTest < Test::Unit::TestCase
     assert_doc_pass(doc)
   end
 
+  def test_valid_active_support_multibyte_chars
+    unless RUBY_PLATFORM =~ /java/
+      doc = {'doc' => ActiveSupport::Multibyte::Chars.new('aé')}
+      assert_doc_pass(doc)
+
+      bson = @encoder.serialize(doc)
+      doc = @encoder.deserialize(bson)
+      assert_equal doc['doc'], 'aé'
+    end
+  end
+
   def test_valid_utf8_key
     doc = {'aé' => 'hello'}
     assert_doc_pass(doc)
@@ -101,12 +124,11 @@ class BSONTest < Test::Unit::TestCase
   # In 1.8 we test that other string encodings raise an exception.
   # In 1.9 we test that they get auto-converted.
   if RUBY_VERSION < '1.9'
-    if ! RUBY_PLATFORM =~ /java/
+    unless RUBY_PLATFORM == 'java'
       require 'iconv'
       def test_non_utf8_string
         string = Iconv.conv('iso-8859-1', 'utf-8', 'aé')
         doc = {'doc' => string}
-        assert_doc_pass(doc)
         assert_raise InvalidStringEncoding do
           @encoder.serialize(doc)
         end
@@ -121,48 +143,50 @@ class BSONTest < Test::Unit::TestCase
       end
     end
   else
-    def test_non_utf8_string
-      assert_raise BSON::InvalidStringEncoding do
-        BSON::BSON_CODER.serialize({'str' => 'aé'.encode('iso-8859-1')})
+    unless RUBY_PLATFORM == 'java'
+      def test_non_utf8_string
+        assert_raise BSON::InvalidStringEncoding do
+          BSON::BSON_CODER.serialize({'str' => 'aé'.encode('iso-8859-1')})
+        end
       end
-    end
 
-    def test_invalid_utf8_string
-      str = "123\xD9"
-      assert !str.valid_encoding?
-      assert_raise BSON::InvalidStringEncoding do
-        BSON::BSON_CODER.serialize({'str' => str})
+      def test_invalid_utf8_string
+        str = "123\xD9"
+        assert !str.valid_encoding?
+        assert_raise BSON::InvalidStringEncoding do
+          BSON::BSON_CODER.serialize({'str' => str})
+        end
       end
-    end
 
-    def test_non_utf8_key
-      assert_raise BSON::InvalidStringEncoding do
-        BSON::BSON_CODER.serialize({'aé'.encode('iso-8859-1') => 'hello'})
+      def test_non_utf8_key
+        assert_raise BSON::InvalidStringEncoding do
+          BSON::BSON_CODER.serialize({'aé'.encode('iso-8859-1') => 'hello'})
+        end
       end
-    end
 
-    def test_forced_encoding_with_valid_utf8
-      doc = {'doc' => "\xC3\xB6".force_encoding("ISO-8859-1")}
-      serialized = @encoder.serialize(doc)
-      deserialized = @encoder.deserialize(serialized)
-      assert_equal(doc['doc'], deserialized['doc'].force_encoding("ISO-8859-1"))
-    end
+      def test_forced_encoding_with_valid_utf8
+        doc = {'doc' => "\xC3\xB6".force_encoding("ISO-8859-1")}
+        serialized = @encoder.serialize(doc)
+        deserialized = @encoder.deserialize(serialized)
+        assert_equal(doc['doc'], deserialized['doc'].force_encoding("ISO-8859-1"))
+      end
 
-    # Based on a test from sqlite3-ruby
-    def test_default_internal_is_honored
-      before_enc = Encoding.default_internal
+      # Based on a test from sqlite3-ruby
+      def test_default_internal_is_honored
+        before_enc = Encoding.default_internal
 
-      str = "壁に耳あり、障子に目あり"
-      bson = BSON::BSON_CODER.serialize("x" => str)
+        str = "壁に耳あり、障子に目あり"
+        bson = BSON::BSON_CODER.serialize("x" => str)
 
-      silently { Encoding.default_internal = 'EUC-JP' }
-      out = BSON::BSON_CODER.deserialize(bson)["x"]
+        silently { Encoding.default_internal = 'EUC-JP' }
+        out = BSON::BSON_CODER.deserialize(bson)["x"]
 
-      assert_equal Encoding.default_internal, out.encoding
-      assert_equal str.encode('EUC-JP'), out
-      assert_equal str, out.encode(str.encoding)
-    ensure
-      silently { Encoding.default_internal = before_enc }
+        assert_equal Encoding.default_internal, out.encoding
+        assert_equal str.encode('EUC-JP'), out
+        assert_equal str, out.encode(str.encoding)
+      ensure
+        silently { Encoding.default_internal = before_enc }
+      end
     end
   end
 
@@ -287,7 +311,7 @@ class BSONTest < Test::Unit::TestCase
   end
 
   def test_date_before_epoch
-    if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/ then return true end 
+    if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/ then return true end
     begin
       doc = {'date' => Time.utc(1600)}
       bson = @encoder.serialize(doc)