bson 1.8.4 → 1.8.5

data/test/bson/byte_buffer_test.rb

@@ -1,215 +0,0 @@
-# encoding: binary
-require 'test_helper'
-
-class ByteBufferTest < Test::Unit::TestCase
-  include BSON
-
-  def setup
-    @buf = ByteBuffer.new
-  end
-
-  def test_initial_state
-    assert_equal 0, @buf.position
-    assert_equal [], @buf.to_a
-    assert_equal "", @buf.to_s
-    assert_equal 0, @buf.length
-  end
-
-  def test_initialize_with_string_and_clear
-    @buf = ByteBuffer.new("a")
-    assert_equal 1, @buf.size
-    assert_equal 1, @buf.position
-    @buf.clear
-    assert_equal 0, @buf.position
-    assert_equal "", @buf.to_s
-    assert_equal 0, @buf.size
-  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_unpack
-    @buf.put_array([17, 2, 3, 4])
-    assert_equal [17, 2, 3, 4], @buf.to_a
-    assert_equal ["11020304"], @buf.unpack("H*")
-    assert_equal ["11020304"], @buf.to_a("H*")
-  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_length
-    @buf.put_int 3
-    assert_equal 4, @buf.length
-  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
-  
-  if BSON_CODER == BSON::BSON_RUBY
-    if defined?(Encoding)
-      def test_serialize_cstr_throws_error_for_bad_utf8
-        bad = "hello \xC8".force_encoding("ISO-8859-7")
-        assert_raises(BSON::InvalidStringEncoding) do
-          BSON_CODER::serialize_cstr(@buf, bad)
-        end
-      end
-
-      def test_serialize_cstr_does_not_validate_data_as_utf8
-        assert_raises(BSON::InvalidStringEncoding) do
-          BSON_CODER::serialize_cstr(@buf, "hello \xFF")
-        end
-      end
-    else
-      def test_serialize_cstr_forces_encoding_to_utf8
-        # Unicode snowman (\u2603)
-        BSON_CODER::serialize_cstr(@buf, "hello \342\230\203")
-        assert_equal "hello \342\230\203\0", @buf.to_s
-      end
-
-      def test_serialize_cstr_validates_data_as_utf8
-        assert_raises(BSON::InvalidStringEncoding) do
-          BSON_CODER::serialize_cstr(@buf, "hello \xFF")
-        end
-      end
-    end
-  end
-  
-  def test_put_negative_byte
-    @buf.put(-1)
-    @buf.rewind
-    assert_equal 255, @buf.get
-    assert_equal "\xFF", @buf.to_s
-  end
-  
-  def test_put_with_offset
-    @buf.put(1)
-    @buf.put(2, 0)
-    @buf.put(3, 3)
-    assert_equal "\x02\x00\x00\x03", @buf.to_s
-  end
-  
-  def test_put_array_with_offset
-    @buf.put(1)
-    @buf.put_array([2, 3], 0)
-    @buf.put_array([4, 5], 4)
-    assert_equal "\x02\x03\x00\x00\x04\x05", @buf.to_s
-  end
-  
-  def test_put_int_with_offset
-    @buf.put(1)
-    @buf.put_int(2, 0)
-    @buf.put_int(3, 5)
-    assert_equal "\x02\x00\x00\x00\x00\x03\x00\x00\x00", @buf.to_s
-  end
-  
-  def test_put_long_with_offset
-    @buf.put(1)
-    @buf.put_long(2, 0)
-    @buf.put_long(3, 9)
-    assert_equal(
-      "\x02\x00\x00\x00\x00\x00\x00\x00" +
-      "\x00" +
-      "\x03\x00\x00\x00\x00\x00\x00\x00",
-      @buf.to_s)
-  end
-  
-  def test_put_binary
-    @buf.put(1)
-    @buf.put_binary("\x02\x03", 0)
-    @buf.put_binary("\x04\x05", 4)
-    assert_equal "\x02\x03\x00\x00\x04\x05", @buf.to_s
-  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
-  
-  def test_array_as_initial_input
-    @buf = ByteBuffer.new([5, 0, 0, 0])
-    assert_equal 4, @buf.size
-    assert_equal "\x05\x00\x00\x00", @buf.to_s
-    assert_equal [5, 0, 0, 0], @buf.to_a
-    @buf.put_int(32)
-    @buf.rewind
-    assert_equal 5, @buf.get_int
-    assert_equal 32, @buf.get_int
-  end
-  
-  def test_binary_string_as_initial_input
-    str = "abcd"
-    str.force_encoding('binary') if str.respond_to?(:force_encoding)
-    @buf = ByteBuffer.new(str)
-    assert_equal "abcd", @buf.to_s
-    assert_equal [97, 98, 99, 100], @buf.to_a
-    @buf.put_int(0)
-    assert_equal [97, 98, 99, 100, 0, 0, 0, 0], @buf.to_a
-  end
-  
-  def test_more
-    assert !@buf.more?
-    @buf.put_int(5)
-    assert !@buf.more?
-    @buf.rewind
-    assert @buf.more?
-    @buf.get_int
-    assert !@buf.more?
-  end
-  
-  def test_equality
-    @buf = ByteBuffer.new("foo")
-    assert_equal @buf, @buf
-    assert_equal ByteBuffer.new(""), ByteBuffer.new("")
-    assert_equal ByteBuffer.new("123"), ByteBuffer.new("123")
-    assert_not_equal ByteBuffer.new("123"), ByteBuffer.new("1234")
-    assert_equal @buf, "foo"
-    assert_not_equal @buf, 123
-    assert_not_equal @buf, nil
-  end
-end

data/test/bson/hash_with_indifferent_access_test.rb

@@ -1,48 +0,0 @@
-# encoding:utf-8
-require 'test_helper'
-
-# Note: HashWithIndifferentAccess is so commonly used
-# that we always need to make sure that the driver works
-# with it. However, the bson gem should never need to
-# depend on it.
-
-# As a result, ActiveSupport is no longer a gem dependency and it should remain
-# that way. It must be required by the application code or
-# via bundler for developmet.
-
-require 'bson/support/hash_with_indifferent_access'
-
-class HashWithIndifferentAccessTest < Test::Unit::TestCase
-  include BSON
-
-  def setup
-    @encoder = BSON::BSON_CODER
-  end
-
-  def test_document
-    doc = HashWithIndifferentAccess.new
-    doc['foo'] = 1
-    doc['bar'] = 'baz'
-
-    bson = @encoder.serialize(doc)
-    assert_equal doc, @encoder.deserialize(bson.to_s)
-  end
-
-  def test_embedded_document
-    jimmy = HashWithIndifferentAccess.new
-    jimmy['name']     = 'Jimmy'
-    jimmy['species'] = 'Siberian Husky'
-
-    stats = HashWithIndifferentAccess.new
-    stats['eyes'] = 'blue'
-
-    person = HashWithIndifferentAccess.new
-    person['_id'] = BSON::ObjectId.new
-    person['name'] = 'Mr. Pet Lover'
-    person['pets'] = [jimmy, {'name' => 'Sasha'}]
-    person['stats'] = stats
-
-    bson = @encoder.serialize(person)
-    assert_equal person, @encoder.deserialize(bson.to_s)
-  end
-end

data/test/bson/json_test.rb

@@ -1,16 +0,0 @@
-require 'test_helper'
-require 'json'
-
-class JSONTest < Test::Unit::TestCase
-
-  # This test passes when run by itself but fails
-  # when run as part of the whole test suite.
-  def test_object_id_as_json
-    #warn "Pending test object id as json"
-    #id = BSON::ObjectId.new
-
-    #obj = {'_id' => id}
-    #assert_equal "{\"_id\":#{id.to_json}}", obj.to_json
-  end
-
-end

data/test/bson/object_id_test.rb

@@ -1,153 +0,0 @@
-require 'test_helper'
-require 'json'
-
-class ObjectIdTest < Test::Unit::TestCase
-
-  def setup
-    @o = ObjectId.new
-  end
-
-  def test_hashcode
-    assert_equal @o.instance_variable_get(:@data).hash, @o.hash
-  end
-
-  def test_array_uniq_for_equilavent_ids
-    a = ObjectId.new('123')
-    b = ObjectId.new('123')
-    assert_equal a, b
-    assert_equal 1, [a, b].uniq.size
-  end
-
-  def test_create_pk_method
-    doc = {:name => 'Mongo'}
-    doc = ObjectId.create_pk(doc)
-    assert doc[:_id]
-
-    doc = {:name => 'Mongo', :_id => '12345'}
-    doc = ObjectId.create_pk(doc)
-    assert_equal '12345', doc[:_id]
-  end
-
-  def test_different
-    a = ObjectId.new
-    b = ObjectId.new
-    assert_not_equal a.to_a, b.to_a
-    assert_not_equal a, b
-  end
-
-  def test_eql?
-    o2 = ObjectId.new(@o.to_a)
-    assert_equal @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_to_s2
-    @o = ObjectId.new([76, 244, 52, 174, 44, 84, 121, 76, 88, 0, 0, 3])
-    s = '4cf434ae2c54794c58000003'
-    assert_equal @o.to_s, s
-  end
-
-  def test_method
-    assert_equal ObjectId.from_string(@o.to_s), BSON::ObjectId(@o.to_s)
-  end
-
-  def test_inspect
-    assert_equal "BSON::ObjectId('#{@o.to_s}')", @o.inspect
-  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_illegal_from_string
-    assert_raise InvalidObjectId do
-      ObjectId.from_string("")
-    end
-  end
-
-  def test_from_string_with_object_id
-    assert_raise InvalidObjectId do
-      ObjectId.from_string(@o)
-    end
-  end
-
-  def test_legal
-    assert !ObjectId.legal?(nil)
-    assert !ObjectId.legal?("fred")
-    assert !ObjectId.legal?("0000")
-    assert !ObjectId.legal?('000102030405060708090A0')
-    assert ObjectId.legal?('000102030405060708090A0B')
-    assert ObjectId.legal?('abcdefABCDEF123456789012')
-    assert !ObjectId.legal?('abcdefABCDEF12345678901x')
-  end
-
-  def test_from_string_leading_zeroes
-    hex_str = '000000000000000000000000'
-    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 [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b], o.to_a
-  end
-
-  def test_generation_time
-    time = Time.now
-    id   = ObjectId.new
-    generated_time = id.generation_time
-
-    assert_in_delta time.to_i, generated_time.to_i, 2
-    assert_equal "UTC", generated_time.zone
-  end
-
-  def test_from_time
-    time = Time.now.utc
-    id   = ObjectId.from_time(time)
-
-    assert id.to_a[4, 8].all? {|byte| byte == 0 }
-    assert_equal time.to_i, id.generation_time.to_i
-  end
-
-  def test_from_time_unique
-    time = Time.now.utc
-    id   = ObjectId.from_time(time, :unique => true)
-
-    assert_equal id.to_a[4, 3], ObjectId.machine_id.unpack("C3")
-    assert_equal time.to_i, id.generation_time.to_i
-
-    id2 = ObjectId.new(nil, time)
-    assert_equal time.to_i, id2.generation_time.to_i
-  end
-
-  def test_json
-    id = ObjectId.new
-    assert_equal "{\"$oid\": \"#{id}\"}", id.to_json
-  end
-
-  def test_as_json
-    id = ObjectId.new
-    assert_equal({"$oid" => id.to_s}, id.as_json)
-  end
-
-  def test_object_id_array_flatten
-    id = ObjectId.new
-    assert_equal [ id ], [[ id ]].flatten
-  end
-
-  def test_object_id_array_flatten_bang
-    id = ObjectId.new
-    assert_equal [ id ], [[ id ]].flatten!
-  end
-end

data/test/bson/ordered_hash_test.rb

@@ -1,247 +0,0 @@
-require 'test_helper'
-
-class OrderedHashTest < Test::Unit::TestCase
-
-  def setup
-    @oh = BSON::OrderedHash.new
-    @oh['c'] = 1
-    @oh['a'] = 2
-    @oh['z'] = 3
-    @ordered_keys = %w(c a z)
-  end
-
-  def test_initialize
-    a = BSON::OrderedHash.new
-    a['x'] = 1
-    a['y'] = 2
-
-    b = BSON::OrderedHash['x', 1, 'y', 2]
-    assert_equal a, b
-  end
-
-  def test_hash_code
-    o = BSON::OrderedHash.new
-    o['number'] = 50
-    assert o.hash
-  end
-
-  def test_empty
-    assert_equal [], BSON::OrderedHash.new.keys
-  end
-
-  def test_uniq
-    list = []
-    doc  = BSON::OrderedHash.new
-    doc['_id']  = 'ab12'
-    doc['name'] = 'test'
-
-    same_doc = BSON::OrderedHash.new
-    same_doc['_id']  = 'ab12'
-    same_doc['name'] = 'test'
-
-    list << doc
-    list << same_doc
-
-    assert_equal 2, list.size
-    assert_equal 1, list.uniq.size
-  end
-
-  if !(RUBY_VERSION =~ /1.8.6/)
-    def test_compatibility_with_hash
-      list = []
-      doc  = BSON::OrderedHash.new
-      doc['_id']  = 'ab12'
-      doc['name'] = 'test'
-
-      doc2 = {}
-      doc2['_id']  = 'ab12'
-      doc2['name'] = 'test'
-      list << doc
-      list << doc2
-
-      assert_equal 1, list.uniq.size
-    end
-  end
-
-  def test_equality
-    a = BSON::OrderedHash.new
-    a['x'] = 1
-    a['y'] = 2
-
-    b = BSON::OrderedHash.new
-    b['y'] = 2
-    b['x'] = 1
-
-    c = BSON::OrderedHash.new
-    c['x'] = 1
-    c['y'] = 2
-
-    d = BSON::OrderedHash.new
-    d['x'] = 2
-    d['y'] = 3
-
-    e = BSON::OrderedHash.new
-    e['z'] = 1
-    e['y'] = 2
-
-    assert_equal a, c
-    assert_not_equal a, b
-    assert_not_equal a, d
-    assert_not_equal a, e
-  end
-
-  def test_order_preserved
-    assert_equal @ordered_keys, @oh.keys
-  end
-
-  def test_replace
-    h1 = BSON::OrderedHash.new
-    h1[:a] = 1
-    h1[:b] = 2
-
-    h2 = BSON::OrderedHash.new
-    h2[:c] = 3
-    h2[:d] = 4
-    h1.replace(h2)
-
-    assert_equal [:c, :d], h1.keys
-    assert_equal [3, 4], h1.values
-    assert h1.keys.object_id != h2.keys.object_id
-  end
-
-  def test_to_a_order_preserved
-    assert_equal @ordered_keys, @oh.to_a.map {|m| m.first}
-  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
-
-    assert_equal @oh, @oh.each {|k,v|}
-  end
-
-  def test_values
-    assert_equal [1, 2, 3], @oh.values
-  end
-
-  def test_merge
-    other = BSON::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 = BSON::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 = BSON::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_equality_with_hash
-    o = BSON::OrderedHash.new
-    o[:a] = 1
-    o[:b] = 2
-    o[:c] = 3
-    r = {:a => 1, :b => 2, :c => 3}
-    assert r == o
-    assert o == r
-  end
-
-  def test_update
-    other = BSON::OrderedHash.new
-    other['f'] = 'foo'
-    noob = @oh.update(other)
-    assert_equal @ordered_keys + ['f'], noob.keys
-    assert_equal [1, 2, 3, 'foo'], noob.values
-  end
-
-  if RUBY_VERSION < "1.9.2"
-    def test_inspect_retains_order
-      assert_equal "#<BSON::OrderedHash:0x#{@oh.object_id.to_s(16)} {\"c\"=>1, \"a\"=>2, \"z\"=>3}>", @oh.inspect
-    end
-  end
-
-  def test_clear
-    @oh.clear
-    assert @oh.keys.empty?
-  end
-
-  def test_delete
-    assert @oh.keys.include?('z')
-    @oh.delete('z')
-    assert !@oh.keys.include?('z')
-  end
-
-  def test_delete_if
-    assert @oh.keys.include?('z')
-    @oh.delete_if { |k,v| k == 'z' }
-    assert !@oh.keys.include?('z')
-    @oh.delete_if { |k, v| v > 0 }
-    assert @oh.keys.empty?
-  end
-
-  def test_reject
-    new = @oh.reject { |k, v| k == 'foo' }
-    assert new.keys == @oh.keys
-
-    new = @oh.reject { |k, v| k == 'z' }
-    assert !new.keys.include?('z')
-  end
-
-  def test_reject_bang
-    @oh.reject! { |k, v| k == 'z' }
-    assert !@oh.keys.include?('z')
-    assert_nil @oh.reject! { |k, v| k == 'z' }
-  end
-
-  def test_clone
-    copy = @oh.clone
-    assert copy.keys == @oh.keys
-
-    copy[:foo] = 1
-    assert copy.keys != @oh.keys
-  end
-
-  def test_dup
-    oh2 = @oh.dup
-    oh2['f'] = 9
-    assert_nil @oh['f']
-    assert_equal ['c', 'a', 'z'], @oh.keys
-  end
-end