bson 0.20

data/test/mongo_bson/byte_buffer_test.rb

@@ -0,0 +1,82 @@
+require 'test/test_helper'
+
+class ByteBufferTest < Test::Unit::TestCase
+  include BSON
+
+  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/mongo_bson/objectid_test.rb

@@ -0,0 +1,126 @@
+require 'test/test_helper'
+
+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_inspect
+    assert_equal "ObjectID('#{@o.to_s}')", @o.inspect
+  end
+
+  def test_save_and_restore
+    host = ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost'
+    port = ENV['MONGO_RUBY_DRIVER_PORT'] || Connection::DEFAULT_PORT
+    db = Connection.new(host, port).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_equal time.to_i, id.generation_time.to_i
+  end
+
+  def test_json
+    id = ObjectID.new
+    assert_equal "{\"$oid\": \"#{id}\"}", id.to_json
+  end
+end

data/test/mongo_bson/ordered_hash_test.rb

@@ -0,0 +1,172 @@
+require 'test/test_helper'
+
+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_initialize
+    a = OrderedHash.new
+    a['x'] = 1
+    a['y'] = 2
+
+    b = OrderedHash['x' => 1, 'y' => 2]
+    assert_equal a, b
+  end
+
+  def test_hash_code
+    o = OrderedHash.new
+    o['number'] = 50
+    assert o.hash
+  end
+
+  def test_empty
+    assert_equal [], OrderedHash.new.keys
+  end
+
+  def test_uniq
+    list = []
+    doc  = OrderedHash.new
+    doc['_id']  = 'ab12'
+    doc['name'] = 'test'
+
+    same_doc = 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 = OrderedHash.new
+    a['x'] = 1
+    a['y'] = 2
+
+    b = OrderedHash.new
+    b['y'] = 2
+    b['x'] = 1
+
+    c = OrderedHash.new
+    c['x'] = 1
+    c['y'] = 2
+
+    d = OrderedHash.new
+    d['x'] = 2
+    d['y'] = 3
+
+    e = 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 = 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_update
+    other = 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
+
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: bson
+version: !ruby/object:Gem::Version 
+  version: "0.20"
+platform: ruby
+authors: 
+- Jim Menard
+- Mike Dirolf
+- Kyle Banker
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-07 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: A Ruby BSON implementation for MongoDB. For more information about Mongo, see http://www.mongodb.org. For more information on BSON, see http://www.bsonspec.org.
+email: mongodb-dev@googlegroups.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- bson.gemspec
+- LICENSE.txt
+- lib/bson.rb
+- lib/bson/bson_c.rb
+- lib/bson/bson_ruby.rb
+- lib/bson/byte_buffer.rb
+- lib/bson/exceptions.rb
+- lib/bson/ordered_hash.rb
+- lib/bson/types/binary.rb
+- lib/bson/types/code.rb
+- lib/bson/types/dbref.rb
+- lib/bson/types/min_max_keys.rb
+- lib/bson/types/objectid.rb
+has_rdoc: true
+homepage: http://www.mongodb.org
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Ruby implementation of BSON
+test_files: 
+- test/mongo_bson/binary_test.rb
+- test/mongo_bson/bson_test.rb
+- test/mongo_bson/byte_buffer_test.rb
+- test/mongo_bson/objectid_test.rb
+- test/mongo_bson/ordered_hash_test.rb