mongo_mapper-unstable 2009.10.16 → 2009.10.31

data/test/unit/test_finder_options.rb

@@ -1,73 +1,89 @@
 require 'test_helper'
+require 'models'
 
 class FinderOptionsTest < Test::Unit::TestCase
   include MongoMapper
   
   should "raise error if provided something other than a hash" do
-    lambda { FinderOptions.new }.should raise_error(ArgumentError)
-    lambda { FinderOptions.new(1) }.should raise_error(ArgumentError)
+    lambda { FinderOptions.new(Room) }.should raise_error(ArgumentError)
+    lambda { FinderOptions.new(Room, 1) }.should raise_error(ArgumentError)
   end
   
   should "symbolize the keys of the hash provided" do
-    FinderOptions.new('offset' => 1).options.keys.map do |key|
+    FinderOptions.new(Room, 'offset' => 1).options.keys.map do |key|
       key.should be_instance_of(Symbol)
     end
   end
   
-  context "#criteria" do
-    should "convert conditions to criteria" do
-      FinderOptions.expects(:to_mongo_criteria).with(:foo => 1).returns({})
-      FinderOptions.new(:conditions => {:foo => 1}).criteria
+  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 == {
+        :foo => 'bar'
+      }
     end
-  end
-  
-  context "#options" do
-    should "convert options to mongo options" do
-      FinderOptions.expects(:to_mongo_options).with(:order => 'foo asc', :select => 'foo,bar').returns({})
-      FinderOptions.new(:order => 'foo asc', :select => 'foo,bar').options
+    
+    should "not add _type to nested conditions" do
+      FinderOptions.new(Enter, :foo => 'bar', :age => {'$gt' => 21}).criteria.should == {
+        :foo => 'bar',
+        :age => {'$gt' => 21},
+        :_type => 'Enter'
+      }
     end
-  end
-  
-  context "Converting conditions to criteria" do
+    
+    %w{gt lt gte lte ne in nin mod size where exists}.each do |operator|
+      should "convert #{operator} conditions" do
+        FinderOptions.new(Room, :age.send(operator) => 21).criteria.should == {
+          :age => {"$#{operator}" => 21}
+        }
+      end
+    end
+    
+    should "automatically add _type to query if model is single collection inherited" do
+      FinderOptions.new(Enter, :foo => 'bar').criteria.should == {
+        :foo => 'bar',
+        :_type => 'Enter'
+      }
+    end
+    
     should "work with simple criteria" do
-      FinderOptions.to_mongo_criteria(:foo => 'bar').should == {
+      FinderOptions.new(Room, :foo => 'bar').criteria.should == {
         :foo => 'bar'
       }
       
-      FinderOptions.to_mongo_criteria(:foo => 'bar', :baz => 'wick').should == {
+      FinderOptions.new(Room, :foo => 'bar', :baz => 'wick').criteria.should == {
         :foo => 'bar', 
         :baz => 'wick'
       }
     end
     
     should "convert id to _id" do
-      FinderOptions.to_mongo_criteria(:id => '1').should == {
+      FinderOptions.new(Room, :id => '1').criteria.should == {
         :_id => '1'
       }
     end
     
     should "use $in for arrays" do
-      FinderOptions.to_mongo_criteria(:foo => [1,2,3]).should == {
+      FinderOptions.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.to_mongo_criteria(:foo => {'$all' => [1,2,3]}).should == {
+      FinderOptions.new(Room, :foo => {'$all' => [1,2,3]}).criteria.should == {
         :foo => {'$all' => [1,2,3]}
       }
 
-      FinderOptions.to_mongo_criteria(:foo => {'$any' => [1,2,3]}).should == {
+      FinderOptions.new(Room, :foo => {'$any' => [1,2,3]}).criteria.should == {
         :foo => {'$any' => [1,2,3]}
       }
     end
     
     should "work arbitrarily deep" do
-      FinderOptions.to_mongo_criteria(:foo => {:bar => [1,2,3]}).should == {
+      FinderOptions.new(Room, :foo => {:bar => [1,2,3]}).criteria.should == {
         :foo => {:bar => {'$in' => [1,2,3]}}
       }
       
-      FinderOptions.to_mongo_criteria(:foo => {:bar => {'$any' => [1,2,3]}}).should == {
+      FinderOptions.new(Room, :foo => {:bar => {'$any' => [1,2,3]}}).criteria.should == {
         :foo => {:bar => {'$any' => [1,2,3]}}
       }
     end
@@ -76,166 +92,166 @@ class FinderOptionsTest < Test::Unit::TestCase
   context "ordering" do
     should "single field with ascending direction" do
       sort = [['foo', 1]]
-      FinderOptions.to_mongo_options(:order => 'foo asc')[:sort].should == sort
-      FinderOptions.to_mongo_options(:order => 'foo ASC')[:sort].should == sort
+      FinderOptions.new(Room, :order => 'foo asc').options[:sort].should == sort
+      FinderOptions.new(Room, :order => 'foo ASC').options[:sort].should == sort
     end
     
     should "single field with descending direction" do
       sort = [['foo', -1]]
-      FinderOptions.to_mongo_options(:order => 'foo desc')[:sort].should == sort
-      FinderOptions.to_mongo_options(:order => 'foo DESC')[:sort].should == sort
+      FinderOptions.new(Room, :order => 'foo desc').options[:sort].should == sort
+      FinderOptions.new(Room, :order => 'foo DESC').options[:sort].should == sort
     end
     
     should "convert field without direction to ascending" do
       sort = [['foo', 1]]
-      FinderOptions.to_mongo_options(:order => 'foo')[:sort].should == sort
+      FinderOptions.new(Room, :order => 'foo').options[:sort].should == sort
     end
     
     should "convert multiple fields with directions" do
       sort = [['foo', -1], ['bar', 1], ['baz', -1]]
-      FinderOptions.to_mongo_options(:order => 'foo desc, bar asc, baz desc')[:sort].should == sort
+      FinderOptions.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.to_mongo_options(:order => 'foo desc, bar, baz')[:sort].should == sort
+      FinderOptions.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.to_mongo_options(:sort => sort, :order => 'foo asc')[:sort].should == sort
+      FinderOptions.new(Room, :sort => sort, :order => 'foo asc').options[:sort].should == sort
     end
     
     should "convert natural in order to proper" do
       sort = [['$natural', 1]]
-      FinderOptions.to_mongo_options(:order => '$natural asc')[:sort].should == sort
+      FinderOptions.new(Room, :order => '$natural asc').options[:sort].should == sort
       sort = [['$natural', -1]]
-      FinderOptions.to_mongo_options(:order => '$natural desc')[:sort].should == sort
+      FinderOptions.new(Room, :order => '$natural desc').options[:sort].should == sort
     end
     
     should "work for natural order ascending" do
-      FinderOptions.to_mongo_options(:sort => {'$natural' => 1})[:sort]['$natural'].should == 1
+      FinderOptions.new(Room, :sort => {'$natural' => 1}).options[:sort]['$natural'].should == 1
     end
     
     should "work for natural order descending" do
-      FinderOptions.to_mongo_options(:sort => {'$natural' => -1})[:sort]['$natural'].should == -1
+      FinderOptions.new(Room, :sort => {'$natural' => -1}).options[:sort]['$natural'].should == -1
     end
   end
   
   context "skip" do
     should "default to 0" do
-      FinderOptions.to_mongo_options({})[:skip].should == 0
+      FinderOptions.new(Room, {}).options[:skip].should == 0
     end
     
     should "use skip provided" do
-      FinderOptions.to_mongo_options(:skip => 2)[:skip].should == 2
+      FinderOptions.new(Room, :skip => 2).options[:skip].should == 2
     end
     
     should "covert string to integer" do
-      FinderOptions.to_mongo_options(:skip => '2')[:skip].should == 2
+      FinderOptions.new(Room, :skip => '2').options[:skip].should == 2
     end
     
     should "convert offset to skip" do
-      FinderOptions.to_mongo_options(:offset => 1)[:skip].should == 1
+      FinderOptions.new(Room, :offset => 1).options[:skip].should == 1
     end
   end
   
   context "limit" do
     should "default to 0" do
-      FinderOptions.to_mongo_options({})[:limit].should == 0
+      FinderOptions.new(Room, {}).options[:limit].should == 0
     end
     
     should "use limit provided" do
-      FinderOptions.to_mongo_options(:limit => 2)[:limit].should == 2
+      FinderOptions.new(Room, :limit => 2).options[:limit].should == 2
     end
     
     should "covert string to integer" do
-      FinderOptions.to_mongo_options(:limit => '2')[:limit].should == 2
+      FinderOptions.new(Room, :limit => '2').options[:limit].should == 2
     end
   end
   
   context "fields" do
     should "default to nil" do
-      FinderOptions.to_mongo_options({})[:fields].should be(nil)
+      FinderOptions.new(Room, {}).options[:fields].should be(nil)
     end
     
     should "be converted to nil if empty string" do
-      FinderOptions.to_mongo_options(:fields => '')[:fields].should be(nil)
+      FinderOptions.new(Room, :fields => '').options[:fields].should be(nil)
     end
     
     should "be converted to nil if []" do
-      FinderOptions.to_mongo_options(:fields => [])[:fields].should be(nil)
+      FinderOptions.new(Room, :fields => []).options[:fields].should be(nil)
     end
     
     should "should work with array" do
-      FinderOptions.to_mongo_options({:fields => %w(a b)})[:fields].should == %w(a b)
+      FinderOptions.new(Room, {:fields => %w(a b)}).options[:fields].should == %w(a b)
     end
     
     should "convert comma separated list to array" do
-      FinderOptions.to_mongo_options({:fields => 'a, b'})[:fields].should == %w(a b)
+      FinderOptions.new(Room, {:fields => 'a, b'}).options[:fields].should == %w(a b)
     end
     
     should "also work as select" do
-      FinderOptions.new(:select => %w(a b)).options[:fields].should == %w(a b)
+      FinderOptions.new(Room, :select => %w(a b)).options[:fields].should == %w(a b)
     end
   end
   
   context "Condition auto-detection" do
     should "know :conditions are criteria" do
-      finder = FinderOptions.new(:conditions => {:foo => 'bar'})
+      finder = FinderOptions.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(:fields => ['foo'])
+      finder = FinderOptions.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(:select => 'foo')
+      finder = FinderOptions.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(:skip => 10)
+      finder = FinderOptions.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(:offset => 10)
+      finder = FinderOptions.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(:limit => 10)
+      finder = FinderOptions.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(:sort => [['foo', 1]])
+      finder = FinderOptions.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(:order => 'foo')
+      finder = FinderOptions.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({
+      finder_options = FinderOptions.new(Room, {
         :foo => 'bar',
         :baz => true,
         :sort => [['foo', 1]],

data/test/unit/test_mongomapper.rb

@@ -15,9 +15,9 @@ class MongoMapperTest < Test::Unit::TestCase
   end
   
   should "be able to write and read default database" do
-    MongoMapper.database = DefaultDatabase
+    MongoMapper.database = 'test'
     MongoMapper.database.should be_instance_of(Mongo::DB)
-    MongoMapper.database.name.should == DefaultDatabase
+    MongoMapper.database.name.should == 'test'
   end
   
   should "have document not found error" do

data/test/unit/test_pagination.rb

@@ -58,6 +58,10 @@ class PaginationTest < Test::Unit::TestCase
     should "know how many records to skip" do
       PaginationProxy.new(25, 2, 10).skip.should == 10
     end
+    
+    should "alias offset to skip" do
+      PaginationProxy.new(25, 2, 10).offset.should == 10
+    end
         
     context "previous_page" do
       should "be nil if current page 1" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mongo_mapper-unstable
 version: !ruby/object:Gem::Version 
-  version: 2009.10.16
+  version: 2009.10.31
 platform: ruby
 authors: 
 - John Nunemaker
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-16 00:00:00 -05:00
+date: 2009-10-31 00:00:00 -05:00
 default_executable: mmconsole
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -30,7 +30,7 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 0.15.1
+        version: "0.16"
     version: 
 - !ruby/object:Gem::Dependency 
   name: jnunemaker-validatable
@@ -40,7 +40,7 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 1.7.4
+        version: 1.8.1
     version: 
 - !ruby/object:Gem::Dependency 
   name: jnunemaker-matchy
@@ -147,7 +147,7 @@ files:
 - test/functional/test_validations.rb
 - test/models.rb
 - test/support/custom_matchers.rb
-- test/support/test_timing.rb
+- test/support/timing.rb
 - test/test_helper.rb
 - test/unit/serializers/test_json_serializer.rb
 - test/unit/test_association_base.rb
@@ -187,7 +187,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: mongomapper
+rubyforge_project: 
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
@@ -210,7 +210,7 @@ test_files:
 - test/unit/test_pagination.rb
 - test/test_helper.rb
 - test/support/custom_matchers.rb
-- test/support/test_timing.rb
+- test/support/timing.rb
 - test/functional/test_embedded_document.rb
 - test/functional/test_associations.rb
 - test/functional/associations/test_belongs_to_proxy.rb