mongo-lyon 1.2.4

data/test/bson/byte_buffer_test.rb

@@ -0,0 +1,190 @@
+# encoding: binary
+require './test/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_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_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
+  
+  if defined?(Encoding)
+    def test_serialize_cstr_converts_encoding_to_utf8
+      theta = "hello \xC8".force_encoding("ISO-8859-7")
+      ByteBuffer.serialize_cstr(@buf, theta)
+      assert_equal "hello \xCE\x98\0", @buf.to_s
+      assert_equal Encoding.find('binary'), @buf.to_s.encoding
+    end
+    
+    def test_serialize_cstr_validates_data_as_utf8
+      assert_raises(Encoding::UndefinedConversionError) do
+        ByteBuffer.serialize_cstr(@buf, "hello \xFF")
+      end
+    end
+  else
+    def test_serialize_cstr_forces_encoding_to_utf8
+      # Unicode snowman (\u2603)
+      ByteBuffer.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
+        ByteBuffer.serialize_cstr(@buf, "hello \xFF")
+      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
+
+end

data/test/bson/hash_with_indifferent_access_test.rb

@@ -0,0 +1,38 @@
+# encoding:utf-8
+require './test/test_helper'
+require './test/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

@@ -0,0 +1,17 @@
+require './test/test_helper'
+require 'rubygems'
+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

@@ -0,0 +1,154 @@
+require './test/test_helper'
+require 'rubygems'
+require 'json'
+
+class ObjectIdTest < Test::Unit::TestCase
+
+  include Mongo
+  include BSON
+
+  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_save_and_restore
+    db = standard_connection.db(MONGO_TEST_DB)
+    coll = db.collection('test')
+
+    coll.remove
+    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_illegal_from_string
+    assert_raise InvalidObjectId do 
+      ObjectId.from_string("")
+    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)
+
+    mac_id = Digest::MD5.digest(Socket.gethostname)[0, 3].unpack("C3")
+    assert_equal id.to_a[4, 3], mac_id
+    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
+end

data/test/bson/ordered_hash_test.rb

@@ -0,0 +1,197 @@
+require './test/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
+
+  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_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
+
+  def test_inspect_retains_order
+    assert_equal '{"c"=>1, "a"=>2, "z"=>3}', @oh.inspect
+  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')
+  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_clone
+    copy = @oh.clone
+    assert copy.keys == @oh.keys
+
+    copy[:foo] = 1
+    assert copy.keys != @oh.keys
+  end
+end