mongo_mapper 0.5.6 → 0.5.7

data/test/support/{test_timing.rb → timing.rb}

@@ -5,7 +5,7 @@ class Test::Unit::TestCase
     end_time = Time.now
  
     duration = end_time - begin_time
-    threshold = 0.3
+    threshold = 0.5
     
     if duration > threshold
       puts "\nSLOW TEST: #{duration} - #{self.name}"

data/test/test_helper.rb

@@ -1,4 +1,4 @@
-require File.join(File.expand_path(File.dirname(__FILE__) + '/../lib/mongo_mapper'))
+require File.expand_path(File.dirname(__FILE__) + '/../lib/mongo_mapper')
 
 gem 'jnunemaker-matchy', '0.4.0'
 gem 'shoulda', '2.10.2'
@@ -12,19 +12,19 @@ require 'mocha'
 require 'pp'
 
 require 'support/custom_matchers'
-require 'support/test_timing'
+require 'support/timing'
 
 class Test::Unit::TestCase
   include CustomMatchers
-  
-  def clear_all_collections
-    MongoMapper::Document.descendants.map { |d| d.collection.clear }
-  end
 end
 
 DefaultDatabase = 'test' unless defined?(DefaultDatabase)
 AlternateDatabase = 'test2' unless defined?(AlternateDatabase)
 
-logger = Logger.new(File.expand_path(File.dirname(__FILE__) + '/../tmp/test.log'))
-MongoMapper.connection = Mongo::Connection.new('127.0.0.1', 27017, :logger => logger)
+test_dir = File.expand_path(File.dirname(__FILE__) + '/../tmp')
+FileUtils.mkdir_p(test_dir) unless File.exist?(test_dir)
+
+MongoMapper.connection = Mongo::Connection.new('127.0.0.1', 27017, {
+  :logger => Logger.new(test_dir + '/test.log')
+})
 MongoMapper.database = DefaultDatabase

data/test/unit/test_association_base.rb

@@ -48,6 +48,23 @@ class AssociationBaseTest < Test::Unit::TestCase
     end
   end
   
+  context "finder_options" do
+    should "default to empty hash" do
+      base = Base.new(:many, :foos)
+      base.finder_options.should == {}
+    end
+    
+    should "work with order" do
+      base = Base.new(:many, :foos, :order => 'position')
+      base.finder_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'}
+    end
+  end
+  
   context "belongs_to?" do
     should "be true if belongs_to" do
       Base.new(:belongs_to, :foo).belongs_to?.should be_true

data/test/unit/test_document.rb

@@ -47,13 +47,24 @@ class DocumentTest < Test::Unit::TestCase
     end
     
     should "default collection name to class name tableized" do
-      class Item
+      class ::Item
         include MongoMapper::Document
       end
       
       Item.collection.should be_instance_of(Mongo::Collection)
       Item.collection.name.should == 'items'
     end
+    
+    should "default collection name of namespaced class to tableized with dot separation" do
+      module ::BloggyPoo
+        class Post
+          include MongoMapper::Document
+        end
+      end
+
+      BloggyPoo::Post.collection.should be_instance_of(Mongo::Collection)
+      BloggyPoo::Post.collection.name.should == 'bloggy_poo.posts'
+    end
 
     should "allow setting the collection name" do
       @document.set_collection_name('foobar')

data/test/unit/test_embedded_document.rb

@@ -465,11 +465,20 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
         clone.age.should == 27
       end
     end
-
+    
     context "key shorcut access" do
-      should "be able to read key with []" do
-        doc = @document.new(:name => 'string')
-        doc[:name].should == 'string'
+      context "[]" do
+        should "work when key found" do
+          doc = @document.new(:name => 'string')
+          doc[:name].should == 'string'
+        end
+        
+        should "raise exception when key not found" do
+          doc = @document.new(:name => 'string')
+          lambda {
+            doc[:not_here]
+          }.should raise_error(MongoMapper::KeyNotFound)
+        end
       end
       
       context "[]=" do

data/test/unit/test_finder_options.rb

@@ -15,73 +15,75 @@ class FinderOptionsTest < Test::Unit::TestCase
     end
   end
   
-  context "#criteria" do
-    should "convert conditions to criteria" do
-      FinderOptions.expects(:to_mongo_criteria).with(Room, :foo => 1).returns({})
-      FinderOptions.new(Room, :conditions => {:foo => 1}).criteria
-    end
-  end
-  
-  context "#options" do
-    should "convert options to mongo options" do
-      FinderOptions.expects(:to_mongo_options).with(Room, :order => 'foo asc', :select => 'foo,bar').returns({})
-      FinderOptions.new(Room, :order => 'foo asc', :select => 'foo,bar').options
-    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.to_mongo_criteria(Message, :foo => 'bar').should == {
+      FinderOptions.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 == {
+        :foo => 'bar',
+        :age => {'$gt' => 21},
+        :_type => 'Enter'
+      }
+    end
+    
+    %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.to_mongo_criteria(Enter, :foo => 'bar').should == {
+      FinderOptions.new(Enter, :foo => 'bar').criteria.should == {
         :foo => 'bar',
         :_type => 'Enter'
       }
     end
     
     should "work with simple criteria" do
-      FinderOptions.to_mongo_criteria(Room, :foo => 'bar').should == {
+      FinderOptions.new(Room, :foo => 'bar').criteria.should == {
         :foo => 'bar'
       }
       
-      FinderOptions.to_mongo_criteria(Room, :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(Room, :id => '1').should == {
+      FinderOptions.new(Room, :id => '1').criteria.should == {
         :_id => '1'
       }
     end
     
     should "use $in for arrays" do
-      FinderOptions.to_mongo_criteria(Room, :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(Room, :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(Room, :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(Room, :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(Room, :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
@@ -90,103 +92,103 @@ class FinderOptionsTest < Test::Unit::TestCase
   context "ordering" do
     should "single field with ascending direction" do
       sort = [['foo', 1]]
-      FinderOptions.to_mongo_options(Room, :order => 'foo asc')[:sort].should == sort
-      FinderOptions.to_mongo_options(Room, :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(Room, :order => 'foo desc')[:sort].should == sort
-      FinderOptions.to_mongo_options(Room, :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(Room, :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(Room, :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(Room, :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(Room, :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(Room, :order => '$natural asc')[:sort].should == sort
+      FinderOptions.new(Room, :order => '$natural asc').options[:sort].should == sort
       sort = [['$natural', -1]]
-      FinderOptions.to_mongo_options(Room, :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(Room, :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(Room, :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(Room, {})[:skip].should == 0
+      FinderOptions.new(Room, {}).options[:skip].should == 0
     end
     
     should "use skip provided" do
-      FinderOptions.to_mongo_options(Room, :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(Room, :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(Room, :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(Room, {})[:limit].should == 0
+      FinderOptions.new(Room, {}).options[:limit].should == 0
     end
     
     should "use limit provided" do
-      FinderOptions.to_mongo_options(Room, :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(Room, :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(Room, {})[: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(Room, :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(Room, :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(Room, {: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(Room, {: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

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
 version: !ruby/object:Gem::Version 
-  version: 0.5.6
+  version: 0.5.7
 platform: ruby
 authors: 
 - John Nunemaker
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-22 00:00:00 -04:00
+date: 2009-10-28 00:00:00 -04:00
 default_executable: mmconsole
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -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
@@ -212,7 +212,7 @@ test_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