mongo_mapper-unstable 2010.1.22 → 2010.1.25

data/VERSION

@@ -1 +1 @@
-2010.01.22
+2010.01.25

data/lib/mongo_mapper/document.rb

@@ -90,6 +90,13 @@ module MongoMapper
         collection.find(to_criteria(options)).count
       end
 
+      def find_each(options={})
+        criteria, options = to_finder_options(options)
+        collection.find(criteria, options).each do |doc|
+          yield load(doc)
+        end
+      end
+
       def exists?(options={})
         !count(options).zero?
       end
@@ -343,13 +350,14 @@ module MongoMapper
       end
 
       def save(options={})
+        options.assert_valid_keys(:validate, :safe)
         options.reverse_merge!(:validate => true)
-        perform_validations = options.delete(:validate)
-        !perform_validations || valid? ? create_or_update(options) : false
+        !options[:validate] || valid? ? create_or_update(options) : false
       end
 
-      def save!
-        save || raise(DocumentNotValid.new(self))
+      def save!(options={})
+        options.assert_valid_keys(:safe)
+        save(options) || raise(DocumentNotValid.new(self))
       end
       
       def update_attributes(attrs={})

data/lib/mongo_mapper/plugins.rb

@@ -5,14 +5,9 @@ module MongoMapper
     end
     
     def plugin(mod)
-      if mod.const_defined?(:ClassMethods)
-        extend mod::ClassMethods
-      end
-      
-      if mod.const_defined?(:InstanceMethods)
-        include mod::InstanceMethods
-      end
-      
+      extend mod::ClassMethods     if mod.const_defined?(:ClassMethods)
+      include mod::InstanceMethods if mod.const_defined?(:InstanceMethods)
+      mod.configure(self)          if mod.respond_to?(:configure)
       plugins << mod
     end
   end

data/lib/mongo_mapper/plugins/callbacks.rb

@@ -1,23 +1,23 @@
 module MongoMapper
   module Plugins
     module Callbacks
-      module InstanceMethods
-        def self.included(model)
-          model.class_eval do
-            include ActiveSupport::Callbacks
+      def self.configure(model)
+        model.class_eval do
+          include ActiveSupport::Callbacks
 
-            define_callbacks(
-              :before_save, :after_save, 
-              :before_create, :after_create, 
-              :before_update, :after_update, 
-              :before_validation, :after_validation, 
-              :before_validation_on_create, :after_validation_on_create, 
-              :before_validation_on_update, :after_validation_on_update, 
-              :before_destroy, :after_destroy
-            )
-          end
+          define_callbacks(
+            :before_save, :after_save, 
+            :before_create, :after_create, 
+            :before_update, :after_update, 
+            :before_validation, :after_validation, 
+            :before_validation_on_create, :after_validation_on_create, 
+            :before_validation_on_update, :after_validation_on_update, 
+            :before_destroy, :after_destroy
+          )
         end
-        
+      end
+      
+      module InstanceMethods
         def valid?
           action = new? ? 'create' : 'update'
 

data/lib/mongo_mapper/plugins/equality.rb

@@ -5,6 +5,18 @@ module MongoMapper
         def ==(other)
           other.is_a?(self.class) && _id == other._id
         end
+        
+        def eql?(other)
+          self == other
+        end
+        
+        def equal?(other)
+          object_id === other.object_id
+        end
+        
+        def hash
+          _id.hash
+        end
       end
     end
   end

data/lib/mongo_mapper/plugins/identity_map.rb

@@ -1,40 +1,40 @@
 module MongoMapper
   module Plugins
     module IdentityMap
-      def self.identity_map
-        Thread.current[:mongo_mapper_identity_map] ||= {}
+      def self.models
+        @models ||= Set.new
       end
-      
-      def self.identity_map=(v)
-        Thread.current[:mongo_mapper_identity_map] = v
+
+      def self.clear
+        models.each { |m| m.identity_map.clear }
       end
       
+      def self.configure(model)
+        IdentityMap.models << model
+      end
+
       module ClassMethods
-        def identity_map
-          IdentityMap.identity_map
+        def inherited(descendant)
+          descendant.identity_map = identity_map
+          super
         end
 
-        def identity_map=(v)
-          IdentityMap.identity_map = v
+        def identity_map
+          @identity_map ||= {}
         end
 
-        def identity_map_key(id)
-          "#{collection.name}:#{id}"
+        def identity_map=(v)
+          @identity_map = v
         end
 
         def find_one(options={})
-          criteria, finder_options   = to_finder_options(options)
-          document_in_map            = identity_map[identity_map_key(criteria[:_id])]
-          find_by_single_id          = criteria.keys == [:_id]
-          find_by_single_id_with_sci = criteria.keys.to_set == [:_id, :_type].to_set
-          
-          if find_by_single_id && document_in_map
-            document_in_map
-          elsif find_by_single_id_with_sci && document_in_map
-            document_in_map
+          criteria, finder_options = to_finder_options(options)
+
+          if simple_find?(criteria) && identity_map.key?(criteria[:_id])
+            identity_map[criteria[:_id]]
           else
             super.tap do |document|
-              remove_documents_from_map(document) unless finder_options[:fields].nil?
+              remove_documents_from_map(document) if selecting_fields?(finder_options)
             end
           end
         end
@@ -42,46 +42,78 @@ module MongoMapper
         def find_many(options)
           criteria, finder_options = to_finder_options(options)
           super.tap do |documents|
-            remove_documents_from_map(documents) unless finder_options[:fields].nil?
+            remove_documents_from_map(documents) if selecting_fields?(finder_options)
           end
         end
 
         def load(attrs)
-          key = identity_map_key(attrs['_id'])
-          unless document = identity_map[key]
+          document = identity_map[attrs['_id']]
+          
+          if document.nil? || identity_map_off?
             document = super
-            identity_map[document.identity_map_key] = document
+            identity_map[document._id] = document if identity_map_on?
           end
 
           document
         end
-        
+
+        def identity_map_status
+          defined?(@identity_map_status) ? @identity_map_status : true
+        end
+
+        def identity_map_on
+          @identity_map_status = true
+        end
+
+        def identity_map_off
+          @identity_map_status = false
+        end
+
+        def identity_map_on?
+          identity_map_status
+        end
+
+        def identity_map_off?
+          !identity_map_on?
+        end
+
+        def without_identity_map(&block)
+          identity_map_off
+          yield
+        ensure
+          identity_map_on
+        end
+
         private
           def remove_documents_from_map(*documents)
             documents.flatten.compact.each do |document|
-              identity_map.delete(identity_map_key(document._id))
+              identity_map.delete(document._id)
             end
           end
+
+          def simple_find?(criteria)
+            criteria.keys == [:_id] || criteria.keys.to_set == [:_id, :_type].to_set
+          end
+
+          def selecting_fields?(options)
+            !options[:fields].nil?
+          end
       end
 
       module InstanceMethods
-        def identity_map_key
-          @identity_map_key ||= self.class.identity_map_key(_id)
-        end
-
         def identity_map
           self.class.identity_map
         end
 
         def save(*args)
           if result = super
-            identity_map[identity_map_key] = self
+            identity_map[_id] = self if self.class.identity_map_on?
           end
           result
         end
 
         def delete
-          identity_map.delete(identity_map_key)
+          identity_map.delete(_id) if self.class.identity_map_on?
           super
         end
       end

data/lib/mongo_mapper/plugins/keys.rb

@@ -1,6 +1,10 @@
 module MongoMapper
   module Plugins
     module Keys
+      def self.configure(model)
+        model.key :_id, ObjectId
+      end
+      
       module ClassMethods
         def inherited(descendant)
           descendant.instance_variable_set(:@keys, keys.dup)
@@ -133,10 +137,6 @@ module MongoMapper
       end
       
       module InstanceMethods
-        def self.included(model)
-          model.key :_id, ObjectId
-        end
-        
         def initialize(attrs={}, from_db=false)
           unless attrs.nil?
             provided_keys = attrs.keys.map { |k| k.to_s }

data/lib/mongo_mapper/plugins/serialization.rb

@@ -3,6 +3,10 @@ require 'active_support/json'
 module MongoMapper
   module Plugins
     module Serialization
+      def self.configure(model)
+        model.class_eval { include Json }
+      end
+      
       class Serializer
         attr_reader :options
 
@@ -96,14 +100,6 @@ module MongoMapper
             options[:except] = except
           end
       end
-      
-      module InstanceMethods
-        def self.included(model)
-          model.class_eval do
-            include Json
-          end
-        end
-      end
     end
   end
 end

data/lib/mongo_mapper/plugins/validations.rb

@@ -1,10 +1,8 @@
 module MongoMapper
   module Plugins
     module Validations
-      module InstanceMethods
-        def self.included(model)
-          model.class_eval { include Validatable }
-        end
+      def self.configure(model)
+        model.class_eval { include Validatable }
       end
       
       module DocumentMacros

data/test/functional/associations/test_belongs_to_proxy.rb

@@ -15,6 +15,14 @@ class BelongsToProxyTest < Test::Unit::TestCase
     @comment_class.new.post.nil?.should be_true
   end
   
+  should "send object id to target" do
+    post = @post_class.new(:name => 'mongomapper')
+    comment = @comment_class.new(:name => 'Foo!', :post => post)
+    comment.save
+    
+    comment.post.object_id.should == comment.post.target.object_id
+  end
+  
   should "have boolean presence method" do
     comment = @comment_class.new(:name => 'Foo!')
     comment.post?.should be_false

data/test/functional/associations/test_one_proxy.rb

@@ -13,6 +13,18 @@ class OneProxyTest < Test::Unit::TestCase
     @post_class.new.author.nil?.should be_true
   end
   
+  should "send object id to target" do
+    @post_class.one :author, :class => @author_class
+    
+    post = @post_class.new
+    author = @author_class.new(:name => 'Frank')
+    post.author = author
+    author.save.should be_true
+    post.save.should be_true
+    
+    post.author.object_id.should == post.author.target.object_id
+  end
+  
   should "be able to replace the association" do
     @post_class.one :author, :class => @author_class
     

data/test/functional/test_document.rb

@@ -338,6 +338,18 @@ class DocumentTest < Test::Unit::TestCase
       end
     end
 
+    context "#find_each" do
+      should "yield all documents found, based on criteria" do
+        yield_documents = []
+        @document.find_each(:order => "first_name") {|doc| yield_documents << doc }
+        yield_documents.should == [@doc1, @doc3, @doc2]
+
+        yield_documents = []
+        @document.find_each(:last_name => 'Nunemaker', :order => 'age desc') {|doc| yield_documents << doc }
+        yield_documents.should == [@doc1, @doc3]
+      end
+    end
+
     context "dynamic finders" do
       should "find document based on all arguments" do
         @document.find_by_first_name_and_last_name_and_age('John', 'Nunemaker', 27).should == @doc1
@@ -751,6 +763,47 @@ class DocumentTest < Test::Unit::TestCase
         @document.new(:name => 'John').save(:safe => true)
       end
     end
+    
+    should "raise argument error if options has unsupported key" do
+      doc = @document.new
+      assert_raises(ArgumentError) { doc.save(:foo => true) }
+    end
+  end
+  
+  context "#save! (with options)" do
+    setup do
+      MongoMapper.ensured_indexes = []
+      
+      @document = Doc do
+        key :name, String
+        set_collection_name 'test_indexes'
+        ensure_index :name, :unique => true
+      end
+      
+      if @document.database.collection_names.include?(@document.collection.name)
+        @document.collection.drop_indexes
+      end
+      
+      MongoMapper.ensure_indexes!
+    end
+    
+    should "allow passing safe" do
+      doc = @document.create(:name => 'John')
+      
+      assert_raises(Mongo::OperationFailure) do
+        @document.new(:name => 'John').save!(:safe => true)
+      end
+    end
+    
+    should "raise argument error if options has unsupported key" do
+      doc = @document.new
+      assert_raises(ArgumentError) { doc.save!(:foo => true) }
+    end
+    
+    should "raise argument error if using validate as that would be pointless with save!" do
+      doc = @document.new
+      assert_raises(ArgumentError) { doc.save!(:validate => false) }
+    end
   end
 
   context "#destroy" do

data/test/functional/test_identity_map.rb

@@ -1,34 +1,40 @@
 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
+  def assert_in_map(*resources)
+    [resources].flatten.each do |resource|
+      resource.identity_map.keys.should include(resource._id)
+      mapped_resource = resource.identity_map[resource._id]
+      resource.should equal(mapped_resource)
+    end
   end
-  
-  def assert_not_in_map(resource)
-    resource.identity_map.keys.should_not include(resource.identity_map_key)
+
+  def assert_not_in_map(*resources)
+    [resources].flatten.each do |resource|
+      resource.identity_map.keys.should_not include(resource._id)
+    end
   end
-  
+
   def expect_no_queries
     Mongo::Collection.any_instance.expects(:find_one).never
     Mongo::Collection.any_instance.expects(:find).never
   end
-  
+
   def expects_one_query
     Mongo::Collection.any_instance.expects(:find_one).once.returns({})
   end
-  
+
   context "Document" do
     setup do
+      MongoMapper::Plugins::IdentityMap.models.clear
+
       @person_class = Doc('Person') do
         set_collection_name 'people'
         plugin MongoMapper::Plugins::IdentityMap
         
         key :name, String
       end
-      
+
       @post_class = Doc('Post') do
         set_collection_name 'posts'
         plugin MongoMapper::Plugins::IdentityMap
@@ -36,35 +42,62 @@ class IdentityMapTest < Test::Unit::TestCase
         key :title, String
         key :person_id, ObjectId
       end
-      
+
       @post_class.belongs_to :person, :class => @person_class
       @person_class.many :posts, :class => @post_class
-      
-      @person_class.identity_map.clear
-      @post_class.identity_map.clear
+
+      @post_class.identity_map_on
+      @person_class.identity_map_on
+      MongoMapper::Plugins::IdentityMap.clear
     end
 
-    should "default identity map to hash" do
-      Doc() do
-        plugin MongoMapper::Plugins::IdentityMap
-      end.identity_map.should == {}
+    should "track identity mapped models" do
+      MongoMapper::Plugins::IdentityMap.models.should == [@person_class, @post_class].to_set
     end
 
-    should "share identity map with other classes" do
-      map = @post_class.identity_map
-      map.object_id.should == @person_class.identity_map.object_id
+    should "be able to clear the map of all models" do
+      person = @person_class.create(:name => 'John')
+      post = @post_class.create(:title => 'IM 4eva')
+      assert_in_map(person, post)
+
+      MongoMapper::Plugins::IdentityMap.clear
+
+      assert_not_in_map(person, post)
+
+      [@person_class, @post_class].each { |klass| klass.identity_map.should == {} }
     end
+    
+    context "IM on off status" do
+      teardown do
+        @post_class.identity_map_on
+        @person_class.identity_map_on
+      end
 
-    should "have identity map key that is always unique per document and class" do
-      person = @person_class.new
-      person.identity_map_key.should == "people:#{person.id}"
-      @person_class.identity_map_key(person.id).should == person.identity_map_key
+      should "default identity map status to on" do
+        Doc { plugin MongoMapper::Plugins::IdentityMap }.identity_map_status.should be_true
+      end
+
+      should "be true if on" do
+        @post_class.identity_map_on
+        @post_class.should be_identity_map_on
+        @post_class.should_not be_identity_map_off
+      end
 
-      post = @post_class.new
-      post.identity_map_key.should == "posts:#{post.id}"
-      @post_class.identity_map_key(post.id).should == post.identity_map_key
+      should "be false if off" do
+        @post_class.identity_map_off
+        @post_class.should be_identity_map_off
+        @post_class.should_not be_identity_map_on
+      end
 
-      person.identity_map_key.should_not == post.identity_map_key
+      should "not share with other classes" do
+        @post_class.identity_map_off
+        @person_class.identity_map_on
+        @post_class.identity_map_status.should_not == @person_class.identity_map_status
+      end
+    end
+
+    should "default identity map to hash" do
+      Doc { plugin MongoMapper::Plugins::IdentityMap }.identity_map.should == {}
     end
 
     should "add key to map when saved" do
@@ -73,7 +106,7 @@ class IdentityMapTest < Test::Unit::TestCase
       person.save.should be_true
       assert_in_map(person)
     end
-    
+
     should "allow saving with options" do
       person = @person_class.new
       assert_nothing_raised do
@@ -87,7 +120,7 @@ class IdentityMapTest < Test::Unit::TestCase
       person.destroy
       assert_not_in_map(person)
     end
-    
+
     context "reload" do
       setup do
         @person = @person_class.create(:name => 'Fred')
@@ -101,8 +134,8 @@ class IdentityMapTest < Test::Unit::TestCase
       
       should "add object back into map" do
         assert_in_map(@person)
-        object_id = @person.object_id
-        @person.reload.object_id.should == object_id
+        before_reload = @person
+        @person.reload.should equal(before_reload)
         assert_in_map(@person)
       end
     end
@@ -121,10 +154,10 @@ class IdentityMapTest < Test::Unit::TestCase
         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
+        first_load.should equal(second_load)
       end
     end
-    
+
     context "#find (with one id)" do
       context "for object not in map" do
         setup do
@@ -142,7 +175,7 @@ class IdentityMapTest < Test::Unit::TestCase
           found_person = @person_class.find(@person.id)
           assert_in_map(found_person)
         end
-        
+
         should "return nil if not found " do
           @person_class.find(1234).should be_nil
         end
@@ -157,15 +190,15 @@ class IdentityMapTest < Test::Unit::TestCase
           expect_no_queries
           @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
+          found_person.should equal(@person)
         end
       end
     end
-    
+
     context "#find (with one id and options)" do
       setup do
         @person = @person_class.create(:name => 'Fred')
@@ -195,7 +228,7 @@ class IdentityMapTest < Test::Unit::TestCase
         @person.posts.find(1234).should be_nil
       end
     end
-    
+
     context "#find (with multiple ids)" do
       should "add all documents to map" do
         person1 = @person_class.create(:name => 'Fred')
@@ -204,7 +237,7 @@ class IdentityMapTest < Test::Unit::TestCase
         @person_class.identity_map.clear
 
         people = @person_class.find(person1.id, person2.id, person3.id)
-        people.each { |person| assert_in_map(person) }
+        assert_in_map(people)
       end
 
       should "add missing documents to map and return existing ones" do
@@ -214,16 +247,14 @@ class IdentityMapTest < Test::Unit::TestCase
         person3 = @person_class.create(:name => 'Jesse')
 
         assert_not_in_map(person1)
-        assert_in_map(person2)
-        assert_in_map(person3)
+        assert_in_map(person2, 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)
+        assert_in_map(person2, person3)
       end
     end
-    
+
     context "#first" do
       context "for object not in map" do
         setup do
@@ -256,15 +287,15 @@ class IdentityMapTest < Test::Unit::TestCase
           expect_no_queries
           @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
+          found_person.should equal(@person)
         end
       end
     end
-    
+
     context "#all" do
       should "add all documents to map" do
         person1 = @person_class.create(:name => 'Fred')
@@ -273,7 +304,7 @@ class IdentityMapTest < Test::Unit::TestCase
         @person_class.identity_map.clear
 
         people = @person_class.all(:_id => [person1.id, person2.id, person3.id])
-        people.each { |person| assert_in_map(person) }
+        assert_in_map(people)
       end
 
       should "add missing documents to map and return existing ones" do
@@ -283,13 +314,11 @@ class IdentityMapTest < Test::Unit::TestCase
         person3 = @person_class.create(:name => 'Jesse')
 
         assert_not_in_map(person1)
-        assert_in_map(person2)
-        assert_in_map(person3)
+        assert_in_map(person2, 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)
+        # people.first is making sure one that wasn't mapped now is
+        assert_in_map(people.first, person2, person3)
       end
     end
     
@@ -303,7 +332,7 @@ class IdentityMapTest < Test::Unit::TestCase
         @person_class.find_by_id(1234).should be_nil
       end
     end
-    
+
     context "querying and selecting certain fields" do
       setup do
         @person = @person_class.create(:name => 'Bill')
@@ -324,8 +353,8 @@ class IdentityMapTest < Test::Unit::TestCase
         @person_class.find(1234, :select => 'name').should be_nil
       end
     end
-    
-    context "single collection inheritance" do
+
+    context "single collection inherited models" do
       setup do
         class ::Item
           include MongoMapper::Document
@@ -339,10 +368,9 @@ class IdentityMapTest < Test::Unit::TestCase
           one :child, :class_name => 'Blog'
         end
         Item.collection.remove
-        Item.identity_map.clear
 
         class ::Blog < ::Item; end
-        
+
         class ::BlogPost < ::Item
           key :blog_id, ObjectId
           belongs_to :blog
@@ -355,11 +383,10 @@ class IdentityMapTest < Test::Unit::TestCase
         Object.send :remove_const, 'BlogPost' if defined?(::BlogPost)
       end
 
-      should "share the same identity map 4eva" do
+      should "share the same identity map" do
         blog = Blog.create(:title => 'Jill')
         assert_in_map(blog)
-        Item.identity_map_key(blog).should == Blog.identity_map_key(blog)
-        Item.identity_map.object_id.should == Blog.identity_map.object_id
+        Item.identity_map.should equal(Blog.identity_map)
       end
       
       should "not query when finding by _id and _type" do
@@ -369,8 +396,7 @@ class IdentityMapTest < Test::Unit::TestCase
         
         blog = Item.find(blog.id)
         post = Item.find(post.id)
-        assert_in_map(blog)
-        assert_in_map(post)
+        assert_in_map(blog, post)
         
         expect_no_queries
         post.blog
@@ -379,7 +405,7 @@ class IdentityMapTest < Test::Unit::TestCase
       
       should "load from map when using parent collection inherited class" do
         blog = Blog.create(:title => 'Jill')
-        Item.find(blog.id).object_id.should == blog.object_id
+        Item.find(blog.id).should equal(blog)
       end
       
       should "work correctly with belongs to proxy" do
@@ -388,7 +414,7 @@ class IdentityMapTest < Test::Unit::TestCase
         
         blog = Blog.create(:title => 'Jill', :parent => root)
         assert_in_map(blog)
-        root.object_id.should == blog.parent.object_id
+        root.should equal(blog.parent)
       end
       
       should "work correctly with one proxy" do
@@ -397,8 +423,79 @@ class IdentityMapTest < Test::Unit::TestCase
 
         root = Item.create(:title => 'Root', :child => blog)
         assert_in_map(root)
+        root.child.should equal(blog)
+      end
+    end
+
+    context "without identity map" do
+      should "not add to map on save" do
+        @post_class.without_identity_map do
+          post = @post_class.create(:title => 'Bill')
+          assert_not_in_map(post)
+        end
+      end
+      
+      should "not remove from map on delete" do
+        post = @post_class.create(:title => 'Bill')
+        assert_in_map(post)
+        
+        @post_class.without_identity_map do
+          post.destroy
+        end
+        
+        assert_in_map(post)
+      end
+      
+      should "not add to map when loading" do
+        @post_class.without_identity_map do
+          post = @post_class.load({'_id' => Mongo::ObjectID.new, 'title' => 'Awesome!'})
+          assert_not_in_map(post)
+        end
+      end
+      
+      should "not load from map when loading" do
+        post = @post_class.create(:title => 'Awesome!')
         
-        root.child.object_id.should == blog.object_id
+        @post_class.without_identity_map do
+          loaded = @post_class.load('_id' => post._id, 'title' => 'Awesome!')
+          loaded.should_not equal(post)
+        end
+      end
+      
+      context "all" do
+        should "not add to map" do
+          @post_class.without_identity_map do
+            post1 = @post_class.create(:title => 'Foo')
+            post2 = @post_class.create(:title => 'Bar')
+            @post_class.identity_map.clear
+            
+            assert_not_in_map(@post_class.all)
+          end
+        end
+      end
+      
+      context "first" do
+        should "not add to map" do
+          @post_class.without_identity_map do
+            post1 = @post_class.create(:title => 'Foo')
+            post2 = @post_class.create(:title => 'Bar')
+            @post_class.identity_map.clear
+            
+            assert_not_in_map(@post_class.first)
+          end
+        end
+      end
+      
+      context "last" do
+        should "not add to map" do
+          @post_class.without_identity_map do
+            post1 = @post_class.create(:title => 'Foo')
+            post2 = @post_class.create(:title => 'Bar')
+            @post_class.identity_map.clear
+            
+            assert_not_in_map(@post_class.last(:order => 'title'))
+          end
+        end
       end
     end
   end

data/test/unit/associations/test_proxy.rb

@@ -8,10 +8,12 @@ class FakeBlankProxy < MongoMapper::Plugins::Associations::Proxy
   def find_target; '' end
 end
 
+class FakeNumberProxy < MongoMapper::Plugins::Associations::Proxy
+  def find_target; 17 end
+end
+
 class FakeProxy < MongoMapper::Plugins::Associations::Proxy
-  def find_target
-    [1, 2]
-  end
+  def find_target; [1, 2] end
 end
 
 class ProxyTest < Test::Unit::TestCase

data/test/unit/test_document.rb

@@ -186,6 +186,34 @@ class DocumentTest < Test::Unit::TestCase
         @oid = Mongo::ObjectID.new
       end
       
+      should "delegate hash to _id" do
+        doc = @document.new
+        doc.hash.should == doc._id.hash
+      end
+      
+      should "delegate eql to ==" do
+        doc = @document.new
+        other = @document.new
+        doc.eql?(other).should == (doc == other)
+        doc.eql?(doc).should == (doc == doc)
+      end
+      
+      should "know if same object as another" do
+        doc = @document.new
+        doc.should equal(doc)
+        doc.should_not equal(@document.new)
+      end
+      
+      should "allow set operations on array of documents" do
+        @document.key :parent_id, ObjectId
+        @document.belongs_to :parent, :class => @document
+        
+        parent = @document.create
+        child = @document.create(:parent => parent)
+        
+        ([child.parent] & [parent]).should == [parent]
+      end
+      
       should "be equal if id and class are the same" do
         (@document.new('_id' => @oid) == @document.new('_id' => @oid)).should be(true)
       end

data/test/unit/test_embedded_document.rb

@@ -566,6 +566,30 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
       setup do
         @oid = Mongo::ObjectID.new
       end
+      
+      should "delegate hash to _id" do
+        doc = @document.new
+        doc.hash.should == doc._id.hash
+      end
+      
+      should "delegate eql to ==" do
+        doc = @document.new
+        other = @document.new
+        doc.eql?(other).should == (doc == other)
+        doc.eql?(doc).should == (doc == doc)
+      end
+      
+      should "know if same object as another" do
+        doc = @document.new
+        doc.should equal(doc)
+        doc.should_not equal(@document.new)
+      end
+      
+      should "allow set operations on array of documents" do
+        doc = @document.new
+        ([doc] & [doc]).should == [doc]
+      end
+      
       should "be equal if id and class are the same" do
         (@document.new('_id' => @oid) == @document.new('_id' => @oid)).should be_true
       end

data/test/unit/test_plugins.rb

@@ -1,12 +1,16 @@
 require 'test_helper'
 
 module MyPlugin
+  def self.configure(model)
+    model.class_eval { attr_accessor :from_configure }
+  end
+
   module ClassMethods
     def class_foo
       'class_foo'
     end
   end
-  
+
   module InstanceMethods
     def instance_foo
       'instance_foo'
@@ -26,15 +30,19 @@ class PluginsTest < Test::Unit::TestCase
     should "include instance methods" do
       @document.new.instance_foo.should == 'instance_foo'
     end
-    
+
     should "extend class methods" do
       @document.class_foo.should == 'class_foo'
     end
-    
+
+    should "pass model to configure" do
+      @document.new.should respond_to(:from_configure)
+    end
+
     should "default plugins to empty array" do
       Class.new { extend MongoMapper::Plugins }.plugins.should == []
     end
-    
+
     should "add plugin to plugins" do
       @document.plugins.should include(MyPlugin)
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mongo_mapper-unstable
 version: !ruby/object:Gem::Version 
-  version: 2010.1.22
+  version: 2010.1.25
 platform: ruby
 authors: 
 - John Nunemaker
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-22 00:00:00 -05:00
+date: 2010-01-25 00:00:00 -05:00
 default_executable: mmconsole
 dependencies: 
 - !ruby/object:Gem::Dependency