bson 1.0.9 → 1.1

data/test/mongo_bson/json_test.rb

@@ -1,16 +0,0 @@
-require './test/test_helper'
-require 'rubygems'
-require 'json'
-
-class JSONTest < Test::Unit::TestCase
-
-  include Mongo
-  include BSON
-
-  def test_object_id_as_json
-    id = ObjectId.new
-    obj = {'_id' => id}
-    assert_equal "{\"_id\":{\"$oid\": \"#{id.to_s}\"}}", obj.to_json
-  end
-
-end

data/test/mongo_bson/object_id_test.rb

@@ -1,132 +0,0 @@
-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_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
-    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

@@ -1,197 +0,0 @@
-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