bson 0.20

data/lib/bson/types/code.rb

@@ -0,0 +1,36 @@
+# --
+# Copyright (C) 2008-2010 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.
+# ++
+
+module BSON
+
+  # JavaScript code to be evaluated by MongoDB.
+  class Code < String
+
+    # Hash mapping identifiers to their values
+    attr_accessor :scope
+
+    # Wrap code to be evaluated by MongoDB.
+    #
+    # @param [String] code the JavaScript code.
+    # @param [Hash] a document mapping identifiers to values, which
+    #   represent the scope in which the code is to be executed.
+    def initialize(code, scope={})
+      super(code)
+      @scope = scope
+    end
+
+  end
+end

data/lib/bson/types/dbref.rb

@@ -0,0 +1,40 @@
+# --
+# Copyright (C) 2008-2010 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.
+# ++
+
+module BSON
+
+  # A reference to another object in a MongoDB database.
+  class DBRef
+
+    attr_reader :namespace, :object_id
+
+    # Create a DBRef. Use this class in conjunction with DB#dereference.
+    #
+    # @param [String] a collection name
+    # @param [ObjectID] an object id
+    #
+    # @core dbrefs constructor_details
+    def initialize(namespace, object_id)
+      @namespace = namespace
+      @object_id = object_id
+    end
+
+    def to_s
+      "ns: #{namespace}, id: #{object_id}"
+    end
+
+  end
+end

data/lib/bson/types/min_max_keys.rb

@@ -0,0 +1,58 @@
+# --
+# Copyright (C) 2008-2010 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.
+# ++
+
+module BSON
+
+  # A class representing the BSON MaxKey type. MaxKey will always compare greater than
+  # all other BSON types and values.
+  #
+  # @example Sorting (assume @numbers is a collection):
+  #
+  #   >> @numbers.save({"n" => Mongo::MaxKey.new})
+  #   >> @numbers.save({"n" => 0})
+  #   >> @numbers.save({"n" => 5_000_000})
+  #   >> @numbers.find.sort("n").to_a
+  #   => [{"_id"=>4b5a050c238d3bace2000004, "n"=>0},
+  #       {"_id"=>4b5a04e6238d3bace2000002, "n"=>5_000_000},
+  #       {"_id"=>4b5a04ea238d3bace2000003, "n"=>#<Mongo::MaxKey:0x1014ef410>},
+  #      ]
+  class MaxKey
+
+    def ==(obj)
+      obj.class == MaxKey
+    end
+  end
+
+  # A class representing the BSON MinKey type. MinKey will always compare less than
+  # all other BSON types and values.
+  #
+  # @example Sorting (assume @numbers is a collection):
+  #
+  #   >> @numbers.save({"n" => Mongo::MinKey.new})
+  #   >> @numbers.save({"n" => -1_000_000})
+  #   >> @numbers.save({"n" => 1_000_000})
+  #   >> @numbers.find.sort("n").to_a
+  #   => [{"_id"=>4b5a050c238d3bace2000004, "n"=>#<Mongo::MinKey:0x1014ef410>},
+  #       {"_id"=>4b5a04e6238d3bace2000002, "n"=>-1_000_000},
+  #       {"_id"=>4b5a04ea238d3bace2000003, "n"=>1_000_000},
+  #      ]
+  class MinKey
+
+    def ==(obj)
+      obj.class == MinKey
+    end
+  end
+end

data/lib/bson/types/objectid.rb

@@ -0,0 +1,180 @@
+# --
+# Copyright (C) 2008-2010 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 'thread'
+require 'socket'
+require 'digest/md5'
+
+module BSON
+
+  # Generates MongoDB object ids.
+  #
+  # @core objectids
+  class ObjectID
+    @@lock  = Mutex.new
+    @@index = 0
+
+    # Create a new object id. If no parameter is given, an id corresponding
+    # to the ObjectID BSON data type will be created. This is a 12-byte value
+    # consisting of a 4-byte timestamp, a 3-byte machine id, a 2-byte process id,
+    # and a 3-byte counter.
+    #
+    # @param [Array] data should be an array of bytes. If you want
+    #   to generate a standard MongoDB object id, leave this argument blank.
+    def initialize(data=nil)
+      @data = data || generate
+    end
+
+    # Determine if the supplied string is legal. Legal strings will
+    # consist of 24 hexadecimal characters.
+    #
+    # @param [String] str
+    #
+    # @return [Boolean]
+    def self.legal?(str)
+      len = 24
+      str =~ /([0-9a-f]+)/i
+      match = $1
+      str && str.length == len && match == str
+    end
+
+    # Create an object id from the given time. This is useful for doing range
+    # queries; it works because MongoDB's object ids begin
+    # with a timestamp.
+    #
+    # @param [Time] time a utc time to encode as an object id.
+    #
+    # @return [Mongo::ObjectID]
+    #
+    # @example Return all document created before Jan 1, 2010.
+    #   time = Time.utc(2010, 1, 1)
+    #   time_id = ObjectID.from_time(time)
+    #   collection.find({'_id' => {'$lt' => time_id}})
+    def self.from_time(time)
+      self.new([time.to_i,0,0].pack("NNN").unpack("C12"))
+    end
+
+    # Adds a primary key to the given document if needed.
+    #
+    # @param [Hash] doc a document requiring an _id.
+    #
+    # @return [Mongo::ObjectID, Object] returns a newly-created or 
+    #   current _id for the given document.
+    def self.create_pk(doc)
+      doc.has_key?(:_id) || doc.has_key?('_id') ? doc : doc.merge!(:_id => self.new)
+    end
+
+    # Check equality of this object id with another.
+    #
+    # @param [Mongo::ObjectID] object_id
+    def eql?(object_id)
+      @data == object_id.instance_variable_get("@data")
+    end
+    alias_method :==, :eql?
+
+    # Get a unique hashcode for this object.
+    # This is required since we've defined an #eql? method.
+    #
+    # @return [Integer]
+    def hash
+      @data.hash
+    end
+
+    # Get an array representation of the object id.
+    #
+    # @return [Array]
+    def to_a
+      @data.dup
+    end
+
+    # Given a string representation of an ObjectID, return a new ObjectID
+    # with that value.
+    #
+    # @param [String] str
+    #
+    # @return [Mongo::ObjectID]
+    def self.from_string(str)
+      raise InvalidObjectID, "illegal ObjectID format" unless legal?(str)
+      data = []
+      12.times do |i|
+        data[i] = str[i * 2, 2].to_i(16)
+      end
+      self.new(data)
+    end
+
+    # Get a string representation of this object id.
+    #
+    # @return [String]
+    def to_s
+      str = ' ' * 24
+      12.times do |i|
+        str[i * 2, 2] = '%02x' % @data[i]
+      end
+      str
+    end
+
+    def inspect
+      "ObjectID('#{to_s}')"
+    end
+
+    # Convert to MongoDB extended JSON format. Since JSON includes type information,
+    # but lacks an ObjectID type, this JSON format encodes the type using an $id key.
+    #
+    # @return [String] the object id represented as MongoDB extended JSON.
+    def to_json(escaped=false)
+      "{\"$oid\": \"#{to_s}\"}"
+    end
+
+    # Return the UTC time at which this ObjectID was generated. This may
+    # be used in lieu of a created_at timestamp since this information
+    # is always encoded in the object id.
+    #
+    # @return [Time] the time at which this object was created.
+    def generation_time
+      Time.at(@data.pack("C4").unpack("N")[0]).utc
+    end
+
+    private
+
+    # We need to define this method only if CBson isn't loaded.
+    unless defined? CBson
+      def generate
+        oid = ''
+
+        # 4 bytes current time
+        time = Time.new.to_i
+        oid += [time].pack("N")
+
+        # 3 bytes machine
+        oid += Digest::MD5.digest(Socket.gethostname)[0, 3]
+
+        # 2 bytes pid
+        oid += [Process.pid % 0xFFFF].pack("n")
+
+        # 3 bytes inc
+        oid += [get_inc].pack("N")[1, 3]
+
+        oid.unpack("C12")
+      end
+    end
+
+    def get_inc
+      @@lock.synchronize do
+        @@index = (@@index + 1) % 0xFFFFFF
+      end
+    end
+  end
+end

data/test/mongo_bson/binary_test.rb

@@ -0,0 +1,15 @@
+# encoding:utf-8
+require 'test/test_helper'
+
+class BinaryTest < Test::Unit::TestCase
+  context "Inspecting" do
+    setup do
+      @data = ("THIS IS BINARY " * 50).unpack("c*")
+    end
+
+    should "not display actual data" do
+      binary = BSON::Binary.new(@data)
+      assert_equal "<BSON::Binary:#{binary.object_id}>", binary.inspect
+    end
+  end
+end

data/test/mongo_bson/bson_test.rb

@@ -0,0 +1,471 @@
+# encoding:utf-8
+require 'test/test_helper'
+require 'complex'
+require 'bigdecimal'
+require 'rational'
+
+begin
+  require 'active_support/core_ext'
+  require 'active_support/hash_with_indifferent_access'
+  Time.zone = "Pacific Time (US & Canada)"
+  Zone = Time.zone.now
+rescue LoadError
+  warn 'Could not test BSON with HashWithIndifferentAccess.'
+  module ActiveSupport
+    class TimeWithZone
+    end
+  end
+  Zone = ActiveSupport::TimeWithZone.new
+end
+
+class BSONTest < Test::Unit::TestCase
+
+  include BSON
+
+  def test_deprecated_bson_module
+    doc = {'doc' => 'hello, world'}
+    bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
+  end
+
+  def test_string
+    doc = {'doc' => 'hello, world'}
+    bson = bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+  end
+
+  def test_valid_utf8_string
+    doc = {'doc' => 'aé'}
+    bson = bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+  end
+
+  def test_valid_utf8_key
+    doc = {'aé' => 'hello'}
+    bson = bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+  end
+
+  def test_document_length
+    doc = {'name' => 'a' * 5 * 1024 * 1024}
+    assert_raise InvalidDocument do
+      assert BSON::BSON_CODER.serialize(doc)
+    end
+  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::BSON_CODER.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::BSON_CODER.serialize(doc)
+      end
+    end
+  else
+    def test_non_utf8_string
+      bson = BSON::BSON_CODER.serialize({'str' => 'aé'.encode('iso-8859-1')})
+      result = BSON::BSON_CODER.deserialize(bson)['str']
+      assert_equal 'aé', result
+      assert_equal 'UTF-8', result.encoding.name
+    end
+
+    def test_non_utf8_key
+      bson = BSON::BSON_CODER.serialize({'aé'.encode('iso-8859-1') => 'hello'})
+      assert_equal 'hello', BSON::BSON_CODER.deserialize(bson)['aé']
+    end
+  end
+
+  def test_code
+    doc = {'$where' => Code.new('this.a.b < this.b')}
+    bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+  end
+
+  def test_number
+    doc = {'doc' => 41.99}
+    bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+  end
+
+  def test_int
+    doc = {'doc' => 42}
+    bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+
+    doc = {"doc" => -5600}
+    bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+
+    doc = {"doc" => 2147483647}
+    bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+
+    doc = {"doc" => -2147483648}
+    bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+  end
+
+  def test_ordered_hash
+    doc = OrderedHash.new
+    doc["b"] = 1
+    doc["a"] = 2
+    doc["c"] = 3
+    doc["d"] = 4
+    bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+  end
+
+  def test_object
+    doc = {'doc' => {'age' => 42, 'name' => 'Spongebob', 'shoe_size' => 9.5}}
+    bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+  end
+
+  def test_oid
+    doc = {'doc' => ObjectID.new}
+    bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+  end
+
+  def test_array
+    doc = {'doc' => [1, 2, 'a', 'b']}
+    bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+  end
+
+  def test_regex
+    doc = {'doc' => /foobar/i}
+    bson = BSON::BSON_CODER.serialize(doc)
+    doc2 = BSON::BSON_CODER.deserialize(bson)
+    assert_equal doc, doc2
+
+    r = doc2['doc']
+    assert_kind_of Regexp, r
+
+    doc = {'doc' => r}
+    bson_doc = BSON::BSON_CODER.serialize(doc)
+    doc2 = nil
+    doc2 = BSON::BSON_CODER.deserialize(bson_doc)
+    assert_equal doc, doc2
+  end
+
+  def test_boolean
+    doc = {'doc' => true}
+    bson = BSON::BSON_CODER.serialize(doc)
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+  end
+
+  def test_date
+    doc = {'date' => Time.now}
+    bson = BSON::BSON_CODER.serialize(doc)
+    doc2 = BSON::BSON_CODER.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}
+    bson = BSON::BSON_CODER.serialize(doc)
+    doc2 = BSON::BSON_CODER.deserialize(bson)
+    assert doc2['date'].utc?
+  end
+
+  def test_date_before_epoch
+    begin
+      doc = {'date' => Time.utc(1600)}
+      bson = BSON::BSON_CODER.serialize(doc)
+      doc2 = BSON::BSON_CODER.deserialize(bson)
+      # Mongo only stores up to the millisecond
+      assert_in_delta doc['date'], doc2['date'], 0.001
+    rescue ArgumentError
+      # some versions of Ruby won't let you create pre-epoch Time instances
+      #
+      # TODO figure out how that will work if somebady has saved data
+      # w/ early dates already and is just querying for it.
+    end
+  end
+
+  def test_exeption_on_using_unsupported_date_class
+    [DateTime.now, Date.today, Zone].each do |invalid_date|
+      doc = {:date => invalid_date}
+      begin
+      bson = BSON::BSON_CODER.serialize(doc)
+      rescue => e
+      ensure
+        if !invalid_date.is_a? Time
+          assert_equal InvalidDocument, e.class
+          assert_match /UTC Time/, e.message
+        end
+      end
+    end
+  end
+
+  def test_dbref
+    oid = ObjectID.new
+    doc = {}
+    doc['dbref'] = DBRef.new('namespace', oid)
+    bson = BSON::BSON_CODER.serialize(doc)
+    doc2 = BSON::BSON_CODER.deserialize(bson)
+    assert_equal 'namespace', doc2['dbref'].namespace
+    assert_equal oid, doc2['dbref'].object_id
+  end
+
+  def test_symbol
+    doc = {'sym' => :foo}
+    bson = BSON::BSON_CODER.serialize(doc)
+    doc2 = BSON::BSON_CODER.deserialize(bson)
+    assert_equal :foo, doc2['sym']
+  end
+
+  def test_binary
+    bin = Binary.new
+    'binstring'.each_byte { |b| bin.put(b) }
+
+    doc = {'bin' => bin}
+    bson = BSON::BSON_CODER.serialize(doc)
+    doc2 = BSON::BSON_CODER.deserialize(bson)
+    bin2 = doc2['bin']
+    assert_kind_of Binary, bin2
+    assert_equal 'binstring', bin2.to_s
+    assert_equal Binary::SUBTYPE_BYTES, bin2.subtype
+  end
+
+  def test_binary_with_string
+    b = Binary.new('somebinarystring')
+    doc = {'bin' => b}
+    bson = BSON::BSON_CODER.serialize(doc)
+    doc2 = BSON::BSON_CODER.deserialize(bson)
+    bin2 = doc2['bin']
+    assert_kind_of Binary, bin2
+    assert_equal 'somebinarystring', bin2.to_s
+    assert_equal Binary::SUBTYPE_BYTES, bin2.subtype
+  end
+
+  def test_binary_type
+    bin = Binary.new([1, 2, 3, 4, 5], Binary::SUBTYPE_USER_DEFINED)
+
+    doc = {'bin' => bin}
+    bson = BSON::BSON_CODER.serialize(doc)
+    doc2 = BSON::BSON_CODER.deserialize(bson)
+    bin2 = doc2['bin']
+    assert_kind_of Binary, bin2
+    assert_equal [1, 2, 3, 4, 5], bin2.to_a
+    assert_equal Binary::SUBTYPE_USER_DEFINED, bin2.subtype
+  end
+
+  def test_binary_byte_buffer
+    bb = Binary.new
+    5.times { |i| bb.put(i + 1) }
+
+    doc = {'bin' => bb}
+    bson = BSON::BSON_CODER.serialize(doc)
+    doc2 = BSON::BSON_CODER.deserialize(bson)
+    bin2 = doc2['bin']
+    assert_kind_of Binary, bin2
+    assert_equal [1, 2, 3, 4, 5], bin2.to_a
+    assert_equal Binary::SUBTYPE_BYTES, bin2.subtype
+  end
+
+  def test_put_id_first
+    val = OrderedHash.new
+    val['not_id'] = 1
+    val['_id'] = 2
+    roundtrip = BSON::BSON_CODER.deserialize(BSON::BSON_CODER.serialize(val, false, true).to_a)
+    assert_kind_of OrderedHash, roundtrip
+    assert_equal '_id', roundtrip.keys.first
+
+    val = {'a' => 'foo', 'b' => 'bar', :_id => 42, 'z' => 'hello'}
+    roundtrip = BSON::BSON_CODER.deserialize(BSON::BSON_CODER.serialize(val, false, true).to_a)
+    assert_kind_of OrderedHash, roundtrip
+    assert_equal '_id', roundtrip.keys.first
+  end
+
+  def test_nil_id
+    doc = {"_id" => nil}
+    assert_equal doc, BSON::BSON_CODER.deserialize(bson = BSON::BSON_CODER.serialize(doc, false, true).to_a)
+  end
+
+  def test_timestamp
+    val = {"test" => [4, 20]}
+    assert_equal val, BSON::BSON_CODER.deserialize([0x13, 0x00, 0x00, 0x00,
+                                      0x11, 0x74, 0x65, 0x73,
+                                      0x74, 0x00, 0x04, 0x00,
+                                      0x00, 0x00, 0x14, 0x00,
+                                      0x00, 0x00, 0x00])
+  end
+
+  def test_overflow
+    doc = {"x" => 2**75}
+    assert_raise RangeError do
+      bson = BSON::BSON_CODER.serialize(doc)
+    end
+
+    doc = {"x" => 9223372036854775}
+    assert_equal doc, BSON::BSON_CODER.deserialize(BSON::BSON_CODER.serialize(doc).to_a)
+
+    doc = {"x" => 9223372036854775807}
+    assert_equal doc, BSON::BSON_CODER.deserialize(BSON::BSON_CODER.serialize(doc).to_a)
+
+    doc["x"] = doc["x"] + 1
+    assert_raise RangeError do
+      bson = BSON::BSON_CODER.serialize(doc)
+    end
+
+    doc = {"x" => -9223372036854775}
+    assert_equal doc, BSON::BSON_CODER.deserialize(BSON::BSON_CODER.serialize(doc).to_a)
+
+    doc = {"x" => -9223372036854775808}
+    assert_equal doc, BSON::BSON_CODER.deserialize(BSON::BSON_CODER.serialize(doc).to_a)
+
+    doc["x"] = doc["x"] - 1
+    assert_raise RangeError do
+      bson = BSON::BSON_CODER.serialize(doc)
+    end
+  end
+
+  def test_invalid_numeric_types
+    [BigDecimal.new("1.0"), Complex(0, 1), Rational(2, 3)].each do |type|
+      doc = {"x" => type}
+      begin
+        BSON::BSON_CODER.serialize(doc)
+      rescue => e
+      ensure
+        assert_equal InvalidDocument, e.class
+        assert_match /Cannot serialize/, e.message
+      end
+    end
+  end
+
+  def test_do_not_change_original_object
+    val = OrderedHash.new
+    val['not_id'] = 1
+    val['_id'] = 2
+    assert val.keys.include?('_id')
+    BSON::BSON_CODER.serialize(val)
+    assert val.keys.include?('_id')
+
+    val = {'a' => 'foo', 'b' => 'bar', :_id => 42, 'z' => 'hello'}
+    assert val.keys.include?(:_id)
+    BSON::BSON_CODER.serialize(val)
+    assert val.keys.include?(:_id)
+  end
+
+  # note we only test for _id here because in the general case we will
+  # write duplicates for :key and "key". _id is a special case because
+  # we call has_key? to check for it's existance rather than just iterating
+  # over it like we do for the rest of the keys. thus, things like
+  # HashWithIndifferentAccess can cause problems for _id but not for other
+  # keys. rather than require rails to test with HWIA directly, we do this
+  # somewhat hacky test.
+  def test_no_duplicate_id
+    dup = {"_id" => "foo", :_id => "foo"}
+    one = {"_id" => "foo"}
+
+    assert_equal BSON::BSON_CODER.serialize(one).to_a, BSON::BSON_CODER.serialize(dup).to_a
+  end
+
+  def test_no_duplicate_id_when_moving_id
+    dup = {"_id" => "foo", :_id => "foo"}
+    one = {:_id => "foo"}
+
+    assert_equal BSON::BSON_CODER.serialize(one, false, true).to_s, BSON::BSON_CODER.serialize(dup, false, true).to_s
+  end
+
+  def test_null_character
+    doc = {"a" => "\x00"}
+
+    assert_equal doc, BSON::BSON_CODER.deserialize(BSON::BSON_CODER.serialize(doc).to_a)
+
+    assert_raise InvalidDocument do
+      BSON::BSON_CODER.serialize({"\x00" => "a"})
+    end
+
+    assert_raise InvalidDocument do
+      BSON::BSON_CODER.serialize({"a" => (Regexp.compile "ab\x00c")})
+    end
+  end
+
+  def test_max_key
+    doc = {"a" => MaxKey.new}
+
+    assert_equal doc, BSON::BSON_CODER.deserialize(BSON::BSON_CODER.serialize(doc).to_a)
+  end
+
+  def test_min_key
+    doc = {"a" => MinKey.new}
+
+    assert_equal doc, BSON::BSON_CODER.deserialize(BSON::BSON_CODER.serialize(doc).to_a)
+  end
+
+  def test_invalid_object
+    o = Object.new
+    assert_raise InvalidDocument do
+      BSON::BSON_CODER.serialize({:foo => o})
+    end
+
+    assert_raise InvalidDocument do
+      BSON::BSON_CODER.serialize({:foo => Date.today})
+    end
+  end
+
+  def test_move_id
+    a = OrderedHash.new
+    a['text'] = 'abc'
+    a['key'] = 'abc'
+    a['_id']  = 1
+
+
+    assert_equal ")\000\000\000\020_id\000\001\000\000\000\002text" +
+                 "\000\004\000\000\000abc\000\002key\000\004\000\000\000abc\000\000",
+                 BSON::BSON_CODER.serialize(a, false, true).to_s
+    assert_equal ")\000\000\000\002text\000\004\000\000\000abc\000\002key" +
+                 "\000\004\000\000\000abc\000\020_id\000\001\000\000\000\000",
+                 BSON::BSON_CODER.serialize(a, false, false).to_s
+  end
+
+  def test_move_id_with_nested_doc
+    b = OrderedHash.new
+    b['text'] = 'abc'
+    b['_id']   = 2
+    c = OrderedHash.new
+    c['text'] = 'abc'
+    c['hash'] = b
+    c['_id']  = 3
+    assert_equal ">\000\000\000\020_id\000\003\000\000\000\002text" +
+                 "\000\004\000\000\000abc\000\003hash\000\034\000\000" +
+                 "\000\002text\000\004\000\000\000abc\000\020_id\000\002\000\000\000\000\000",
+                 BSON::BSON_CODER.serialize(c, false, true).to_s
+    assert_equal ">\000\000\000\002text\000\004\000\000\000abc\000\003hash" +
+                 "\000\034\000\000\000\002text\000\004\000\000\000abc\000\020_id" +
+                 "\000\002\000\000\000\000\020_id\000\003\000\000\000\000",
+                 BSON::BSON_CODER.serialize(c, false, false).to_s
+  end
+
+  if defined?(HashWithIndifferentAccess)
+    def test_keep_id_with_hash_with_indifferent_access
+      doc = HashWithIndifferentAccess.new
+      embedded = HashWithIndifferentAccess.new
+      embedded['_id'] = ObjectID.new
+      doc['_id']      = ObjectID.new
+      doc['embedded'] = [embedded]
+      BSON::BSON_CODER.serialize(doc, false, true).to_a
+      assert doc.has_key?("_id")
+      assert doc['embedded'][0].has_key?("_id")
+
+      doc['_id'] = ObjectID.new
+      BSON::BSON_CODER.serialize(doc, false, true).to_a
+      assert doc.has_key?("_id")
+    end
+  end
+end