mongo_mapper 0.7.1 → 0.7.2

data/test/functional/test_modifiers.rb

@@ -317,6 +317,14 @@ class ModifierTest < Test::Unit::TestCase
       page2.reload
       page.tags.should == %w(foo)
     end
-  end
+    
+    should "be able to pop with modifier hashes" do
+      page = @page_class.create(:tags => %w(foo bar))
+
+      page.pop({:tags => 1})
 
+      page.reload
+      page.tags.should == %w(foo)
+    end
+  end
 end

data/test/functional/test_validations.rb

@@ -1,19 +1,19 @@
 require 'test_helper'
 
-class ValidationsTest < Test::Unit::TestCase  
+class ValidationsTest < Test::Unit::TestCase
   context "Saving a new document that is invalid" do
     setup do
       @document = Doc do
         key :name, String, :required => true
       end
     end
-    
+
     should "not insert document" do
       doc = @document.new
       doc.save
       @document.count.should == 0
     end
-    
+
     should "populate document's errors" do
       doc = @document.new
       doc.errors.size.should == 0
@@ -28,7 +28,7 @@ class ValidationsTest < Test::Unit::TestCase
         key :name, String, :required => true
       end
     end
-    
+
     should "raise error" do
       doc = @document.new
       lambda { doc.save! }.should raise_error(MongoMapper::DocumentNotValid)
@@ -41,7 +41,7 @@ class ValidationsTest < Test::Unit::TestCase
         key :name, String, :required => true
       end
     end
-    
+
     should "raise error" do
       lambda { @document.create! }.should raise_error(MongoMapper::DocumentNotValid)
     end
@@ -51,29 +51,29 @@ class ValidationsTest < Test::Unit::TestCase
       instance.new_record?.should be_false
     end
   end
-  
+
   context "Saving an existing document that is invalid" do
     setup do
       @document = Doc do
         key :name, String, :required => true
       end
-      
+
       @doc = @document.create(:name => 'John Nunemaker')
     end
-    
+
     should "not update document" do
       @doc.name = nil
       @doc.save
       @doc.reload.name.should == 'John Nunemaker'
     end
-    
+
     should "populate document's errors" do
       @doc.name = nil
       @doc.save
       @doc.errors.full_messages.should == ["Name can't be empty"]
     end
   end
-  
+
   context "Adding validation errors" do
     setup do
       @document = Doc do
@@ -83,38 +83,38 @@ class ValidationsTest < Test::Unit::TestCase
         end
       end
     end
-    
+
     should "work with validate_on_create callback" do
       @document.validate_on_create :action_present
-      
+
       doc = @document.new
       doc.action = nil
       doc.should have_error_on(:action)
-      
+
       doc.action = 'kick'
       doc.should_not have_error_on(:action)
       doc.save
-      
+
       doc.action = nil
       doc.should_not have_error_on(:action)
     end
-    
+
     should "work with validate_on_update callback" do
       @document.validate_on_update :action_present
-      
+
       doc = @document.new
       doc.action = nil
       doc.should_not have_error_on(:action)
       doc.save
-      
+
       doc.action = nil
       doc.should have_error_on(:action)
-      
+
       doc.action = 'kick'
       doc.should_not have_error_on(:action)
     end
   end
-  
+
   context "validating uniqueness of" do
     setup do
       @document = Doc do
@@ -167,13 +167,13 @@ class ValidationsTest < Test::Unit::TestCase
       doc2 = @document.new("name" => "joe")
       doc2.should have_error_on(:name)
     end
-    
+
     should "allow multiple blank entries if :allow_blank => true" do
       document = Doc do
         key :name
         validates_uniqueness_of :name, :allow_blank => :true
       end
-      
+
       doc = document.new("name" => "")
       doc.save.should be_true
 
@@ -219,7 +219,7 @@ class ValidationsTest < Test::Unit::TestCase
           validates_uniqueness_of :name, :case_sensitive => false
         end
       end
-      
+
       should "fail on entries that differ only in case" do
         doc = @document.new("name" => "BLAMMO")
         doc.save.should be_true
@@ -232,6 +232,19 @@ class ValidationsTest < Test::Unit::TestCase
         doc = @document.new("name" => nil)
         lambda { doc.valid? }.should_not raise_error
       end
+
+      should "not raise an error if special Regexp characters used" do
+        doc = @document.new("name" => '?')
+        lambda { doc.valid? }.should_not raise_error
+      end
+
+      should "check for uniqueness using entire string" do
+        doc = @document.new("name" => "John Doe")
+        doc.save.should be_true
+
+        doc2 = @document.new("name" => "John")
+        doc2.valid?.should be_true
+      end
     end
 
     context "scoped by a single attribute" do
@@ -246,7 +259,7 @@ class ValidationsTest < Test::Unit::TestCase
       should "fail if the same name exists in the scope" do
         doc = @document.new("name" => "joe", "scope" => "one")
         doc.save.should be_true
-        
+
         @document \
           .stubs(:first) \
           .with(:name => 'joe', :scope => "one") \
@@ -279,11 +292,11 @@ class ValidationsTest < Test::Unit::TestCase
           validates_uniqueness_of :name, :scope => [:first_scope, :second_scope]
         end
       end
-      
+
       should "fail if the same name exists in the scope" do
         doc = @document.new("name" => "joe", "first_scope" => "one", "second_scope" => "two")
         doc.save.should be_true
-        
+
         @document \
           .stubs(:first) \
           .with(:name => 'joe', :first_scope => 'one', :second_scope => 'two') \
@@ -292,11 +305,11 @@ class ValidationsTest < Test::Unit::TestCase
         doc2 = @document.new("name" => "joe", "first_scope" => "one", "second_scope" => "two")
         doc2.should have_error_on(:name)
       end
-      
+
       should "pass if the same name exists in a different scope" do
         doc = @document.new("name" => "joe", "first_scope" => "one", "second_scope" => "two")
         doc.save.should be_true
-        
+
         @document \
           .stubs(:first) \
           .with(:name => 'joe', :first_scope => 'one', :second_scope => 'one') \
@@ -307,21 +320,21 @@ class ValidationsTest < Test::Unit::TestCase
       end
     end
   end
-  
+
   context "validates uniqueness of with :unique shortcut" do
     should "work" do
       @document = Doc do
         key :name, String, :unique => true
       end
-      
+
       doc = @document.create(:name => 'John')
       doc.should_not have_error_on(:name)
-      
+
       @document \
         .stubs(:first) \
         .with(:name => 'John') \
         .returns(doc)
-      
+
       second_john = @document.create(:name => 'John')
       second_john.should have_error_on(:name, 'has already been taken')
     end

data/test/test_helper.rb

@@ -1,4 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + '/../lib/mongo_mapper')
+require 'fileutils'
 
 gem 'jnunemaker-matchy', '0.4.0'
 gem 'shoulda', '2.10.2'

data/test/unit/test_document.rb

@@ -105,12 +105,6 @@ class DocumentTest < Test::Unit::TestCase
       @document.new._id.should be_instance_of(Mongo::ObjectID)
     end
     
-    should "have to_param that is string representation of id" do
-      doc = @document.new(:id => Mongo::ObjectID.new)
-      doc.to_param.should == doc.id.to_s
-      doc.to_param.should be_instance_of(String)
-    end
-    
     should "have access to logger" do
       doc = @document.new
       doc.logger.should == @document.logger

data/test/unit/test_embedded_document.rb

@@ -11,7 +11,7 @@ module KeyOverride
 end
 
 class EmbeddedDocumentTest < Test::Unit::TestCase
-  context "" do
+  context "EmbeddedDocuments" do
     setup do
       class ::Grandparent
         include MongoMapper::EmbeddedDocument
@@ -221,12 +221,6 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
         end
       end
 
-      should "have to_param that is string representation of id" do
-        doc = @document.new
-        doc.to_param.should == doc.id.to_s
-        doc.to_param.should be_instance_of(String)
-      end
-
       should "have access to class logger" do
         doc = @document.new
         doc.logger.should == @document.logger

data/test/unit/test_query.rb

@@ -3,25 +3,25 @@ require 'models'
 
 class QueryTest < Test::Unit::TestCase
   include MongoMapper
-  
+
   should "raise error if provided something other than a hash" do
     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
     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
       Query.new(Message, :foo => 'bar').criteria.should == {
         :foo => 'bar'
       }
     end
-    
+
     should "not add _type to nested conditions" do
       Query.new(Enter, :foo => 'bar', :age => {'$gt' => 21}).criteria.should == {
         :foo => 'bar',
@@ -29,14 +29,14 @@ class QueryTest < Test::Unit::TestCase
         :_type => 'Enter'
       }
     end
-    
+
     should "automatically add _type to query if model is single collection inherited" do
       Query.new(Enter, :foo => 'bar').criteria.should == {
         :foo => 'bar',
         :_type => 'Enter'
       }
     end
-    
+
     %w{gt lt gte lte ne in nin mod all size where exists}.each do |operator|
       next if operator == 'size' && RUBY_VERSION >= '1.9.1' # 1.9 defines Symbol#size
 
@@ -46,75 +46,75 @@ class QueryTest < Test::Unit::TestCase
         }
       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
       Query.new(Room, :foo => 'bar').criteria.should == {
         :foo => 'bar'
       }
-      
+
       Query.new(Room, :foo => 'bar', :baz => 'wick').criteria.should == {
-        :foo => 'bar', 
+        :foo => 'bar',
         :baz => 'wick'
       }
     end
-    
+
     should "convert id to _id" do
       id = Mongo::ObjectID.new
       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
       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
       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
       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
       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
       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 = 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 = 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
       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
       Query.new(Room, :foo => {'$all' => [1,2,3]}).criteria.should == {
         :foo => {'$all' => [1,2,3]}
@@ -124,155 +124,179 @@ class QueryTest < Test::Unit::TestCase
         :foo => {'$any' => [1,2,3]}
       }
     end
-    
+
+    should "use $in for sets" do
+      Query.new(Room, :foo => Set.new([1,2,3])).criteria.should == {
+        :foo => {'$in' => [1,2,3]}
+      }
+    end
+
+    should "not use $in for sets if already using array operator" do
+      Query.new(Room, :foo => {'$all' => Set.new([1,2,3])}).criteria.should == {
+        :foo => {'$all' => [1,2,3]}
+      }
+
+      Query.new(Room, :foo => {'$any' => Set.new([1,2,3])}).criteria.should == {
+        :foo => {'$any' => [1,2,3]}
+      }
+    end
+
     should "work arbitrarily deep" do
       Query.new(Room, :foo => {:bar => [1,2,3]}).criteria.should == {
         :foo => {:bar => {'$in' => [1,2,3]}}
       }
-      
+
       Query.new(Room, :foo => {:bar => {'$any' => [1,2,3]}}).criteria.should == {
         :foo => {:bar => {'$any' => [1,2,3]}}
       }
     end
+    
+    should "make sure that ids in array are object ids" do
+      id1, id2, id3 = Mongo::ObjectID.new, Mongo::ObjectID.new, Mongo::ObjectID.new
+      
+      Query.new(Room, :_id => [id1.to_s, id2.to_s, id3.to_s]).criteria.should == {
+        :_id => {'$in' => [id1, id2, id3]}
+      }
+    end
   end
-  
+
   context "ordering" do
     should "single field with ascending direction" do
       sort = [['foo', 1]]
       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]]
       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
       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
       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]]
       Query.new(Room, :order => 'foo').options[:sort].should == sort
     end
-    
+
     should "convert multiple fields with directions" do
       sort = [['foo', -1], ['bar', 1], ['baz', -1]]
       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]]
       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]]
       Query.new(Room, :sort => sort, :order => 'foo asc').options[:sort].should == sort
     end
-    
+
     should "normalize id to _id" do
       Query.new(Room, :order => :id.asc).options[:sort].should == [['_id', 1]]
     end
-    
+
     should "convert natural in order to proper" do
       sort = [['$natural', 1]]
       Query.new(Room, :order => '$natural asc').options[:sort].should == sort
       sort = [['$natural', -1]]
       Query.new(Room, :order => '$natural desc').options[:sort].should == sort
     end
-    
+
     should "work for natural order ascending" do
       Query.new(Room, :sort => {'$natural' => 1}).options[:sort]['$natural'].should == 1
     end
-    
+
     should "work for natural order descending" do
       Query.new(Room, :sort => {'$natural' => -1}).options[:sort]['$natural'].should == -1
     end
   end
-  
+
   context "skip" do
     should "default to 0" do
       Query.new(Room, {}).options[:skip].should == 0
     end
-    
+
     should "use skip provided" do
       Query.new(Room, :skip => 2).options[:skip].should == 2
     end
-    
+
     should "covert string to integer" do
       Query.new(Room, :skip => '2').options[:skip].should == 2
     end
-    
+
     should "convert offset to skip" do
       Query.new(Room, :offset => 1).options[:skip].should == 1
     end
   end
-  
+
   context "limit" do
     should "default to 0" do
       Query.new(Room, {}).options[:limit].should == 0
     end
-    
+
     should "use limit provided" do
       Query.new(Room, :limit => 2).options[:limit].should == 2
     end
-    
+
     should "covert string to integer" do
       Query.new(Room, :limit => '2').options[:limit].should == 2
     end
   end
-  
+
   context "fields" do
     should "default to nil" do
       Query.new(Room, {}).options[:fields].should be(nil)
     end
-    
+
     should "be converted to nil if empty string" do
       Query.new(Room, :fields => '').options[:fields].should be(nil)
     end
-    
+
     should "be converted to nil if []" do
       Query.new(Room, :fields => []).options[:fields].should be(nil)
     end
-    
+
     should "should work with array" do
       Query.new(Room, {:fields => %w(a b)}).options[:fields].should == %w(a b)
     end
-    
+
     should "convert comma separated list to array" do
       Query.new(Room, {:fields => 'a, b'}).options[:fields].should == %w(a b)
     end
-    
+
     should "also work as select" do
       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 = 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 = 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 = Query.new(Room, :select => 'foo')
@@ -280,13 +304,13 @@ class QueryTest < Test::Unit::TestCase
       finder.criteria.keys.should_not include(:select)
       finder.criteria.keys.should_not include(:fields)
     end
-    
+
     should "know skip is an option" do
       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 = Query.new(Room, :offset => 10)
@@ -313,7 +337,7 @@ class QueryTest < Test::Unit::TestCase
       finder.options.keys.should include(:sort)
       finder.criteria.keys.should_not include(:sort)
     end
-        
+
     should "work with full range of things" do
       query_options = Query.new(Room, {
         :foo => 'bar',
@@ -323,12 +347,12 @@ class QueryTest < Test::Unit::TestCase
         :limit => 10,
         :skip => 10,
       })
-      
+
       query_options.criteria.should == {
         :foo => 'bar',
         :baz => true,
       }
-      
+
       query_options.options.should == {
         :sort => [['foo', 1]],
         :fields => ['foo', 'baz'],