mongo 1.1.5 → 1.3.0

data/test/bson/bson_test.rb

@@ -1,10 +1,14 @@
 # encoding:utf-8
 require './test/test_helper'
-require 'complex'
+
+if RUBY_VERSION < '1.9'
+  require 'complex'
+  require 'rational'
+end
 require 'bigdecimal'
-require 'rational'
 
 begin
+  require 'tzinfo'
   require 'active_support/core_ext'
   Time.zone = "Pacific Time (US & Canada)"
   Zone = Time.zone.now
@@ -67,13 +71,26 @@ class BSONTest < Test::Unit::TestCase
     assert_doc_pass(doc)
   end
 
-  def test_document_length
-    doc = {'name' => 'a' * 5 * 1024 * 1024}
+  def test_limit_max_bson_size
+    doc = {'name' => 'a' * BSON_CODER.max_bson_size}
     assert_raise InvalidDocument do
       assert @encoder.serialize(doc)
     end
   end
 
+  def test_max_bson_size
+    assert BSON_CODER.max_bson_size >= BSON::DEFAULT_MAX_BSON_SIZE
+  end
+
+  def test_update_max_bson_size
+    require 'ostruct'
+    mock_conn = OpenStruct.new
+    size      = 7 * 1024 * 1024
+    mock_conn.max_bson_size = size
+    assert_equal size, BSON_CODER.update_max_bson_size(mock_conn)
+    assert_equal size, BSON_CODER.max_bson_size
+  end
+
   def test_round_trip
     doc = {'doc' => 123}
     @encoder.deserialize(@encoder.serialize(doc))
@@ -103,15 +120,23 @@ class BSONTest < Test::Unit::TestCase
     end
   else
     def test_non_utf8_string
-      bson = BSON::BSON_CODER.serialize({'str' => 'aé'.encode('iso-8859-1')})
-      result = BSON::BSON_CODER.deserialize(bson)['str']
-      assert_equal 'aé', result
-      assert_equal 'UTF-8', result.encoding.name
+      assert_raise BSON::InvalidStringEncoding do
+        BSON::BSON_CODER.serialize({'str' => 'aé'.encode('iso-8859-1')})
+      end
+    end
+
+    def test_invalid_utf8_string
+      str = "123\xD9"
+      assert !str.valid_encoding?
+      assert_raise BSON::InvalidStringEncoding do
+        BSON::BSON_CODER.serialize({'str' => str})
+      end
     end
 
     def test_non_utf8_key
-      bson = BSON::BSON_CODER.serialize({'aé'.encode('iso-8859-1') => 'hello'})
-      assert_equal 'hello', BSON::BSON_CODER.deserialize(bson)['aé']
+      assert_raise BSON::InvalidStringEncoding do
+        BSON::BSON_CODER.serialize({'aé'.encode('iso-8859-1') => 'hello'})
+      end
     end
 
     # Based on a test from sqlite3-ruby
@@ -121,14 +146,14 @@ class BSONTest < Test::Unit::TestCase
       str = "壁に耳あり、障子に目あり"
       bson = BSON::BSON_CODER.serialize("x" => str)
 
-      Encoding.default_internal = 'EUC-JP'
+      silently { Encoding.default_internal = 'EUC-JP' }
       out = BSON::BSON_CODER.deserialize(bson)["x"]
 
       assert_equal Encoding.default_internal, out.encoding
       assert_equal str.encode('EUC-JP'), out
       assert_equal str, out.encode(str.encoding)
     ensure
-      Encoding.default_internal = before_enc
+      silently { Encoding.default_internal = before_enc }
     end
   end
 
@@ -137,17 +162,23 @@ class BSONTest < Test::Unit::TestCase
     assert_doc_pass(doc)
   end
 
+  def test_code_with_symbol
+    assert_raise_error ArgumentError, "BSON::Code must be in the form of a String" do
+      Code.new(:fubar)
+    end
+  end
+
   def test_code_with_scope
     doc = {'$where' => Code.new('this.a.b < this.b', {'foo' => 1})}
     assert_doc_pass(doc)
   end
 
-   def test_double
-     doc = {'doc' => 41.25}
-     assert_doc_pass(doc)
-   end
+  def test_double
+    doc = {'doc' => 41.25}
+    assert_doc_pass(doc)
+  end
 
- def test_int
+  def test_int
     doc = {'doc' => 42}
     assert_doc_pass(doc)
 
@@ -200,6 +231,15 @@ class BSONTest < Test::Unit::TestCase
     assert_doc_pass(doc)
   end
 
+  def test_array_keys
+    doc = {'doc' => [1, 2, 'a', 'b']}
+    bson = @encoder.serialize(doc).to_a
+    assert_equal 48, bson[14]
+    assert_equal 49, bson[21]
+    assert_equal 50, bson[28]
+    assert_equal 51, bson[37]
+  end
+
   def test_regex
     doc = {'doc' => /foobar/i}
     assert_doc_pass(doc)
@@ -218,8 +258,14 @@ class BSONTest < Test::Unit::TestCase
     assert_in_delta doc['date'], doc2['date'], 0.001
   end
 
+  def test_date_in_array
+    doc = {'date' => [Time.now.utc]}
+    bson = @encoder.serialize(doc)
+    doc2 = @encoder.deserialize(bson)
+  end
+
   def test_date_returns_as_utc
-    doc = {'date' => Time.now}
+    doc = {'date' => Time.now.utc}
     bson = @encoder.serialize(doc)
     doc2 = @encoder.deserialize(bson)
     assert doc2['date'].utc?
@@ -249,7 +295,7 @@ class BSONTest < Test::Unit::TestCase
       ensure
         if !invalid_date.is_a? Time
           assert_equal InvalidDocument, e.class
-          assert_match /UTC Time/, e.message
+          assert_match(/UTC Time/, e.message)
         end
       end
     end
@@ -283,6 +329,20 @@ class BSONTest < Test::Unit::TestCase
     bin = Binary.new
     'binstring'.each_byte { |b| bin.put(b) }
 
+    doc = {'bin' => bin}
+    bson = @encoder.serialize(doc)
+    doc2 = @encoder.deserialize(bson)
+    bin2 = doc2['bin']
+    assert_kind_of Binary, bin2
+    assert_equal 'binstring', bin2.to_s
+    assert_equal Binary::SUBTYPE_SIMPLE, bin2.subtype
+  end
+
+  def test_binary_with_deprecated_subtype
+    bin = Binary.new
+    'binstring'.each_byte { |b| bin.put(b) }
+    bin.subtype = Binary::SUBTYPE_BYTES
+
     doc = {'bin' => bin}
     bson = @encoder.serialize(doc)
     doc2 = @encoder.deserialize(bson)
@@ -300,7 +360,7 @@ class BSONTest < Test::Unit::TestCase
     bin2 = doc2['bin']
     assert_kind_of Binary, bin2
     assert_equal 'somebinarystring', bin2.to_s
-    assert_equal Binary::SUBTYPE_BYTES, bin2.subtype
+    assert_equal Binary::SUBTYPE_SIMPLE, bin2.subtype
   end
 
   def test_binary_type
@@ -340,7 +400,7 @@ class BSONTest < Test::Unit::TestCase
     bin2 = doc2['bin']
     assert_kind_of Binary, bin2
     assert_equal [1, 2, 3, 4, 5], bin2.to_a
-    assert_equal Binary::SUBTYPE_BYTES, bin2.subtype
+    assert_equal Binary::SUBTYPE_SIMPLE, bin2.subtype
   end
 
   def test_put_id_first
@@ -365,15 +425,24 @@ class BSONTest < Test::Unit::TestCase
   if !(RUBY_PLATFORM =~ /java/)
     def test_timestamp
       val = {"test" => [4, 20]}
-      assert_equal val, @encoder.deserialize([0x13, 0x00, 0x00, 0x00,
-                                        0x11, 0x74, 0x65, 0x73,
-                                        0x74, 0x00, 0x04, 0x00,
-                                        0x00, 0x00, 0x14, 0x00,
-                                        0x00, 0x00, 0x00])
-
+      result = @encoder.deserialize([0x13, 0x00, 0x00, 0x00,
+                                     0x11, 0x74, 0x65, 0x73,
+                                     0x74, 0x00, 0x04, 0x00,
+                                     0x00, 0x00, 0x14, 0x00,
+                                     0x00, 0x00, 0x00])
+
+      assert_equal 4, result["test"][0]
+      assert_equal 20, result["test"][1]
     end
   end
 
+  def test_timestamp_type
+    ts = Timestamp.new(5000, 100)
+    doc = {:ts => ts}
+    bson = @encoder.serialize(doc)
+    assert_equal ts, @encoder.deserialize(bson)["ts"]
+  end
+
   def test_overflow
     doc = {"x" => 2**75}
     assert_raise RangeError do
@@ -411,7 +480,7 @@ class BSONTest < Test::Unit::TestCase
       rescue => e
       ensure
         assert_equal InvalidDocument, e.class
-        assert_match /Cannot serialize/, e.message
+        assert_match(/Cannot serialize/, e.message)
       end
     end
   end
@@ -534,4 +603,47 @@ class BSONTest < Test::Unit::TestCase
     end
   end
 
+  def test_invalid_key_names
+    assert @encoder.serialize({"hello" => "world"}, true)
+    assert @encoder.serialize({"hello" => {"hello" => "world"}}, true)
+
+    assert @encoder.serialize({"he$llo" => "world"}, true)
+    assert @encoder.serialize({"hello" => {"hell$o" => "world"}}, true)
+
+    assert_raise BSON::InvalidDocument do
+      @encoder.serialize({"he\0llo" => "world"}, true)
+    end
+
+    assert_raise BSON::InvalidKeyName do
+      @encoder.serialize({"$hello" => "world"}, true)
+    end
+
+    assert_raise BSON::InvalidKeyName do
+      @encoder.serialize({"hello" => {"$hello" => "world"}}, true)
+    end
+
+    assert_raise BSON::InvalidKeyName  do
+      @encoder.serialize({".hello" => "world"}, true)
+    end
+
+    assert_raise BSON::InvalidKeyName do
+      @encoder.serialize({"hello" => {".hello" => "world"}}, true)
+    end
+
+    assert_raise BSON::InvalidKeyName do
+      @encoder.serialize({"hello." => "world"}, true)
+    end
+
+    assert_raise BSON::InvalidKeyName do
+      @encoder.serialize({"hello" => {"hello." => "world"}}, true)
+    end
+
+    assert_raise BSON::InvalidKeyName do
+      @encoder.serialize({"hel.lo" => "world"}, true)
+    end
+
+    assert_raise BSON::InvalidKeyName do
+      @encoder.serialize({"hello" => {"hel.lo" => "world"}}, true)
+    end
+  end
 end

data/test/bson/byte_buffer_test.rb

@@ -21,6 +21,13 @@ class ByteBufferTest < Test::Unit::TestCase
     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
@@ -186,5 +193,16 @@ class ByteBufferTest < Test::Unit::TestCase
     @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/object_id_test.rb

@@ -126,14 +126,27 @@ class ObjectIdTest < Test::Unit::TestCase
     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)

data/test/bson/ordered_hash_test.rb

@@ -194,4 +194,11 @@ class OrderedHashTest < Test::Unit::TestCase
     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

data/test/bson/timestamp_test.rb

@@ -0,0 +1,24 @@
+require './test/test_helper'
+
+class TiumestampTest < Test::Unit::TestCase
+  include Mongo
+
+  def test_timestamp_equality
+    t1 = Timestamp.new(5000, 200)
+    t2 = Timestamp.new(5000, 200)
+    assert_equal t2, t1
+  end
+
+  def test_implements_array_for_backward_compatibility
+    ts = Timestamp.new(5000, 200)
+    assert_equal 200, ts[0]
+    assert_equal 5000, ts[1]
+
+    array = ts.map {|t| t }
+    assert_equal 2, array.length
+
+    assert_equal 200, array[0]
+    assert_equal 5000, array[1]
+  end
+
+end

data/test/collection_test.rb

@@ -1,7 +1,7 @@
 require './test/test_helper'
 
 class TestCollection < Test::Unit::TestCase
-  @@connection ||= standard_connection
+  @@connection ||= standard_connection(:op_timeout => 2)
   @@db   = @@connection.db(MONGO_TEST_DB)
   @@test = @@db.collection("test")
   @@version = @@connection.server_version
@@ -32,11 +32,11 @@ class TestCollection < Test::Unit::TestCase
   end
 
   def test_pk_factory_on_collection
-    @coll = Collection.new(@@db, 'foo', TestPK)
+    @coll = Collection.new('foo', @@db, TestPK)
     assert_equal TestPK, @coll.pk_factory
 
 
-    @coll2 = Collection.new(@@db, 'foo', :pk => TestPK)
+    @coll2 = Collection.new('foo', @@db, :pk => TestPK)
     assert_equal TestPK, @coll2.pk_factory
   end
 
@@ -373,8 +373,8 @@ class TestCollection < Test::Unit::TestCase
 
     docs = [{"hello" => "world"}, {"hello" => "world"}]
     @@test.insert(docs)
-    docs.each do |doc|
-      assert(doc.include?(:_id))
+    docs.each do |d|
+      assert(d.include?(:_id))
     end
   end
 
@@ -417,7 +417,7 @@ class TestCollection < Test::Unit::TestCase
 
       m = "function() { emit(this.user_id, 1); }"
       r = "function(k,vals) { return 1; }"
-      res = @@test.map_reduce(m, r);
+      res = @@test.map_reduce(m, r, :out => 'foo');
       assert res.find_one({"_id" => 1})
       assert res.find_one({"_id" => 2})
     end
@@ -428,7 +428,7 @@ class TestCollection < Test::Unit::TestCase
 
       m = Code.new("function() { emit(this.user_id, 1); }")
       r = Code.new("function(k,vals) { return 1; }")
-      res = @@test.map_reduce(m, r);
+      res = @@test.map_reduce(m, r, :out => 'foo');
       assert res.find_one({"_id" => 1})
       assert res.find_one({"_id" => 2})
     end
@@ -441,7 +441,7 @@ class TestCollection < Test::Unit::TestCase
 
       m = Code.new("function() { emit(this.user_id, 1); }")
       r = Code.new("function(k,vals) { return 1; }")
-      res = @@test.map_reduce(m, r, :query => {"user_id" => {"$gt" => 1}});
+      res = @@test.map_reduce(m, r, :query => {"user_id" => {"$gt" => 1}}, :out => 'foo');
       assert_equal 2, res.count
       assert res.find_one({"_id" => 2})
       assert res.find_one({"_id" => 3})
@@ -450,7 +450,7 @@ class TestCollection < Test::Unit::TestCase
     def test_map_reduce_with_raw_response
       m = Code.new("function() { emit(this.user_id, 1); }")
       r = Code.new("function(k,vals) { return 1; }")
-      res = @@test.map_reduce(m, r, :raw => true)
+      res = @@test.map_reduce(m, r, :raw => true, :out => 'foo')
       assert res["result"]
       assert res["counts"]
       assert res["timeMillis"]
@@ -465,6 +465,36 @@ class TestCollection < Test::Unit::TestCase
       assert res["counts"]
       assert res["timeMillis"]
     end
+
+
+    if @@version >= "1.8.0"
+      def test_map_reduce_with_collection_merge
+        @@test << {:user_id => 1}
+        @@test << {:user_id => 2}
+        output_collection = "test-map-coll"
+        m = Code.new("function() { emit(this.user_id, {count: 1}); }")
+        r = Code.new("function(k,vals) { var sum = 0;" +
+          " vals.forEach(function(v) { sum += v.count;} ); return {count: sum}; }")
+        res = @@test.map_reduce(m, r, :out => output_collection)
+
+        @@test.remove
+        @@test << {:user_id => 3}
+        res = @@test.map_reduce(m, r, :out => {:merge => output_collection})
+        assert res.find.to_a.any? {|doc| doc["_id"] == 3 && doc["value"]["count"] == 1}
+
+        @@test.remove
+        @@test << {:user_id => 3}
+        res = @@test.map_reduce(m, r, :out => {:reduce => output_collection})
+        assert res.find.to_a.any? {|doc| doc["_id"] == 3 && doc["value"]["count"] == 2}
+
+        assert_raise ArgumentError do
+          @@test.map_reduce(m, r, :out => {:inline => 1})
+        end
+
+        @@test.map_reduce(m, r, :raw => true, :out => {:inline => 1})
+        assert res["results"]
+      end
+    end
   end
 
   if @@version > "1.3.0"
@@ -565,6 +595,20 @@ class TestCollection < Test::Unit::TestCase
     assert_equal 1, x
   end
 
+  def test_find_with_transformer
+    klass       = Struct.new(:id, :a)
+    transformer = Proc.new { |doc| klass.new(doc['_id'], doc['a']) }
+    cursor      = @@test.find({}, :transformer => transformer)
+    assert_equal(transformer, cursor.transformer)
+  end
+  
+  def test_find_one_with_transformer
+    klass       = Struct.new(:id, :a)
+    transformer = Proc.new { |doc| klass.new(doc['_id'], doc['a']) }
+    id          = @@test.insert('a' => 1)
+    doc         = @@test.find_one(id, :transformer => transformer)
+    assert_instance_of(klass, doc)
+  end
 
   def test_ensure_index
     @@test.drop_indexes
@@ -600,6 +644,23 @@ class TestCollection < Test::Unit::TestCase
     @@test.drop_index("a_1")
   end
 
+  def test_ensure_index_timeout
+    @@db.cache_time = 2
+    coll = @@db['ensure_test']
+    coll.expects(:generate_indexes).twice
+    coll.ensure_index([['a', 1]])
+
+    # These will be cached
+    coll.ensure_index([['a', 1]])
+    coll.ensure_index([['a', 1]])
+    coll.ensure_index([['a', 1]])
+    coll.ensure_index([['a', 1]])
+
+    sleep(3)
+    # This won't be, so generate_indexes will be called twice
+    coll.ensure_index([['a', 1]])
+  end
+
   context "Grouping" do
     setup do
       @@test.remove
@@ -609,15 +670,25 @@ class TestCollection < Test::Unit::TestCase
       @reduce_function = "function (obj, prev) { prev.count += inc_value; }"
     end
 
+    should "fail if missing required options" do
+      assert_raise MongoArgumentError do
+        @@test.group(:initial => {})
+      end
+
+      assert_raise MongoArgumentError do
+        @@test.group(:reduce => "foo")
+      end
+    end
+
     should "group results using eval form" do
-      assert_equal 1, @@test.group([], {}, @initial, Code.new(@reduce_function, {"inc_value" => 0.5}))[0]["count"]
-      assert_equal 2, @@test.group([], {}, @initial, Code.new(@reduce_function, {"inc_value" => 1}))[0]["count"]
-      assert_equal 4, @@test.group([], {}, @initial, Code.new(@reduce_function, {"inc_value" => 2}))[0]["count"]
+      assert_equal 1, @@test.group(:initial => @initial, :reduce => Code.new(@reduce_function, {"inc_value" => 0.5}))[0]["count"]
+      assert_equal 2, @@test.group(:initial => @initial, :reduce => Code.new(@reduce_function, {"inc_value" => 1}))[0]["count"]
+      assert_equal 4, @@test.group(:initial => @initial, :reduce => Code.new(@reduce_function, {"inc_value" => 2}))[0]["count"]
     end
 
     should "finalize grouped results" do
       @finalize = "function(doc) {doc.f = doc.count + 200; }"
-      assert_equal 202, @@test.group([], {}, @initial, Code.new(@reduce_function, {"inc_value" => 1}), @finalize)[0]["f"]
+      assert_equal 202, @@test.group(:initial => @initial, :reduce => Code.new(@reduce_function, {"inc_value" => 1}), :finalize => @finalize)[0]["f"]
     end
   end
 
@@ -633,7 +704,7 @@ class TestCollection < Test::Unit::TestCase
     end
 
     should "group" do
-      result = @@test.group([:a], {}, @initial, @reduce_function, nil)
+      result = @@test.group(:key => :a, :initial => @initial, :reduce => @reduce_function)
       assert result.all? { |r| r['count'] == 200 }
     end
   end
@@ -652,10 +723,17 @@ class TestCollection < Test::Unit::TestCase
     end
 
     should "group results" do
-      results = @@test.group(@keyf, {}, @initial, @reduce).sort {|a, b| a['count'] <=> b['count']}
+      results = @@test.group(:keyf => @keyf, :initial => @initial, :reduce => @reduce).sort {|a, b| a['count'] <=> b['count']}
       assert results[0]['even'] && results[0]['count'] == 2.0
       assert results[1]['odd'] && results[1]['count'] == 3.0
     end
+
+    should "group filtered results" do
+      results = @@test.group(:keyf => @keyf, :cond => {:a => {'$ne' => 2}},
+        :initial => @initial, :reduce => @reduce).sort {|a, b| a['count'] <=> b['count']}
+      assert results[0]['even'] && results[0]['count'] == 1.0
+      assert results[1]['odd'] && results[1]['count'] == 3.0
+    end
   end
 
   context "A collection with two records" do
@@ -693,6 +771,17 @@ class TestCollection < Test::Unit::TestCase
       @geo        = @@db.collection('geo')
     end
 
+    should "create index using symbols" do
+      @collection.create_index :foo, :name => :bar
+      @geo.create_index :goo, :name => :baz
+      assert @collection.index_information['bar']
+      @collection.drop_index :bar
+      assert_nil @collection.index_information['bar']
+      assert @geo.index_information['baz']
+      @geo.drop_index(:baz)
+      assert_nil @geo.index_information['baz']
+    end
+
     should "create a geospatial index" do
       @geo.save({'loc' => [-100, 100]})
       @geo.create_index([['loc', Mongo::GEO2D]])