mongo_mapper-unstable 2010.1.6 → 2010.1.12

data/test/functional/test_document.rb

@@ -593,7 +593,15 @@ class DocumentTest < Test::Unit::TestCase
     end
 
     should "allow to use custom methods to assign properties" do
-      person = RealPerson.new(:realname => 'David')
+      klass = Doc do
+        key :name, String
+        
+        def realname=(value)
+          self.name = value
+        end
+      end
+      
+      person = klass.new(:realname => 'David')
       person.save
       person.reload.name.should == 'David'
     end
@@ -713,17 +721,12 @@ class DocumentTest < Test::Unit::TestCase
       end
     end
 
-    should "insert document" do
+    should "insert invalid document" do
       doc = @document.new
+      doc.expects(:valid?).never
       doc.save(:validate => false)
       @document.count.should == 1
     end
-    
-    should "work with false passed to save" do
-      doc = @document.new
-      doc.save(false)
-      @document.count.should == 1
-    end
   end
   
   context "#save (with options)" do
@@ -956,11 +959,19 @@ class DocumentTest < Test::Unit::TestCase
 
   context "timestamping" do
     setup do
-      @document.timestamps!
+      @klass = Doc do
+        set_collection_name 'users'
+
+        key :first_name, String
+        key :last_name, String
+        key :age, Integer
+        key :date, Date
+      end
+      @klass.timestamps!
     end
 
     should "set created_at and updated_at on create" do
-      doc = @document.new(:first_name => 'John', :age => 27)
+      doc = @klass.new(:first_name => 'John', :age => 27)
       doc.created_at.should be(nil)
       doc.updated_at.should be(nil)
       doc.save
@@ -970,7 +981,7 @@ class DocumentTest < Test::Unit::TestCase
     
     should "not overwrite created_at if it already exists" do
       original_created_at = 1.month.ago
-      doc = @document.new(:first_name => 'John', :age => 27, :created_at => original_created_at)
+      doc = @klass.new(:first_name => 'John', :age => 27, :created_at => original_created_at)
       doc.created_at.to_i.should == original_created_at.to_i
       doc.updated_at.should be_nil
       doc.save
@@ -979,7 +990,7 @@ class DocumentTest < Test::Unit::TestCase
     end
 
     should "set updated_at on field update but leave created_at alone" do
-      doc = @document.create(:first_name => 'John', :age => 27)
+      doc = @klass.create(:first_name => 'John', :age => 27)
       old_created_at = doc.created_at
       old_updated_at = doc.updated_at
       doc.first_name = 'Johnny'
@@ -993,12 +1004,12 @@ class DocumentTest < Test::Unit::TestCase
     end
 
     should "set updated_at on document update but leave created_at alone" do
-      doc = @document.create(:first_name => 'John', :age => 27)
+      doc = @klass.create(:first_name => 'John', :age => 27)
       old_created_at = doc.created_at
       old_updated_at = doc.updated_at
 
       Timecop.freeze(Time.now + 5.seconds) do
-        @document.update(doc._id, { :first_name => 'Johnny' })
+        @klass.update(doc._id, { :first_name => 'Johnny' })
       end
 
       doc = doc.reload
@@ -1094,16 +1105,6 @@ class DocumentTest < Test::Unit::TestCase
       @instance.reload.object_id.should == @instance.object_id
     end
   end
-  
-  context "Saving a document with a custom id" do
-    should "clear custom id flag when saved" do
-      @document.key :_id, String
-      doc = @document.new(:id => '1234')
-      doc.using_custom_id?.should be_true
-      doc.save.should be_true
-      doc.using_custom_id?.should be_false
-    end
-  end
 
   context "Loading a document from the database with keys that are not defined" do
     setup do
@@ -1164,7 +1165,6 @@ class DocumentTest < Test::Unit::TestCase
     should "work with :index shortcut when defining key" do
       @document.key :father, String, :index => true
       MongoMapper.ensure_indexes!
-
       @document.should have_index('father_1')
     end
   end

data/test/functional/test_embedded_document.rb

@@ -3,21 +3,29 @@ require 'models'
 
 class EmbeddedDocumentTest < Test::Unit::TestCase
   def setup
-    @document = Doc do
-      set_collection_name 'users'
+    @klass = Doc do
       key :first_name, String
       key :last_name, String
     end
+    
+    @pet_klass = EDoc do
+      key :name, String
+    end
+    
+    @klass.many :pets, :class => @pet_klass
+    
+    @address_class = EDoc do
+      key :city, String
+      key :state, String
+    end
   end
     
   context "Saving a document with an embedded document" do
     setup do
-      @document.class_eval do
-        key :foo, Address
-      end
+      @klass.key :foo, @address_class
       
-      @address = Address.new(:city => 'South Bend', :state => 'IN')
-      @doc = @document.new(:foo => @address)
+      @address = @address_class.new(:city => 'South Bend', :state => 'IN')
+      @doc = @klass.new(:foo => @address)
     end
     
     should "embed embedded document" do
@@ -42,27 +50,25 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
   
   context "new?" do
     setup do
-      @document.class_eval do
-        key :foo, Address
-      end
+      @klass.key :foo, @address_class
     end
 
     should "be new until document is saved" do
-      address = Address.new(:city => 'South Bend', :state => 'IN')
-      doc = @document.new(:foo => address)
+      address = @address_class.new(:city => 'South Bend', :state => 'IN')
+      doc = @klass.new(:foo => address)
       address.new?.should == true
     end
     
     should "not be new after document is saved" do
-      address = Address.new(:city => 'South Bend', :state => 'IN')
-      doc = @document.new(:foo => address)
+      address = @address_class.new(:city => 'South Bend', :state => 'IN')
+      doc = @klass.new(:foo => address)
       doc.save
       doc.foo.new?.should == false
     end
     
     should "not be new when document is read back" do
-      address = Address.new(:city => 'South Bend', :state => 'IN')
-      doc = @document.new(:foo => address)
+      address = @address_class.new(:city => 'South Bend', :state => 'IN')
+      doc = @klass.new(:foo => address)
       doc.save
       
       doc = doc.reload
@@ -70,53 +76,50 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
     end
   end
   
-  context "save" do
-    should "save the root document" do
-      person = RealPerson.create
-
-      pet = Pet.new :name => 'sparky'
-      person.pets << pet
-      pet.save
-
-      person = person.reload
-      person.pets.first.should == pet
-    end
+  should "be able to save" do
+    person = @klass.create
     
-    should "save new keys" do
-      person = RealPerson.new
-      person[:new_attribute] = 'foobar'
-      person.save
-      
-      person = person.reload
-      person.new_attribute.should == 'foobar'
-    end
+    pet = @pet_klass.new(:name => 'sparky')
+    person.pets << pet
+    pet.should be_new
+    pet.save
+    pet.should_not be_new
+    
+    person.reload
+    person.pets.first.should == pet
   end
   
-  context "update_attributes" do
-    should "save the root document" do
-      person = RealPerson.create
-
-      pet = Pet.new(:name => 'sparky')
-      person.pets << pet
-      pet.save
-
-      person = person.reload
-      pet = person.pets.first
-      pet.update_attributes :name => 'koda'
-
-      person = person.reload
-      person.pets.first._id.should == pet._id
-      person.pets.first.name.should == 'koda'
-    end
-  end  
-
-  context "update_attributes!" do
-    should "pass the attributes to self.attributes" do
-      person = RealPerson.create
-      attributes = { :foo => 'bar' }
-      person.expects(:attributes=).with(attributes)
-      person.expects(:save!)
-      person.update_attributes!(attributes)
-    end
-  end  
-end
+  should "be able to dynamically add new keys and save" do
+    person = @klass.create
+    
+    pet = @pet_klass.new(:name => 'sparky', :crazy_key => 'crazy')
+    person.pets << pet
+    pet.save
+    
+    person.reload
+    person.pets.first.crazy_key.should == 'crazy'
+  end
+  
+  should "be able to update_attributes" do
+    pet = @pet_klass.new(:name => 'sparky')
+    person = @klass.create(:pets => [pet])
+    person.reload
+    pet = person.pets.first
+    
+    pet.update_attributes(:name => 'koda').should be_true
+    person.reload
+    person.pets.first._id.should == pet._id
+    person.pets.first.name.should == 'koda'
+  end
+  
+  should "be able to update_attributes!" do
+    person = @klass.create(:pets => [@pet_klass.new(:name => 'sparky')])
+    person.reload
+    pet = person.pets.first
+    
+    attributes = {:name => 'koda'}
+    pet.expects(:attributes=).with(attributes)
+    pet.expects(:save!)
+    pet.update_attributes!(attributes)
+  end
+end

data/test/functional/test_identity_map.rb

@@ -0,0 +1,233 @@
+require 'test_helper'
+
+class IdentityMapTest < Test::Unit::TestCase
+  def assert_in_map(resource)
+    resource.identity_map.keys.should include(resource.identity_map_key)
+    mapped_resource = resource.identity_map[resource.identity_map_key]
+    resource.object_id.should == mapped_resource.object_id
+  end
+  
+  def assert_not_in_map(resource)
+    resource.identity_map.keys.should_not include(resource.identity_map_key)
+  end
+  
+  context "Document" do
+    setup do
+      @person_class = Doc('Person') do
+        key :name, String
+        plugin MongoMapper::Plugins::IdentityMap
+      end
+      
+      @post_class = Doc('Post') do
+        key :title, String
+        plugin MongoMapper::Plugins::IdentityMap
+      end
+      
+      @person_class.identity_map = {}
+      @post_class.identity_map   = {}
+    end
+
+    should "default identity map to hash" do
+      Doc() do
+        plugin MongoMapper::Plugins::IdentityMap
+      end.identity_map.should == {}
+    end
+
+    should "share identity map with other classes" do
+      map = @post_class.identity_map
+      map.object_id.should == @person_class.identity_map.object_id
+    end
+
+    should "have identity map key that is always unique per document and class" do
+      person = @person_class.new
+      person.identity_map_key.should == "Person:#{person.id}"
+      @person_class.identity_map_key(person.id).should == person.identity_map_key
+
+      post = @post_class.new
+      post.identity_map_key.should == "Post:#{post.id}"
+      @post_class.identity_map_key(post.id).should == post.identity_map_key
+
+      person.identity_map_key.should_not == post.identity_map_key
+    end
+
+    should "add key to map when saved" do
+      person = @person_class.new
+      assert_not_in_map(person)
+      person.save.should be_true
+      assert_in_map(person)
+    end
+
+    should "remove key from map when deleted" do
+      person = @person_class.create(:name => 'Fred')
+      assert_in_map(person)
+      person.destroy
+      assert_not_in_map(person)
+    end
+    
+    context "#load" do
+      setup do
+        @id = Mongo::ObjectID.new
+      end
+      
+      should "add document to map with _id key as symbol" do
+        loaded = @person_class.load({:_id => @id, :name => 'Frank'})
+        assert_in_map(loaded)
+      end
+      
+      should "add document to map with _id key as string" do
+        loaded = @person_class.load({'_id' => @id, :name => 'Frank'})
+        assert_in_map(loaded)
+      end
+      
+      should "add document to map with id key as symbol" do
+        loaded = @person_class.load({:id => @id, :name => 'Frank'})
+        assert_in_map(loaded)
+      end
+      
+      should "add document to map with id key as string" do
+        loaded = @person_class.load({'id' => @id, :name => 'Frank'})
+        assert_in_map(loaded)
+      end
+      
+      should "return document if already in map" do
+        first_load = @person_class.load({:_id => @id, :name => 'Frank'})
+        @person_class.identity_map.expects(:[]=).never
+        second_load = @person_class.load({:_id => @id, :name => 'Frank'})
+        first_load.object_id.should == second_load.object_id
+      end
+    end
+    
+    context "#find (with one id)" do
+      context "for object not in map" do
+        setup do
+          @person = @person_class.create(:name => 'Fred')
+          @person_class.identity_map.clear
+        end
+
+        should "query the database" do
+          Mongo::Collection.any_instance.expects(:find_one).once
+          @person_class.find(@person.id)
+        end
+
+        should "add object to map" do
+          assert_not_in_map(@person)
+          found_person = @person_class.find(@person.id)
+          assert_in_map(found_person)
+        end
+      end
+
+      context "for object in map" do
+        setup do
+          @person = @person_class.create(:name => 'Fred')
+        end
+
+        should "not query database" do
+          Mongo::Collection.any_instance.expects(:find).never
+          Mongo::Collection.any_instance.expects(:find_one).never
+          @person_class.find(@person.id)
+        end
+        
+        should "return exact object" do
+          assert_in_map(@person)
+          found_person = @person_class.find(@person.id)
+          found_person.object_id.should == @person.object_id
+        end
+      end
+    end
+    
+    context "#find (with multiple ids)" do
+      should "add all documents to map" do
+        person1 = @person_class.create(:name => 'Fred')
+        person2 = @person_class.create(:name => 'Bill')
+        person3 = @person_class.create(:name => 'Jesse')
+        @person_class.identity_map.clear
+
+        people = @person_class.find(person1.id, person2.id, person3.id)
+        people.each { |person| assert_in_map(person) }
+      end
+
+      should "add missing documents to map and return existing ones" do
+        person1 = @person_class.create(:name => 'Fred')
+        @person_class.identity_map.clear
+        person2 = @person_class.create(:name => 'Bill')
+        person3 = @person_class.create(:name => 'Jesse')
+
+        assert_not_in_map(person1)
+        assert_in_map(person2)
+        assert_in_map(person3)
+
+        people = @person_class.find(person1.id, person2.id, person3.id)
+        assert_in_map(people.first) # making sure one that wasn't mapped now is
+        assert_in_map(person2)
+        assert_in_map(person3)
+      end
+    end
+    
+    context "#first" do
+      context "for object not in map" do
+        setup do
+          @person = @person_class.create(:name => 'Fred')
+          @person_class.identity_map.clear
+        end
+
+        should "query the database" do
+          Mongo::Collection.any_instance.expects(:find_one).once
+          @person_class.first(:_id => @person.id)
+        end
+
+        should "add object to map" do
+          assert_not_in_map(@person)
+          found_person = @person_class.first(:_id => @person.id)
+          assert_in_map(found_person)
+        end
+      end
+
+      context "for object in map" do
+        setup do
+          @person = @person_class.create(:name => 'Fred')
+        end
+
+        should "not query database" do
+          Mongo::Collection.any_instance.expects(:find).never
+          Mongo::Collection.any_instance.expects(:find_one).never
+          @person_class.first(:_id => @person.id)
+        end
+        
+        should "return exact object" do
+          assert_in_map(@person)
+          found_person = @person_class.first(:_id => @person.id)
+          found_person.object_id.should == @person.object_id
+        end
+      end
+    end
+    
+    context "#all" do
+      should "add all documents to map" do
+        person1 = @person_class.create(:name => 'Fred')
+        person2 = @person_class.create(:name => 'Bill')
+        person3 = @person_class.create(:name => 'Jesse')
+        @person_class.identity_map.clear
+
+        people = @person_class.all(:_id => [person1.id, person2.id, person3.id])
+        people.each { |person| assert_in_map(person) }
+      end
+
+      should "add missing documents to map and return existing ones" do
+        person1 = @person_class.create(:name => 'Fred')
+        @person_class.identity_map.clear
+        person2 = @person_class.create(:name => 'Bill')
+        person3 = @person_class.create(:name => 'Jesse')
+
+        assert_not_in_map(person1)
+        assert_in_map(person2)
+        assert_in_map(person3)
+
+        people = @person_class.all(:_id => [person1.id, person2.id, person3.id])
+        assert_in_map(people.first) # making sure one that wasn't mapped now is
+        assert_in_map(person2)
+        assert_in_map(person3)
+      end
+    end
+    
+  end
+end

data/test/functional/test_modifiers.rb

@@ -235,4 +235,18 @@ class ModifierTest < Test::Unit::TestCase
     page2.reload
     page.tags.should == %w(foo)
   end
+  
+  should "be able to remove the last element the array" do
+    page  = @page_class.create(:title => 'Home', :tags => %w(foo bar))
+    @page_class.pop(page.id, :tags => 1)
+    page.reload
+    page.tags.should == %w(foo)
+  end
+
+  should "be able to remove the first element of the array" do
+    page  = @page_class.create(:title => 'Home', :tags => %w(foo bar))
+    @page_class.pop(page.id, :tags => -1)
+    page.reload
+    page.tags.should == %w(bar)
+  end
 end

data/test/functional/test_string_id_compatibility.rb

@@ -19,7 +19,7 @@ class StringIdCompatibilityTest < Test::Unit::TestCase
     
     @task_class.belongs_to :project, :class => @project_class
     @project_class.many :notes, :class => @note_class
-    @project_class.many :tasks, :class => @task_class, :foreign_key => 'project_id'
+    @project_class.many :tasks, :class => @task_class, :foreign_key => 'project_id', :order => :position.asc
   end
   
   should "assign correct _id for documents" do
@@ -55,9 +55,9 @@ class StringIdCompatibilityTest < Test::Unit::TestCase
   end
   
   should "be able to associate records" do
-    t1 = @task_class.new(:body => 'First task')
-    t2 = @task_class.new(:body => 'Second task')
-    t3 = @task_class.new(:body => 'Third task')
+    t1 = @task_class.new(:body => 'First task', :position => 1)
+    t2 = @task_class.new(:body => 'Second task', :position => 2)
+    t3 = @task_class.new(:body => 'Third task', :position => 3)
     project = @project_class.create(:name => 'MM', :tasks => [t1, t2, t3])
     
     project = project.reload

data/test/functional/test_validations.rb

@@ -186,6 +186,19 @@ class ValidationsTest < Test::Unit::TestCase
       doc2.should_not have_error_on(:name)
     end
 
+    should "allow multiple nil entries if :allow_nil => true" do
+      document = Doc do
+        key :name
+        validates_uniqueness_of :name, :allow_nil => :true
+      end
+
+      doc = document.new('name' => nil)
+      doc.save.should be_true
+
+      doc2 = document.new('name' => nil)
+      doc2.should_not have_error_on(:name)
+    end
+
     should "allow entries that differ only in case by default" do
       document = Doc do
         key :name

data/test/models.rb

@@ -109,12 +109,6 @@ class Answer
   key :body, String
 end
 
-module PeopleExtensions
-  def find_by_name(name)
-    detect { |p| p.name == name }
-  end
-end
-
 module CollaboratorsExtensions
   def top
     first
@@ -126,9 +120,7 @@ class Project
 
   key :name, String
   
-  many :people, :extend => PeopleExtensions
   many :collaborators, :extend => CollaboratorsExtensions
-  
   many :statuses, :order => 'position' do
     def open
       all(:name => %w(New Assigned))
@@ -163,37 +155,6 @@ class Status
   belongs_to :target, :polymorphic => true
 end
 
-class RealPerson
-  include MongoMapper::Document
-
-  key :room_id, ObjectId
-  key :name, String
-  
-  belongs_to :room
-  
-  many :pets
-  
-  def realname=(n)
-    self.name = n
-  end
-end
-
-class Person
-  include MongoMapper::EmbeddedDocument
-
-  key :name, String
-  key :child, Person
-
-  many :pets
-end
-
-class Pet
-  include MongoMapper::EmbeddedDocument
-
-  key :name, String
-  key :species, String
-end
-
 class Media
   include MongoMapper::EmbeddedDocument
 

data/test/test_helper.rb

@@ -38,10 +38,16 @@ class Test::Unit::TestCase
     klass
   end
   
-  def EDoc(&block)
+  def EDoc(name=nil, &block)
     Class.new do
       include MongoMapper::EmbeddedDocument
-      instance_eval(&block) if block_given?
+      
+      if name
+        class_eval "def self.name; '#{name}' end"
+        class_eval "def self.to_s; '#{name}' end"
+      end
+      
+      class_eval(&block) if block_given?
     end
   end
 end

data/test/unit/associations/test_base.rb

@@ -4,7 +4,7 @@ require 'models'
 class FooMonster; end
 
 class AssociationBaseTest < Test::Unit::TestCase
-  include MongoMapper::Associations
+  include MongoMapper::Plugins::Associations
   
   should "initialize with type and name" do
     base = Base.new(:many, :foos)

data/test/unit/associations/test_proxy.rb

@@ -1,14 +1,14 @@
 require 'test_helper'
 
-class FakeNilProxy < MongoMapper::Associations::Proxy
+class FakeNilProxy < MongoMapper::Plugins::Associations::Proxy
   def find_target; nil end
 end
 
-class FakeBlankProxy < MongoMapper::Associations::Proxy
+class FakeBlankProxy < MongoMapper::Plugins::Associations::Proxy
   def find_target; '' end
 end
 
-class FakeProxy < MongoMapper::Associations::Proxy
+class FakeProxy < MongoMapper::Plugins::Associations::Proxy
   def find_target
     [1, 2]
   end