mongo 0.18 → 0.18.1

data/lib/mongo/util/byte_buffer.rb

@@ -27,6 +27,25 @@ class ByteBuffer
     @double_pack_order = 'E'
   end
 
+  if RUBY_VERSION >= '1.9'
+    def self.to_utf8(str)
+      str.encode("utf-8")
+    end
+  else
+    def self.to_utf8(str)
+      begin
+      str.unpack("U*")
+      rescue => ex
+        raise InvalidStringEncoding, "String not valid utf-8: #{str}"
+      end
+      str
+    end
+  end
+
+  def self.serialize_cstr(buf, val)
+    buf.put_array(to_utf8(val.to_s).unpack("C*") + [0])
+  end
+
   # +endianness+ should be :little_endian or :big_endian. Default is :little_endian
   def order=(endianness)
     @order = endianness
@@ -160,6 +179,10 @@ class ByteBuffer
     end
   end
 
+  def unpack(args)
+    to_a
+  end
+
   def to_s
     if @buf.respond_to? :fast_pack
       @buf.fast_pack

data/test/test_admin.rb

@@ -1,6 +1,4 @@
-$LOAD_PATH[0,0] = File.join(File.dirname(__FILE__), '..', 'lib')
-require 'mongo'
-require 'test/unit'
+require 'test/test_helper'
 
 # NOTE: assumes Mongo is running
 class AdminTest < Test::Unit::TestCase

data/test/test_bson.rb

@@ -1,53 +1,89 @@
-$LOAD_PATH[0,0] = File.join(File.dirname(__FILE__), '..', 'lib')
-require 'mongo'
-require 'mongo/util/ordered_hash'
-require 'test/unit'
+# encoding:utf-8
+require 'test/test_helper'
 
 class BSONTest < Test::Unit::TestCase
 
   include Mongo
 
-  def setup
-    # We don't pass a DB to the constructor, even though we are about to test
-    # deserialization. This means that when we deserialize, any DBRefs will
-    # have nil @db ivars. That's fine for now.
-    @b = BSON.new
-  end
-
   def test_string
     doc = {'doc' => 'hello, world'}
-    @b.serialize(doc)
-    assert_equal doc, @b.deserialize
+    bson = bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
+  end
+
+  def test_valid_utf8_string
+    doc = {'doc' => 'aé'}
+    bson = bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
+  end
+
+  def test_valid_utf8_key
+    doc = {'aé' => 'hello'}
+    bson = bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
+  end
+
+  # 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'
+    require 'iconv'
+    def test_invalid_string
+      string = Iconv.conv('iso-8859-1', 'utf-8', 'aé')
+      doc = {'doc' => string}
+      assert_raise InvalidStringEncoding do
+        BSON.serialize(doc)
+      end
+    end
+
+    def test_invalid_key
+      key = Iconv.conv('iso-8859-1', 'utf-8', 'aé')
+      doc = {key => 'hello'}
+      assert_raise InvalidStringEncoding do
+        BSON.serialize(doc)
+      end
+    end
+  else
+    def test_non_utf8_string
+      bson = BSON.serialize({'str' => 'aé'.encode('iso-8859-1')})
+      result = BSON.deserialize(bson)['str']
+      assert_equal 'aé', result
+      assert_equal 'UTF-8', result.encoding.name
+    end
+
+    def test_non_utf8_key
+      bson = BSON.serialize({'aé'.encode('iso-8859-1') => 'hello'})
+      assert_equal 'hello', BSON.deserialize(bson)['aé']
+    end
   end
 
   def test_code
     doc = {'$where' => Code.new('this.a.b < this.b')}
-    @b.serialize(doc)
-    assert_equal doc, @b.deserialize
+    bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
   end
 
   def test_number
     doc = {'doc' => 41.99}
-    @b.serialize(doc)
-    assert_equal doc, @b.deserialize
+    bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
   end
 
   def test_int
     doc = {'doc' => 42}
-    @b.serialize(doc)
-    assert_equal doc, @b.deserialize
+    bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
 
     doc = {"doc" => -5600}
-    @b.serialize(doc)
-    assert_equal doc, @b.deserialize
+    bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
 
     doc = {"doc" => 2147483647}
-    @b.serialize(doc)
-    assert_equal doc, @b.deserialize
+    bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
 
     doc = {"doc" => -2147483648}
-    @b.serialize(doc)
-    assert_equal doc, @b.deserialize
+    bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
   end
 
   def test_ordered_hash
@@ -56,32 +92,32 @@ class BSONTest < Test::Unit::TestCase
     doc["a"] = 2
     doc["c"] = 3
     doc["d"] = 4
-    @b.serialize(doc)
-    assert_equal doc, @b.deserialize
+    bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
   end
 
   def test_object
     doc = {'doc' => {'age' => 42, 'name' => 'Spongebob', 'shoe_size' => 9.5}}
-    @b.serialize(doc)
-    assert_equal doc, @b.deserialize
+    bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
   end
 
   def test_oid
     doc = {'doc' => ObjectID.new}
-    @b.serialize(doc)
-    assert_equal doc, @b.deserialize
+    bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
   end
 
   def test_array
     doc = {'doc' => [1, 2, 'a', 'b']}
-    @b.serialize(doc)
-    assert_equal doc, @b.deserialize
+    bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
   end
 
   def test_regex
     doc = {'doc' => /foobar/i}
-    @b.serialize(doc)
-    doc2 = @b.deserialize
+    bson = BSON.serialize(doc)
+    doc2 = BSON.deserialize(bson)
     assert_equal doc, doc2
 
     r = doc2['doc']
@@ -91,11 +127,10 @@ class BSONTest < Test::Unit::TestCase
     r.extra_options_str << 'zywcab'
     assert_equal 'zywcab', r.extra_options_str
 
-    b = BSON.new
     doc = {'doc' => r}
-    b.serialize(doc)
+    bson_doc = BSON.serialize(doc)
     doc2 = nil
-    doc2 = b.deserialize
+    doc2 = BSON.deserialize(bson_doc)
     assert_equal doc, doc2
 
     r = doc2['doc']
@@ -105,30 +140,30 @@ class BSONTest < Test::Unit::TestCase
 
   def test_boolean
     doc = {'doc' => true}
-    @b.serialize(doc)
-    assert_equal doc, @b.deserialize
+    bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
   end
 
   def test_date
     doc = {'date' => Time.now}
-    @b.serialize(doc)
-    doc2 = @b.deserialize
+    bson = BSON.serialize(doc)
+    doc2 = BSON.deserialize(bson)
     # Mongo only stores up to the millisecond
     assert_in_delta doc['date'], doc2['date'], 0.001
   end
 
   def test_date_returns_as_utc
     doc = {'date' => Time.now}
-    @b.serialize(doc)
-    doc2 = @b.deserialize
+    bson = BSON.serialize(doc)
+    doc2 = BSON.deserialize(bson)
     assert doc2['date'].utc?
   end
 
   def test_date_before_epoch
     begin
       doc = {'date' => Time.utc(1600)}
-      @b.serialize(doc)
-      doc2 = @b.deserialize
+      bson = BSON.serialize(doc)
+      doc2 = BSON.deserialize(bson)
       # Mongo only stores up to the millisecond
       assert_in_delta doc['date'], doc2['date'], 0.001
     rescue ArgumentError
@@ -143,16 +178,16 @@ class BSONTest < Test::Unit::TestCase
     oid = ObjectID.new
     doc = {}
     doc['dbref'] = DBRef.new('namespace', oid)
-    @b.serialize(doc)
-    doc2 = @b.deserialize
+    bson = BSON.serialize(doc)
+    doc2 = BSON.deserialize(bson)
     assert_equal 'namespace', doc2['dbref'].namespace
     assert_equal oid, doc2['dbref'].object_id
   end
 
   def test_symbol
     doc = {'sym' => :foo}
-    @b.serialize(doc)
-    doc2 = @b.deserialize
+    bson = BSON.serialize(doc)
+    doc2 = BSON.deserialize(bson)
     assert_equal :foo, doc2['sym']
   end
 
@@ -161,8 +196,8 @@ class BSONTest < Test::Unit::TestCase
     'binstring'.each_byte { |b| bin.put(b) }
 
     doc = {'bin' => bin}
-    @b.serialize(doc)
-    doc2 = @b.deserialize
+    bson = BSON.serialize(doc)
+    doc2 = BSON.deserialize(bson)
     bin2 = doc2['bin']
     assert_kind_of Binary, bin2
     assert_equal 'binstring', bin2.to_s
@@ -173,8 +208,8 @@ class BSONTest < Test::Unit::TestCase
     bin = Binary.new([1, 2, 3, 4, 5], Binary::SUBTYPE_USER_DEFINED)
 
     doc = {'bin' => bin}
-    @b.serialize(doc)
-    doc2 = @b.deserialize
+    bson = BSON.serialize(doc)
+    doc2 = BSON.deserialize(bson)
     bin2 = doc2['bin']
     assert_kind_of Binary, bin2
     assert_equal [1, 2, 3, 4, 5], bin2.to_a
@@ -186,8 +221,8 @@ class BSONTest < Test::Unit::TestCase
     5.times { |i| bb.put(i + 1) }
 
     doc = {'bin' => bb}
-    @b.serialize(doc)
-    doc2 = @b.deserialize
+    bson = BSON.serialize(doc)
+    doc2 = BSON.deserialize(bson)
     bin2 = doc2['bin']
     assert_kind_of Binary, bin2
     assert_equal [1, 2, 3, 4, 5], bin2.to_a
@@ -198,24 +233,24 @@ class BSONTest < Test::Unit::TestCase
     val = OrderedHash.new
     val['not_id'] = 1
     val['_id'] = 2
-    roundtrip = @b.deserialize(@b.serialize(val).to_a)
+    roundtrip = BSON.deserialize(BSON.serialize(val).to_a)
     assert_kind_of OrderedHash, roundtrip
     assert_equal '_id', roundtrip.keys.first
 
     val = {'a' => 'foo', 'b' => 'bar', :_id => 42, 'z' => 'hello'}
-    roundtrip = @b.deserialize(@b.serialize(val).to_a)
+    roundtrip = BSON.deserialize(BSON.serialize(val).to_a)
     assert_kind_of OrderedHash, roundtrip
     assert_equal '_id', roundtrip.keys.first
   end
 
   def test_nil_id
     doc = {"_id" => nil}
-    assert_equal doc, @b.deserialize(@b.serialize(doc).to_a)
+    assert_equal doc, BSON.deserialize(bson = BSON.serialize(doc).to_a)
   end
 
   def test_timestamp
     val = {"test" => [4, 20]}
-    assert_equal val, @b.deserialize([0x13, 0x00, 0x00, 0x00,
+    assert_equal val, BSON.deserialize([0x13, 0x00, 0x00, 0x00,
                                       0x11, 0x74, 0x65, 0x73,
                                       0x74, 0x00, 0x04, 0x00,
                                       0x00, 0x00, 0x14, 0x00,
@@ -225,29 +260,29 @@ class BSONTest < Test::Unit::TestCase
   def test_overflow
     doc = {"x" => 2**75}
     assert_raise RangeError do
-      @b.serialize(doc)
+      bson = BSON.serialize(doc)
     end
 
     doc = {"x" => 9223372036854775}
-    assert_equal doc, @b.deserialize(@b.serialize(doc).to_a)
+    assert_equal doc, BSON.deserialize(BSON.serialize(doc).to_a)
 
     doc = {"x" => 9223372036854775807}
-    assert_equal doc, @b.deserialize(@b.serialize(doc).to_a)
+    assert_equal doc, BSON.deserialize(BSON.serialize(doc).to_a)
 
     doc["x"] = doc["x"] + 1
     assert_raise RangeError do
-      @b.serialize(doc)
+      bson = BSON.serialize(doc)
     end
 
     doc = {"x" => -9223372036854775}
-    assert_equal doc, @b.deserialize(@b.serialize(doc).to_a)
+    assert_equal doc, BSON.deserialize(BSON.serialize(doc).to_a)
 
     doc = {"x" => -9223372036854775808}
-    assert_equal doc, @b.deserialize(@b.serialize(doc).to_a)
+    assert_equal doc, BSON.deserialize(BSON.serialize(doc).to_a)
 
     doc["x"] = doc["x"] - 1
     assert_raise RangeError do
-      @b.serialize(doc)
+      bson = BSON.serialize(doc)
     end
   end
 
@@ -256,12 +291,12 @@ class BSONTest < Test::Unit::TestCase
     val['not_id'] = 1
     val['_id'] = 2
     assert val.keys.include?('_id')
-    @b.serialize(val)
+    BSON.serialize(val)
     assert val.keys.include?('_id')
 
     val = {'a' => 'foo', 'b' => 'bar', :_id => 42, 'z' => 'hello'}
     assert val.keys.include?(:_id)
-    @b.serialize(val)
+    BSON.serialize(val)
     assert val.keys.include?(:_id)
   end
 
@@ -276,7 +311,7 @@ class BSONTest < Test::Unit::TestCase
     dup = {"_id" => "foo", :_id => "foo"}
     one = {"_id" => "foo"}
 
-    assert_equal @b.serialize(one).to_a, @b.serialize(dup).to_a
+    assert_equal BSON.serialize(one).to_a, BSON.serialize(dup).to_a
   end
 
 end

data/test/test_byte_buffer.rb

@@ -1,6 +1,4 @@
-$LOAD_PATH[0,0] = File.join(File.dirname(__FILE__), '..', 'lib')
-require 'mongo'
-require 'test/unit'
+require 'test/test_helper'
 
 class ByteBufferTest < Test::Unit::TestCase
 

data/test/test_chunk.rb

@@ -1,6 +1,4 @@
-$LOAD_PATH[0,0] = File.join(File.dirname(__FILE__), '..', 'lib')
-require 'test/unit'
-require 'mongo'
+require 'test/test_helper'
 require 'mongo/gridfs'
 
 class ChunkTest < Test::Unit::TestCase

data/test/test_collection.rb

@@ -1,20 +1,5 @@
-# --
-# Copyright (C) 2008-2009 10gen 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/test_helper'
+
 class TestCollection < Test::Unit::TestCase
   @@connection = Connection.new(ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost', ENV['MONGO_RUBY_DRIVER_PORT'] || Connection::DEFAULT_PORT)
   @@db   = @@connection.db('ruby-mongo-test')
@@ -41,11 +26,20 @@ class TestCollection < Test::Unit::TestCase
     assert @coll.pk_factory.is_a?(Object)
   end
 
-  def test_collection
+  def test_valid_names
     assert_raise InvalidName do
       @@db["te$t"]
     end
 
+    assert_raise InvalidName do
+      @@db['$main']
+    end
+
+    assert @@db['$cmd']
+    assert @@db['oplog.$main']
+  end
+
+  def test_collection
     assert_kind_of Collection, @@db["test"]
     assert_equal @@db["test"].name(), @@db.collection("test").name()
     assert_equal @@db["test"].name(), @@db[:test].name()