mongo_mapper-unstable 2010.2.9 → 2010.2.10

data/test/unit/associations/test_base.rb

@@ -104,20 +104,20 @@ class AssociationBaseTest < Test::Unit::TestCase
     end
   end
   
-  context "finder_options" do
+  context "query_options" do
     should "default to empty hash" do
       base = Base.new(:many, :foos)
-      base.finder_options.should == {}
+      base.query_options.should == {}
     end
     
     should "work with order" do
       base = Base.new(:many, :foos, :order => 'position')
-      base.finder_options.should == {:order => 'position'}
+      base.query_options.should == {:order => 'position'}
     end
     
     should "correctly parse from options" do
       base = Base.new(:many, :foos, :order => 'position', :somekey => 'somevalue')
-      base.finder_options.should == {:order => 'position', :somekey => 'somevalue'}
+      base.query_options.should == {:order => 'position', :somekey => 'somevalue'}
     end
   end
   

data/test/unit/test_pagination.rb

@@ -14,14 +14,14 @@ class PaginationTest < Test::Unit::TestCase
     
     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|
@@ -32,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_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,179 +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
-      FinderOptions.new(Room, :select => [:a, :b]).options[:fields].should == [:a, :b]
+      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]],
@@ -312,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,
@@ -325,5 +331,4 @@ class FinderOptionsTest < Test::Unit::TestCase
       }
     end
   end
-  
-end # FinderOptionsTest
+end