jnunemaker-mongomapper 0.1.2 → 0.2.0

data/test/test_associations.rb

@@ -2,51 +2,148 @@ require 'test_helper'
 
 class Address
   include MongoMapper::EmbeddedDocument
-  
+
   key :address, String
   key :city,    String
   key :state,   String
   key :zip,     Integer
 end
 
+class Project
+  include MongoMapper::Document
+
+  key :name, String
+
+  many :statuses
+  many :addresses
+end
+
+class Status
+  include MongoMapper::Document
+
+  belongs_to :project
+  belongs_to :target, :polymorphic => true
+
+  key :name, String
+end
+
 class AssociationsTest < Test::Unit::TestCase
   def setup
-    @document = Class.new do
-      include MongoMapper::Document
+    Project.collection.clear
+    Status.collection.clear
+  end
+
+  context "Polymorphic Belongs To" do
+    should "default to nil" do
+      status = Status.new
+      status.target.should be_nil
+    end
+
+    should "store the association" do
+      status = Status.new
+      project = Project.new(:name => "mongomapper")
+      status.target = project
+      status.save.should be_true
+
+      from_db = Status.find(status.id)
+      from_db.target.should_not be_nil
+      from_db.target_id.should == project.id
+      from_db.target_type.should == "Project"
+      from_db.target.name.should == "mongomapper"
+    end
+
+    should "unset the association" do
+      status = Status.new
+      project = Project.new(:name => "mongomapper")
+      status.target = project
+      status.save.should be_true
+
+      from_db = Status.find(status.id)
+      from_db.target = nil
+      from_db.target_type.should be_nil
+      from_db.target_id.should be_nil
+      from_db.target.should be_nil
     end
   end
-  
-  context "Many embedded documents" do
-    setup do
-      @document.class_eval do
-        many :addresses
-      end
+
+  context "Belongs To" do
+    should "default to nil" do
+      status = Status.new
+      status.project.should be_nil
     end
 
+    should "store the association" do
+      status = Status.new
+      project = Project.new(:name => "mongomapper")
+      status.project = project
+      status.save.should be_true
+
+      from_db = Status.find(status.id)
+      from_db.project.should_not be_nil
+      from_db.project.name.should == "mongomapper"
+    end
+
+    should "unset the association" do
+      status = Status.new
+      project = Project.new(:name => "mongomapper")
+      status.project = project
+      status.save.should be_true
+
+      from_db = Status.find(status.id)
+      from_db.project = nil
+      from_db.project.should be_nil
+    end
+  end
+
+  context "Many documents" do
+    should "default reader to empty array" do
+      project = Project.new
+      project.statuses.should == []
+    end
+
+    should "allow adding to association like it was an array" do
+      project = Project.new
+      project.statuses << Status.new
+      project.statuses.push Status.new
+      project.statuses.size.should == 2
+    end
+
+    should "store the association" do
+      project = Project.new
+      project.statuses = [Status.new("name" => "ready")]
+      project.save.should be_true
+
+      from_db = Project.find(project.id)
+      from_db.statuses.size.should == 1
+      from_db.statuses[0].name.should == "ready"
+    end
+  end
+
+  context "Many embedded documents" do
     should "default reader to empty array" do
-      instance = @document.new
-      instance.addresses.should == []
+      project = Project.new
+      project.addresses.should == []
     end
-  
+
     should "allow adding to association like it was an array" do
-      instance = @document.new
-      instance.addresses << Address.new
-      instance.addresses.push Address.new
-      instance.addresses.size.should == 2
+      project = Project.new
+      project.addresses << Address.new
+      project.addresses.push Address.new
+      project.addresses.size.should == 2
     end
-  
+
     should "be embedded in document on save" do
       sb = Address.new(:city => 'South Bend', :state => 'IN')
       chi = Address.new(:city => 'Chicago', :state => 'IL')
-      instance = @document.new
-      instance.addresses << sb
-      instance.addresses << chi
-      instance.save
-    
-      from_db = @document.find(instance.id)
+      project = Project.new
+      project.addresses << sb
+      project.addresses << chi
+      project.save
+
+      from_db = Project.find(project.id)
       from_db.addresses.size.should == 2
       from_db.addresses[0].should == sb
       from_db.addresses[1].should == chi
-    end    
+    end
   end
 end

data/test/test_callbacks.rb

@@ -1,7 +1,5 @@
 require 'test_helper'
 
-include ActiveSupport::Callbacks
-
 class CallbacksTest < Test::Unit::TestCase
   context "Defining and running callbacks" do
     setup do
@@ -15,8 +13,7 @@ class CallbacksTest < Test::Unit::TestCase
           :before_create,     :after_create, 
           :before_update,     :after_update,
           :before_save,       :after_save,
-          :before_destroy,    :after_destroy,
-          :validate, :validate_on_create, :validate_on_update].each do |callback|
+          :before_destroy,    :after_destroy].each do |callback|
           callback_method = "#{callback}_callback"
           send(callback, callback_method)
           define_method(callback_method) do
@@ -37,7 +34,7 @@ class CallbacksTest < Test::Unit::TestCase
     
     should "get the order right for creating documents" do
       doc = @document.create(:name => 'John Nunemaker')
-      doc.history.should == [:before_validation, :before_validation_on_create, :validate, :validate_on_create, :after_validation, :before_save, :before_create, :after_create, :after_save]
+      doc.history.should == [:before_validation, :before_validation_on_create, :after_validation, :before_save, :before_create, :after_create, :after_save]
     end
     
     should "get the order right for updating documents" do
@@ -45,7 +42,7 @@ class CallbacksTest < Test::Unit::TestCase
       doc.clear_history
       doc.name = 'John'
       doc.save
-      doc.history.should == [:before_validation, :before_validation_on_update, :validate, :validate_on_update, :after_validation, :before_save, :before_update, :after_update, :after_save]
+      doc.history.should == [:before_validation, :before_validation_on_update, :after_validation, :before_save, :before_update, :after_update, :after_save]
     end
     
     should "work for before and after validation" do

data/test/test_document.rb

@@ -13,8 +13,12 @@ class DocumentTest < Test::Unit::TestCase
         include MongoMapper::Document
       end
     end
-    
-    should "should be able to define a key" do
+
+    should "track its descendants" do
+      MongoMapper::Document.descendants.should include(@document)
+    end
+
+    should "be able to define a key" do
       key = @document.key(:name, String)
       key.name.should == 'name'
       key.type.should == String
@@ -380,6 +384,11 @@ class DocumentTest < Test::Unit::TestCase
         @document.delete_all({:fname => 'John'})
         @document.count.should == 2
       end
+      
+      should "convert the conditions to mongo criteria" do
+        @document.delete_all(:age => [26, 27])
+        @document.count.should == 1
+      end
     end
     
     context "Destroying a document" do
@@ -436,6 +445,11 @@ class DocumentTest < Test::Unit::TestCase
         @document.destroy_all(:age => 26)
         @document.count.should == 1
       end
+      
+      should "convert the conditions to mongo criteria" do
+        @document.destroy_all(:age => [26, 27])
+        @document.count.should == 1
+      end
     end
     
     context "Counting documents in collection" do
@@ -466,6 +480,10 @@ class DocumentTest < Test::Unit::TestCase
       should "return count for matching documents if conditions provided" do
         @document.count(:age => 27).should == 1
       end
+      
+      should "convert the conditions to mongo criteria" do
+        @document.count(:age => [26, 27]).should == 2
+      end
     end
     
     context "Indexing" do
@@ -561,18 +579,6 @@ class DocumentTest < Test::Unit::TestCase
       end
     end
     
-    context "when initialized" do
-      should "accept a hash that sets keys and values" do
-        doc = @document.new(:name => 'John', :age => 23)
-        doc.attributes.should == {'name' => 'John', 'age' => 23}
-      end
-      
-      should "silently reject keys that have not been defined" do
-        doc = @document.new(:foobar => 'baz')
-        doc.attributes.should == {}
-      end
-    end
-    
     context "mass assigning keys" do
       should "update values for keys provided" do
         doc = @document.new(:name => 'foobar', :age => 10)

data/test/test_embedded_document.rb

@@ -29,9 +29,8 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
         doc.attributes.should == {'name' => 'John', 'age' => 23}
       end
       
-      should "silently reject keys that have not been defined" do
-        doc = @document.new(:foobar => 'baz')
-        doc.attributes.should == {}
+      should "not throw error if initialized with nil" do
+        doc = @document.new(nil)
       end
     end
     

data/test/test_finder_options.rb

@@ -14,26 +14,41 @@ class FinderOptionsTest < Test::Unit::TestCase
     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
+    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
+    end
+  end
+  
+  
   context "Converting conditions to criteria" do
     should "work with simple criteria" do
-      FinderOptions.new(:conditions => {:foo => 'bar'}).criteria.should == {
+      FinderOptions.to_mongo_criteria(:foo => 'bar').should == {
         :foo => 'bar'
       }
       
-      FinderOptions.new(:conditions => {:foo => 'bar', :baz => 'wick'}).criteria.should == {
+      FinderOptions.to_mongo_criteria(:foo => 'bar', :baz => 'wick').should == {
         :foo => 'bar', 
         :baz => 'wick'
       }
     end
     
     should "use $in for arrays" do
-      FinderOptions.new(:conditions => {:foo => [1,2,3]}).criteria.should == {
+      FinderOptions.to_mongo_criteria(:foo => [1,2,3]).should == {
         :foo => {'$in' => [1,2,3]}
       }
     end
     
     should "work arbitrarily deep" do
-      FinderOptions.new(:conditions => {:foo => {:bar => [1,2,3]}}).criteria.should == {
+      FinderOptions.to_mongo_criteria(:foo => {:bar => [1,2,3]}).should == {
         :foo => {:bar => {'$in' => [1,2,3]}}
       }
     end
@@ -43,21 +58,21 @@ class FinderOptionsTest < Test::Unit::TestCase
     should "single field with ascending direction" do
       hash = OrderedHash.new
       hash[:foo] = 1
-      FinderOptions.new(:order => 'foo asc').options[:sort].should == hash
-      FinderOptions.new(:order => 'foo ASC').options[:sort].should == hash
+      FinderOptions.to_mongo_options(:order => 'foo asc')[:sort].should == hash
+      FinderOptions.to_mongo_options(:order => 'foo ASC')[:sort].should == hash
     end
     
     should "single field with descending direction" do
       hash = OrderedHash.new
       hash[:foo] = -1
-      FinderOptions.new(:order => 'foo desc').options[:sort].should == hash
-      FinderOptions.new(:order => 'foo DESC').options[:sort].should == hash
+      FinderOptions.to_mongo_options(:order => 'foo desc')[:sort].should == hash
+      FinderOptions.to_mongo_options(:order => 'foo DESC')[:sort].should == hash
     end
     
     should "convert field without direction to ascending" do
       hash = OrderedHash.new
       hash[:foo] = 1
-      FinderOptions.new(:order => 'foo').options[:sort].should == hash
+      FinderOptions.to_mongo_options(:order => 'foo')[:sort].should == hash
     end
     
     should "convert multiple fields with directions" do
@@ -65,7 +80,7 @@ class FinderOptionsTest < Test::Unit::TestCase
       hash[:foo] = -1
       hash[:bar] = 1
       hash[:baz] = -1
-      options = FinderOptions.new(:order => 'foo desc, bar asc, baz desc').options[:sort].should == hash
+      FinderOptions.to_mongo_options(:order => 'foo desc, bar asc, baz desc')[:sort].should == hash
     end
     
     should "convert multiple fields with some missing directions" do
@@ -73,57 +88,57 @@ class FinderOptionsTest < Test::Unit::TestCase
       hash[:foo] = -1
       hash[:bar] = 1
       hash[:baz] = 1
-      options = FinderOptions.new(:order => 'foo desc, bar, baz').options[:sort].should == hash
+      FinderOptions.to_mongo_options(:order => 'foo desc, bar, baz')[:sort].should == hash
     end
   end
   
   context "offset" do
     should "default to 0" do
-      FinderOptions.new({}).options[:offset].should == 0
+      FinderOptions.to_mongo_options({})[:offset].should == 0
     end
     
     should "use offset provided" do
-      FinderOptions.new(:offset => 2).options[:offset].should == 2
+      FinderOptions.to_mongo_options(:offset => 2)[:offset].should == 2
     end
     
     should "covert string to integer" do
-      FinderOptions.new(:offset => '2').options[:offset].should == 2
+      FinderOptions.to_mongo_options(:offset => '2')[:offset].should == 2
     end
   end
   
   context "limit" do
     should "default to 0" do
-      FinderOptions.new({}).options[:limit].should == 0
+      FinderOptions.to_mongo_options({})[:limit].should == 0
     end
     
     should "use offset provided" do
-      FinderOptions.new(:limit => 2).options[:limit].should == 2
+      FinderOptions.to_mongo_options(:limit => 2)[:limit].should == 2
     end
     
     should "covert string to integer" do
-      FinderOptions.new(:limit => '2').options[:limit].should == 2
+      FinderOptions.to_mongo_options(:limit => '2')[:limit].should == 2
     end
   end
   
   context "fields" do
     should "default to nil" do
-      FinderOptions.new({}).options[:fields].should be(nil)
+      FinderOptions.to_mongo_options({})[:fields].should be(nil)
     end
     
     should "be converted to nil if empty string" do
-      FinderOptions.new(:fields => '').options[:fields].should be(nil)
+      FinderOptions.to_mongo_options(:fields => '')[:fields].should be(nil)
     end
     
     should "be converted to nil if []" do
-      FinderOptions.new(:fields => []).options[:fields].should be(nil)
+      FinderOptions.to_mongo_options(:fields => [])[:fields].should be(nil)
     end
     
     should "should work with array" do
-      FinderOptions.new({:fields => %w(a b)}).options[:fields].should == %w(a b)
+      FinderOptions.to_mongo_options({:fields => %w(a b)})[:fields].should == %w(a b)
     end
     
     should "convert comma separated list to array" do
-      FinderOptions.new({:fields => 'a, b'}).options[:fields].should == %w(a b)
+      FinderOptions.to_mongo_options({:fields => 'a, b'})[:fields].should == %w(a b)
     end
     
     should "also work as select" do

data/test/test_key.rb

@@ -2,7 +2,7 @@ require 'test_helper'
 
 class Address
   include MongoMapper::EmbeddedDocument
-  
+
   key :address, String
   key :city,    String
   key :state,   String
@@ -11,65 +11,65 @@ end
 
 class KeyTest < Test::Unit::TestCase
   include MongoMapper
-  
+
   context "The Key Class" do
     should "have the native types defined" do
-      Key::NativeTypes.should == [String, Float, Time, Integer, Boolean, Array, Hash]
+      Key::NativeTypes.should == [String, Float, Time, Integer, Boolean, Array, Hash, Ref]
     end
   end
-  
+
   context "Initializing a new key" do
     should "allow setting the name" do
       Key.new(:foo, String).name.should == 'foo'
     end
-    
+
     should "allow setting the type" do
       Key.new(:foo, Integer).type.should be(Integer)
     end
-    
+
     should "allow setting options" do
       Key.new(:foo, Integer, :required => true).options[:required].should be(true)
     end
-    
+
     should "symbolize option keys" do
       Key.new(:foo, Integer, 'required' => true).options[:required].should be(true)
     end
   end
-  
+
   context "A key" do
     should "be equal to another key with same name and type" do
       Key.new(:name, String).should == Key.new(:name, String)
     end
-    
+
     should "not be equal to another key with different name" do
       Key.new(:name, String).should_not == Key.new(:foo, String)
     end
-    
+
     should "not be equal to another key with different type" do
       Key.new(:name, String).should_not == Key.new(:name, Integer)
     end
-    
+
     should "know if it is native" do
       Key.new(:name, String).native?.should be_true
     end
-    
+
     should "know if it is not native" do
       klass = Class.new
       Key.new(:name, klass).native?.should be_false
     end
-    
+
     should "know if it is a embedded_document" do
       klass = Class.new do
         include MongoMapper::EmbeddedDocument
       end
       Key.new(:name, klass).embedded_document?.should be_true
     end
-    
+
     should "know if it is not a embedded_document" do
       Key.new(:name, String).embedded_document?.should be_false
     end
   end
-  
+
   context "setting a value" do
     should "correctly typecast Strings" do
       key = Key.new(:foo, String)
@@ -101,25 +101,25 @@ class KeyTest < Test::Unit::TestCase
       key = Key.new(:foo, Date)
       key.set('2000-01-01').should == Date.new(2000, 1, 1)
     end
-    
+
     should "correctly typecast Boolean" do
       key = Key.new(:foo, Boolean)
       ['false', false, 'f', '0', 0].each do |b|
         key.set(b).should == false
       end
-      
+
       ['true', true, 't', '1', 1].each do |b|
         key.set(b).should == true
       end
     end
-    
+
     should "correctly typecast Array" do
       key = Key.new(:foo, Array)
       key.set([1,2,3,4]).should == [1,2,3,4]
       key.set({'1' => '2', '3' => '4'}).should == [['1', '2'], ['3', '4']]
       key.set('1').should == ['1']
     end
-    
+
     should "correctly typecast Hash using indifferent access" do
       key = Key.new(:foo, Hash)
       key.set(:foo => 'bar')[:foo].should == 'bar'
@@ -128,13 +128,13 @@ class KeyTest < Test::Unit::TestCase
       key.set(:foo => {:bar => 'baz'})['foo']['bar'].should == 'baz'
     end
   end
-  
+
   context "getting a value" do
     should "work" do
       key = Key.new(:foo, String)
       key.get('bar').should == 'bar'
     end
-    
+
     context "for a key with a default value set" do
       setup do
         @key = Key.new(:foo, String, :default => 'baz')
@@ -143,34 +143,34 @@ class KeyTest < Test::Unit::TestCase
       should "return default value if value nil" do
         @key.get(nil).should == 'baz'
       end
-      
+
       should "return value if not blank" do
         @key.get('foobar').should == 'foobar'
       end
     end
-    
+
     context "for a boolean key" do
       should "allow setting default to false" do
         Key.new(:active, Boolean, :default => false).get(nil).should be_false
       end
-      
+
       should "allow setting default to true" do
         Key.new(:active, Boolean, :default => true).get(nil).should be_true
       end
     end
-    
+
     context "for an array" do
       should "return array" do
         key = Key.new(:foo, Array)
         key.get([1,2]).should == [1,2]
       end
-      
+
       should "default to empty array" do
         key = Key.new(:foo, Array)
         key.get(nil).should == []
       end
     end
-    
+
     context "for a hash" do
       should "default to empty hash" do
         key = Key.new(:foo, Hash)
@@ -183,13 +183,13 @@ class KeyTest < Test::Unit::TestCase
         key.get({:foo => 'bar'})[:foo].should == 'bar'
       end
     end
-    
+
     context "for a embedded_document" do
-      should "default to nil" do        
+      should "default to nil" do
         key = Key.new(:foo, Address)
         key.get(nil).should be_nil
       end
-      
+
       should "return instance if instance" do
         address = Address.new(:city => 'South Bend', :state => 'IN', :zip => 46544)
         key = Key.new(:foo, Address)