mongo 0.18.3 → 0.19

data/test/{test_db_api.rb → db_api_test.rb}

@@ -539,22 +539,19 @@ class DBAPITest < Test::Unit::TestCase
     test = @@db.collection("test")
 
     assert_equal [], test.group([], {}, {"count" => 0}, "function (obj, prev) { prev.count++; }")
-    assert_equal [], test.group([], {}, {"count" => 0}, "function (obj, prev) { prev.count++; }", true)
+    assert_equal [], test.group([], {}, {"count" => 0}, "function (obj, prev) { prev.count++; }")
 
     test.insert("a" => 2)
     test.insert("b" => 5)
     test.insert("a" => 1)
 
     assert_equal 3, test.group([], {}, {"count" => 0}, "function (obj, prev) { prev.count++; }")[0]["count"]
-    assert_equal 3, test.group([], {}, {"count" => 0}, "function (obj, prev) { prev.count++; }", true)[0]["count"]
+    assert_equal 3, test.group([], {}, {"count" => 0}, "function (obj, prev) { prev.count++; }")[0]["count"]
+    assert_equal 1, test.group([], {"a" => {"$gt" => 1}}, {"count" => 0}, "function (obj, prev) { prev.count++; }")[0]["count"]
     assert_equal 1, test.group([], {"a" => {"$gt" => 1}}, {"count" => 0}, "function (obj, prev) { prev.count++; }")[0]["count"]
-    assert_equal 1, test.group([], {"a" => {"$gt" => 1}}, {"count" => 0}, "function (obj, prev) { prev.count++; }", true)[0]["count"]
 
     finalize = "function (obj) { obj.f = obj.count - 1; }"
     assert_equal 2, test.group([], {}, {"count" => 0}, "function (obj, prev) { prev.count++; }", true, finalize)[0]["f"]
-    assert_raise OperationFailure do
-      test.group([], {}, {"count" => 0}, "function (obj, prev) { prev.count++; }", false, finalize)[0]["f"]
-    end
 
     test.insert("a" => 2, "b" => 3)
     expected = [{"a" => 2, "count" => 2},

data/test/{test_db.rb → db_test.rb}

@@ -21,18 +21,6 @@ class DBTest < Test::Unit::TestCase
   @@db    = @@conn.db('ruby-mongo-test')
   @@users = @@db.collection('system.users')
 
-  def setup
-    @spongebob = 'spongebob'
-    @spongebob_password = 'squarepants'
-    @@users.remove
-    @@users.insert(:user => @spongebob, :pwd => @@db.send(:hash_password, @spongebob, @spongebob_password))
-  end
-
-  def teardown
-    @@users.remove if @@users
-    @@db.error
-  end
-
   def test_close
     @@conn.close
     assert !@@conn.connected?
@@ -139,9 +127,25 @@ class DBTest < Test::Unit::TestCase
   end
 
   def test_authenticate
-    assert !@@db.authenticate('nobody', 'nopassword')
-    assert !@@db.authenticate(@spongebob, 'squareliederhosen')
-    assert @@db.authenticate(@spongebob, @spongebob_password)
+    @@db.add_user('spongebob', 'squarepants')
+    assert_raise Mongo::AuthenticationError do
+      assert !@@db.authenticate('nobody', 'nopassword')
+    end
+    assert_raise Mongo::AuthenticationError do
+      assert !@@db.authenticate('spongebob' , 'squareliederhosen')
+    end
+    assert @@db.authenticate('spongebob', 'squarepants')
+    @@db.logout
+    @@db.remove_user('spongebob')
+  end
+
+  def test_authenticate_with_connection_uri
+    @@db.add_user('spongebob', 'squarepants')
+    assert Mongo::Connection.from_uri("mongodb://spongebob:squarepants@localhost/#{@@db.name}")
+
+    assert_raise Mongo::AuthenticationError do
+      Mongo::Connection.from_uri("mongodb://wrong:info@localhost/#{@@db.name}")
+    end
   end
 
   def test_logout
@@ -202,6 +206,20 @@ class DBTest < Test::Unit::TestCase
     assert db.collection('users').remove
   end
 
+  def test_user_management
+    @@db.add_user("bob", "secret")
+    assert @@db.authenticate("bob", "secret")
+    @@db.logout
+    assert @@db.remove_user("bob")
+    assert_raise Mongo::AuthenticationError do
+      @@db.authenticate("bob", "secret")
+    end
+  end
+
+  def test_remove_non_existant_user
+    assert !@@db.remove_user("joe")
+  end
+
   context "database profiling" do
     setup do
       @db  = @@conn['ruby-mongo-test-admin-functions']

data/test/grid_file_system_test.rb

@@ -0,0 +1,210 @@
+require 'test/test_helper'
+include Mongo
+
+class GridFileSystemTest < Test::Unit::TestCase
+  context "GridFileSystem:" do
+    setup do
+      @con = Connection.new(ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost',
+        ENV['MONGO_RUBY_DRIVER_PORT'] || Connection::DEFAULT_PORT)
+      @db = @con.db('mongo-ruby-test')
+    end
+
+    teardown do
+      @db['fs.files'].remove
+      @db['fs.chunks'].remove
+    end
+
+    context "When reading:" do
+      setup do
+        @chunks_data = "CHUNKS" * 50000
+        @grid = GridFileSystem.new(@db)
+        @grid.open('sample.file', 'w') do |f|
+          f.write @chunks_data
+        end
+
+        @grid = GridFileSystem.new(@db)
+      end
+
+      should "read sample data" do
+        data = @grid.open('sample.file', 'r') { |f| f.read }
+        assert_equal data.length, @chunks_data.length
+      end
+
+      should "return an empty string if length is zero" do
+        data = @grid.open('sample.file', 'r') { |f| f.read(0) }
+        assert_equal '', data
+      end
+
+      should "return the first n bytes" do
+        data = @grid.open('sample.file', 'r') {|f| f.read(288888) }
+        assert_equal 288888, data.length
+        assert_equal @chunks_data[0...288888], data
+      end
+
+      should "return the first n bytes even with an offset" do
+        data = @grid.open('sample.file', 'r') do |f| 
+          f.seek(1000)
+          f.read(288888)
+        end
+        assert_equal 288888, data.length
+        assert_equal @chunks_data[1000...289888], data
+      end
+    end
+
+    context "When writing:" do
+     setup do
+       @data   = "BYTES" * 50
+       @grid = GridFileSystem.new(@db)
+       @grid.open('sample', 'w') do |f|
+         f.write @data
+       end
+     end
+
+     should "read sample data" do
+       data = @grid.open('sample', 'r') { |f| f.read }
+       assert_equal data.length, @data.length
+     end
+
+     should "return the total number of bytes written" do
+       data = 'a' * 300000
+       assert_equal 300000, @grid.open('sample', 'w') {|f| f.write(data) }
+     end
+
+     should "more read sample data" do
+       data = @grid.open('sample', 'r') { |f| f.read }
+       assert_equal data.length, @data.length
+     end
+
+     should "raise exception if not opened for write" do
+       assert_raise GridError do
+         @grid.open('io', 'r') { |f| f.write('hello') }
+       end
+     end
+
+     context "and when overwriting the file" do
+       setup do
+         @old = @grid.open('sample', 'r')
+
+         @new_data = "DATA" * 10
+         sleep(2)
+         @grid.open('sample', 'w') do |f|
+           f.write @new_data
+         end
+
+         @new = @grid.open('sample', 'r')
+       end
+
+       should "have a newer upload date" do
+         assert @new.upload_date > @old.upload_date, "New data is not greater than old date."
+       end
+
+       should "have a different files_id" do
+         assert_not_equal @new.files_id, @old.files_id
+       end
+
+       should "contain the new data" do
+         assert_equal @new_data, @new.read, "Expected DATA"
+       end
+
+       context "and on a second overwrite" do
+         setup do
+           sleep(2)
+           new_data = "NEW" * 1000
+           @grid.open('sample', 'w') do |f|
+             f.write new_data
+           end
+
+           @ids = @db['fs.files'].find({'filename' => 'sample'}).map {|file| file['_id']}
+         end
+
+         should "write a third version of the file" do
+           assert_equal 3, @db['fs.files'].find({'filename' => 'sample'}).count
+           assert_equal 3, @db['fs.chunks'].find({'files_id' => {'$in' => @ids}}).count
+         end
+
+         should "remove all versions and their data on delete" do
+           @grid.delete('sample')
+           assert_equal 0, @db['fs.files'].find({'filename' => 'sample'}).count
+           assert_equal 0, @db['fs.chunks'].find({'files_id' => {'$in' => @ids}}).count
+         end
+       end
+     end
+   end
+
+   context "When writing chunks:" do
+      setup do
+        data   = "B" * 50000
+        @grid = GridFileSystem.new(@db)
+        @grid.open('sample', 'w', :chunk_size => 1000) do |f|
+          f.write data
+        end
+      end
+
+      should "write the correct number of chunks" do
+        file   = @db['fs.files'].find_one({:filename => 'sample'})
+        chunks = @db['fs.chunks'].find({'files_id' => file['_id']}).to_a
+        assert_equal 50, chunks.length
+      end
+    end
+
+    context "Positioning:" do
+      setup do
+        data = 'hello, world' + '1' * 5000 + 'goodbye!' + '2' * 1000 + '!'
+        @grid = GridFileSystem.new(@db)
+        @grid.open('hello', 'w', :chunk_size => 1000) do |f|
+          f.write data
+        end
+      end
+
+      should "seek within chunks" do
+        @grid.open('hello', 'r') do |f|
+          f.seek(0)
+          assert_equal 'h', f.read(1)
+          f.seek(7)
+          assert_equal 'w', f.read(1)
+          f.seek(4)
+          assert_equal 'o', f.read(1)
+          f.seek(0)
+          f.seek(7, IO::SEEK_CUR)
+          assert_equal 'w', f.read(1)
+          f.seek(-2, IO::SEEK_CUR)
+          assert_equal ' ', f.read(1)
+          f.seek(-4, IO::SEEK_CUR)
+          assert_equal 'l', f.read(1)
+          f.seek(3, IO::SEEK_CUR)
+          assert_equal 'w', f.read(1)
+        end
+      end
+
+      should "seek between chunks" do
+        @grid.open('hello', 'r') do |f|
+          f.seek(1000)
+          assert_equal '11111', f.read(5)
+
+          f.seek(5009)
+          assert_equal '111goodbye!222', f.read(14)
+
+          f.seek(-1, IO::SEEK_END)
+          assert_equal '!', f.read(1)
+          f.seek(-6, IO::SEEK_END)
+          assert_equal '2', f.read(1)
+        end
+      end
+
+      should "tell the current position" do
+        @grid.open('hello', 'r') do |f|
+          assert_equal 0, f.tell
+
+          f.seek(999)
+          assert_equal 999, f.tell
+        end
+      end
+
+      should "seek only in read mode" do
+        assert_raise GridError do
+          @grid.open('hello', 'w') {|f| f.seek(0) }
+        end
+      end
+    end
+  end
+end

data/test/grid_io_test.rb

@@ -0,0 +1,78 @@
+require 'test/test_helper'
+include Mongo
+
+class GridIOTest < Test::Unit::TestCase
+
+  context "GridIO" do
+    setup do
+      @db ||= Connection.new(ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost',
+        ENV['MONGO_RUBY_DRIVER_PORT'] || Connection::DEFAULT_PORT).db('ruby-mongo-test')
+      @files  = @db.collection('fs.files')
+      @chunks = @db.collection('fs.chunks')
+      @chunks.create_index([['files_id', Mongo::ASCENDING], ['n', Mongo::ASCENDING]])
+    end
+
+    teardown do
+      @files.remove
+      @chunks.remove
+    end
+
+    context "Options" do
+      setup do
+        @filename = 'test'
+        @mode     = 'w'
+      end
+
+      should "set default 256k chunk size" do
+        file = GridIO.new(@files, @chunks, @filename, @mode)
+        assert_equal 256 * 1024, file.chunk_size
+      end
+
+      should "set chunk size" do
+        file = GridIO.new(@files, @chunks, @filename, @mode, :chunk_size => 1000)
+        assert_equal 1000, file.chunk_size
+      end
+    end
+
+    context "Grid MD5 check" do
+      should "run in safe mode" do
+        file = GridIO.new(@files, @chunks, 'smallfile', 'w', :safe => true)
+        file.write("DATA" * 100)
+        assert file.close
+        assert_equal file.server_md5, file.client_md5
+      end
+
+      should "validate with a large file" do
+        io = File.open(File.join(File.dirname(__FILE__), 'data', 'sample_file.pdf'), 'r')
+        file = GridIO.new(@files, @chunks, 'bigfile', 'w', :safe => true)
+        file.write(io)
+        assert file.close
+        assert_equal file.server_md5, file.client_md5
+      end
+    end
+
+    context "Content types" do
+
+      if defined?(MIME)
+        should "determine common content types from the extension" do
+          file = GridIO.new(@files, @chunks, 'sample.pdf', 'w')
+          assert_equal 'application/pdf', file.content_type
+
+          file = GridIO.new(@files, @chunks, 'sample.txt', 'w')
+          assert_equal 'text/plain', file.content_type
+        end
+      end
+
+      should "default to binary/octet-stream when type is unknown" do
+        file = GridIO.new(@files, @chunks, 'sample.l33t', 'w')
+        assert_equal 'binary/octet-stream', file.content_type
+      end
+
+      should "use any provided content type by default" do
+        file = GridIO.new(@files, @chunks, 'sample.l33t', 'w', :content_type => 'image/jpg')
+        assert_equal 'image/jpg', file.content_type
+      end
+    end
+  end
+
+end

data/test/{test_grid_store.rb → grid_store_test.rb}

@@ -130,7 +130,22 @@ class GridStoreTest < Test::Unit::TestCase
     }
 
     assert_equal 3, @@chunks.count
-    #assert_equal ('x' * size) + ('y' * size) + ('z' * size), GridStore.read(@@db, 'biggie')
+  end
+
+  def test_binary
+    file = File.open(File.join(File.dirname(__FILE__), 'data', 'data.tar.gz'), 'r')
+    GridStore.open(@@db, 'zip', 'w') do |f|
+      f.write(file.read)
+    end
+
+    file.rewind
+    data = file.read
+    if data.respond_to?(:force_encoding)
+      data.force_encoding(:binary)
+    end
+    GridStore.open(@@db, 'zip', 'r') do |f|
+      assert_equal data.length, f.read.length
+    end
   end
 
   def test_puts_and_readlines
@@ -151,7 +166,23 @@ class GridStoreTest < Test::Unit::TestCase
     assert_equal 0, @@files.count
     assert_equal 0, @@chunks.count
   end
-  
+
+  def test_unlink_alternate_root_collection
+    GridStore.default_root_collection = 'gridfs'
+    GridStore.open(@@db, 'foobar', 'w') do |f|
+      f.puts "Hello"
+    end
+    assert GridStore.exist?(@@db, 'foobar')
+
+    GridStore.default_root_collection = 'fs'
+    GridStore.unlink(@@db, 'foobar')
+    assert !GridStore.exist?(@@db, 'foobar')
+
+    GridStore.default_root_collection = 'gridfs'
+    GridStore.unlink(@@db, 'foobar')
+    assert !GridStore.exist?(@@db, 'foobar')
+  end
+
   def test_mv
     assert_equal 1, @@files.count
     assert_equal 1, @@chunks.count

data/test/grid_test.rb

@@ -0,0 +1,87 @@
+require 'test/test_helper'
+include Mongo
+
+class GridTest < Test::Unit::TestCase
+  context "Tests:" do
+    setup do
+      @db ||= Connection.new(ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost',
+        ENV['MONGO_RUBY_DRIVER_PORT'] || Connection::DEFAULT_PORT).db('ruby-mongo-test')
+      @files  = @db.collection('test-fs.files')
+      @chunks = @db.collection('test-fs.chunks')
+    end
+
+    teardown do
+      @files.remove
+      @chunks.remove
+    end
+
+    context "A basic grid-stored file" do
+      setup do
+        @data = "GRIDDATA" * 50000
+        @grid = Grid.new(@db, 'test-fs')
+        @id   = @grid.put(@data, 'sample', :metadata => {'app' => 'photos'})
+      end
+
+      should "retrieve the stored data" do
+        data = @grid.get(@id).data
+        assert_equal @data, data
+      end
+
+      should "store the filename" do
+        file = @grid.get(@id)
+        assert_equal 'sample', file.filename
+      end
+
+      should "store any relevant metadata" do
+        file = @grid.get(@id)
+        assert_equal 'photos', file.metadata['app']
+      end
+
+      should "delete the file and any chunks" do
+        @grid.delete(@id)
+        assert_raise GridError do
+          @grid.get(@id)
+        end
+      end
+    end
+
+    context "Streaming: " do || {}
+      setup do
+        def read_and_write_stream(filename, read_length, opts={})
+          io   = File.open(File.join(File.dirname(__FILE__), 'data', filename), 'r')
+          id   = @grid.put(io, filename + read_length.to_s, opts)
+          file = @grid.get(id)
+          io.rewind
+          data = io.read
+          if data.respond_to?(:force_encoding)
+            data.force_encoding(:binary)
+          end
+          read_data = ""
+          while(chunk = file.read(read_length))
+            read_data << chunk
+          end
+          assert_equal data.length, read_data.length
+          assert_equal data, read_data, "Unequal!"
+        end
+
+        @grid = Grid.new(@db, 'test-fs')
+      end
+
+      should "put and get a small io object with a small chunk size" do
+        read_and_write_stream('small_data.txt', 1, :chunk_size => 2)
+      end
+
+      should "put and get a small io object" do
+        read_and_write_stream('small_data.txt', 1)
+      end
+
+      should "put and get a large io object when reading smaller than the chunk size" do
+        read_and_write_stream('sample_file.pdf', 256 * 1024)
+      end
+
+      should "put and get a large io object when reading larger than the chunk size" do
+        read_and_write_stream('sample_file.pdf', 300 * 1024)
+      end
+    end
+  end
+end