animehunter-mongo 0.9

data/tests/mongo-qa/_common.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH[0,0] = File.join(File.dirname(__FILE__), '../..', 'lib')
+require 'mongo'
+
+DEFAULT_HOST = '127.0.0.1'
+DEFAULT_PORT = 27017
+DEFAULT_DB = 'driver_test_framework'
+
+include XGen::Mongo::Driver

data/tests/mongo-qa/admin

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '_common.rb')
+db = Mongo.new(DEFAULT_HOST, DEFAULT_PORT).db(DEFAULT_DB)
+
+db.collection('test').insert({'test' => 1})
+admin = db.admin
+
+if $DEBUG
+  db.drop_collection('tester')
+  admin.profiling_level = :slow_only
+end
+
+['test', 'pdlskwmf', '$'].each { |name|
+  begin
+    admin.validate_collection(name)
+    puts 'true'
+  rescue => ex
+    puts 'false'
+  end
+}
+
+level_xlation = {:off => 'off', :all => 'all', :slow_only => 'slowOnly'}
+puts level_xlation[admin.profiling_level]
+admin.profiling_level = :off
+puts level_xlation[admin.profiling_level]

data/tests/mongo-qa/capped

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '_common.rb')
+db = Mongo.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/tests/mongo-qa/count1

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '_common.rb')
+db = Mongo.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').count('i' => 'a')
+puts db.collection('test3').count('i' => 3)
+puts db.collection('test3').count({'i' => {'$gte' => 67}})

data/tests/mongo-qa/dbs

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '_common.rb')
+db = Mongo.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/tests/mongo-qa/find

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

data/tests/mongo-qa/find1

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '_common.rb')
+db = Mongo.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', :offset => 20, :limit => 10)
+cursor.each { |row| puts row['z'] }

data/tests/mongo-qa/gridfs_in

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '_common.rb')
+
+require 'mongo/gridfs'
+include XGen::Mongo::GridFS
+
+db = Mongo.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/tests/mongo-qa/gridfs_out

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '_common.rb')
+
+require 'mongo/gridfs'
+include XGen::Mongo::GridFS
+
+db = Mongo.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/tests/mongo-qa/indices

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '_common.rb')
+
+include XGen::Mongo
+
+db = Mongo.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/tests/mongo-qa/remove

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '_common.rb')
+db = Mongo.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/tests/mongo-qa/stress1

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+LONG_STRING = "lksjhasoh1298alshasoidiohaskjasiouashoasasiugoas" * 6
+
+require File.join(File.dirname(__FILE__), '_common.rb')
+db = Mongo.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_first({: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/tests/mongo-qa/test1

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '_common.rb')
+db = Mongo.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/tests/mongo-qa/update

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '_common.rb')
+db = Mongo.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_admin.rb

@@ -0,0 +1,69 @@
+$LOAD_PATH[0,0] = File.join(File.dirname(__FILE__), '..', 'lib')
+require 'mongo'
+require 'test/unit'
+
+# NOTE: assumes Mongo is running
+class AdminTest < Test::Unit::TestCase
+
+  include XGen::Mongo::Driver
+
+  @@db = Mongo.new(ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost',
+                   ENV['MONGO_RUBY_DRIVER_PORT'] || Mongo::DEFAULT_PORT).db('ruby-mongo-test')
+  @@coll = @@db.collection('test')
+
+  def setup
+    # Insert some data to make sure the database itself exists.
+    @@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
+    @admin.profiling_level = :off
+    @@coll.clear if @@coll
+    @@db.error
+  end
+
+  def test_default_profiling_level
+    assert_equal :off, @admin.profiling_level
+  end
+
+  def test_change_profiling_level
+    @admin.profiling_level = :slow_only
+    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()
+    @admin.profiling_level = :off
+
+    info = @admin.profiling_info
+    assert_kind_of Array, info
+    assert info.length >= 1
+    first = info.first
+    assert_kind_of String, first['info']
+    assert_kind_of Time, first['ts']
+    assert_kind_of Numeric, first['millis']
+  end
+
+  def test_validate_collection
+    doc = @admin.validate_collection(@@coll.name)
+    assert_not_nil doc
+    result = doc['result']
+    assert_not_nil result
+    assert_match /firstExtent/, result
+  end
+
+end

data/tests/test_bson.rb

@@ -0,0 +1,246 @@
+$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 XGen::Mongo::Driver
+
+  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 XGen::Mongo::Driver::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 XGen::Mongo::Driver::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_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_undefined
+    doc = {'undef' => Undefined.new}
+    @b.serialize(doc)
+    doc2 = @b.deserialize
+    assert_kind_of Undefined, doc2['undef']
+  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**45}
+    assert_raise RangeError do
+      @b.serialize(doc)
+    end
+
+    doc = {"x" => 2147483647}
+    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