mongodb-mongo 0.1.3

data/tests/test_db_api.rb

@@ -0,0 +1,354 @@
+$LOAD_PATH[0,0] = File.join(File.dirname(__FILE__), '..', 'lib')
+require 'mongo'
+require 'test/unit'
+
+# NOTE: assumes Mongo is running
+class DBAPITest < Test::Unit::TestCase
+
+  include XGen::Mongo::Driver
+
+  def setup
+    host = ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost'
+    port = ENV['MONGO_RUBY_DRIVER_PORT'] || Mongo::DEFAULT_PORT
+    @db = Mongo.new(host, port).db('ruby-mongo-test')
+    @coll = @db.collection('test')
+    @coll.clear
+    @r1 = @coll.insert('a' => 1) # collection not created until it's used
+    @coll_full_name = 'ruby-mongo-test.test'
+  end
+
+  def teardown
+    if @db.connected?
+      @coll.clear unless @coll == nil
+      @db.close
+    end
+  end
+
+  def test_clear
+    assert_equal 1, @coll.count
+    @coll.clear
+    assert_equal 0, @coll.count
+  end
+
+  def test_insert
+    @coll.insert('a' => 2)
+    @coll.insert('b' => 3)
+
+    assert_equal 3, @coll.count
+    docs = @coll.find().to_a
+    assert_equal 3, docs.length
+    assert docs.detect { |row| row['a'] == 1 }
+    assert docs.detect { |row| row['a'] == 2 }
+    assert docs.detect { |row| row['b'] == 3 }
+
+    @coll << {'b' => 4}
+    docs = @coll.find().to_a
+    assert_equal 4, docs.length
+    assert docs.detect { |row| row['b'] == 4 }
+  end
+
+  def test_find_simple
+    @r2 = @coll.insert('a' => 2)
+    @r3 = @coll.insert('b' => 3)
+    # Check sizes
+    docs = @coll.find().to_a
+    assert_equal 3, docs.size
+    assert_equal 3, @coll.count
+
+    # Find by other value
+    docs = @coll.find('a' => @r1['a']).to_a
+    assert_equal 1, docs.size
+    doc = docs.first
+    assert_equal doc['_id'], @r1['_id']
+    assert_equal doc['a'], @r1['a']
+  end
+
+  def test_find_advanced
+    @coll.insert('a' => 2)
+    @coll.insert('b' => 3)
+
+    # Find by advanced query (less than)
+    docs = @coll.find('a' => { '$lt' => 10 }).to_a
+    assert_equal 2, docs.size
+    assert docs.detect { |row| row['a'] == 1 }
+    assert docs.detect { |row| row['a'] == 2 }
+
+    # Find by advanced query (greater than)
+    docs = @coll.find('a' => { '$gt' => 1 }).to_a
+    assert_equal 1, docs.size
+    assert docs.detect { |row| row['a'] == 2 }
+
+    # Find by advanced query (less than or equal to)
+    docs = @coll.find('a' => { '$lte' => 1 }).to_a
+    assert_equal 1, docs.size
+    assert docs.detect { |row| row['a'] == 1 }
+
+    # Find by advanced query (greater than or equal to)
+    docs = @coll.find('a' => { '$gte' => 1 }).to_a
+    assert_equal 2, docs.size
+    assert docs.detect { |row| row['a'] == 1 }
+    assert docs.detect { |row| row['a'] == 2 }
+
+    # Find by advanced query (between)
+    docs = @coll.find('a' => { '$gt' => 1, '$lt' => 3 }).to_a
+    assert_equal 1, docs.size
+    assert docs.detect { |row| row['a'] == 2 }
+
+    # Find by advanced query (in clause)
+    docs = @coll.find('a' => {'$in' => [1,2]}).to_a
+    assert_equal 2, docs.size
+    assert docs.detect { |row| row['a'] == 1 }
+    assert docs.detect { |row| row['a'] == 2 }
+
+    # Find by advanced query (regexp)
+    docs = @coll.find('a' => /[1|2]/).to_a
+    assert_equal 2, docs.size
+    assert docs.detect { |row| row['a'] == 1 }
+    assert docs.detect { |row| row['a'] == 2 }
+  end
+
+  def test_find_sorting
+    @coll.clear
+    @coll.insert('a' => 1, 'b' => 2)
+    @coll.insert('a' => 2, 'b' => 1)
+    @coll.insert('a' => 3, 'b' => 2)
+    @coll.insert('a' => 4, 'b' => 1)
+
+    # Sorting (ascending)
+    docs = @coll.find({'a' => { '$lt' => 10 }}, :sort => {'a' => 1}).to_a
+    assert_equal 4, docs.size
+    assert_equal 1, docs[0]['a']
+    assert_equal 2, docs[1]['a']
+    assert_equal 3, docs[2]['a']
+    assert_equal 4, docs[3]['a']
+
+    # Sorting (descending)
+    docs = @coll.find({'a' => { '$lt' => 10 }}, :sort => {'a' => -1}).to_a
+    assert_equal 4, docs.size
+    assert_equal 4, docs[0]['a']
+    assert_equal 3, docs[1]['a']
+    assert_equal 2, docs[2]['a']
+    assert_equal 1, docs[3]['a']
+
+    # Sorting using array of names; assumes ascending order.
+    docs = @coll.find({'a' => { '$lt' => 10 }}, :sort => ['a']).to_a
+    assert_equal 4, docs.size
+    assert_equal 1, docs[0]['a']
+    assert_equal 2, docs[1]['a']
+    assert_equal 3, docs[2]['a']
+    assert_equal 4, docs[3]['a']
+
+    # Sorting using single name; assumes ascending order.
+    docs = @coll.find({'a' => { '$lt' => 10 }}, :sort => 'a').to_a
+    assert_equal 4, docs.size
+    assert_equal 1, docs[0]['a']
+    assert_equal 2, docs[1]['a']
+    assert_equal 3, docs[2]['a']
+    assert_equal 4, docs[3]['a']
+
+    docs = @coll.find({'a' => { '$lt' => 10 }}, :sort => ['b', 'a']).to_a
+    assert_equal 4, docs.size
+    assert_equal 2, docs[0]['a']
+    assert_equal 4, docs[1]['a']
+    assert_equal 1, docs[2]['a']
+    assert_equal 3, docs[3]['a']
+
+    # Sorting using empty array; no order guarantee (Mongo bug #898) but
+    # should not blow up.
+    docs = @coll.find({'a' => { '$lt' => 10 }}, :sort => []).to_a
+    assert_equal 4, docs.size
+
+    # Sorting using array of hashes; no order guarantee (Mongo bug #898) but
+    # should not blow up.
+    docs = @coll.find({'a' => { '$lt' => 10 }}, :sort => [{'b' => 1}, {'a' => -1}]).to_a
+    assert_equal 4, docs.size
+
+    # Sorting using ordered hash. You can use an unordered one, but then the
+    # order of the keys won't be guaranteed thus your sort won't make sense.
+    oh = OrderedHash.new
+    oh['a'] = -1
+    docs = @coll.find({'a' => { '$lt' => 10 }}, :sort => oh).to_a
+    assert_equal 4, docs.size
+    assert_equal 4, docs[0]['a']
+    assert_equal 3, docs[1]['a']
+    assert_equal 2, docs[2]['a']
+    assert_equal 1, docs[3]['a']
+
+    # TODO this will not pass due to known Mongo bug #898
+#     oh = OrderedHash.new
+#     oh['b'] = -1
+#     oh['a'] = 1
+#     docs = @coll.find({'a' => { '$lt' => 10 }}, :sort => oh).to_a
+#     assert_equal 4, docs.size
+#     assert_equal 1, docs[0]['a']
+#     assert_equal 3, docs[1]['a']
+#     assert_equal 2, docs[2]['a']
+#     assert_equal 4, docs[3]['a']
+  end
+
+  def test_find_limits
+    @coll.insert('b' => 2)
+    @coll.insert('c' => 3)
+    @coll.insert('d' => 4)
+
+    docs = @coll.find({}, :limit => 1).to_a
+    assert_equal 1, docs.size
+    docs = @coll.find({}, :limit => 2).to_a
+    assert_equal 2, docs.size
+    docs = @coll.find({}, :limit => 3).to_a
+    assert_equal 3, docs.size
+    docs = @coll.find({}, :limit => 4).to_a
+    assert_equal 4, docs.size
+    docs = @coll.find({}).to_a
+    assert_equal 4, docs.size
+    docs = @coll.find({}, :limit => 99).to_a
+    assert_equal 4, docs.size
+  end
+
+  def test_drop_collection
+    assert @db.drop_collection(@coll.name), "drop of collection #{@coll.name} failed"
+    assert !@db.collection_names.include?(@coll_full_name)
+    @coll = nil
+  end
+
+  def test_collection_names
+    names = @db.collection_names
+    assert names.length >= 1
+    assert names.include?(@coll_full_name)
+
+    coll2 = @db.collection('test2')
+    coll2.insert('a' => 1)      # collection not created until it's used
+    names = @db.collection_names
+    assert names.length >= 2
+    assert names.include?(@coll_full_name)
+    assert names.include?('ruby-mongo-test.test2')
+  ensure
+    @db.drop_collection('test2')
+  end
+
+  def test_collections_info
+    cursor = @db.collections_info
+    rows = cursor.to_a
+    assert rows.length >= 1
+    row = rows.detect { |r| r['name'] == @coll_full_name }
+    assert_not_nil row
+  end
+
+  def test_collection_options
+    @db.drop_collection('foobar')
+    @db.strict = true
+
+    begin
+      coll = @db.create_collection('foobar', :capped => true, :size => 1024)
+      options = coll.options()
+      assert_equal 'foobar', options['create']
+      assert_equal true, options['capped']
+      assert_equal 1024, options['size']
+    rescue => ex
+      @db.drop_collection('foobar')
+      fail "did not expect exception \"#{ex}\""
+    end
+  end
+
+  def test_index_information
+    @db.create_index(@coll.name, 'index_name', ['a'])
+    list = @db.index_information(@coll.name)
+    assert_equal 1, list.length
+
+    info = list[0]
+    assert_equal 'index_name', info[:name]
+    assert_equal 1, info[:keys]['a']
+  end
+
+  def test_array
+    @coll << {'b' => [1, 2, 3]}
+    rows = @coll.find({}, {:fields => ['b']}).to_a
+    assert_equal 1, rows.length
+    assert_equal [1, 2, 3], rows[0]['b']
+  end
+
+  def test_regex
+    regex = /foobar/i
+    @coll << {'b' => regex}
+    rows = @coll.find({}, {:fields => ['b']}).to_a
+    assert_equal 1, rows.length
+    assert_equal regex, rows[0]['b']
+  end
+
+  def test_strict
+    assert !@db.strict?
+    @db.strict = true
+    assert @db.strict?
+  end
+
+  def test_strict_access_collection
+    @db.strict = true
+    begin
+      @db.collection('does-not-exist')
+      fail "expected exception"
+    rescue => ex
+      assert_equal "Collection does-not-exist doesn't exist. Currently in strict mode.", ex.to_s
+    ensure
+      @db.strict = false
+      @db.drop_collection('does-not-exist')
+    end
+  end
+
+  def test_strict_create_collection
+    @db.drop_collection('foobar')
+    @db.strict = true
+
+    begin
+      @db.create_collection('foobar')
+      assert true
+    rescue => ex
+      fail "did not expect exception \"#{ex}\""
+    end
+
+    # Now the collection exists. This time we should see an exception.
+    begin
+      @db.create_collection('foobar')
+      fail "expected exception"
+    rescue => ex
+      assert_equal "Collection foobar already exists. Currently in strict mode.", ex.to_s
+    ensure
+      @db.strict = false
+      @db.drop_collection('foobar')
+    end
+  end
+
+  def test_to_a
+    cursor = @coll.find()
+    rows = cursor.to_a
+
+    # Make sure we get back exactly the same array the next time we ask
+    rows2 = cursor.to_a
+    assert_same rows, rows2
+
+    # Make sure we can still iterate after calling to_a
+    rows_with_each = cursor.collect{|row| row}
+    assert_equal rows, rows_with_each
+
+    # Make sure we can iterate more than once after calling to_a
+  end
+
+  def test_to_a_after_each
+    cursor = @coll.find
+    cursor.each { |row| row }
+    begin
+      cursor.to_a
+      fail "expected \"can't call\" error"
+    rescue => ex
+      assert_equal "can't call Cursor#to_a after calling Cursor#each", ex.to_s
+    end
+  end
+
+  def test_ismaster
+    assert @db.master?
+  end
+
+  def test_master
+    assert_equal "#{@db.host}:#{@db.port}", @db.master
+  end
+
+end

data/tests/test_db_connection.rb

@@ -0,0 +1,17 @@
+$LOAD_PATH[0,0] = File.join(File.dirname(__FILE__), '..', 'lib')
+require 'mongo'
+require 'test/unit'
+
+# NOTE: assumes Mongo is running
+class DBConnectionTest < Test::Unit::TestCase
+
+  include XGen::Mongo::Driver
+
+  def test_no_exceptions
+    host = ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost'
+    port = ENV['MONGO_RUBY_DRIVER_PORT'] || Mongo::DEFAULT_PORT
+    db = Mongo.new(host, port).db('ruby-mongo-demo')
+    coll = db.collection('test')
+    coll.clear
+  end
+end

data/tests/test_message.rb

@@ -0,0 +1,35 @@
+$LOAD_PATH[0,0] = File.join(File.dirname(__FILE__), '..', 'lib')
+require 'mongo'
+require 'test/unit'
+
+class MessageTest < Test::Unit::TestCase
+
+  include XGen::Mongo::Driver
+
+  def setup
+    @msg = Message.new(42)
+  end
+
+  def test_initial_info
+    assert_equal Message::HEADER_SIZE, @msg.buf.length
+    @msg.write_long(1029)
+    @msg.buf.rewind
+    assert_equal Message::HEADER_SIZE + 8, @msg.buf.get_int
+    @msg.buf.get_int            # skip message id
+    assert_equal 0, @msg.buf.get_int
+    assert_equal 42,  @msg.buf.get_int
+    assert_equal 1029, @msg.buf.get_long
+  end
+
+  def test_update_length
+    @msg.update_message_length
+    @msg.buf.rewind
+    assert_equal Message::HEADER_SIZE, @msg.buf.get_int
+  end
+
+  def test_long_length
+    @msg.write_long(1027)
+    assert_equal Message::HEADER_SIZE + 8, @msg.buf.length
+  end
+
+end

data/tests/test_objectid.rb

@@ -0,0 +1,98 @@
+$LOAD_PATH[0,0] = File.join(File.dirname(__FILE__), '..', 'lib')
+require 'mongo'
+require 'test/unit'
+
+class ObjectIDTest < Test::Unit::TestCase
+
+  include XGen::Mongo::Driver
+
+  def setup
+    @t = 42
+    @o = ObjectID.new(nil, @t)
+  end
+
+  def test_index_for_time
+    t = 99
+    assert_equal 0, @o.index_for_time(t)
+    assert_equal 1, @o.index_for_time(t)
+    assert_equal 2, @o.index_for_time(t)
+    t = 100
+    assert_equal 0, @o.index_for_time(t)
+  end
+
+  def test_time_bytes
+    a = @o.to_a
+    assert_equal @t, a[0]
+    3.times { |i| assert_equal 0, a[i+1] }
+
+    t = 43
+    o = ObjectID.new(nil, t)
+    a = o.to_a
+    assert_equal t, a[0]
+    3.times { |i| assert_equal 0, a[i+1] }
+    assert_equal 1, o.index_for_time(t) # 0 was used for o
+  end
+
+  def test_different
+    o2 = ObjectID.new(nil, @t)
+    assert @o.to_a != o2.to_a
+  end
+
+  def test_eql?
+    o2 = ObjectID.new(@o.to_a)
+    assert @o.eql?(o2)
+    assert @o == o2
+  end
+
+  def test_to_s
+    s = @o.to_s
+    assert_equal 24, s.length
+    s =~ /^([0-9a-f]+)$/
+    assert_equal 24, $1.length
+  end
+
+  def test_save_and_restore
+    host = ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost'
+    port = ENV['MONGO_RUBY_DRIVER_PORT'] || Mongo::DEFAULT_PORT
+    db = Mongo.new(host, port).db('ruby-mongo-test')
+    coll = db.collection('test')
+
+    coll.clear
+    coll << {'a' => 1, '_id' => @o}
+
+    row = coll.find().collect.first
+    assert_equal 1, row['a']
+    assert_equal @o, row['_id']
+  end
+
+  def test_from_string
+    hex_str = @o.to_s
+    o2 = ObjectID.from_string(hex_str)
+    assert_equal hex_str, o2.to_s
+    assert_equal @o, o2
+    assert_equal @o.to_s, o2.to_s
+  end
+
+  def test_legal_oid_string
+    assert !ObjectID.legal_oid_string(nil)
+    assert !ObjectID.legal_oid_string("fred")
+    assert !ObjectID.legal_oid_string("0000")
+    assert !ObjectID.legal_oid_string('000102030405060708090A0')
+    assert ObjectID.legal_oid_string('000102030405060708090A0B')
+    assert ObjectID.legal_oid_string('abcdefABCDEF123456789012')
+    assert !ObjectID.legal_oid_string('abcdefABCDEF12345678901x')
+  end
+
+  def test_from_string_leading_zeroes
+    hex_str = '000000000000000000abcdef'
+    o = ObjectID.from_string(hex_str)
+    assert_equal hex_str, o.to_s
+  end
+
+  def test_byte_order
+    hex_str = '000102030405060708090A0B'
+    o = ObjectID.from_string(hex_str)
+    assert_equal [0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x0b, 0x0a, 0x09, 0x08], o.to_a
+  end
+
+end

data/tests/test_ordered_hash.rb

@@ -0,0 +1,85 @@
+$LOAD_PATH[0,0] = File.join(File.dirname(__FILE__), '..', 'lib')
+require 'mongo/util/ordered_hash'
+require 'test/unit'
+
+class OrderedHashTest < Test::Unit::TestCase
+
+  def setup
+    @oh = OrderedHash.new
+    @oh['c'] = 1
+    @oh['a'] = 2
+    @oh['z'] = 3
+    @ordered_keys = %w(c a z)
+  end
+
+  def test_empty
+    assert_equal [], OrderedHash.new.keys
+  end
+
+  def test_order_preserved
+    assert_equal @ordered_keys, @oh.keys
+  end
+
+  def test_order_preserved_after_replace
+    @oh['a'] = 42
+    assert_equal @ordered_keys, @oh.keys
+    @oh['c'] = 'foobar'
+    assert_equal @ordered_keys, @oh.keys
+    @oh['z'] = /huh?/
+    assert_equal @ordered_keys, @oh.keys
+  end
+
+  def test_each
+    keys = []
+    @oh.each { |k, v| keys << k }
+    assert_equal keys, @oh.keys
+
+    @oh['z'] = 42
+    assert_equal keys, @oh.keys
+  end
+
+  def test_values
+    assert_equal [1, 2, 3], @oh.values
+  end
+
+  def test_merge
+    other = OrderedHash.new
+    other['f'] = 'foo'
+    noob = @oh.merge(other)
+    assert_equal @ordered_keys + ['f'], noob.keys
+    assert_equal [1, 2, 3, 'foo'], noob.values
+  end
+
+  def test_merge_bang
+    other = OrderedHash.new
+    other['f'] = 'foo'
+    @oh.merge!(other)
+    assert_equal @ordered_keys + ['f'], @oh.keys
+    assert_equal [1, 2, 3, 'foo'], @oh.values
+  end
+
+  def test_merge_bang_with_overlap
+    other = OrderedHash.new
+    other['a'] = 'apple'
+    other['c'] = 'crab'
+    other['f'] = 'foo'
+    @oh.merge!(other)
+    assert_equal @ordered_keys + ['f'], @oh.keys
+    assert_equal ['crab', 'apple', 3, 'foo'], @oh.values
+  end
+
+  def test_merge_bang_with_hash_with_overlap
+    other = Hash.new
+    other['a'] = 'apple'
+    other['c'] = 'crab'
+    other['f'] = 'foo'
+    @oh.merge!(other)
+    assert_equal @ordered_keys + ['f'], @oh.keys
+    assert_equal ['crab', 'apple', 3, 'foo'], @oh.values
+  end
+
+  def test_inspect_retains_order
+    assert_equal '{"c"=>1, "a"=>2, "z"=>3}', @oh.inspect
+  end
+
+end

data/tests/test_round_trip.rb

@@ -0,0 +1,116 @@
+HERE = File.dirname(__FILE__)
+$LOAD_PATH[0,0] = File.join(HERE, '..', 'lib')
+require 'mongo'
+require 'mongo/util/xml_to_ruby'
+require 'test/unit'
+
+# For each xml/bson file in the data subdirectory, we turn the XML into an
+# OrderedHash and then test both Ruby-to-BSON and BSON-to-Ruby translations.
+#
+# There is a whole other project that includes similar tests
+# (http://github.com/mongodb/mongo-qa). If the directory ../mongo-qa exists,
+# then we find the BSON test files there and use those, too. Use the Rake task
+# "mongo_qa" to obtain those tests.
+class RoundTripTest < Test::Unit::TestCase
+
+  include XGen::Mongo::Driver
+
+  @@ruby = nil
+
+  def setup
+    unless @@ruby
+      names = Dir[File.join(HERE, 'data', '*.xml')].collect {|f| File.basename(f).sub(/\.xml$/, '') }
+      @@ruby = {}
+      names.each { |name|
+        File.open(File.join(HERE, 'data', "#{name}.xml")) { |f|
+          @@ruby[name] = XMLToRuby.new.xml_to_ruby(f)
+        }
+      }
+    end
+  end
+
+  def test_dummy
+    assert true
+  end
+
+  def self.create_test_for_round_trip_files_in_dir(dir)
+    names = Dir[File.join(dir, '*.xson')].collect {|f| File.basename(f).sub(/\.xson$/, '') }
+    names.each { |name|
+      eval <<EOS
+def test_#{name}_#{dir.gsub(/[^a-zA-Z0-9_]/, '_')}
+  one_round_trip("#{dir}", "#{name}")
+end
+EOS
+    }
+  end
+
+  # Dynamically generate one test for each test file. This way, if one test
+  # fails the others will still run.
+  create_test_for_round_trip_files_in_dir(File.join(HERE, 'data'))
+  mongo_qa_dir = File.join(HERE, '..', 'mongo-qa/modules/bson_tests/tests')
+  if File.exist?(mongo_qa_dir)
+    %w(basic_types complex single_types).each { |subdir_name|
+      create_test_for_round_trip_files_in_dir(File.join(mongo_qa_dir, subdir_name))
+    }
+  end
+
+  # Round-trip comparisons of Ruby-to-BSON and back.
+  # * Take the objects that were read from XML
+  # * Turn them into BSON bytes
+  # * Compare that with the BSON files we have
+  # * Turn those BSON bytes back in to Ruby objects
+  # * Turn them back into BSON bytes
+  # * Compare that with the BSON files we have (or the bytes that were already
+  #   generated)
+  def one_round_trip(dir, name)
+    obj = File.open(File.join(dir, "#{name}.xson")) { |f|
+      XMLToRuby.new.xml_to_ruby(f)
+    }
+
+    File.open(File.join(dir, "#{name}.bson"), 'r') { |f|
+      # Read the BSON from the file
+      bson = f.read
+      bson = if RUBY_VERSION >= '1.9'
+               bson.bytes.to_a
+             else
+               bson.split(//).collect { |c| c[0] }
+             end
+
+      # Turn the Ruby object into BSON bytes and compare with the BSON bytes
+      # from the file.
+      bson_from_ruby = BSON.new.serialize(obj).to_a
+
+      begin
+        assert_equal bson.length, bson_from_ruby.length
+        assert_equal bson, bson_from_ruby
+      rescue => ex
+#         File.open(File.join(dir, "#{name}_out_a.bson"), 'wb') { |f| # DEBUG
+#           bson_from_ruby.each { |b| f.putc(b) }
+#         }
+        raise ex
+      end
+
+      # Turn those BSON bytes back into a Ruby object.
+      #
+      # We're passing a nil db to the contructor here, but that's OK because
+      # the BSON DBFef bytes don't contain the db object in any case, and we
+      # don't care what the database is.
+      obj_from_bson = BSON.new(nil).deserialize(ByteBuffer.new(bson_from_ruby))
+      assert_kind_of OrderedHash, obj_from_bson
+
+      # Turn that Ruby object into BSON and compare it to the original BSON
+      # bytes.
+      bson_from_ruby = BSON.new.serialize(obj_from_bson).to_a
+      begin
+        assert_equal bson.length, bson_from_ruby.length
+        assert_equal bson, bson_from_ruby
+      rescue => ex
+#         File.open(File.join(dir, "#{name}_out_b.bson"), 'wb') { |f| # DEBUG
+#           bson_from_ruby.each { |b| f.putc(b) }
+#         }
+        raise ex
+      end
+    }
+  end
+
+end