mongo_mapper 0.6.10 → 0.7.0

data/test/unit/{test_key.rb → test_keys.rb}

@@ -20,7 +20,7 @@ class FooType < Struct.new(:bar)
 end
 
 class KeyTest < Test::Unit::TestCase
-  include MongoMapper
+  include MongoMapper::Plugins::Keys
 
   context "Initializing a new key" do
     should "allow setting the name" do
@@ -82,10 +82,7 @@ class KeyTest < Test::Unit::TestCase
     end
     
     should "know if it is a embedded_document" do
-      klass = Class.new do
-        include MongoMapper::EmbeddedDocument
-      end
-      Key.new(:name, klass).embeddable?.should be_true
+      Key.new(:name, EDoc()).embeddable?.should be_true
     end
 
     should "know if it is not a embedded_document" do

data/test/unit/test_mongo_mapper.rb

@@ -8,58 +8,118 @@ class MongoMapperTest < Test::Unit::TestCase
     MongoMapper.connection = conn
     MongoMapper.connection.should == conn
   end
-  
+
   should "default connection to new mongo ruby driver" do
     MongoMapper.connection = nil
     MongoMapper.connection.should be_instance_of(Mongo::Connection)
   end
-  
+
   should "be able to write and read default database" do
     MongoMapper.database = 'test'
     MongoMapper.database.should be_instance_of(Mongo::DB)
     MongoMapper.database.name.should == 'test'
   end
-  
+
   should "have document not found error" do
     lambda {
       MongoMapper::DocumentNotFound
     }.should_not raise_error
   end
+
+  should "be able to read/write config" do
+    config = {
+      'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test'},
+      'production'  => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test-prod'}
+    }
+
+    MongoMapper.config = config
+    MongoMapper.config.should == config
+  end
+
+  context "connecting to environment from config" do
+    should "work without authentication" do
+      MongoMapper.config = {
+        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test'}
+      }
+
+      Mongo::Connection.expects(:new).with('127.0.0.1', 27017, {})
+      MongoMapper.expects(:database=).with('test')
+      Mongo::DB.any_instance.expects(:authenticate).never
+      MongoMapper.connect('development')
+    end
+
+    should "work with options" do
+      MongoMapper.config = {
+        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test'}
+      }
+
+      connection, logger = mock('connection'), mock('logger')
+      Mongo::Connection.expects(:new).with('127.0.0.1', 27017, :logger => logger)
+      MongoMapper.connect('development', :logger => logger)
+    end
+
+    should "work with authentication" do
+      MongoMapper.config = {
+        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test', 'username' => 'john', 'password' => 'secret'}
+      }
+
+      Mongo::DB.any_instance.expects(:authenticate).with('john', 'secret')
+      MongoMapper.connect('development')
+    end
+  end
+
+  context "setup" do
+    should "work as shortcut for setting config, environment and options" do
+      config, logger = mock('config'), mock('logger')
+      MongoMapper.expects(:config=).with(config)
+      MongoMapper.expects(:connect).with('development', :logger => logger)
+      MongoMapper.expects(:handle_passenger_forking).never
+      MongoMapper.setup(config, 'development', :logger => logger)
+    end
+    
+    should "handle passenger if option present" do
+      config, logger = mock('config'), mock('logger')
+      MongoMapper.expects(:config=).with(config)
+      MongoMapper.expects(:connect).with('development', :logger => logger)
+      MongoMapper.expects(:handle_passenger_forking)
+      MongoMapper.setup(config, 'development', :logger => logger, :passenger => true)
+    end
+  end
   
+
   context "use_time_zone?" do
     should "be true if Time.zone set" do
       Time.zone = 'Hawaii'
       MongoMapper.use_time_zone?.should be_true
       Time.zone = nil
     end
-    
+
     should "be false if Time.zone not set" do
       MongoMapper.use_time_zone?.should be_false
     end
   end
-  
+
   context "time_class" do
     should "be Time.zone if using time zones" do
       Time.zone = 'Hawaii'
       MongoMapper.time_class.should == Time.zone
       Time.zone = nil
     end
-    
+
     should "be Time if not using time zones" do
       MongoMapper.time_class.should == Time
     end
   end
-  
+
   context "normalize_object_id" do
     should "turn string into object id" do
       id = Mongo::ObjectID.new
       MongoMapper.normalize_object_id(id.to_s).should == id
     end
-    
+
     should "leave object id alone" do
       id = Mongo::ObjectID.new
       MongoMapper.normalize_object_id(id).should == id
     end
   end
-  
 end

data/test/unit/test_pagination.rb

@@ -1,19 +1,27 @@
 require 'test_helper'
 
-class PaginationTest < Test::Unit::TestCase  
+class PaginationTest < Test::Unit::TestCase
+  should "default per_page to 25" do
+    Doc().per_page.should == 25
+  end
+  
+  should "allow overriding per_page" do
+    Doc() { def self.per_page; 1 end }.per_page.should == 1
+  end
+  
   context "Pagination proxy" do
-    include MongoMapper::Pagination
+    include MongoMapper::Plugins::Pagination
     
     should "should have accessors for subject" do
       subject = [1,2,3,4,5]
-      collection = PaginationProxy.new(25, 2)
+      collection = Proxy.new(25, 2)
       collection.subject = subject
       collection.subject.should == subject
     end
     
     should "delegate any methods not defined to the subject" do
       subject = [1,2,3,4,5]
-      collection = PaginationProxy.new(25, 2, 10)
+      collection = Proxy.new(25, 2, 10)
       collection.subject = subject
       collection.size.should == 5
       collection.each_with_index do |value, i|
@@ -24,96 +32,96 @@ class PaginationTest < Test::Unit::TestCase
     end
     
     should "return correct value for total_entries" do
-      PaginationProxy.new(25, 2, 10).total_entries.should == 25
-      PaginationProxy.new('25', 2, 10).total_entries.should == 25
+      Proxy.new(25, 2, 10).total_entries.should == 25
+      Proxy.new('25', 2, 10).total_entries.should == 25
     end
     
     should "return correct value for per_page" do
-      PaginationProxy.new(25, 2, 10).per_page.should == 10
-      PaginationProxy.new(25, 2, '10').per_page.should == 10
+      Proxy.new(25, 2, 10).per_page.should == 10
+      Proxy.new(25, 2, '10').per_page.should == 10
     end
     
     should "alias limit to per_page" do
-      PaginationProxy.new(100, 1, 300).limit.should == 300
+      Proxy.new(100, 1, 300).limit.should == 300
     end
     
     should "set per_page to 25 if nil or blank" do
-      PaginationProxy.new(25, 2).per_page.should == 25
-      PaginationProxy.new(25, 2, '').per_page.should == 25
+      Proxy.new(25, 2).per_page.should == 25
+      Proxy.new(25, 2, '').per_page.should == 25
     end
     
     should "return correct value for current_page" do
-      PaginationProxy.new(25, 2, 10).current_page.should == 2
-      PaginationProxy.new(25, '2', 10).current_page.should == 2
+      Proxy.new(25, 2, 10).current_page.should == 2
+      Proxy.new(25, '2', 10).current_page.should == 2
     end
     
     should "not allow value less than 1 for current page" do
-      PaginationProxy.new(25, -1).current_page.should == 1
+      Proxy.new(25, -1).current_page.should == 1
     end
     
     should "automatically calculate total_pages from total_entries and per page" do
-      PaginationProxy.new(25, 2, 10).total_pages.should == 3
+      Proxy.new(25, 2, 10).total_pages.should == 3
     end
     
     should "know how many records to skip" do
-      PaginationProxy.new(25, 2, 10).skip.should == 10
+      Proxy.new(25, 2, 10).skip.should == 10
     end
     
     should "alias offset to skip" do
-      PaginationProxy.new(25, 2, 10).offset.should == 10
+      Proxy.new(25, 2, 10).offset.should == 10
     end
     
     should "return true for === Array" do
-      collection = PaginationProxy.new(25, 2, 10)
+      collection = Proxy.new(25, 2, 10)
       collection.subject = [1, 2]
       collection.should === Array
     end
         
     context "previous_page" do
       should "be nil if current page 1" do
-        PaginationProxy.new(25, 1, 10).previous_page.should be_nil
+        Proxy.new(25, 1, 10).previous_page.should be_nil
       end
       
       should "be one less than current page if current is > 1" do
-        PaginationProxy.new(25, 2, 10).previous_page.should == 1
+        Proxy.new(25, 2, 10).previous_page.should == 1
       end
     end
     
     context "next_page" do
       should "be nil if current page is last page" do
-        PaginationProxy.new(25, 3, 10).next_page.should be_nil
+        Proxy.new(25, 3, 10).next_page.should be_nil
       end
       
       should "work for any page that is not last" do
-        PaginationProxy.new(25, 1, 10).next_page.should == 2
-        PaginationProxy.new(25, 2, 10).next_page.should == 3
+        Proxy.new(25, 1, 10).next_page.should == 2
+        Proxy.new(25, 2, 10).next_page.should == 3
       end
     end
     
     context "previous_page" do
       should "be nil if current page is first page" do
-        PaginationProxy.new(25, 1, 10).previous_page.should be_nil
+        Proxy.new(25, 1, 10).previous_page.should be_nil
       end
       
       should "work for any page other than first" do
-        PaginationProxy.new(25, 2, 10).previous_page.should == 1
-        PaginationProxy.new(25, 3, 10).previous_page.should == 2
+        Proxy.new(25, 2, 10).previous_page.should == 1
+        Proxy.new(25, 3, 10).previous_page.should == 2
       end
     end
     
     context "out_of_bounds?" do
       should "be true if current_page is greater than total_pages" do
-        PaginationProxy.new(25, 10, 4).out_of_bounds?.should be_true
+        Proxy.new(25, 10, 4).out_of_bounds?.should be_true
       end
       
       should "be false if current_page is less than total_pages" do
-        PaginationProxy.new(25, 10, 1).out_of_bounds?.should be_false
-        PaginationProxy.new(25, 2, 10).out_of_bounds?.should be_false
+        Proxy.new(25, 10, 1).out_of_bounds?.should be_false
+        Proxy.new(25, 2, 10).out_of_bounds?.should be_false
       end
       
       should "be false if current_page is equal to total_pages" do
-        PaginationProxy.new(25, 3, 10).out_of_bounds?.should be_false
+        Proxy.new(25, 3, 10).out_of_bounds?.should be_false
       end
     end
-  end # end of pagination proxy
-end # end of test case
+  end
+end

data/test/unit/test_plugins.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+module MyPlugin
+  def self.configure(model)
+    model.class_eval { attr_accessor :from_configure }
+  end
+
+  module ClassMethods
+    def class_foo
+      'class_foo'
+    end
+  end
+
+  module InstanceMethods
+    def instance_foo
+      'instance_foo'
+    end
+  end
+end
+
+class PluginsTest < Test::Unit::TestCase
+  context "plugin" do
+    setup do
+      @document = Class.new do
+        extend MongoMapper::Plugins
+        plugin MyPlugin
+      end
+    end
+
+    should "include instance methods" do
+      @document.new.instance_foo.should == 'instance_foo'
+    end
+
+    should "extend class methods" do
+      @document.class_foo.should == 'class_foo'
+    end
+
+    should "pass model to configure" do
+      @document.new.should respond_to(:from_configure)
+    end
+
+    should "default plugins to empty array" do
+      Class.new { extend MongoMapper::Plugins }.plugins.should == []
+    end
+
+    should "add plugin to plugins" do
+      @document.plugins.should include(MyPlugin)
+    end
+  end
+end

data/test/unit/{test_finder_options.rb → test_query.rb}

@@ -1,29 +1,29 @@
 require 'test_helper'
 require 'models'
 
-class FinderOptionsTest < Test::Unit::TestCase
+class QueryTest < Test::Unit::TestCase
   include MongoMapper
   
   should "raise error if provided something other than a hash" do
-    lambda { FinderOptions.new(Room) }.should raise_error(ArgumentError)
-    lambda { FinderOptions.new(Room, 1) }.should raise_error(ArgumentError)
+    lambda { Query.new(Room) }.should raise_error(ArgumentError)
+    lambda { Query.new(Room, 1) }.should raise_error(ArgumentError)
   end
   
   should "symbolize the keys of the hash provided" do
-    FinderOptions.new(Room, 'offset' => 1).options.keys.map do |key|
+    Query.new(Room, 'offset' => 1).options.keys.map do |key|
       key.should be_instance_of(Symbol)
     end
   end
   
   context "Converting conditions to criteria" do
     should "not add _type to query if model does not have superclass that is single collection inherited" do
-      FinderOptions.new(Message, :foo => 'bar').criteria.should == {
+      Query.new(Message, :foo => 'bar').criteria.should == {
         :foo => 'bar'
       }
     end
     
     should "not add _type to nested conditions" do
-      FinderOptions.new(Enter, :foo => 'bar', :age => {'$gt' => 21}).criteria.should == {
+      Query.new(Enter, :foo => 'bar', :age => {'$gt' => 21}).criteria.should == {
         :foo => 'bar',
         :age => {'$gt' => 21},
         :_type => 'Enter'
@@ -31,26 +31,32 @@ class FinderOptionsTest < Test::Unit::TestCase
     end
     
     should "automatically add _type to query if model is single collection inherited" do
-      FinderOptions.new(Enter, :foo => 'bar').criteria.should == {
+      Query.new(Enter, :foo => 'bar').criteria.should == {
         :foo => 'bar',
         :_type => 'Enter'
       }
     end
     
-    %w{gt lt gte lte ne in nin mod size where exists}.each do |operator|
+    %w{gt lt gte lte ne in nin mod all size where exists}.each do |operator|
       should "convert #{operator} conditions" do
-        FinderOptions.new(Room, :age.send(operator) => 21).criteria.should == {
+        Query.new(Room, :age.send(operator) => 21).criteria.should == {
           :age => {"$#{operator}" => 21}
         }
       end
     end
     
+    should "normalize value when using symbol operators" do
+      time = Time.now.in_time_zone('Indiana (East)')
+      criteria = Query.new(Room, :created_at.gt => time).criteria
+      criteria[:created_at]['$gt'].should be_utc
+    end
+    
     should "work with simple criteria" do
-      FinderOptions.new(Room, :foo => 'bar').criteria.should == {
+      Query.new(Room, :foo => 'bar').criteria.should == {
         :foo => 'bar'
       }
       
-      FinderOptions.new(Room, :foo => 'bar', :baz => 'wick').criteria.should == {
+      Query.new(Room, :foo => 'bar', :baz => 'wick').criteria.should == {
         :foo => 'bar', 
         :baz => 'wick'
       }
@@ -58,71 +64,71 @@ class FinderOptionsTest < Test::Unit::TestCase
     
     should "convert id to _id" do
       id = Mongo::ObjectID.new
-      FinderOptions.new(Room, :id => id).criteria.should == {:_id => id}
+      Query.new(Room, :id => id).criteria.should == {:_id => id}
     end
     
     should "convert id with symbol operator to _id with modifier" do
       id = Mongo::ObjectID.new
-      FinderOptions.new(Room, :id.ne => id).criteria.should == {
+      Query.new(Room, :id.ne => id).criteria.should == {
         :_id => {'$ne' => id}
       }
     end
     
     should "make sure that _id's are object ids" do
       id = Mongo::ObjectID.new
-      FinderOptions.new(Room, :_id => id.to_s).criteria.should == {:_id => id}
+      Query.new(Room, :_id => id.to_s).criteria.should == {:_id => id}
     end
     
     should "work fine with _id's that are object ids" do
       id = Mongo::ObjectID.new
-      FinderOptions.new(Room, :_id => id).criteria.should == {:_id => id}
+      Query.new(Room, :_id => id).criteria.should == {:_id => id}
     end
     
     should "make sure other object id typed keys get converted" do
       id = Mongo::ObjectID.new
-      FinderOptions.new(Message, :room_id => id.to_s).criteria.should == {:room_id => id}
+      Query.new(Message, :room_id => id.to_s).criteria.should == {:room_id => id}
     end
     
     should "work fine with object ids for object id typed keys" do
       id = Mongo::ObjectID.new
-      FinderOptions.new(Message, :room_id => id).criteria.should == {:room_id => id}
+      Query.new(Message, :room_id => id).criteria.should == {:room_id => id}
     end
     
     should "convert times to utc if they aren't already" do
       time = Time.now.in_time_zone('Indiana (East)')
-      criteria = FinderOptions.new(Room, :created_at => time).criteria
+      criteria = Query.new(Room, :created_at => time).criteria
       criteria[:created_at].utc?.should be_true
     end
     
     should "not funk with times already in utc" do
       time = Time.now.utc
-      criteria = FinderOptions.new(Room, :created_at => time).criteria
+      criteria = Query.new(Room, :created_at => time).criteria
       criteria[:created_at].utc?.should be_true
       criteria[:created_at].should == time
     end
     
     should "use $in for arrays" do
-      FinderOptions.new(Room, :foo => [1,2,3]).criteria.should == {
+      Query.new(Room, :foo => [1,2,3]).criteria.should == {
         :foo => {'$in' => [1,2,3]}
       }
     end
     
     should "not use $in for arrays if already using array operator" do
-      FinderOptions.new(Room, :foo => {'$all' => [1,2,3]}).criteria.should == {
+      Query.new(Room, :foo => {'$all' => [1,2,3]}).criteria.should == {
         :foo => {'$all' => [1,2,3]}
       }
 
-      FinderOptions.new(Room, :foo => {'$any' => [1,2,3]}).criteria.should == {
+      Query.new(Room, :foo => {'$any' => [1,2,3]}).criteria.should == {
         :foo => {'$any' => [1,2,3]}
       }
     end
     
     should "work arbitrarily deep" do
-      FinderOptions.new(Room, :foo => {:bar => [1,2,3]}).criteria.should == {
+      Query.new(Room, :foo => {:bar => [1,2,3]}).criteria.should == {
         :foo => {:bar => {'$in' => [1,2,3]}}
       }
       
-      FinderOptions.new(Room, :foo => {:bar => {'$any' => [1,2,3]}}).criteria.should == {
+      Query.new(Room, :foo => {:bar => {'$any' => [1,2,3]}}).criteria.should == {
         :foo => {:bar => {'$any' => [1,2,3]}}
       }
     end
@@ -131,175 +137,179 @@ class FinderOptionsTest < Test::Unit::TestCase
   context "ordering" do
     should "single field with ascending direction" do
       sort = [['foo', 1]]
-      FinderOptions.new(Room, :order => 'foo asc').options[:sort].should == sort
-      FinderOptions.new(Room, :order => 'foo ASC').options[:sort].should == sort
+      Query.new(Room, :order => 'foo asc').options[:sort].should == sort
+      Query.new(Room, :order => 'foo ASC').options[:sort].should == sort
     end
     
     should "single field with descending direction" do
       sort = [['foo', -1]]
-      FinderOptions.new(Room, :order => 'foo desc').options[:sort].should == sort
-      FinderOptions.new(Room, :order => 'foo DESC').options[:sort].should == sort
+      Query.new(Room, :order => 'foo desc').options[:sort].should == sort
+      Query.new(Room, :order => 'foo DESC').options[:sort].should == sort
     end
     
     should "convert order operators to mongo sort" do
-      FinderOptions.new(Room, :order => :foo.asc).options[:sort].should == [['foo', 1]]
-      FinderOptions.new(Room, :order => :foo.desc).options[:sort].should == [['foo', -1]]
+      Query.new(Room, :order => :foo.asc).options[:sort].should == [['foo', 1]]
+      Query.new(Room, :order => :foo.desc).options[:sort].should == [['foo', -1]]
     end
     
     should "convert array of order operators to mongo sort" do
-      FinderOptions.new(Room, :order => [:foo.asc, :bar.desc]).options[:sort].should == [['foo', 1], ['bar', -1]]
+      Query.new(Room, :order => [:foo.asc, :bar.desc]).options[:sort].should == [['foo', 1], ['bar', -1]]
     end
     
     should "convert field without direction to ascending" do
       sort = [['foo', 1]]
-      FinderOptions.new(Room, :order => 'foo').options[:sort].should == sort
+      Query.new(Room, :order => 'foo').options[:sort].should == sort
     end
     
     should "convert multiple fields with directions" do
       sort = [['foo', -1], ['bar', 1], ['baz', -1]]
-      FinderOptions.new(Room, :order => 'foo desc, bar asc, baz desc').options[:sort].should == sort
+      Query.new(Room, :order => 'foo desc, bar asc, baz desc').options[:sort].should == sort
     end
     
     should "convert multiple fields with some missing directions" do
       sort = [['foo', -1], ['bar', 1], ['baz', 1]]
-      FinderOptions.new(Room, :order => 'foo desc, bar, baz').options[:sort].should == sort
+      Query.new(Room, :order => 'foo desc, bar, baz').options[:sort].should == sort
     end
     
     should "just use sort if sort and order are present" do
       sort = [['$natural', 1]]
-      FinderOptions.new(Room, :sort => sort, :order => 'foo asc').options[:sort].should == sort
+      Query.new(Room, :sort => sort, :order => 'foo asc').options[:sort].should == sort
     end
     
     should "convert natural in order to proper" do
       sort = [['$natural', 1]]
-      FinderOptions.new(Room, :order => '$natural asc').options[:sort].should == sort
+      Query.new(Room, :order => '$natural asc').options[:sort].should == sort
       sort = [['$natural', -1]]
-      FinderOptions.new(Room, :order => '$natural desc').options[:sort].should == sort
+      Query.new(Room, :order => '$natural desc').options[:sort].should == sort
     end
     
     should "work for natural order ascending" do
-      FinderOptions.new(Room, :sort => {'$natural' => 1}).options[:sort]['$natural'].should == 1
+      Query.new(Room, :sort => {'$natural' => 1}).options[:sort]['$natural'].should == 1
     end
     
     should "work for natural order descending" do
-      FinderOptions.new(Room, :sort => {'$natural' => -1}).options[:sort]['$natural'].should == -1
+      Query.new(Room, :sort => {'$natural' => -1}).options[:sort]['$natural'].should == -1
     end
   end
   
   context "skip" do
     should "default to 0" do
-      FinderOptions.new(Room, {}).options[:skip].should == 0
+      Query.new(Room, {}).options[:skip].should == 0
     end
     
     should "use skip provided" do
-      FinderOptions.new(Room, :skip => 2).options[:skip].should == 2
+      Query.new(Room, :skip => 2).options[:skip].should == 2
     end
     
     should "covert string to integer" do
-      FinderOptions.new(Room, :skip => '2').options[:skip].should == 2
+      Query.new(Room, :skip => '2').options[:skip].should == 2
     end
     
     should "convert offset to skip" do
-      FinderOptions.new(Room, :offset => 1).options[:skip].should == 1
+      Query.new(Room, :offset => 1).options[:skip].should == 1
     end
   end
   
   context "limit" do
     should "default to 0" do
-      FinderOptions.new(Room, {}).options[:limit].should == 0
+      Query.new(Room, {}).options[:limit].should == 0
     end
     
     should "use limit provided" do
-      FinderOptions.new(Room, :limit => 2).options[:limit].should == 2
+      Query.new(Room, :limit => 2).options[:limit].should == 2
     end
     
     should "covert string to integer" do
-      FinderOptions.new(Room, :limit => '2').options[:limit].should == 2
+      Query.new(Room, :limit => '2').options[:limit].should == 2
     end
   end
   
   context "fields" do
     should "default to nil" do
-      FinderOptions.new(Room, {}).options[:fields].should be(nil)
+      Query.new(Room, {}).options[:fields].should be(nil)
     end
     
     should "be converted to nil if empty string" do
-      FinderOptions.new(Room, :fields => '').options[:fields].should be(nil)
+      Query.new(Room, :fields => '').options[:fields].should be(nil)
     end
     
     should "be converted to nil if []" do
-      FinderOptions.new(Room, :fields => []).options[:fields].should be(nil)
+      Query.new(Room, :fields => []).options[:fields].should be(nil)
     end
     
     should "should work with array" do
-      FinderOptions.new(Room, {:fields => %w(a b)}).options[:fields].should == %w(a b)
+      Query.new(Room, {:fields => %w(a b)}).options[:fields].should == %w(a b)
     end
     
     should "convert comma separated list to array" do
-      FinderOptions.new(Room, {:fields => 'a, b'}).options[:fields].should == %w(a b)
+      Query.new(Room, {:fields => 'a, b'}).options[:fields].should == %w(a b)
     end
     
     should "also work as select" do
-      FinderOptions.new(Room, :select => %w(a b)).options[:fields].should == %w(a b)
+      Query.new(Room, :select => %w(a b)).options[:fields].should == %w(a b)
+    end
+    
+    should "also work with select as array of symbols" do
+      Query.new(Room, :select => [:a, :b]).options[:fields].should == [:a, :b]
     end
   end
   
   context "Condition auto-detection" do
     should "know :conditions are criteria" do
-      finder = FinderOptions.new(Room, :conditions => {:foo => 'bar'})
+      finder = Query.new(Room, :conditions => {:foo => 'bar'})
       finder.criteria.should == {:foo => 'bar'}
       finder.options.keys.should_not include(:conditions)
     end
     
     should "know fields is an option" do
-      finder = FinderOptions.new(Room, :fields => ['foo'])
+      finder = Query.new(Room, :fields => ['foo'])
       finder.options[:fields].should == ['foo']
       finder.criteria.keys.should_not include(:fields)
     end
     
     # select gets converted to fields so just checking keys
     should "know select is an option" do
-      finder = FinderOptions.new(Room, :select => 'foo')
+      finder = Query.new(Room, :select => 'foo')
       finder.options.keys.should include(:sort)
       finder.criteria.keys.should_not include(:select)
       finder.criteria.keys.should_not include(:fields)
     end
     
     should "know skip is an option" do
-      finder = FinderOptions.new(Room, :skip => 10)
+      finder = Query.new(Room, :skip => 10)
       finder.options[:skip].should == 10
       finder.criteria.keys.should_not include(:skip)
     end
     
     # offset gets converted to skip so just checking keys
     should "know offset is an option" do
-      finder = FinderOptions.new(Room, :offset => 10)
+      finder = Query.new(Room, :offset => 10)
       finder.options.keys.should include(:skip)
       finder.criteria.keys.should_not include(:skip)
       finder.criteria.keys.should_not include(:offset)
     end
 
     should "know limit is an option" do
-      finder = FinderOptions.new(Room, :limit => 10)
+      finder = Query.new(Room, :limit => 10)
       finder.options[:limit].should == 10
       finder.criteria.keys.should_not include(:limit)
     end
 
     should "know sort is an option" do
-      finder = FinderOptions.new(Room, :sort => [['foo', 1]])
+      finder = Query.new(Room, :sort => [['foo', 1]])
       finder.options[:sort].should == [['foo', 1]]
       finder.criteria.keys.should_not include(:sort)
     end
 
     # order gets converted to sort so just checking keys
     should "know order is an option" do
-      finder = FinderOptions.new(Room, :order => 'foo')
+      finder = Query.new(Room, :order => 'foo')
       finder.options.keys.should include(:sort)
       finder.criteria.keys.should_not include(:sort)
     end
         
     should "work with full range of things" do
-      finder_options = FinderOptions.new(Room, {
+      query_options = Query.new(Room, {
         :foo => 'bar',
         :baz => true,
         :sort => [['foo', 1]],
@@ -308,12 +318,12 @@ class FinderOptionsTest < Test::Unit::TestCase
         :skip => 10,
       })
       
-      finder_options.criteria.should == {
+      query_options.criteria.should == {
         :foo => 'bar',
         :baz => true,
       }
       
-      finder_options.options.should == {
+      query_options.options.should == {
         :sort => [['foo', 1]],
         :fields => ['foo', 'baz'],
         :limit => 10,
@@ -321,5 +331,4 @@ class FinderOptionsTest < Test::Unit::TestCase
       }
     end
   end
-  
-end # FinderOptionsTest
+end