djsun-mongomapper 0.3.1

data/test/functional/associations/test_many_proxy.rb

@@ -0,0 +1,236 @@
+require 'test_helper'
+require 'models'
+
+class ManyProxyTest < Test::Unit::TestCase
+  def setup
+    clear_all_collections
+  end
+  
+  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.concat Status.new
+    project.statuses.size.should == 3
+  end
+
+  should "be able to replace 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
+  
+  should "correctly assign foreign key when using <<, push and concat" do
+    project = Project.new
+    project.statuses <<     Status.new(:name => '<<')
+    project.statuses.push   Status.new(:name => 'push')
+    project.statuses.concat Status.new(:name => 'concat')
+    
+    from_db = Project.find(project.id)
+    from_db.statuses[0].project_id.should == project.id
+    from_db.statuses[1].project_id.should == project.id
+    from_db.statuses[2].project_id.should == project.id
+  end
+  
+  context "build" do
+    should "assign foreign key" do
+      project = Project.create
+      status = project.statuses.build
+      status.project_id.should == project.id
+    end
+
+    should "allow assigning attributes" do
+      project = Project.create
+      status = project.statuses.build(:name => 'Foo')
+      status.name.should == 'Foo'
+    end
+  end
+  
+  context "create" do
+    should "assign foreign key" do
+      project = Project.create
+      status = project.statuses.create
+      status.project_id.should == project.id
+    end
+    
+    should "save record" do
+      project = Project.create
+      lambda {
+        project.statuses.create
+      }.should change { Status.count }
+    end
+    
+    should "allow passing attributes" do
+      project = Project.create
+      status = project.statuses.create(:name => 'Foo!')
+      status.name.should == 'Foo!'
+    end
+  end
+  
+  context "count" do
+    should "work scoped to association" do
+      project = Project.create
+      3.times { project.statuses.create }
+      
+      other_project = Project.create
+      2.times { other_project.statuses.create }
+      
+      project.statuses.count.should == 3
+      other_project.statuses.count.should == 2
+    end
+    
+    should "work with conditions" do
+      project = Project.create
+      project.statuses.create(:name => 'Foo')
+      project.statuses.create(:name => 'Other 1')
+      project.statuses.create(:name => 'Other 2')
+      
+      project.statuses.count(:name => 'Foo').should == 1
+    end
+  end
+  
+  context "Finding scoped to association" do
+    setup do
+      @project1          = Project.new(:name => 'Project 1')
+      @brand_new         = Status.create(:name => 'New')
+      @complete          = Status.create(:name => 'Complete')
+      @project1.statuses = [@brand_new, @complete]
+      @project1.save
+      
+      @project2          = Project.create(:name => 'Project 2')
+      @in_progress       = Status.create(:name => 'In Progress')
+      @archived          = Status.create(:name => 'Archived')
+      @another_complete  = Status.create(:name => 'Complete')
+      @project2.statuses = [@in_progress, @archived, @another_complete]
+      @project2.save
+    end
+    
+    context "with :all" do
+      should "work" do
+        @project1.statuses.find(:all).should == [@brand_new, @complete]
+      end
+      
+      should "work with conditions" do
+        statuses = @project1.statuses.find(:all, :conditions => {'name' => 'Complete'})
+        statuses.should == [@complete]
+      end
+      
+      should "work with order" do
+        statuses = @project1.statuses.find(:all, :order => 'name asc')
+        statuses.should == [@complete, @brand_new]
+      end
+    end
+
+    context "with #all" do
+      should_eventually "work" do
+        @project1.statuses.all.should == [@brand_new, @complete]
+      end
+      
+      should "work with conditions" do
+        statuses = @project1.statuses.all(:conditions => {'name' => 'Complete'})
+        statuses.should == [@complete]
+      end
+      
+      should "work with order" do
+        statuses = @project1.statuses.all(:order => 'name asc')
+        statuses.should == [@complete, @brand_new]
+      end
+    end
+    
+    context "with :first" do
+      should "work" do
+        @project1.statuses.find(:first).should == @brand_new
+      end
+      
+      should "work with conditions" do
+        status = @project1.statuses.find(:first, :conditions => {:name => 'Complete'})
+        status.should == @complete
+      end
+    end
+    
+    context "with #first" do
+      should "work" do
+        @project1.statuses.first.should == @brand_new
+      end
+      
+      should "work with conditions" do
+        status = @project1.statuses.first(:conditions => {:name => 'Complete'})
+        status.should == @complete
+      end
+    end
+    
+    context "with :last" do
+      should "work" do
+        @project1.statuses.find(:last).should == @complete
+      end
+      
+      should "work with conditions" do
+        status = @project1.statuses.find(:last, :conditions => {:name => 'New'})
+        status.should == @brand_new
+      end
+    end
+    
+    context "with #last" do
+      should "work" do
+        @project1.statuses.last.should == @complete
+      end
+      
+      should "work with conditions" do
+        status = @project1.statuses.last(:conditions => {:name => 'New'})
+        status.should == @brand_new
+      end
+    end
+    
+    context "with one id" do
+      should "work for id in association" do
+        @project1.statuses.find(@complete.id).should == @complete
+      end
+      
+      should "not work for id not in association" do
+        lambda {
+          @project1.statuses.find(@archived.id)
+        }.should raise_error(MongoMapper::DocumentNotFound)
+      end
+    end
+    
+    context "with multiple ids" do
+      should "work for ids in association" do
+        statuses = @project1.statuses.find(@brand_new.id, @complete.id)
+        statuses.should == [@brand_new, @complete]
+      end
+      
+      should "not work for ids not in association" do
+        lambda {
+          @project1.statuses.find(@brand_new.id, @complete.id, @archived.id)
+        }.should raise_error(MongoMapper::DocumentNotFound)
+      end
+    end
+    
+    context "with #paginate" do
+      setup do
+        @statuses = @project2.statuses.paginate(:per_page => 2, :page => 1, :order => '$natural asc')
+      end
+      
+      should "return total pages" do
+        @statuses.total_pages.should == 2
+      end
+      
+      should "return total entries" do
+        @statuses.total_entries.should == 3
+      end
+      
+      should "return the subject" do
+        @statuses.should == [@in_progress, @archived]
+      end
+    end
+  end
+end

data/test/functional/test_associations.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+require 'models'
+
+class AssociationsTest < Test::Unit::TestCase
+  def setup
+    clear_all_collections
+  end
+  
+  should "allow changing class names" do
+    class AwesomeUser
+      include MongoMapper::Document
+      many :posts, :class_name => 'AssociationsTest::AwesomePost', :foreign_key => :creator_id
+    end
+    
+    class AwesomeTag
+      include MongoMapper::EmbeddedDocument
+      key :name, String
+      belongs_to :post, :class_name => 'AssociationsTest::AwesomeUser'
+    end
+    
+    class AwesomePost
+      include MongoMapper::Document
+      belongs_to :creator, :class_name => 'AssociationsTest::AwesomeUser'
+      many :tags, :class_name => 'AssociationsTest::AwesomeTag', :foreign_key => :post_id
+    end
+    
+    AwesomeUser.collection.clear
+    AwesomePost.collection.clear
+    
+    user = AwesomeUser.create
+    tag1 = AwesomeTag.new(:name => 'awesome')
+    tag2 = AwesomeTag.new(:name => 'grand')
+    post1 = AwesomePost.create(:creator => user, :tags => [tag1])
+    post2 = AwesomePost.create(:creator => user, :tags => [tag2])
+    user.posts.should == [post1, post2]
+    
+    post1_from_db = AwesomePost.find(post1.id)
+    post1_from_db.tags.should == [tag1]
+  end
+end

data/test/functional/test_callbacks.rb

@@ -0,0 +1,85 @@
+require 'test_helper'
+
+class CallbacksTest < Test::Unit::TestCase
+  context "Defining and running callbacks" do
+    setup do
+      @document = Class.new do
+        include MongoMapper::Document
+        
+        key :name, String
+        
+        [ :before_validation_on_create, :before_validation_on_update,
+          :before_validation, :after_validation,
+          :before_create,     :after_create, 
+          :before_update,     :after_update,
+          :before_save,       :after_save,
+          :before_destroy,    :after_destroy].each do |callback|
+          callback_method = "#{callback}_callback"
+          send(callback, callback_method)
+          define_method(callback_method) do
+            history << callback.to_sym
+          end
+        end
+        
+        def history
+          @history ||= []
+        end
+        
+        def clear_history
+          @history = nil
+        end
+      end
+      
+      clear_all_collections
+    end
+    
+    should "get the order right for creating documents" do
+      doc = @document.create(:name => 'John Nunemaker')
+      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
+      doc = @document.create(:name => 'John Nunemaker')
+      doc.clear_history
+      doc.name = 'John'
+      doc.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
+      doc = @document.new(:name => 'John Nunemaker')
+      doc.valid?
+      doc.history.should include(:before_validation)
+      doc.history.should include(:after_validation)
+    end
+    
+    should "work for before and after create" do
+      doc = @document.create(:name => 'John Nunemaker')
+      doc.history.should include(:before_create)
+      doc.history.should include(:after_create)
+    end
+    
+    should "work for before and after update" do
+      doc = @document.create(:name => 'John Nunemaker')
+      doc.name = 'John Doe'
+      doc.save
+      doc.history.should include(:before_update)
+      doc.history.should include(:after_update)
+    end
+    
+    should "work for before and after save" do
+      doc = @document.new
+      doc.name = 'John Doe'
+      doc.save
+      doc.history.should include(:before_save)
+      doc.history.should include(:after_save)
+    end
+    
+    should "work for before and after destroy" do
+      doc = @document.create(:name => 'John Nunemaker')
+      doc.destroy
+      doc.history.should include(:before_destroy)
+      doc.history.should include(:after_destroy)
+    end
+  end
+end

data/test/functional/test_document.rb

@@ -0,0 +1,691 @@
+require 'test_helper'
+require 'models'
+
+class DocumentTest < Test::Unit::TestCase
+  def setup
+    @document = Class.new do
+      include MongoMapper::Document
+      collection 'users'
+
+      key :first_name, String
+      key :last_name, String
+      key :age, Integer
+    end
+
+    @document.collection.clear
+  end
+
+  context "Document Class Methods" do
+    context "Using key with type Array" do
+      setup do
+        @document.key :tags, Array
+      end
+
+      should "give correct default" do
+        doc = @document.new
+        doc.tags.should == []
+      end
+
+      should "work with assignment" do
+        doc = @document.new
+        doc.tags = %w(foo bar)
+        doc.tags.should == %w(foo bar)
+      end
+
+      should "work with assignment after saving" do
+        doc = @document.new
+        doc.tags = %w(foo bar)
+        doc.save
+        doc.tags.should == %w(foo bar)
+        @document.find(doc.id).tags.should == %w(foo bar)
+      end
+
+      should "work with assignment then <<" do
+        doc = @document.new
+        doc.tags = []
+        doc.tags << "foo"
+        doc.tags.should == ["foo"]
+      end
+
+      should "work with <<" do
+        doc = @document.new
+        doc.tags << "foo"
+        doc.tags.should == ["foo"]
+      end
+
+      should_eventually "work with << then save" do
+        doc = @document.new
+        doc.tags << "foo"
+        doc.tags << "bar"
+        doc.save
+        doc.tags.should == %w(foo bar)
+        @document.find(doc.id).tags.should == %w(foo bar)
+      end
+
+    end
+
+    context "Using key with type Hash" do
+      setup do
+        @document.key :foo, Hash
+      end
+
+      should "give correct default" do
+        doc = @document.new
+        doc.foo.should == {}
+      end
+      
+      should "work with []=" do
+        doc = @document.new
+        doc.foo["quux"] = "bar"
+        doc.foo["quux"].should == "bar"
+        doc.foo.should == { "quux" => "bar" }
+      end
+      
+      should "work with indifferent access" do
+        doc = @document.new
+        doc.foo = {:baz => 'bar'}
+        doc.foo[:baz].should == 'bar'
+        doc.foo['baz'].should == 'bar'
+      end
+
+      should "work with indifferent access after save" do
+        doc = @document.new
+        doc.foo = {:baz => 'bar'}
+        doc.save
+        doc = @document.find(doc.id)
+        doc.foo[:baz].should == 'bar'
+        doc.foo['baz'].should == 'bar'
+      end
+    end
+
+    context "Saving a document with an embedded document" do
+      setup do
+        @document.class_eval do
+          key :foo, Address
+        end
+      end
+
+      should "embed embedded document" do
+        address = Address.new(:city => 'South Bend', :state => 'IN')
+        doc = @document.new(:foo => address)
+        doc.save
+        doc.foo.city.should == 'South Bend'
+        doc.foo.state.should == 'IN'
+
+        from_db = @document.find(doc.id)
+        from_db.foo.city.should == 'South Bend'
+        from_db.foo.state.should == 'IN'
+      end
+    end
+
+    context "Creating a single document" do
+      setup do
+        @doc_instance = @document.create({:first_name => 'John', :last_name => 'Nunemaker', :age => '27'})
+      end
+
+      should "create a document in correct collection" do
+        @document.count.should == 1
+      end
+
+      should "automatically set id" do
+        @doc_instance.id.should_not be_nil
+        @doc_instance.id.size.should == 24
+      end
+
+      should "return instance of document" do
+        @doc_instance.should be_instance_of(@document)
+        @doc_instance.first_name.should == 'John'
+        @doc_instance.last_name.should == 'Nunemaker'
+        @doc_instance.age.should == 27
+      end
+    end
+
+    context "Creating a document with no attributes provided" do
+      setup do
+        @document = Class.new do
+          include MongoMapper::Document
+        end
+        @document.collection.clear
+      end
+
+      should "create the document" do
+        lambda {
+          @document.create
+        }.should change { @document.count }.by(1)
+      end
+    end
+
+    context "Creating multiple documents" do
+      setup do
+        @doc_instances = @document.create([
+          {:first_name => 'John', :last_name => 'Nunemaker', :age => '27'},
+          {:first_name => 'Steve', :last_name => 'Smith', :age => '28'},
+        ])
+      end
+
+      should "create multiple documents" do
+        @document.count.should == 2
+      end
+
+      should "return an array of doc instances" do
+        @doc_instances.map do |doc_instance|
+          doc_instance.should be_instance_of(@document)
+        end
+      end
+    end
+
+    context "Updating a document" do
+      setup do
+        doc = @document.create({:first_name => 'John', :last_name => 'Nunemaker', :age => '27'})
+        @doc_instance = @document.update(doc.id, {:age => 40})
+      end
+
+      should "update attributes provided" do
+        @doc_instance.age.should == 40
+      end
+
+      should "not update existing attributes that were not set to update" do
+        @doc_instance.first_name.should == 'John'
+        @doc_instance.last_name.should == 'Nunemaker'
+      end
+
+      should "not create new document" do
+        @document.count.should == 1
+      end
+    end
+
+    should "raise error when updating single doc if not provided id and attributes" do
+      doc = @document.create({:first_name => 'John', :last_name => 'Nunemaker', :age => '27'})
+      lambda { @document.update }.should raise_error(ArgumentError)
+      lambda { @document.update(doc.id) }.should raise_error(ArgumentError)
+      lambda { @document.update(doc.id, [1]) }.should raise_error(ArgumentError)
+    end
+
+    context "Updating multiple documents" do
+      setup do
+        @doc1 = @document.create({:first_name => 'John', :last_name => 'Nunemaker', :age => '27'})
+        @doc2 = @document.create({:first_name => 'Steve', :last_name => 'Smith', :age => '28'})
+
+        @doc_instances = @document.update({
+          @doc1.id => {:age => 30},
+          @doc2.id => {:age => 30},
+        })
+      end
+
+      should "not create any new documents" do
+        @document.count.should == 2
+      end
+
+      should "should return an array of doc instances" do
+        @doc_instances.map do |doc_instance|
+          doc_instance.should be_instance_of(@document)
+        end
+      end
+
+      should "update the documents" do
+        @document.find(@doc1.id).age.should == 30
+        @document.find(@doc2.id).age.should == 30
+      end
+    end
+
+    should "raise error when updating multiple documents if not a hash" do
+      lambda { @document.update([1, 2]) }.should raise_error(ArgumentError)
+    end
+
+    context "Finding documents" do
+      setup do
+        @doc1 = @document.create({:first_name => 'John', :last_name => 'Nunemaker', :age => '27'})
+        @doc2 = @document.create({:first_name => 'Steve', :last_name => 'Smith', :age => '28'})
+        @doc3 = @document.create({:first_name => 'Steph', :last_name => 'Nunemaker', :age => '26'})
+      end
+
+      should "raise document not found if nothing provided" do
+        lambda { @document.find }.should raise_error(MongoMapper::DocumentNotFound)
+      end
+
+      context "with a single id" do
+        should "work" do
+          @document.find(@doc1.id).should == @doc1
+        end
+
+        should "raise error if document not found" do
+          lambda { @document.find(MongoID.new) }.should raise_error(MongoMapper::DocumentNotFound)
+        end
+
+        should_eventually "raise error if id is illegal" do
+          lambda { @document.find(1) }.should raise_error(MongoMapper::IllegalID)
+        end
+      end
+
+      context "with multiple id's" do
+        should "work as arguments" do
+          @document.find(@doc1.id, @doc2.id).should == [@doc1, @doc2]
+        end
+
+        should "work as array" do
+          @document.find([@doc1.id, @doc2.id]).should == [@doc1, @doc2]
+        end
+      end
+
+      context "with :all" do
+        should "find all documents" do
+          @document.find(:all, :order => 'first_name').should == [@doc1, @doc3, @doc2]
+        end
+
+        should "be able to add conditions" do
+          @document.find(:all, :conditions => {:first_name => 'John'}).should == [@doc1]
+        end
+      end
+
+      context "with #all" do
+        should "find all documents based on criteria" do
+          @document.all(:order => 'first_name').should == [@doc1, @doc3, @doc2]
+          @document.all(:conditions => {:last_name => 'Nunemaker'}).should == [@doc1, @doc3]
+        end
+      end
+
+      context "with :first" do
+        should "find first document" do
+          @document.find(:first, :order => 'first_name').should == @doc1
+        end
+      end
+
+      context "with #first" do
+        should "find first document based on criteria" do
+          @document.first(:order => 'first_name').should == @doc1
+          @document.first(:conditions => {:age => 28}).should == @doc2
+        end
+      end
+
+      context "with :last" do
+        should "find last document" do
+          @document.find(:last).should == @doc3
+        end
+      end
+
+      context "with #last" do
+        should "find last document based on criteria" do
+          @document.last.should == @doc3
+          @document.last(:conditions => {:age => 28}).should == @doc2
+        end
+      end
+
+    end # finding documents
+
+    context "Finding document by id" do
+      setup do
+        @doc1 = @document.create({:first_name => 'John', :last_name => 'Nunemaker', :age => '27'})
+        @doc2 = @document.create({:first_name => 'Steve', :last_name => 'Smith', :age => '28'})
+      end
+
+      should "be able to find by id" do
+        @document.find_by_id(@doc1.id).should == @doc1
+        @document.find_by_id(@doc2.id).should == @doc2
+      end
+
+      should "return nil if document not found" do
+        @document.find_by_id(MongoID.new).should be(nil)
+      end
+    end
+
+    context "Deleting a document" do
+      setup do
+        @doc1 = @document.create({:first_name => 'John', :last_name => 'Nunemaker', :age => '27'})
+        @doc2 = @document.create({:first_name => 'Steve', :last_name => 'Smith', :age => '28'})
+        @document.delete(@doc1.id)
+      end
+
+      should "remove document from collection" do
+        @document.count.should == 1
+      end
+
+      should "not remove other documents" do
+        @document.find(@doc2.id).should_not be(nil)
+      end
+    end
+
+    context "Deleting multiple documents" do
+      should "work with multiple arguments" do
+        @doc1 = @document.create({:first_name => 'John', :last_name => 'Nunemaker', :age => '27'})
+        @doc2 = @document.create({:first_name => 'Steve', :last_name => 'Smith', :age => '28'})
+        @doc3 = @document.create({:first_name => 'Steph', :last_name => 'Nunemaker', :age => '26'})
+        @document.delete(@doc1.id, @doc2.id)
+
+        @document.count.should == 1
+      end
+
+      should "work with array as argument" do
+        @doc1 = @document.create({:first_name => 'John', :last_name => 'Nunemaker', :age => '27'})
+        @doc2 = @document.create({:first_name => 'Steve', :last_name => 'Smith', :age => '28'})
+        @doc3 = @document.create({:first_name => 'Steph', :last_name => 'Nunemaker', :age => '26'})
+        @document.delete([@doc1.id, @doc2.id])
+
+        @document.count.should == 1
+      end
+    end
+
+    context "Deleting all documents" do
+      setup do
+        @doc1 = @document.create({:first_name => 'John', :last_name => 'Nunemaker', :age => '27'})
+        @doc2 = @document.create({:first_name => 'Steve', :last_name => 'Smith', :age => '28'})
+        @doc3 = @document.create({:first_name => 'Steph', :last_name => 'Nunemaker', :age => '26'})
+      end
+
+      should "remove all documents when given no conditions" do
+        @document.delete_all
+        @document.count.should == 0
+      end
+
+      should "only remove matching documents when given conditions" do
+        @document.delete_all({:first_name => '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
+      setup do
+        @doc1 = @document.create({:first_name => 'John', :last_name => 'Nunemaker', :age => '27'})
+        @doc2 = @document.create({:first_name => 'Steve', :last_name => 'Smith', :age => '28'})
+        @document.destroy(@doc1.id)
+      end
+
+      should "remove document from collection" do
+        @document.count.should == 1
+      end
+
+      should "not remove other documents" do
+        @document.find(@doc2.id).should_not be(nil)
+      end
+    end
+
+    context "Destroying multiple documents" do
+      should "work with multiple arguments" do
+        @doc1 = @document.create({:first_name => 'John', :last_name => 'Nunemaker', :age => '27'})
+        @doc2 = @document.create({:first_name => 'Steve', :last_name => 'Smith', :age => '28'})
+        @doc3 = @document.create({:first_name => 'Steph', :last_name => 'Nunemaker', :age => '26'})
+        @document.destroy(@doc1.id, @doc2.id)
+
+        @document.count.should == 1
+      end
+
+      should "work with array as argument" do
+        @doc1 = @document.create({:first_name => 'John', :last_name => 'Nunemaker', :age => '27'})
+        @doc2 = @document.create({:first_name => 'Steve', :last_name => 'Smith', :age => '28'})
+        @doc3 = @document.create({:first_name => 'Steph', :last_name => 'Nunemaker', :age => '26'})
+        @document.destroy([@doc1.id, @doc2.id])
+
+        @document.count.should == 1
+      end
+    end
+
+    context "Destroying all documents" do
+      setup do
+        @doc1 = @document.create({:first_name => 'John', :last_name => 'Nunemaker', :age => '27'})
+        @doc2 = @document.create({:first_name => 'Steve', :last_name => 'Smith', :age => '28'})
+        @doc3 = @document.create({:first_name => 'Steph', :last_name => 'Nunemaker', :age => '26'})
+      end
+
+      should "remove all documents when given no conditions" do
+        @document.destroy_all
+        @document.count.should == 0
+      end
+
+      should "only remove matching documents when given conditions" do
+        @document.destroy_all(:first_name => 'John')
+        @document.count.should == 2
+        @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
+      setup do
+        @doc1 = @document.create({:first_name => 'John', :last_name => 'Nunemaker', :age => '27'})
+        @doc2 = @document.create({:first_name => 'Steve', :last_name => 'Smith', :age => '28'})
+        @doc3 = @document.create({:first_name => 'Steph', :last_name => 'Nunemaker', :age => '26'})
+      end
+
+      should "count all with no arguments" do
+        @document.count.should == 3
+      end
+
+      should "return 0 if there are no documents in the collection" do
+        @document.delete_all
+        @document.count.should == 0
+      end
+
+      should "return 0 if the collection does not exist" do
+        klass = Class.new do
+          include MongoMapper::Document
+          collection 'foobarbazwickdoesnotexist'
+        end
+
+        klass.count.should == 0
+      end
+
+      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
+      setup do
+        @document.collection.drop_indexes
+      end
+
+      should "allow creating index for a key" do
+        index_name = nil
+        lambda {
+          index_name = @document.ensure_index :first_name
+        }.should change { @document.collection.index_information.size }.by(1)
+
+        index_name.should == 'first_name_1'
+        index = @document.collection.index_information[index_name]
+        index.should_not be_nil
+        index.should include(['first_name', 1])
+      end
+
+      should "allow creating unique index for a key" do
+        @document.collection.expects(:create_index).with(:first_name, true)
+        @document.ensure_index :first_name, :unique => true
+      end
+
+      should_eventually "allow creating index on multiple keys" do
+        index_name = nil
+        lambda {
+          index_name = @document.ensure_index [[:first_name, 1], [:last_name, -1]]
+        }.should change { @document.collection.index_information.size }.by(1)
+
+        index_name.should == 'first_name_1_last_name_-1'
+
+        index = @document.collection.index_information[index_name]
+        index.should_not be_nil
+        index.should include(['first_name', 1])
+        index.should include(['last_name', -1])
+      end
+
+      should "work with :index shortcut when defining key" do
+        @document.expects(:ensure_index).with('father').returns(nil)
+        @document.key :father, String, :index => true
+      end
+    end
+  end # Document Class Methods
+
+  context "Saving a new document" do
+    setup do
+      @doc = @document.new(:first_name => 'John', :age => '27')
+      @doc.save
+    end
+
+    should "insert document into the collection" do
+      @document.count.should == 1
+    end
+
+    should "assign an id for the document" do
+      @doc.id.should_not be(nil)
+      @doc.id.size.should == 24
+    end
+
+    should "save attributes" do
+      @doc.first_name.should == 'John'
+      @doc.age.should == 27
+    end
+
+    should "update attributes in the database" do
+      from_db = @document.find(@doc.id)
+      from_db.should == @doc
+      from_db.first_name.should == 'John'
+      from_db.age.should == 27
+    end
+  end
+
+  context "Saving an existing document" do
+    setup do
+      @doc = @document.create(:first_name => 'John', :age => '27')
+      @doc.first_name = 'Johnny'
+      @doc.age = 30
+      @doc.save
+    end
+
+    should "not insert document into collection" do
+      @document.count.should == 1
+    end
+
+    should "update attributes" do
+      @doc.first_name.should == 'Johnny'
+      @doc.age.should == 30
+    end
+
+    should "update attributes in the database" do
+      from_db = @document.find(@doc.id)
+      from_db.first_name.should == 'Johnny'
+      from_db.age.should == 30
+    end
+  end
+
+  context "Calling update attributes on a new document" do
+    setup do
+      @doc = @document.new(:first_name => 'John', :age => '27')
+      @doc.update_attributes(:first_name => 'Johnny', :age => 30)
+    end
+
+    should "insert document into the collection" do
+      @document.count.should == 1
+    end
+
+    should "assign an id for the document" do
+      @doc.id.should_not be(nil)
+      @doc.id.size.should == 24
+    end
+
+    should "save attributes" do
+      @doc.first_name.should == 'Johnny'
+      @doc.age.should == 30
+    end
+
+    should "update attributes in the database" do
+      from_db = @document.find(@doc.id)
+      from_db.should == @doc
+      from_db.first_name.should == 'Johnny'
+      from_db.age.should == 30
+    end
+  end
+
+  context "Updating an existing document using update attributes" do
+    setup do
+      @doc = @document.create(:first_name => 'John', :age => '27')
+      @doc.update_attributes(:first_name => 'Johnny', :age => 30)
+    end
+
+    should "not insert document into collection" do
+      @document.count.should == 1
+    end
+
+    should "update attributes" do
+      @doc.first_name.should == 'Johnny'
+      @doc.age.should == 30
+    end
+
+    should "update attributes in the database" do
+      from_db = @document.find(@doc.id)
+      from_db.first_name.should == 'Johnny'
+      from_db.age.should == 30
+    end
+  end
+
+  context "Destroying a document that exists" do
+    setup do
+      @doc = @document.create(:first_name => 'John', :age => '27')
+      @doc.destroy
+    end
+
+    should "remove the document from the collection" do
+      @document.count.should == 0
+    end
+
+    should "raise error if assignment is attempted" do
+      lambda { @doc.first_name = 'Foo' }.should raise_error(TypeError)
+    end
+  end
+
+  context "Destroying a document that is a new" do
+    setup do
+      setup do
+        @doc = @document.new(:first_name => 'John Nunemaker', :age => '27')
+        @doc.destroy
+      end
+
+      should "not affect collection count" do
+        @document.collection.count.should == 0
+      end
+
+      should "raise error if assignment is attempted" do
+        lambda { @doc.first_name = 'Foo' }.should raise_error(TypeError)
+      end
+    end
+  end
+
+  context "timestamping" do
+    should "set created_at and updated_at on create" do
+      doc = @document.new(:first_name => 'John', :age => 27)
+      doc.created_at.should be(nil)
+      doc.updated_at.should be(nil)
+      doc.save
+      doc.created_at.should_not be(nil)
+      doc.updated_at.should_not be(nil)
+    end
+
+    should "set updated_at on field update but leave created_at alone" do
+      doc = @document.create(:first_name => 'John', :age => 27)
+      old_created_at = doc.created_at
+      old_updated_at = doc.updated_at
+      doc.first_name = 'Johnny'
+      doc.save
+      doc.created_at.should == old_created_at
+      doc.updated_at.should_not == old_updated_at
+    end
+
+    should_eventually "set updated_at on document update but leave created_at alone" do
+      doc = @document.create(:first_name => 'John', :age => 27)
+      old_created_at = doc.created_at
+      old_updated_at = doc.updated_at
+      doc = @document.update(old._id, { :first_name => 'Johnny' })
+      doc.created_at.should == old_created_at
+      doc.updated_at.should_not == old_updated_at
+    end
+  end
+end