djsun-mongo_mapper 0.5.5.3 → 0.5.6.1

data/test/functional/test_pagination.rb

@@ -43,41 +43,41 @@ class PaginationTest < Test::Unit::TestCase
 
     should "accept conditions" do
       result = @document.paginate({
-        :conditions => {:last_name => 'Nunemaker'},
-        :order      => "age DESC",
-        :per_page   => 2, 
-        :page       => 1,
+        :last_name => 'Nunemaker',
+        :order     => "age DESC",
+        :per_page  => 2, 
+        :page      => 1,
       })
       result.should == [@doc1, @doc3]
       result.first.age.should == 27
     end
     
-    should "withstand rigor" do
+    should "withstand rigor" do      
       result = @document.paginate({
-        :per_page   => 1, 
-        :page       => 1,
-        :order      => 'age desc', 
-        :conditions => {:last_name => 'Nunemaker'}
+        :per_page  => 1, 
+        :page      => 1,
+        :order     => 'age desc', 
+        :last_name => 'Nunemaker'
       })
       result.should == [@doc1]
       result.total_entries.should == 2
       result.total_pages.should == 2
       
       result = @document.paginate({
-        :per_page   => 1,
-        :page       => 2,
-        :order      => 'age desc',
-        :conditions => {:last_name => 'Nunemaker'}
+        :per_page  => 1,
+        :page      => 2,
+        :order     => 'age desc',
+        :last_name => 'Nunemaker'
       })
       result.should == [@doc3]
       result.total_entries.should == 2
       result.total_pages.should == 2
       
       result = @document.paginate({
-        :per_page   => 2, 
-        :page       => 1, 
-        :order      => 'age desc',
-        :conditions => {:last_name => 'Nunemaker'}
+        :per_page  => 2,
+        :page      => 1,
+        :order     => 'age desc',
+        :last_name => 'Nunemaker'
       })
       result.should == [@doc1, @doc3]
       result.total_entries.should == 2

data/test/functional/test_validations.rb

@@ -170,8 +170,8 @@ class ValidationsTest < Test::Unit::TestCase
       doc.save.should be_true
 
       @document \
-        .stubs(:find) \
-        .with(:first, :conditions => {:name => 'joe'}, :limit => 1) \
+        .stubs(:first) \
+        .with(:name => 'joe') \
         .returns(doc)
 
       doc.name = "joe"
@@ -184,14 +184,35 @@ class ValidationsTest < Test::Unit::TestCase
       doc.save.should be_true
 
       @document \
-        .stubs(:find) \
-        .with(:first, :conditions => {:name => 'joe'}, :limit => 1) \
+        .stubs(:first) \
+        .with(:name => 'joe') \
         .returns(doc)
 
       doc2 = @document.new("name" => "joe")
       doc2.should have_error_on(:name)
     end
     
+    should "allow multiple blank entries if :allow_blank => true" do
+      document = Class.new do
+        include MongoMapper::Document
+        set_collection_name 'test'
+        
+        key :name
+        validates_uniqueness_of :name, :allow_blank => :true
+      end
+      
+      doc = document.new("name" => "")
+      doc.save.should be_true
+
+      document \
+        .stubs(:first) \
+        .with(:name => '') \
+        .returns(doc)
+
+      doc2 = document.new("name" => "")
+      doc2.should_not have_error_on(:name)
+    end
+    
     context "scoped by a single attribute" do
       setup do
         @document = Class.new do
@@ -210,8 +231,8 @@ class ValidationsTest < Test::Unit::TestCase
         doc.save.should be_true
         
         @document \
-          .stubs(:find) \
-          .with(:first, :conditions => {:name => 'joe', :scope => "one"}, :limit => 1) \
+          .stubs(:first) \
+          .with(:name => 'joe', :scope => "one") \
           .returns(doc)
 
         doc2 = @document.new("name" => "joe", "scope" => "one")
@@ -223,8 +244,8 @@ class ValidationsTest < Test::Unit::TestCase
         doc.save.should be_true
         
         @document \
-          .stubs(:find) \
-          .with(:first, :conditions => {:name => 'joe', :scope => "two"}, :limit => 1) \
+          .stubs(:first) \
+          .with(:name => 'joe', :scope => 'two') \
           .returns(nil)
 
         doc2 = @document.new("name" => "joe", "scope" => "two")
@@ -251,8 +272,8 @@ class ValidationsTest < Test::Unit::TestCase
         doc.save.should be_true
         
         @document \
-          .stubs(:find) \
-          .with(:first, :conditions => {:name => 'joe', :first_scope => "one", :second_scope => "two"}, :limit => 1) \
+          .stubs(:first) \
+          .with(:name => 'joe', :first_scope => 'one', :second_scope => 'two') \
           .returns(doc)
 
         doc2 = @document.new("name" => "joe", "first_scope" => "one", "second_scope" => "two")
@@ -264,8 +285,8 @@ class ValidationsTest < Test::Unit::TestCase
         doc.save.should be_true
         
         @document \
-          .stubs(:find) \
-          .with(:first, :conditions => {:name => 'joe', :first_scope => "one", :second_scope => "one"}, :limit => 1) \
+          .stubs(:first) \
+          .with(:name => 'joe', :first_scope => 'one', :second_scope => 'one') \
           .returns(nil)
 
         doc2 = @document.new("name" => "joe", "first_scope" => "one", "second_scope" => "one")
@@ -288,8 +309,8 @@ class ValidationsTest < Test::Unit::TestCase
       doc.should_not have_error_on(:name)
       
       @document \
-        .stubs(:find) \
-        .with(:first, :conditions => {:name => 'John'}, :limit => 1) \
+        .stubs(:first) \
+        .with(:name => 'John') \
         .returns(doc)
       
       second_john = @document.create(:name => 'John')

data/test/models.rb

@@ -68,12 +68,6 @@ class Message
   belongs_to :room
 end
 
-class Answer
-  include MongoMapper::Document
-
-  key :body, String
-end
-
 class Enter < Message; end
 class Exit < Message;  end
 class Chat < Message;  end
@@ -85,6 +79,12 @@ class Room
   many :messages, :polymorphic => true
 end
 
+class Answer
+  include MongoMapper::Document
+
+  key :body, String
+end
+
 class Project
   include MongoMapper::Document
 

data/test/test_helper.rb

@@ -25,6 +25,8 @@ 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_document.rb

@@ -166,14 +166,12 @@ class DocumentTest < Test::Unit::TestCase
         doc_1 = @document.new('name' => "Doc 1")
         doc_2 = @document.new('name' => "Doc 1")
         doc_1.should == doc_2
-        doc_2.should == doc_1 # check transitivity
       end
 
       should "not be == if key values are different" do
         doc_1 = @document.new('name' => "Doc 1")
         doc_2 = @document.new('name' => "Doc 2")
         doc_1.should_not == doc_2
-        doc_2.should_not == doc_1 # check transitivity
       end
 
       should "not care about type" do
@@ -186,7 +184,7 @@ class DocumentTest < Test::Unit::TestCase
         doc = @document.new('name' => "Doc 1")
         person = @person.new('name' => "Doc 1")
         doc.should == person
-        person.should == doc # check transitivity
+        person.should == doc # test commutativity
       end
     end
 
@@ -195,14 +193,12 @@ class DocumentTest < Test::Unit::TestCase
         doc_1 = @document.new('name' => "Doc 1")
         doc_2 = @document.new('name' => "Doc 1")
         doc_1.should eql?(doc_2)
-        doc_2.should eql?(doc_1) # check transitivity
       end
 
       should "not be == if type matches but key values are different" do
         doc_1 = @document.new('name' => "Doc 1")
         doc_2 = @document.new('name' => "Doc 2")
         doc_1.should_not eql?(doc_2)
-        doc_2.should_not eql?(doc_1) # check transitivity
       end
 
       should "not be eql? if types are different even if values are the same" do
@@ -215,7 +211,7 @@ class DocumentTest < Test::Unit::TestCase
         doc = @document.new('name' => "Doc 1")
         person = @person.new('name' => "Doc 1")
         doc.should_not eql?(person)
-        person.should_not eql?(doc) # check transitivity
+        person.should_not eql?(doc) # test commutativity
       end
     end
   end # instance of a document

data/test/unit/test_embedded_document.rb

@@ -649,14 +649,12 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
         doc_1 = @document.new('name' => "Doc 1")
         doc_2 = @document.new('name' => "Doc 1")
         doc_1.should == doc_2
-        doc_2.should == doc_1 # check transitivity
       end
 
       should "not be == if key values are different" do
         doc_1 = @document.new('name' => "Doc 1")
         doc_2 = @document.new('name' => "Doc 2")
         doc_1.should_not == doc_2
-        doc_2.should_not == doc_1 # check transitivity
       end
 
       should "not care about type" do
@@ -669,7 +667,7 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
         doc = @document.new('name' => "Doc 1")
         person = @person.new('name' => "Doc 1")
         doc.should == person
-        person.should == doc # check transitivity
+        person.should == doc # test commutativity
       end
     end
 
@@ -678,14 +676,12 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
         doc_1 = @document.new('name' => "Doc 1")
         doc_2 = @document.new('name' => "Doc 1")
         doc_1.should eql?(doc_2)
-        doc_2.should eql?(doc_1) # check transitivity
       end
 
       should "not be == if type matches but key values are different" do
         doc_1 = @document.new('name' => "Doc 1")
         doc_2 = @document.new('name' => "Doc 2")
         doc_1.should_not eql?(doc_2)
-        doc_2.should_not eql?(doc_1) # check transitivity
       end
 
       should "not be eql? if types are different even if values are the same" do
@@ -698,7 +694,7 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
         doc = @document.new('name' => "Doc 1")
         person = @person.new('name' => "Doc 1")
         doc.should_not eql?(person)
-        person.should_not eql?(doc) # check transitivity
+        person.should_not eql?(doc) # check commutativity
       end
     end
 

data/test/unit/test_finder_options.rb

@@ -1,73 +1,73 @@
 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 "automatically add _type to query if model is single collection inherited" do
+      FinderOptions.new(Enter, :foo => 'bar').criteria.should == {
+        :foo => 'bar',
+        :_type => 'Enter'
+      }
     end
-  end
-  
-  context "Converting conditions to criteria" do
+    
     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 +76,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]],