minor: removed shoulda dependency

README.rdoc

@@ -292,12 +292,10 @@ It's also possible to test replica pairs with connection pooling:
 
   $ rake test:pooled_pair_insert
 
-===Shoulda and Mocha
+===Mocha
 
-All tests now require shoulda and mocha.  You can install these gems as
+Running the test suite requires mocha.  You can install it as follows:
-follows:
 
-  $ gem install shoulda
   $ gem install mocha
 
 The tests assume that the Mongo database is running on the default port. You
@@ -305,23 +303,6 @@ can override the default host (localhost) and port (Connection::DEFAULT_PORT) by
 using the environment variables MONGO_RUBY_DRIVER_HOST and
 MONGO_RUBY_DRIVER_PORT.
 
-The project mongo-qa (http://github.com/mongodb/mongo-qa) contains many more
-Mongo driver tests that are language independent. To run thoses tests as part
-of the "rake test" task, download the code "next to" this directory. So, after
-installing the mongo-qa code you would have these two directories next to each
-other:
-
-  $ ls
-  mongo-qa
-  mongo-ruby-driver
-  $ rake test
-
-The tests run just fine if the mongo-qa directory is not there.
-
-Additionally, the script bin/validate is used by the mongo-qa project's
-validator script.
-
-
 = Documentation
 
 This documentation is available online at http://api.mongodb.org/ruby. You can
@@ -342,7 +323,7 @@ See CREDITS.
 
 = License
 
- Copyright 2008-2009 10gen Inc.
+ Copyright 2008-2010 10gen Inc.
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -355,4 +336,3 @@ See CREDITS.
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
-

test/binary_test.rb

@@ -1,17 +1,13 @@
 # encoding:utf-8
-
 require 'test/test_helper'
 
-class BinaryTest < Test::Unit::TestCase
+context "Inspecting" do
+  setup do
+    @data = ("THIS IS BINARY " * 50).unpack("c*")
+  end
 
-  context "Inspecting" do
+  should "not display actual data" do
-    setup do
+    binary = Mongo::Binary.new(@data)
-      @data = ("THIS IS BINARY " * 50).unpack("c*")
+    assert_equal "<Mongo::Binary:#{binary.object_id}>", binary.inspect
-    end
-
-    should "not display actual data" do
-      binary = Mongo::Binary.new(@data)
-      assert_equal "<Mongo::Binary:#{binary.object_id}>", binary.inspect
-    end
   end
 end

test/grid_file_system_test.rb

@@ -1,15 +1,15 @@
 require 'test/test_helper'
+include Mongo
 
-class GridTest < Test::Unit::TestCase
+context "GridFileSystem:" do
-
+  setup do
-  def setup
     @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')
   end
 
-  def teardown
+  teardown do
     @files.remove
     @chunks.remove
   end

test/grid_io_test.rb

@@ -1,16 +1,15 @@
 require 'test/test_helper'
+include Mongo
 
-class GridIOTest < Test::Unit::TestCase
+context "" do
-  include GridFS
+  setup do
-
-  def setup
     @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')
   end
 
-  def teardown
+  teardown do
     @files.remove
     @chunks.remove
   end
@@ -30,6 +29,5 @@ class GridIOTest < Test::Unit::TestCase
       file = GridIO.new(@files, @chunks, @filename, @mode, false, :chunk_size => 1000)
       assert_equal 1000, file.chunk_size
     end
-
   end
 end

test/grid_test.rb

@@ -1,15 +1,15 @@
 require 'test/test_helper'
+include Mongo
 
-class GridTest < Test::Unit::TestCase
+context "Tests:" do
-
+  setup do
-  def setup
     @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
 
-  def teardown
+  teardown do
     @files.remove
     @chunks.remove
   end
@@ -44,24 +44,24 @@ class GridTest < Test::Unit::TestCase
     end
   end
 
-  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
-  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
+      end
+
       @grid = Grid.new(@db, 'test-fs')
     end
 

test/test_helper.rb

@@ -5,14 +5,12 @@ require 'test/unit'
 
 begin
   require 'rubygems'
-  require 'shoulda'
   require 'mocha'
   rescue LoadError
     puts <<MSG
 
-This test suite now requires shoulda and mocha.
+This test suite requires mocha.
-You can install these gems as follows:
+You can install it as follows:
-  gem install shoulda
   gem install mocha
 
 MSG
@@ -40,3 +38,31 @@ class Test::Unit::TestCase
     end
   end
 end
+
+# shoulda-mini
+# based on test/spec/mini 5
+# http://gist.github.com/307649
+# chris@ozmm.org
+#
+def context(*args, &block)
+  return super unless (name = args.first) && block
+  require 'test/unit'
+  klass = Class.new(Test::Unit::TestCase) do
+    def self.should(name, &block)
+      define_method("test_#{name.to_s.gsub(/\W/,'_')}", &block) if block
+    end
+    def self.xshould(*args) end
+    def self.context(*args, &block) instance_eval(&block) end
+    def self.setup(&block)
+      define_method(:setup) { self.class.setups.each { |s| instance_eval(&s) } }
+      setups << block
+    end
+    def self.setups; @setups ||= [] end
+    def self.teardown(&block) define_method(:teardown, &block) end
+  end
+  (class << klass; self end).send(:define_method, :name) { name.gsub(/\W/,'_') }
+  klass.class_eval do
+    include Mongo
+  end
+  klass.class_eval &block
+end

test/unit/collection_test.rb

@@ -1,63 +1,58 @@
 require 'test/test_helper'
 
-class ConnectionTest < Test::Unit::TestCase
+context "Basic operations: " do
+  setup do
+    @logger = mock()
+  end
 
-  context "Basic operations: " do
+  should "send update message" do
-    setup do
+    @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
-      @logger = mock()
+    @db   = @conn['testing']
+    @coll = @db.collection('books')
+    @conn.expects(:send_message).with do |op, msg, log|
+      op == 2001 && log.include?("db.books.update")
     end
+    @coll.update({}, {:title => 'Moby Dick'})
+  end
 
-    should "send update message" do
+  should "send insert message" do
-      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
+    @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @conn['testing']
+    @db   = @conn['testing']
-      @coll = @db.collection('books')
+    @coll = @db.collection('books')
-      @conn.expects(:send_message).with do |op, msg, log|
+    @conn.expects(:send_message).with do |op, msg, log|
-        op == 2001 && log.include?("db.books.update")
+      op == 2002 && log.include?("db.books.insert")
-      end
-      @coll.update({}, {:title => 'Moby Dick'})
     end
+    @coll.insert({:title => 'Moby Dick'})
+  end
 
-    should "send insert message" do
+  should "not log binary data" do
-      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
+    @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @conn['testing']
+    @db   = @conn['testing']
-      @coll = @db.collection('books')
+    @coll = @db.collection('books')
-      @conn.expects(:send_message).with do |op, msg, log|
+    data = Mongo::Binary.new(("BINARY " * 1000).unpack("c*"))
-        op == 2002 && log.include?("db.books.insert")
+    @conn.expects(:send_message).with do |op, msg, log|
-      end
+      op == 2002 && log.include?("Mongo::Binary")
-      @coll.insert({:title => 'Moby Dick'})
     end
+    @coll.insert({:data => data})
+  end
 
-    should "not log binary data" do
+  should "send safe update message" do
-      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
+    @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @conn['testing']
+    @db   = @conn['testing']
-      @coll = @db.collection('books')
+    @coll = @db.collection('books')
-      data = Mongo::Binary.new(("BINARY " * 1000).unpack("c*"))
+    @conn.expects(:send_message_with_safe_check).with do |op, msg, db_name, log|
-      @conn.expects(:send_message).with do |op, msg, log|
+      op == 2001 && log.include?("db.books.update")
-        op == 2002 && log.include?("Mongo::Binary")
-      end
-      @coll.insert({:data => data})
     end
+    @coll.update({}, {:title => 'Moby Dick'}, :safe => true)
+  end
 
-    should "send safe update message" do
+  should "send safe insert message" do
-      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
+    @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @conn['testing']
+    @db   = @conn['testing']
-      @coll = @db.collection('books')
+    @coll = @db.collection('books')
-      @conn.expects(:send_message_with_safe_check).with do |op, msg, db_name, log|
+    @conn.expects(:send_message_with_safe_check).with do |op, msg, db_name, log|
-        op == 2001 && log.include?("db.books.update")
+      op == 2001 && log.include?("db.books.update")
-      end
-      @coll.update({}, {:title => 'Moby Dick'}, :safe => true)
-    end
-
-    should "send safe insert message" do
-      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db   = @conn['testing']
-      @coll = @db.collection('books')
-      @conn.expects(:send_message_with_safe_check).with do |op, msg, db_name, log|
-        op == 2001 && log.include?("db.books.update")
-      end
-      @coll.update({}, {:title => 'Moby Dick'}, :safe => true)
     end
+    @coll.update({}, {:title => 'Moby Dick'}, :safe => true)
   end
 end
-
-

test/unit/connection_test.rb

@@ -1,133 +1,115 @@
 require 'test/test_helper'
+include Mongo
 
-class ConnectionTest < Test::Unit::TestCase
+context "Initialization: " do
-
+  setup do
-  def new_mock_socket
+    def new_mock_socket
-    socket = Object.new
+      socket = Object.new
-    socket.stubs(:setsockopt).with(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+      socket.stubs(:setsockopt).with(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-    socket
+      socket
-  end
-
-  def new_mock_db
-    db = Object.new
-  end
-
-  context "Initialization: " do
-
-    context "given a single node" do
-      setup do
-        TCPSocket.stubs(:new).returns(new_mock_socket)
-        @conn = Connection.new('localhost', 27017, :connect => false)
-
-        admin_db = new_mock_db
-        admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1})
-        @conn.expects(:[]).with('admin').returns(admin_db)
-        @conn.connect_to_master
-      end
-
-      should "set localhost and port to master" do
-        assert_equal 'localhost', @conn.host
-        assert_equal 27017, @conn.port
-      end
-
-      should "set connection pool to 1" do
-        assert_equal 1, @conn.size
-      end
-
-      should "default slave_ok to false" do
-        assert !@conn.slave_ok?
-      end
     end
 
-    context "initializing a paired connection" do
+    def new_mock_db
-      should "require left and right nodes" do
+      db = Object.new
-        assert_raise MongoArgumentError do
-          Connection.paired(['localhost', 27018], :connect => false)
-        end
-
-        assert_raise MongoArgumentError do
-          Connection.paired(['localhost', 27018], :connect => false)
-        end
-      end
-
-      should "store both nodes" do
-        @conn = Connection.paired([['localhost', 27017], ['localhost', 27018]], :connect => false)
-
-        assert_equal ['localhost', 27017], @conn.nodes[0]
-        assert_equal ['localhost', 27018], @conn.nodes[1]
-      end
-    end
-
-    context "initializing with a mongodb uri" do
-      should "parse a simple uri" do
-        @conn = Connection.from_uri("mongodb://localhost", :connect => false)
-        assert_equal ['localhost', 27017], @conn.nodes[0]
-      end
-
-      should "parse a uri specifying multiple nodes" do
-        @conn = Connection.from_uri("mongodb://localhost:27017,mydb.com:27018", :connect => false)
-        assert_equal ['localhost', 27017], @conn.nodes[0]
-        assert_equal ['mydb.com', 27018], @conn.nodes[1]
-      end
-
-      should "parse a uri specifying multiple nodes with auth" do
-        @conn = Connection.from_uri("mongodb://kyle:s3cr3t@localhost:27017/app,mickey:m0u5e@mydb.com:27018/dsny", :connect => false)
-        assert_equal ['localhost', 27017], @conn.nodes[0]
-        assert_equal ['mydb.com', 27018], @conn.nodes[1]
-        assert_equal ['kyle', 's3cr3t', 'app'], @conn.auths[0]
-        assert_equal ['mickey', 'm0u5e', 'dsny'], @conn.auths[1]
-      end
-
-      should "attempt to connect" do
-        TCPSocket.stubs(:new).returns(new_mock_socket)
-        @conn = Connection.from_uri("mongodb://localhost", :connect => false)
-
-        admin_db = new_mock_db
-        admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1})
-        @conn.expects(:[]).with('admin').returns(admin_db)
-        @conn.connect_to_master
-      end
-
-      should "raise an error on invalid uris" do
-        assert_raise MongoArgumentError do
-          Connection.from_uri("mongo://localhost", :connect => false)
-        end
-
-        assert_raise MongoArgumentError do
-          Connection.from_uri("mongodb://localhost:abc", :connect => false)
-        end
-
-        assert_raise MongoArgumentError do
-          Connection.from_uri("mongodb://localhost:27017, my.db.com:27018, ", :connect => false)
-        end
-      end
-
-      should "require all of username, password, and database if any one is specified" do
-        assert_raise MongoArgumentError do
-          Connection.from_uri("mongodb://localhost/db", :connect => false)
-        end
-
-        assert_raise MongoArgumentError do
-          Connection.from_uri("mongodb://kyle:password@localhost", :connect => false)
-        end
-      end
     end
   end
 
-  context "with a nonstandard port" do 
+  context "given a single node" do
     setup do
       TCPSocket.stubs(:new).returns(new_mock_socket)
-      @conn = Connection.new('255.255.255.255', 2500, :connect => false)
+      @conn = Connection.new('localhost', 27017, :connect => false)
+
       admin_db = new_mock_db
       admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1})
       @conn.expects(:[]).with('admin').returns(admin_db)
       @conn.connect_to_master
     end
 
-    should "set localhost and port correctly" do
+    should "set localhost and port to master" do
-      assert_equal '255.255.255.255', @conn.host
+      assert_equal 'localhost', @conn.host
-      assert_equal 2500, @conn.port
+      assert_equal 27017, @conn.port
+    end
+
+    should "set connection pool to 1" do
+      assert_equal 1, @conn.size
+    end
+
+    should "default slave_ok to false" do
+      assert !@conn.slave_ok?
+    end
+  end
+
+  context "initializing a paired connection" do
+    should "require left and right nodes" do
+      assert_raise MongoArgumentError do
+        Connection.paired(['localhost', 27018], :connect => false)
+      end
+
+      assert_raise MongoArgumentError do
+        Connection.paired(['localhost', 27018], :connect => false)
+      end
+    end
+
+    should "store both nodes" do
+      @conn = Connection.paired([['localhost', 27017], ['localhost', 27018]], :connect => false)
+
+      assert_equal ['localhost', 27017], @conn.nodes[0]
+      assert_equal ['localhost', 27018], @conn.nodes[1]
+    end
+  end
+
+  context "initializing with a mongodb uri" do
+    should "parse a simple uri" do
+      @conn = Connection.from_uri("mongodb://localhost", :connect => false)
+      assert_equal ['localhost', 27017], @conn.nodes[0]
+    end
+
+    should "parse a uri specifying multiple nodes" do
+      @conn = Connection.from_uri("mongodb://localhost:27017,mydb.com:27018", :connect => false)
+      assert_equal ['localhost', 27017], @conn.nodes[0]
+      assert_equal ['mydb.com', 27018], @conn.nodes[1]
+    end
+
+    should "parse a uri specifying multiple nodes with auth" do
+      @conn = Connection.from_uri("mongodb://kyle:s3cr3t@localhost:27017/app,mickey:m0u5e@mydb.com:27018/dsny", :connect => false)
+      assert_equal ['localhost', 27017], @conn.nodes[0]
+      assert_equal ['mydb.com', 27018], @conn.nodes[1]
+      assert_equal ['kyle', 's3cr3t', 'app'], @conn.auths[0]
+      assert_equal ['mickey', 'm0u5e', 'dsny'], @conn.auths[1]
+    end
+
+    should "attempt to connect" do
+      TCPSocket.stubs(:new).returns(new_mock_socket)
+      @conn = Connection.from_uri("mongodb://localhost", :connect => false)
+
+      admin_db = new_mock_db
+      admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1})
+      @conn.expects(:[]).with('admin').returns(admin_db)
+      @conn.connect_to_master
+    end
+
+    should "raise an error on invalid uris" do
+      assert_raise MongoArgumentError do
+        Connection.from_uri("mongo://localhost", :connect => false)
+      end
+
+      assert_raise MongoArgumentError do
+        Connection.from_uri("mongodb://localhost:abc", :connect => false)
+      end
+
+      assert_raise MongoArgumentError do
+        Connection.from_uri("mongodb://localhost:27017, my.db.com:27018, ", :connect => false)
+      end
+    end
+
+    should "require all of username, password, and database if any one is specified" do
+      assert_raise MongoArgumentError do
+        Connection.from_uri("mongodb://localhost/db", :connect => false)
+      end
+
+      assert_raise MongoArgumentError do
+        Connection.from_uri("mongodb://kyle:password@localhost", :connect => false)
+      end
     end
   end
 end
-

test/unit/cursor_test.rb

@@ -1,94 +1,91 @@
 require 'test/test_helper'
 
-class TestCursor < Test::Unit::TestCase
+context "Cursor options" do
-
+  setup do
-  context "Cursor options" do
+    @connection = stub(:class => Connection)
-    setup do
+    @db         = stub(:name => "testing", :slave_ok? => false, :connection => @connection)
-      @connection = stub(:class => Connection)
+    @collection = stub(:db => @db, :name => "items")
-      @db         = stub(:name => "testing", :slave_ok? => false, :connection => @connection)
+    @cursor     = Cursor.new(@collection)
-      @collection = stub(:db => @db, :name => "items")
-      @cursor     = Cursor.new(@collection)
-    end
-
-    should "set admin to false" do
-      assert_equal false, @cursor.admin
-
-      @cursor = Cursor.new(@collection, :admin => true)
-      assert_equal true, @cursor.admin
-    end
-
-    should "set selector" do
-      assert @cursor.selector == {}
-
-      @cursor = Cursor.new(@collection, :selector => {:name => "Jones"})
-      assert @cursor.selector == {:name => "Jones"}
-    end
-
-    should "set fields" do
-      assert_nil @cursor.fields
-
-      @cursor = Cursor.new(@collection, :fields => [:name, :date])
-      assert @cursor.fields == {:name => 1, :date => 1}
-    end
-
-    should "set limit" do
-      assert_equal 0, @cursor.limit
-
-      @cursor = Cursor.new(@collection, :limit => 10)
-      assert_equal 10, @cursor.limit
-    end
-
-
-    should "set skip" do
-      assert_equal 0, @cursor.skip
-
-      @cursor = Cursor.new(@collection, :skip => 5)
-      assert_equal 5, @cursor.skip
-    end
-
-    should "set sort order" do
-      assert_nil @cursor.order
-
-      @cursor = Cursor.new(@collection, :order => "last_name")
-      assert_equal "last_name", @cursor.order
-    end
-
-    should "set hint" do
-      assert_nil @cursor.hint
-
-      @cursor = Cursor.new(@collection, :hint => "name")
-      assert_equal "name", @cursor.hint
-    end
-
-    should "cache full collection name" do
-      assert_equal "testing.items", @cursor.full_collection_name
-    end
   end
 
-  context "Query fields" do
+  should "set admin to false" do
-    setup do
+    assert_equal false, @cursor.admin
-      @connection = stub(:class => Collection)
-      @db = stub(:slave_ok? => true, :name => "testing", :connection => @connection)
-      @collection = stub(:db => @db, :name => "items")
-    end
 
-    should "when an array should return a hash with each key" do
+    @cursor = Cursor.new(@collection, :admin => true)
-      @cursor = Cursor.new(@collection, :fields => [:name, :age])
+    assert_equal true, @cursor.admin
-      result  = @cursor.fields
+  end
-      assert_equal result.keys.sort{|a,b| a.to_s <=> b.to_s}, [:age, :name].sort{|a,b| a.to_s <=> b.to_s}
-      assert result.values.all? {|v| v == 1}
-    end
 
-    should "when a string, return a hash with just the key" do
+  should "set selector" do
-      @cursor = Cursor.new(@collection, :fields => "name")
+    assert @cursor.selector == {}
-      result  = @cursor.fields
-      assert_equal result.keys.sort, ["name"]
-      assert result.values.all? {|v| v == 1}
-    end
 
-    should "return nil when neither hash nor string nor symbol" do
+    @cursor = Cursor.new(@collection, :selector => {:name => "Jones"})
-      @cursor = Cursor.new(@collection, :fields => 1234567)
+    assert @cursor.selector == {:name => "Jones"}
-      assert_nil @cursor.fields
+  end
-    end
+
+  should "set fields" do
+    assert_nil @cursor.fields
+
+    @cursor = Cursor.new(@collection, :fields => [:name, :date])
+    assert @cursor.fields == {:name => 1, :date => 1}
+  end
+
+  should "set limit" do
+    assert_equal 0, @cursor.limit
+
+    @cursor = Cursor.new(@collection, :limit => 10)
+    assert_equal 10, @cursor.limit
+  end
+
+
+  should "set skip" do
+    assert_equal 0, @cursor.skip
+
+    @cursor = Cursor.new(@collection, :skip => 5)
+    assert_equal 5, @cursor.skip
+  end
+
+  should "set sort order" do
+    assert_nil @cursor.order
+
+    @cursor = Cursor.new(@collection, :order => "last_name")
+    assert_equal "last_name", @cursor.order
+  end
+
+  should "set hint" do
+    assert_nil @cursor.hint
+
+    @cursor = Cursor.new(@collection, :hint => "name")
+    assert_equal "name", @cursor.hint
+  end
+
+  should "cache full collection name" do
+    assert_equal "testing.items", @cursor.full_collection_name
+  end
+end
+
+context "Query fields" do
+  setup do
+    @connection = stub(:class => Collection)
+    @db = stub(:slave_ok? => true, :name => "testing", :connection => @connection)
+    @collection = stub(:db => @db, :name => "items")
+  end
+
+  should "when an array should return a hash with each key" do
+    @cursor = Cursor.new(@collection, :fields => [:name, :age])
+    result  = @cursor.fields
+    assert_equal result.keys.sort{|a,b| a.to_s <=> b.to_s}, [:age, :name].sort{|a,b| a.to_s <=> b.to_s}
+    assert result.values.all? {|v| v == 1}
+  end
+
+  should "when a string, return a hash with just the key" do
+    @cursor = Cursor.new(@collection, :fields => "name")
+    result  = @cursor.fields
+    assert_equal result.keys.sort, ["name"]
+    assert result.values.all? {|v| v == 1}
+  end
+
+  should "return nil when neither hash nor string nor symbol" do
+    @cursor = Cursor.new(@collection, :fields => 1234567)
+    assert_nil @cursor.fields
   end
 end

test/unit/db_test.rb

@@ -1,14 +1,15 @@
 require 'test/test_helper'
 
-class DBTest < Test::Unit::TestCase
+context "DBTest: " do
-
+  setup do
-  def insert_message(db, documents)
+    def insert_message(db, documents)
-    documents = [documents] unless documents.is_a?(Array)
+      documents = [documents] unless documents.is_a?(Array)
-    message = ByteBuffer.new
+      message = ByteBuffer.new
-    message.put_int(0)
+      message.put_int(0)
-    BSON.serialize_cstr(message, "#{db.name}.test")
+      BSON.serialize_cstr(message, "#{db.name}.test")
-    documents.each { |doc| message.put_array(BSON.new.serialize(doc, true).to_a) }
+      documents.each { |doc| message.put_array(BSON.new.serialize(doc, true).to_a) }
-    message = db.add_message_headers(Mongo::Constants::OP_INSERT, message)
+      message = db.add_message_headers(Mongo::Constants::OP_INSERT, message)
+    end
   end
 
   context "DB commands" do