kbaum-mongo 0.18.3p

data/test/bson_test.rb

@@ -0,0 +1,427 @@
+# encoding:utf-8
+require 'test/test_helper'
+require 'complex'
+require 'bigdecimal'
+require 'rational'
+
+# Need to simulating this class
+# without actually loading it.
+module ActiveSupport
+  class TimeWithZone
+  end
+end
+
+class BSONTest < Test::Unit::TestCase
+
+  include Mongo
+
+  def test_string
+    doc = {'doc' => 'hello, world'}
+    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
+
+  def test_document_length
+    doc = {'name' => 'a' * 5 * 1024 * 1024}
+    assert_raise InvalidDocument do
+      assert BSON.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.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')}
+    bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
+  end
+
+  def test_number
+    doc = {'doc' => 41.99}
+    bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
+  end
+
+  def test_int
+    doc = {'doc' => 42}
+    bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
+
+    doc = {"doc" => -5600}
+    bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
+
+    doc = {"doc" => 2147483647}
+    bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
+
+    doc = {"doc" => -2147483648}
+    bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
+  end
+
+  def test_ordered_hash
+    doc = OrderedHash.new
+    doc["b"] = 1
+    doc["a"] = 2
+    doc["c"] = 3
+    doc["d"] = 4
+    bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
+  end
+
+  def test_object
+    doc = {'doc' => {'age' => 42, 'name' => 'Spongebob', 'shoe_size' => 9.5}}
+    bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
+  end
+
+  def test_oid
+    doc = {'doc' => ObjectID.new}
+    bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
+  end
+
+  def test_array
+    doc = {'doc' => [1, 2, 'a', 'b']}
+    bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
+  end
+
+  def test_regex
+    doc = {'doc' => /foobar/i}
+    bson = BSON.serialize(doc)
+    doc2 = BSON.deserialize(bson)
+    assert_equal doc, doc2
+
+    r = doc2['doc']
+    assert_kind_of Regexp, r
+
+    r = RegexpOfHolding.new('st', 0, 'zywcab')
+    assert_equal 'zywcab', r.extra_options_str
+
+    doc = {'doc' => r}
+    bson_doc = BSON.serialize(doc)
+    doc2 = nil
+    doc2 = BSON.deserialize(bson_doc)
+    assert_equal doc, doc2
+
+    r = doc2['doc']
+    assert_kind_of RegexpOfHolding, r
+    assert_equal 'abcwyz', r.extra_options_str # must be sorted
+  end
+
+  def test_boolean
+    doc = {'doc' => true}
+    bson = BSON.serialize(doc)
+    assert_equal doc, BSON.deserialize(bson)
+  end
+
+  def test_date
+    doc = {'date' => Time.now}
+    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}
+    bson = BSON.serialize(doc)
+    doc2 = BSON.deserialize(bson)
+    assert doc2['date'].utc?
+  end
+
+  def test_date_before_epoch
+    begin
+      doc = {'date' => Time.utc(1600)}
+      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
+      # 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, ActiveSupport::TimeWithZone.new].each do |invalid_date|
+      doc = {:date => invalid_date}
+      begin
+      bson = BSON.serialize(doc)
+      rescue => e
+      ensure
+        assert_equal InvalidDocument, e.class
+        assert_match /UTC Time/, e.message
+      end
+    end
+  end
+
+  def test_dbref
+    oid = ObjectID.new
+    doc = {}
+    doc['dbref'] = DBRef.new('namespace', oid)
+    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}
+    bson = BSON.serialize(doc)
+    doc2 = BSON.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.serialize(doc)
+    doc2 = BSON.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_type
+    bin = Binary.new([1, 2, 3, 4, 5], Binary::SUBTYPE_USER_DEFINED)
+
+    doc = {'bin' => bin}
+    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
+    assert_equal Binary::SUBTYPE_USER_DEFINED, bin2.subtype
+  end
+
+  def test_binary_byte_buffer
+    bb = ByteBuffer.new
+    5.times { |i| bb.put(i + 1) }
+
+    doc = {'bin' => bb}
+    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
+    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.deserialize(BSON.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.deserialize(BSON.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.deserialize(bson = BSON.serialize(doc, false, true).to_a)
+  end
+
+  def test_timestamp
+    val = {"test" => [4, 20]}
+    assert_equal val, BSON.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.serialize(doc)
+    end
+
+    doc = {"x" => 9223372036854775}
+    assert_equal doc, BSON.deserialize(BSON.serialize(doc).to_a)
+
+    doc = {"x" => 9223372036854775807}
+    assert_equal doc, BSON.deserialize(BSON.serialize(doc).to_a)
+
+    doc["x"] = doc["x"] + 1
+    assert_raise RangeError do
+      bson = BSON.serialize(doc)
+    end
+
+    doc = {"x" => -9223372036854775}
+    assert_equal doc, BSON.deserialize(BSON.serialize(doc).to_a)
+
+    doc = {"x" => -9223372036854775808}
+    assert_equal doc, BSON.deserialize(BSON.serialize(doc).to_a)
+
+    doc["x"] = doc["x"] - 1
+    assert_raise RangeError do
+      bson = BSON.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.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.serialize(val)
+    assert val.keys.include?('_id')
+
+    val = {'a' => 'foo', 'b' => 'bar', :_id => 42, 'z' => 'hello'}
+    assert val.keys.include?(:_id)
+    BSON.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.serialize(one).to_a, BSON.serialize(dup).to_a
+  end
+
+  def test_null_character
+    doc = {"a" => "\x00"}
+
+    assert_equal doc, BSON.deserialize(BSON.serialize(doc).to_a)
+
+    assert_raise InvalidDocument do
+      BSON.serialize({"\x00" => "a"})
+    end
+
+    assert_raise InvalidDocument do
+      BSON.serialize({"a" => (Regexp.compile "ab\x00c")})
+    end
+  end
+
+  def test_max_key
+    doc = {"a" => MaxKey.new}
+
+    assert_equal doc, BSON.deserialize(BSON.serialize(doc).to_a)
+  end
+
+  def test_min_key
+    doc = {"a" => MinKey.new}
+
+    assert_equal doc, BSON.deserialize(BSON.serialize(doc).to_a)
+  end
+
+  def test_invalid_object
+    o = Object.new
+    assert_raise InvalidDocument do
+      BSON.serialize({:foo => o})
+    end
+
+    assert_raise InvalidDocument do
+      BSON.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.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.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.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.serialize(c, false, false).to_s
+  end
+end

data/test/byte_buffer_test.rb

@@ -0,0 +1,81 @@
+require 'test/test_helper'
+
+class ByteBufferTest < Test::Unit::TestCase
+
+  def setup
+    @buf = ByteBuffer.new
+  end
+
+  def test_nil_get_returns_one_byte
+    @buf.put_array([1, 2, 3, 4])
+    @buf.rewind
+    assert_equal 1, @buf.get
+  end
+
+  def test_one_get_returns_array_length_one
+    @buf.put_array([1, 2, 3, 4])
+    @buf.rewind
+    assert_equal [1], @buf.get(1)
+  end
+
+  def test_zero_get_returns_empty_array
+    @buf.put_array([1, 2, 3, 4])
+    @buf.rewind
+    assert_equal [], @buf.get(0)
+  end
+
+  def test_empty
+    assert_equal 0, @buf.length
+  end
+
+  def test_length
+    @buf.put_int 3
+    assert_equal 4, @buf.length
+  end
+
+  def test_default_order
+    assert_equal :little_endian, @buf.order
+  end
+
+  def test_long_length
+    @buf.put_long 1027
+    assert_equal 8, @buf.length
+  end
+
+  def test_get_long
+    @buf.put_long 1027
+    @buf.rewind
+    assert_equal 1027, @buf.get_long
+  end
+
+  def test_get_double
+    @buf.put_double 41.2
+    @buf.rewind
+    assert_equal 41.2, @buf.get_double
+  end
+
+  def test_rewrite
+    @buf.put_int(0)
+    @buf.rewind
+    @buf.put_int(1027)
+    assert_equal 4, @buf.length
+    @buf.rewind
+    assert_equal 1027, @buf.get_int
+    assert_equal 4, @buf.position
+  end
+
+  def test_prepend_byte_buffer
+    @buf.put_int(4)
+    new_buf = ByteBuffer.new([5, 0, 0, 0])
+    @buf.prepend!(new_buf)
+    assert_equal [5, 0, 0, 0, 4, 0, 0, 0], @buf.to_a
+  end
+
+  def test_append_byte_buffer
+    @buf.put_int(4)
+    new_buf = ByteBuffer.new([5, 0, 0, 0])
+    @buf.append!(new_buf)
+    assert_equal [4, 0, 0, 0, 5, 0, 0, 0], @buf.to_a
+  end
+
+end

data/test/chunk_test.rb

@@ -0,0 +1,82 @@
+require 'test/test_helper'
+require 'mongo/gridfs'
+
+class ChunkTest < Test::Unit::TestCase
+
+  include Mongo
+  include GridFS
+
+  @@db = Connection.new(ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost',
+                        ENV['MONGO_RUBY_DRIVER_PORT'] || Connection::DEFAULT_PORT).db('ruby-mongo-utils-test')
+  @@files = @@db.collection('gridfs.files')
+  @@chunks = @@db.collection('gridfs.chunks')
+
+  def setup
+    @@chunks.remove
+    @@files.remove
+
+    @f = GridStore.new(@@db, 'foobar', 'w')
+    @c = @f.instance_variable_get('@curr_chunk')
+  end
+
+  def teardown
+    @@chunks.remove
+    @@files.remove
+    @@db.error
+  end
+
+  def test_pos
+    assert_equal 0, @c.pos
+    assert @c.eof?              # since data is empty
+
+    b = ByteBuffer.new
+    3.times { |i| b.put(i) }
+    c = Chunk.new(@f, 'data' => b)
+    assert !c.eof?
+  end
+
+  def test_getc
+    b = ByteBuffer.new
+    3.times { |i| b.put(i) }
+    c = Chunk.new(@f, 'data' => b)
+
+    assert !c.eof?
+    assert_equal 0, c.getc
+    assert !c.eof?
+    assert_equal 1, c.getc
+    assert !c.eof?
+    assert_equal 2, c.getc
+    assert c.eof?
+  end
+
+  def test_putc
+    3.times { |i| @c.putc(i) }
+    @c.pos = 0
+
+    assert !@c.eof?
+    assert_equal 0, @c.getc
+    assert !@c.eof?
+    assert_equal 1, @c.getc
+    assert !@c.eof?
+    assert_equal 2, @c.getc
+    assert @c.eof?
+  end
+
+  def test_truncate
+    10.times { |i| @c.putc(i) }
+    assert_equal 10, @c.size
+    @c.pos = 3
+    @c.truncate
+    assert_equal 3, @c.size
+
+    @c.pos = 0
+    assert !@c.eof?
+    assert_equal 0, @c.getc
+    assert !@c.eof?
+    assert_equal 1, @c.getc
+    assert !@c.eof?
+    assert_equal 2, @c.getc
+    assert @c.eof?
+  end
+
+end