mongo 0.1.0 → 0.15

data/test/mongo-qa/capped

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '_common.rb')
+db = Connection.new(DEFAULT_HOST, DEFAULT_PORT).db(DEFAULT_DB)
+
+if $DEBUG
+  db.drop_collection('capped1')
+  db.drop_collection('capped2')
+end
+
+db.create_collection('capped1', :capped => true, :size => 500)
+coll = db.collection('capped1')
+coll.insert('x' => 1)
+coll.insert('x' => 2)
+
+db.create_collection('capped2', :capped => true, :size => 1000, :max => 11)
+coll = db.collection('capped2')
+str = ''
+100.times {
+  coll.insert('dashes' => str)
+  str << '-'
+}

data/test/mongo-qa/count1

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '_common.rb')
+db = Connection.new(DEFAULT_HOST, DEFAULT_PORT).db(DEFAULT_DB)
+
+if $DEBUG
+  3.times { |i| db.drop_collection("test#{i+1}") }
+  db.create_collection('test1')
+  db.collection('test2').insert({:name => 'a'})
+  c = db.collection('test3')
+  100.times { |i| c.insert(:i => i, :foo => 'bar') }
+end
+
+puts db.collection('test1').count
+puts db.collection('test2').count
+puts db.collection('test3').find('i' => 'a').count
+puts db.collection('test3').find('i' => 3).count
+puts db.collection('test3').find({'i' => {'$gte' => 67}}).count

data/test/mongo-qa/dbs

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '_common.rb')
+db = Connection.new(DEFAULT_HOST, DEFAULT_PORT).db(DEFAULT_DB)
+
+if $DEBUG
+  3.times { |i| db.drop_collection("dbs_#{i+1}") }
+end
+
+def print_dbs_names(db)
+  db.collection_names.select{ |n| n =~ /\.dbs/ }.sort.each { |name|
+    puts name.sub(/^#{db.name}\./, '')
+  }
+end
+
+db.collection('dbs_1').insert('foo' => 'bar')
+db.collection('dbs_2').insert('psi' => 'phi')
+puts db.name
+print_dbs_names(db)
+db.drop_collection('dbs_1')
+db.create_collection('dbs_3')
+print_dbs_names(db)

data/test/mongo-qa/find

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '_common.rb')
+db = Connection.new(DEFAULT_HOST, DEFAULT_PORT).db(DEFAULT_DB)
+
+if $DEBUG
+  db.drop_collection('test')
+end
+
+db.collection('test').insert('a' => 2)

data/test/mongo-qa/find1

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '_common.rb')
+db = Connection.new(DEFAULT_HOST, DEFAULT_PORT).db(DEFAULT_DB)
+
+if $DEBUG
+  db.drop_collection('c')
+  c = db.collection('c')
+  (5..15).each { |i| c.insert(:x => 0, :y => i, :z => (i+64).chr) }
+  (1..50).each { |i| c.insert(:x => 1, :y => i, :z => (i+64).chr) }
+  (5..15).each { |i| c.insert(:x => 2, :y => i, :z => (i+64).chr) }
+end
+
+cursor = db.collection('c').find({'x' => 1}, :sort => 'y', :skip => 20, :limit => 10)
+cursor.each { |row| puts row['z'] }

data/test/mongo-qa/gridfs_in

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '_common.rb')
+
+require 'mongo/gridfs'
+include GridFS
+
+db = Connection.new(DEFAULT_HOST, DEFAULT_PORT).db(DEFAULT_DB)
+
+input_file = ARGV[0]
+
+File.open(input_file, "r") { |f|
+  GridStore.open(db, input_file, "w") { |g|
+    g.write(f.read)
+  }
+}

data/test/mongo-qa/gridfs_out

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '_common.rb')
+
+require 'mongo/gridfs'
+include GridFS
+
+db = Connection.new(DEFAULT_HOST, DEFAULT_PORT).db(DEFAULT_DB)
+
+input_file = ARGV[0]
+output_file = ARGV[1]
+
+File.open(output_file, "w") { |f|
+  GridStore.open(db, input_file, "r") { |g|
+    f.write(g.read)
+  }
+}

data/test/mongo-qa/indices

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '_common.rb')
+
+include Mongo
+
+db = Connection.new(DEFAULT_HOST, DEFAULT_PORT).db(DEFAULT_DB)
+x = db.collection('x')
+y = db.collection('y')
+
+def sorted_index_info(c)
+  c.index_information.sort { |a,b| a[:name] <=> b[:name] }
+end
+
+def sorted_info_keys(info)
+  info[:keys].keys.sort.collect { |key| "#{key}_1" }.join("_")
+end
+
+def check_keys(c, expected)
+  keys = sorted_index_info(c).collect {|info| sorted_info_keys(info)}
+  if keys == expected
+    ''
+  else
+    "#{c.name} indices should start out #{expected.inspect} but is #{keys.inspect}"
+  end
+end
+
+if $DEBUG
+  x.drop                        # also drops indexes
+  x.insert('field1' => 'f1', 'field2' => 'f2')
+  x.create_index('field1_1', 'field1')
+  x.create_index('field2_1', 'field2')
+  y.drop
+end
+
+# There should only be two indices on x, and none on y. We raise an error if
+# the preconditions are not met. (They were not, on our testing harness, for a
+# while due to Mongo behavior.)
+err = []
+err << check_keys(x, ['field1_1', 'field2_1'])
+err << check_keys(y, [])
+raise "\n#{err.join("\n")}" unless err == ['', '']
+
+x.drop_index('field1_1')
+sorted_index_info(x).each { |info| puts sorted_info_keys(info) }
+
+y.create_index([['a', ASCENDING], ['b', ASCENDING], ['c', ASCENDING]])
+y.create_index('d')
+sorted_index_info(y).each { |info| puts sorted_info_keys(info) }

data/test/mongo-qa/remove

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '_common.rb')
+db = Connection.new(DEFAULT_HOST, DEFAULT_PORT).db(DEFAULT_DB)
+
+if $DEBUG
+  c = db.collection('remove1')
+  c.clear
+  50.times { |i| c.insert(:a => i) }
+  c = db.collection('remove2')
+  c.clear
+  c.insert(:a => 3, :b => 1)
+  c.insert(:a => 3, :b => 3)
+  c.insert(:a => 2, :b => 3)
+  c.insert(:b => 3)
+end
+
+db.collection('remove1').clear
+db.collection('remove2').remove('a' => 3)
+
+if $DEBUG
+  puts "remove1 count = #{db.collection('remove1').count}"
+  puts "remove2 count = #{db.collection('remove2').count}"
+  db.collection('remove2').find.each { |row| puts row.inspect }
+end

data/test/mongo-qa/stress1

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+LONG_STRING = "lksjhasoh1298alshasoidiohaskjasiouashoasasiugoas" * 6
+
+require File.join(File.dirname(__FILE__), '_common.rb')
+db = Connection.new(DEFAULT_HOST, DEFAULT_PORT).db(DEFAULT_DB)
+c = db.collection('stress1')
+
+n1 = 50_000
+n2 = 10_000
+
+if $DEBUG
+  n1 = 5
+  n2 = 1
+  c.drop
+end
+
+n1.times { |i|
+  c.insert(:name => "asdf#{i}", :date => Time.now, :id => i,
+           :blah => LONG_STRING, :subarray => [])
+}
+puts
+
+n2.times { |i|
+  x = c.find_one({:id => i})
+  x['subarray'] = "foo#{i}"
+  p x
+  c.modify({:id => i}, x)
+}
+puts
+
+if $DEBUG
+  puts "stress1 has #{c.count} records"
+  c.find.each { |row| puts "#{row['id']}: #{row['subarray'].inspect}" }
+end

data/test/mongo-qa/test1

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '_common.rb')
+db = Connection.new(DEFAULT_HOST, DEFAULT_PORT).db(DEFAULT_DB)
+coll = db.collection('part1')
+
+if $DEBUG
+  coll.drop
+end
+
+100.times { |i| coll.insert('x' => i) }

data/test/mongo-qa/update

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '_common.rb')
+db = Connection.new(DEFAULT_HOST, DEFAULT_PORT).db(DEFAULT_DB)
+foo = db.collection('foo')
+
+if $DEBUG
+  foo.drop
+  foo.insert(:x => 1)
+end
+
+foo.modify({:x => 1}, {:x => 1, :y => 2})
+foo.modify({:x => 2}, {:x => 1, :y => 7})
+foo.repsert({:x => 3}, {:x => 4, :y => 1})
+
+if $DEBUG
+  foo.find.each { |row| puts row.inspect }
+end

data/{tests → test}/test_admin.rb

@@ -5,26 +5,24 @@ require 'test/unit'
 # NOTE: assumes Mongo is running
 class AdminTest < Test::Unit::TestCase
 
-  include XGen::Mongo::Driver
+  include Mongo
+
+  @@db = Connection.new(ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost',
+                        ENV['MONGO_RUBY_DRIVER_PORT'] || Connection::DEFAULT_PORT).db('ruby-mongo-test')
+  @@coll = @@db.collection('test')
 
   def setup
-    host = ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost'
-    port = ENV['MONGO_RUBY_DRIVER_PORT'] || Mongo::DEFAULT_PORT
-    @db = Mongo.new(host, port).db('ruby-mongo-test')
     # Insert some data to make sure the database itself exists.
-    @coll = @db.collection('test')
-    @coll.clear
-    @r1 = @coll.insert('a' => 1) # collection not created until it's used
-    @coll_full_name = 'ruby-mongo-test.test'
-    @admin = @db.admin
+    @@coll.clear
+    @r1 = @@coll.insert('a' => 1) # collection not created until it's used
+    @@coll_full_name = 'ruby-mongo-test.test'
+    @admin = @@db.admin
   end
 
   def teardown
-    if @db.connected?
-      @admin.profiling_level = :off
-      @coll.clear if @coll
-      @db.close
-    end
+    @admin.profiling_level = :off
+    @@coll.clear if @@coll
+    @@db.error
   end
 
   def test_default_profiling_level
@@ -36,12 +34,19 @@ class AdminTest < Test::Unit::TestCase
     assert_equal :slow_only, @admin.profiling_level
     @admin.profiling_level = :off
     assert_equal :off, @admin.profiling_level
+    @admin.profiling_level = :all
+    assert_equal :all, @admin.profiling_level
+    begin
+      @admin.profiling_level = :medium
+      fail "shouldn't be able to do this"
+    rescue
+    end
   end
 
   def test_profiling_info
     # Perform at least one query while profiling so we have something to see.
     @admin.profiling_level = :all
-    @coll.find()
+    @@coll.find()
     @admin.profiling_level = :off
 
     info = @admin.profiling_info
@@ -54,7 +59,11 @@ class AdminTest < Test::Unit::TestCase
   end
 
   def test_validate_collection
-    assert @admin.validate_collection(@coll.name)
+    doc = @admin.validate_collection(@@coll.name)
+    assert_not_nil doc
+    result = doc['result']
+    assert_not_nil result
+    assert_match /firstExtent/, result
   end
 
 end

data/test/test_bson.rb

@@ -0,0 +1,268 @@
+$LOAD_PATH[0,0] = File.join(File.dirname(__FILE__), '..', 'lib')
+require 'mongo'
+require 'mongo/util/ordered_hash'
+require 'test/unit'
+
+class BSONTest < Test::Unit::TestCase
+
+  include Mongo
+
+  def setup
+    # We don't pass a DB to the constructor, even though we are about to test
+    # deserialization. This means that when we deserialize, any DBRefs will
+    # have nil @db ivars. That's fine for now.
+    @b = BSON.new
+  end
+
+  def test_string
+    doc = {'doc' => 'hello, world'}
+    @b.serialize(doc)
+    assert_equal doc, @b.deserialize
+  end
+
+  def test_code
+    doc = {'$where' => Code.new('this.a.b < this.b')}
+    @b.serialize(doc)
+    assert_equal doc, @b.deserialize
+  end
+
+  def test_number
+    doc = {'doc' => 41.99}
+    @b.serialize(doc)
+    assert_equal doc, @b.deserialize
+  end
+
+  def test_int
+    doc = {'doc' => 42}
+    @b.serialize(doc)
+    assert_equal doc, @b.deserialize
+
+    doc = {"doc" => -5600}
+    @b.serialize(doc)
+    assert_equal doc, @b.deserialize
+
+    doc = {"doc" => 2147483647}
+    @b.serialize(doc)
+    assert_equal doc, @b.deserialize
+
+    doc = {"doc" => -2147483648}
+    @b.serialize(doc)
+    assert_equal doc, @b.deserialize
+  end
+
+  def test_ordered_hash
+    doc = OrderedHash.new
+    doc["b"] = 1
+    doc["a"] = 2
+    doc["c"] = 3
+    doc["d"] = 4
+    @b.serialize(doc)
+    assert_equal doc, @b.deserialize
+  end
+
+  def test_object
+    doc = {'doc' => {'age' => 42, 'name' => 'Spongebob', 'shoe_size' => 9.5}}
+    @b.serialize(doc)
+    assert_equal doc, @b.deserialize
+  end
+
+  def test_oid
+    doc = {'doc' => ObjectID.new}
+    @b.serialize(doc)
+    assert_equal doc, @b.deserialize
+  end
+
+  def test_array
+    doc = {'doc' => [1, 2, 'a', 'b']}
+    @b.serialize(doc)
+    assert_equal doc, @b.deserialize
+  end
+
+  def test_regex
+    doc = {'doc' => /foobar/i}
+    @b.serialize(doc)
+    doc2 = @b.deserialize
+    assert_equal doc, doc2
+
+    r = doc2['doc']
+    assert_kind_of RegexpOfHolding, r
+    assert_equal '', r.extra_options_str
+
+    r.extra_options_str << 'zywcab'
+    assert_equal 'zywcab', r.extra_options_str
+
+    b = BSON.new
+    doc = {'doc' => r}
+    b.serialize(doc)
+    doc2 = nil
+    doc2 = b.deserialize
+    assert_equal doc, doc2
+
+    r = doc2['doc']
+    assert_kind_of RegexpOfHolding, r
+    assert_equal 'abcwyz', r.extra_options_str # must be sorted
+  end
+
+  def test_boolean
+    doc = {'doc' => true}
+    @b.serialize(doc)
+    assert_equal doc, @b.deserialize
+  end
+
+  def test_date
+    doc = {'date' => Time.now}
+    @b.serialize(doc)
+    doc2 = @b.deserialize
+    # Mongo only stores up to the millisecond
+    assert_in_delta doc['date'], doc2['date'], 0.001
+  end
+
+  def test_date_returns_as_utc
+    doc = {'date' => Time.now}
+    @b.serialize(doc)
+    doc2 = @b.deserialize
+    assert doc2['date'].utc?
+  end
+
+  def test_date_before_epoch
+    begin
+      doc = {'date' => Time.utc(1600)}
+      @b.serialize(doc)
+      doc2 = @b.deserialize
+      # Mongo only stores up to the millisecond
+      assert_in_delta doc['date'], doc2['date'], 0.001
+    rescue ArgumentError
+      # some versions of Ruby won't let you create pre-epoch Time instances
+      #
+      # TODO figure out how that will work if somebady has saved data
+      # w/ early dates already and is just querying for it.
+    end
+  end
+
+  def test_dbref
+    oid = ObjectID.new
+    doc = {}
+    doc['dbref'] = DBRef.new('namespace', oid)
+    @b.serialize(doc)
+    doc2 = @b.deserialize
+    assert_equal 'namespace', doc2['dbref'].namespace
+    assert_equal oid, doc2['dbref'].object_id
+  end
+
+  def test_symbol
+    doc = {'sym' => :foo}
+    @b.serialize(doc)
+    doc2 = @b.deserialize
+    assert_equal :foo, doc2['sym']
+  end
+
+  def test_binary
+    bin = Binary.new
+    'binstring'.each_byte { |b| bin.put(b) }
+
+    doc = {'bin' => bin}
+    @b.serialize(doc)
+    doc2 = @b.deserialize
+    bin2 = doc2['bin']
+    assert_kind_of Binary, bin2
+    assert_equal 'binstring', bin2.to_s
+    assert_equal Binary::SUBTYPE_BYTES, bin2.subtype
+  end
+
+  def test_binary_type
+    bin = Binary.new([1, 2, 3, 4, 5], Binary::SUBTYPE_USER_DEFINED)
+
+    doc = {'bin' => bin}
+    @b.serialize(doc)
+    doc2 = @b.deserialize
+    bin2 = doc2['bin']
+    assert_kind_of Binary, bin2
+    assert_equal [1, 2, 3, 4, 5], bin2.to_a
+    assert_equal Binary::SUBTYPE_USER_DEFINED, bin2.subtype
+  end
+
+  def test_binary_byte_buffer
+    bb = ByteBuffer.new
+    5.times { |i| bb.put(i + 1) }
+
+    doc = {'bin' => bb}
+    @b.serialize(doc)
+    doc2 = @b.deserialize
+    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
+  end
+
+  def test_put_id_first
+    val = OrderedHash.new
+    val['not_id'] = 1
+    val['_id'] = 2
+    roundtrip = @b.deserialize(@b.serialize(val).to_a)
+    assert_kind_of OrderedHash, roundtrip
+    assert_equal '_id', roundtrip.keys.first
+
+    val = {'a' => 'foo', 'b' => 'bar', :_id => 42, 'z' => 'hello'}
+    roundtrip = @b.deserialize(@b.serialize(val).to_a)
+    assert_kind_of OrderedHash, roundtrip
+    assert_equal '_id', roundtrip.keys.first
+  end
+
+  def test_nil_id
+    doc = {"_id" => nil}
+    assert_equal doc, @b.deserialize(@b.serialize(doc).to_a)
+  end
+
+  def test_timestamp
+    val = {"test" => [4, 20]}
+    assert_equal val, @b.deserialize([0x13, 0x00, 0x00, 0x00,
+                                      0x11, 0x74, 0x65, 0x73,
+                                      0x74, 0x00, 0x04, 0x00,
+                                      0x00, 0x00, 0x14, 0x00,
+                                      0x00, 0x00, 0x00])
+  end
+
+  def test_overflow
+    doc = {"x" => 2**75}
+    assert_raise RangeError do
+      @b.serialize(doc)
+    end
+
+    doc = {"x" => 9223372036854775}
+    assert_equal doc, @b.deserialize(@b.serialize(doc).to_a)
+
+    doc = {"x" => 9223372036854775807}
+    assert_equal doc, @b.deserialize(@b.serialize(doc).to_a)
+
+    doc["x"] = doc["x"] + 1
+    assert_raise RangeError do
+      @b.serialize(doc)
+    end
+
+    doc = {"x" => -9223372036854775}
+    assert_equal doc, @b.deserialize(@b.serialize(doc).to_a)
+
+    doc = {"x" => -9223372036854775808}
+    assert_equal doc, @b.deserialize(@b.serialize(doc).to_a)
+
+    doc["x"] = doc["x"] - 1
+    assert_raise RangeError do
+      @b.serialize(doc)
+    end
+  end
+
+  def test_do_not_change_original_object
+    val = OrderedHash.new
+    val['not_id'] = 1
+    val['_id'] = 2
+    assert val.keys.include?('_id')
+    @b.serialize(val)
+    assert val.keys.include?('_id')
+
+    val = {'a' => 'foo', 'b' => 'bar', :_id => 42, 'z' => 'hello'}
+    assert val.keys.include?(:_id)
+    @b.serialize(val)
+    assert val.keys.include?(:_id)
+  end
+
+end