mongo 1.0.9 → 1.1

data/test/bson/json_test.rb

@@ -0,0 +1,16 @@
+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/bson/object_id_test.rb

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

data/test/collection_test.rb

@@ -477,7 +477,7 @@ class TestCollection < Test::Unit::TestCase
   def test_saving_dates_pre_epoch
     begin
       @@test.save({'date' => Time.utc(1600)})
-      assert_in_delta Time.utc(1600), @@test.find_one()["date"], 0.001
+      assert_in_delta Time.utc(1600), @@test.find_one()["date"], 2
     rescue ArgumentError
       # See note in test_date_before_epoch (BSONTest)
     end

data/test/connection_test.rb

@@ -130,7 +130,7 @@ class TestConnection < Test::Unit::TestCase
   end
 
   def test_nodes
-    db = Connection.paired([['foo', 27017], ['bar', 27018]], :connect => false)
+    db = Connection.multi([['foo', 27017], ['bar', 27018]], :connect => false)
     nodes = db.nodes
     assert_equal 2, nodes.length
     assert_equal ['foo', 27017], nodes[0]
@@ -139,10 +139,31 @@ class TestConnection < Test::Unit::TestCase
 
   def test_slave_ok_with_multiple_nodes
     assert_raise MongoArgumentError do
-      Connection.paired([['foo', 27017], ['bar', 27018]], :connect => false, :slave_ok => true)
+      Connection.multi([['foo', 27017], ['bar', 27018]], :connect => false, :slave_ok => true)
     end
   end
 
+  def test_fsync_lock
+    assert !@mongo.locked?
+    @mongo.lock!
+    assert @mongo.locked?
+    assert_equal 1, @mongo['admin']['$cmd.sys.inprog'].find_one['fsyncLock'], "Not fsync-locked"
+    assert_equal "unlock requested", @mongo.unlock!['info']
+    unlocked = false
+    counter  = 0
+    while counter < 5
+      if @mongo['admin']['$cmd.sys.inprog'].find_one['fsyncLock'].nil?
+        unlocked = true
+        break
+      else
+        sleep(1)
+        counter += 1
+      end
+    end
+    assert !@mongo.locked?
+    assert unlocked, "mongod failed to unlock"
+  end
+
   context "Saved authentications" do
     setup do
       @conn = Mongo::Connection.new

data/test/db_api_test.rb

@@ -454,16 +454,6 @@ class DBAPITest < Test::Unit::TestCase
     assert_equal 2, @@coll.find('$where' => BSON::Code.new('this.a > i', {'i' => 1})).count()
   end
 
-  def test_implicit_where
-    @@coll.remove
-    @@coll.insert('a' => 2)
-    @@coll.insert('a' => 3)
-
-    assert_equal 2, @@coll.count
-    assert_equal 1, @@coll.find('this.a > 2').count()
-    assert_equal 2, @@coll.find(BSON::Code.new('this.a > z', {'z' => 1})).to_a.length
-  end
-
   def test_eval
     assert_equal 3, @@db.eval('function (x) {return x;}', 3)
 
@@ -631,6 +621,7 @@ class DBAPITest < Test::Unit::TestCase
     assert_equal("mike", @@coll.find_one()["hello"])
   end
 
+  if !RUBY_PLATFORM =~ /java/
   def test_invalid_key_names
     @@coll.remove
 
@@ -640,6 +631,7 @@ class DBAPITest < Test::Unit::TestCase
     assert_raise BSON::InvalidKeyName do
       @@coll.insert({"$hello" => "world"})
     end
+
     assert_raise BSON::InvalidKeyName do
       @@coll.insert({"hello" => {"$hello" => "world"}})
     end
@@ -666,6 +658,7 @@ class DBAPITest < Test::Unit::TestCase
       @@coll.insert({"hello" => {"hel.lo" => "world"}})
     end
   end
+  end
 
   def test_collection_names
     assert_raise TypeError do

data/test/db_test.rb

@@ -75,20 +75,6 @@ class DBTest < Test::Unit::TestCase
     assert_kind_of Collection, colls[0]
   end
 
-  def test_pair
-    @@conn.close
-    @@users = nil
-    @@conn  = Connection.paired([["this-should-fail", 27017], [@@host, @@port]])
-    @@db    = @@conn[MONGO_TEST_DB]
-    assert @@conn.connected?
-  ensure
-    unless @@conn.connected?
-      @@conn = Connection.new(@@host, @@port)
-      @@db   = @@conn.db(MONGO_TEST_DB)
-    end
-    @@users = @@db.collection('system.users')
-  end
-
   def test_pk_factory
     db = Connection.new(@@host, @@port).db(MONGO_TEST_DB, :pk => TestPKFactory.new)
     coll = db.collection('test')