mongo_mapper-unstable 2009.12.30 → 2010.1.4

data/test/functional/test_document.rb

@@ -3,8 +3,7 @@ require 'models'
 
 class DocumentTest < Test::Unit::TestCase
   def setup
-    @document = Class.new do
-      include MongoMapper::Document
+    @document = Doc do
       set_collection_name 'users'
 
       key :first_name, String
@@ -12,761 +11,554 @@ class DocumentTest < Test::Unit::TestCase
       key :age, Integer
       key :date, Date
     end
-    @document.collection.remove
   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 "Saving a document with a blank binary value" do
+  
+  context "Using key with type Array" do
     setup do
-      @document.key :file, Binary
+      @document.key :tags, Array
     end
 
-    should "not fail" do
-      doc = @document.new(:file => nil)
-      lambda {
-        doc.save
-      }.should_not raise_error
+    should "give correct default" do
+      doc = @document.new
+      doc.tags.should == []
     end
-  end
 
-  context "Loading a document from the database with keys that are not defined" do
-    setup do
-      @id = Mongo::ObjectID.new
-      @document.collection.insert({
-        :_id            => @id,
-        :first_name     => 'John',
-        :last_name      => 'Nunemaker',
-        :age            => 27,
-        :favorite_color => 'red',
-        :skills         => ['ruby', 'rails', 'javascript', 'xhtml', 'css']
-      })
+    should "work with assignment" do
+      doc = @document.new
+      doc.tags = %w(foo bar)
+      doc.tags.should == %w(foo bar)
     end
 
-    should "assign all keys from database" do
-      doc = @document.find(@id)
-      doc.first_name.should == 'John'
-      doc.last_name.should == 'Nunemaker'
-      doc.age.should == 27
-      doc.favorite_color.should == 'red'
-      doc.skills.should == ['ruby', 'rails', 'javascript', 'xhtml', 'css']
+    should "work with assignment after saving" do
+      doc = @document.new
+      doc.tags = %w(foo bar)
+      doc.save
+      doc.tags.should == %w(foo bar)
+      doc.reload.tags.should == %w(foo bar)
     end
-  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)
-        doc.reload.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 "work with << then save" do
-        doc = @document.new
-        doc.tags << "foo"
-        doc.tags << "bar"
-        doc.save
-        doc.tags.should == %w(foo bar)
-        doc.reload.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
 
-    context "Using key with type Hash" do
-      setup do
-        @document.key :foo, Hash
-      end
+    should "work with <<" do
+      doc = @document.new
+      doc.tags << "foo"
+      doc.tags.should == ["foo"]
+    end
 
-      should "give correct default" do
-        doc = @document.new
-        doc.foo.should == {}
-      end
+    should "work with << then save" do
+      doc = @document.new
+      doc.tags << "foo"
+      doc.tags << "bar"
+      doc.save
+      doc.tags.should == %w(foo bar)
+      doc.reload.tags.should == %w(foo bar)
+    end
+  end
 
-      should "work with []=" do
-        doc = @document.new
-        doc.foo["quux"] = "bar"
-        doc.foo["quux"].should == "bar"
-        doc.foo.should == { "quux" => "bar" }
-      end
+  context "Using key with type Hash" do
+    setup do
+      @document.key :foo, Hash
+    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 "give correct default" do
+      doc = @document.new
+      doc.foo.should == {}
+    end
 
-      should "work with indifferent access after save" do
-        doc = @document.new
-        doc.foo = {:baz => 'bar'}
-        doc.save
+    should "work with []=" do
+      doc = @document.new
+      doc.foo["quux"] = "bar"
+      doc.foo["quux"].should == "bar"
+      doc.foo.should == { "quux" => "bar" }
+    end
 
-        doc = doc.reload
-        doc.foo[:baz].should == 'bar'
-        doc.foo['baz'].should == '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
 
-    context "Using key with custom type with default" do
-      setup do
-        @document.key :window, WindowSize, :default => WindowSize.new(600, 480)
-      end
+    should "work with indifferent access after save" do
+      doc = @document.new
+      doc.foo = {:baz => 'bar'}
+      doc.save
 
-      should "default to default" do
-        doc = @document.new
-        doc.window.should == WindowSize.new(600, 480)
+      doc = doc.reload
+      doc.foo[:baz].should == 'bar'
+      doc.foo['baz'].should == 'bar'
+    end
+  end
 
-      end
+  context "Using key with custom type with default" do
+    setup do
+      @document.key :window, WindowSize, :default => WindowSize.new(600, 480)
+    end
 
-      should "save and load from mongo" do
-        doc = @document.new
-        doc.save
+    should "default to default" do
+      doc = @document.new
+      doc.window.should == WindowSize.new(600, 480)
 
-        doc = doc.reload
-        doc.window.should == WindowSize.new(600, 480)
-      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 "save and load from mongo" do
+      doc = @document.new
+      doc.save
 
-      should "automatically set id" do
-        @doc_instance.id.should be_instance_of(Mongo::ObjectID)
-        @doc_instance._id.should be_instance_of(Mongo::ObjectID)
-      end
+      doc = doc.reload
+      doc.window.should == WindowSize.new(600, 480)
+    end
+  end
 
-      should "no longer be new?" do
-        @doc_instance.new?.should be_false
-      end
+  context "ClassMethods#create (single document)" do
+    setup do
+      @doc_instance = @document.create({:first_name => 'John', :last_name => 'Nunemaker', :age => '27'})
+    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
+    should "create a document in correct collection" do
+      @document.count.should == 1
     end
 
-    context "Creating a document with no attributes provided" do
-      setup do
-        @document = Class.new do
-          include MongoMapper::Document
-          set_collection_name 'test'
-        end
-        @document.collection.remove
-      end
+    should "automatically set id" do
+      @doc_instance.id.should be_instance_of(Mongo::ObjectID)
+      @doc_instance._id.should be_instance_of(Mongo::ObjectID)
+    end
 
-      should "create the document" do
-        lambda {
-          @document.create
-        }.should change { @document.count }.by(1)
-      end
+    should "no longer be new?" do
+      @doc_instance.new?.should be_false
     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 "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
+    
+    should "not fail if no attributes provided" do
+      document = Doc()
+      lambda { document.create }.should change { document.count }.by(1)
+    end
+  end
 
-      should "create multiple documents" do
-        @document.count.should == 2
-      end
+  context "ClassMethods#create (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 "return an array of doc instances" do
-        @doc_instances.map do |doc_instance|
-          doc_instance.should be_instance_of(@document)
-        end
-      end
+    should "create multiple documents" do
+      @document.count.should == 2
     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})
+    should "return an array of doc instances" do
+      @doc_instances.map do |doc_instance|
+        doc_instance.should be_instance_of(@document)
       end
+    end
+  end
 
-      should "update attributes provided" do
-        @doc_instance.age.should == 40
-      end
+  context "ClassMethods#update (single 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 "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 "update attributes provided" do
+      @doc_instance.age.should == 40
+    end
 
-      should "not create new document" do
-        @document.count.should == 1
-      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 "raise error when updating single doc if not provided id and attributes" do
+    should "not create new document" do
+      @document.count.should == 1
+    end
+    
+    should "raise error if not provided id" do
       doc = @document.create({:first_name => 'John', :last_name => 'Nunemaker', :age => '27'})
       lambda { @document.update }.should raise_error(ArgumentError)
+    end
+    
+    should "raise error if not provided attributes" do
+      doc = @document.create({:first_name => 'John', :last_name => 'Nunemaker', :age => '27'})
       lambda { @document.update(doc._id) }.should raise_error(ArgumentError)
       lambda { @document.update(doc._id, [1]) }.should raise_error(ArgumentError)
     end
+  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
+  context "ClassMethods#update (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'})
 
-      should "not create any new documents" do
-        @document.count.should == 2
-      end
+      @doc_instances = @document.update({
+        @doc1._id => {:age => 30},
+        @doc2._id => {:age => 30},
+      })
+    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 "not create any new documents" do
+      @document.count.should == 2
+    end
 
-      should "update the documents" do
-        @document.find(@doc1._id).age.should == 30
-        @document.find(@doc2._id).age.should == 30
+    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 "raise error when updating multiple documents if not a hash" do
+    should "update the documents" do
+      @document.find(@doc1._id).age.should == 30
+      @document.find(@doc2._id).age.should == 30
+    end
+    
+    should "raise error if not a hash" do
       lambda { @document.update([1, 2]) }.should raise_error(ArgumentError)
     end
+  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 "return nil if nothing provided for find" do
-        @document.find.should be_nil
-      end
-
-      should "raise document not found if nothing provided for find!" do
-        lambda { @document.find! }.should raise_error(MongoMapper::DocumentNotFound)
-      end
+  context "ClassMethods#find" 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
 
-      context "with a single id" do
-        should "work" do
-          @document.find(@doc1._id).should == @doc1
-        end
+    should "return nil if nothing provided for find" do
+      @document.find.should be_nil
+    end
 
-        should "return nil if document not found with find" do
-          @document.find(123).should be_nil
-        end
+    should "raise document not found if nothing provided for find!" do
+      lambda { @document.find! }.should raise_error(MongoMapper::DocumentNotFound)
+    end
 
-        should "raise error if document not found with find!" do
-          lambda {
-            @document.find!(123)
-          }.should raise_error(MongoMapper::DocumentNotFound)
-        end
+    context "(with a single id)" do
+      should "work" do
+        @document.find(@doc1._id).should == @doc1
       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
-
-        should "return array if array only has one element" do
-          @document.find([@doc1._id]).should == [@doc1]
-        end
+      should "return nil if document not found with find" do
+        @document.find(123).should be_nil
       end
 
-      should "be able to find using condition auto-detection" do
-        @document.first(:first_name => 'John').should == @doc1
-        @document.all(:last_name => 'Nunemaker', :order => 'age desc').should == [@doc1, @doc3]
+      should "raise error if document not found with find!" do
+        lambda {
+          @document.find!(123)
+        }.should raise_error(MongoMapper::DocumentNotFound)
       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, :first_name => 'John').should == [@doc1]
-        end
+    context "(with multiple id's)" do
+      should "work as arguments" do
+        @document.find(@doc1._id, @doc2._id).should == [@doc1, @doc2]
       end
 
-      context "with #all" do
-        should "find all documents based on criteria" do
-          @document.all(:order => 'first_name').should == [@doc1, @doc3, @doc2]
-          @document.all(:last_name => 'Nunemaker', :order => 'age desc').should == [@doc1, @doc3]
-        end
+      should "work as array" do
+        @document.find([@doc1._id, @doc2._id]).should == [@doc1, @doc2]
       end
 
-      context "with :first" do
-        should "find first document" do
-          @document.find(:first, :order => 'first_name').should == @doc1
-        end
+      should "return array if array only has one element" do
+        @document.find([@doc1._id]).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(:age => 28).should == @doc2
-        end
-      end
+    should "be able to find using condition auto-detection" do
+      @document.first(:first_name => 'John').should == @doc1
+      @document.all(:last_name => 'Nunemaker', :order => 'age desc').should == [@doc1, @doc3]
+    end
 
-      context "with :last" do
-        should "find last document" do
-          @document.find(:last, :order => 'age').should == @doc2
-        end
+    context "(with :all)" do
+      should "find all documents" do
+        @document.find(:all, :order => 'first_name').should == [@doc1, @doc3, @doc2]
       end
 
-      context "with #last" do
-        should "find last document based on criteria" do
-          @document.last(:order => 'age').should == @doc2
-          @document.last(:order => 'age', :age => 28).should == @doc2
-        end
-
-        should "raise error if no order provided" do
-          lambda { @document.last() }.should raise_error
-        end
+      should "be able to add conditions" do
+        @document.find(:all, :first_name => 'John').should == [@doc1]
       end
+    end
 
-      context "with :find_by" do
-        should "find document based on argument" do
-          @document.find_by_first_name('John').should == @doc1
-          @document.find_by_last_name('Nunemaker', :order => 'age desc').should == @doc1
-          @document.find_by_age(27).should == @doc1
-        end
-
-        should "not raise error" do
-          @document.find_by_first_name('Mongo').should be_nil
-        end
+    context "(with #all)" do
+      should "find all documents based on criteria" do
+        @document.all(:order => 'first_name').should == [@doc1, @doc3, @doc2]
+        @document.all(:last_name => 'Nunemaker', :order => 'age desc').should == [@doc1, @doc3]
+      end
+    end
 
-        should "define a method for each key" do
-          @document.methods(false).select { |e| e =~ /^find_by_/ }.size == @document.keys.size
-        end
+    context "(with :first)" do
+      should "find first document" do
+        @document.find(:first, :order => 'first_name').should == @doc1
       end
+    end
 
-      context "with 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
-        end
-
-        should "not find the document if an argument is wrong" do
-          @document.find_by_first_name_and_last_name_and_age('John', 'Nunemaker', 28).should be_nil
-        end
-
-        should "find all documents based on arguments" do
-          docs = @document.find_all_by_last_name('Nunemaker')
-          docs.should be_kind_of(Array)
-          docs.should include(@doc1)
-          docs.should include(@doc3)
-        end
-
-        should "initialize document with given arguments" do
-          doc = @document.find_or_initialize_by_first_name_and_last_name('David', 'Cuadrado')
-          doc.should be_new
-          doc.first_name.should == 'David'
-        end
-
-        should "not initialize document if document is found" do
-          doc = @document.find_or_initialize_by_first_name('John')
-          doc.should_not be_new
-        end
-
-        should "create document with given arguments" do
-          doc = @document.find_or_create_by_first_name_and_last_name('David', 'Cuadrado')
-          doc.should_not be_new
-          doc.first_name.should == 'David'
-        end
-
-        should "raise error if document is not found when using !" do
-          lambda {
-            @document.find_by_first_name_and_last_name!(1,2)
-          }.should raise_error(MongoMapper::DocumentNotFound)
-        end
+    context "(with #first)" do
+      should "find first document based on criteria" do
+        @document.first(:order => 'first_name').should == @doc1
+        @document.first(:age => 28).should == @doc2
       end
-    end # finding documents
+    end
 
-    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'})
+    context "(with :last)" do
+      should "find last document" do
+        @document.find(:last, :order => 'age').should == @doc2
       end
+    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
+    context "(with #last)" do
+      should "find last document based on criteria" do
+        @document.last(:order => 'age').should == @doc2
+        @document.last(:order => 'age', :age => 28).should == @doc2
       end
 
-      should "return nil if document not found" do
-        @document.find_by_id(1234).should be(nil)
+      should "raise error if no order provided" do
+        lambda { @document.last() }.should raise_error
       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)
+    context "(with :find_by)" do
+      should "find document based on argument" do
+        @document.find_by_first_name('John').should == @doc1
+        @document.find_by_last_name('Nunemaker', :order => 'age desc').should == @doc1
+        @document.find_by_age(27).should == @doc1
       end
 
-      should "remove document from collection" do
-        @document.count.should == 1
+      should "not raise error" do
+        @document.find_by_first_name('Mongo').should be_nil
       end
 
-      should "not remove other documents" do
-        @document.find(@doc2._id).should_not be(nil)
+      should "define a method for each key" do
+        @document.methods(false).select { |e| e =~ /^find_by_/ }.size == @document.keys.size
       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
+    context "(with 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
       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])
+      should "not find the document if an argument is wrong" do
+        @document.find_by_first_name_and_last_name_and_age('John', 'Nunemaker', 28).should be_nil
+      end
 
-        @document.count.should == 1
+      should "find all documents based on arguments" do
+        docs = @document.find_all_by_last_name('Nunemaker')
+        docs.should be_kind_of(Array)
+        docs.should include(@doc1)
+        docs.should include(@doc3)
       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'})
+      should "initialize document with given arguments" do
+        doc = @document.find_or_initialize_by_first_name_and_last_name('David', 'Cuadrado')
+        doc.should be_new
+        doc.first_name.should == 'David'
       end
 
-      should "remove all documents when given no conditions" do
-        @document.delete_all
-        @document.count.should == 0
+      should "not initialize document if document is found" do
+        doc = @document.find_or_initialize_by_first_name('John')
+        doc.should_not be_new
       end
 
-      should "only remove matching documents when given conditions" do
-        @document.delete_all({:first_name => 'John'})
-        @document.count.should == 2
+      should "create document with given arguments" do
+        doc = @document.find_or_create_by_first_name_and_last_name('David', 'Cuadrado')
+        doc.should_not be_new
+        doc.first_name.should == 'David'
       end
 
-      should "convert the conditions to mongo criteria" do
-        @document.delete_all(:age => [26, 27])
-        @document.count.should == 1
+      should "raise error if document is not found when using !" do
+        lambda {
+          @document.find_by_first_name_and_last_name!(1,2)
+        }.should raise_error(MongoMapper::DocumentNotFound)
       end
     end
+  end # finding documents
 
-    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
+  context "ClassMethods#find_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 "remove document from collection" do
-        @document.count.should == 1
-      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 "not remove other documents" do
-        @document.find(@doc2._id).should_not be(nil)
-      end
+    should "return nil if document not found" do
+      @document.find_by_id(1234).should 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
+  context "ClassMethods#delete (single 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 "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])
+    should "remove document from collection" do
+      @document.count.should == 1
+    end
 
-        @document.count.should == 1
-      end
+    should "not remove other documents" do
+      @document.find(@doc2._id).should_not be(nil)
     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
+  context "ClassMethods#delete (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)
 
-      should "remove all documents when given no conditions" do
-        @document.destroy_all
-        @document.count.should == 0
-      end
+      @document.count.should == 1
+    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 "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])
 
-      should "convert the conditions to mongo criteria" do
-        @document.destroy_all(:age => [26, 27])
-        @document.count.should == 1
-      end
+      @document.count.should == 1
     end
+  end
 
-    context ":dependent" do
-      setup do
-        # FIXME: make use of already defined models
-        class ::Property
-          include MongoMapper::Document
-        end
-        Property.collection.remove
+  context "ClassMethods#delete_all" 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
 
-        class ::Thing
-          include MongoMapper::Document
-          key :name, String
-        end
-        Thing.collection.remove
-      end
+    should "remove all documents when given no conditions" do
+      @document.delete_all
+      @document.count.should == 0
+    end
 
-      teardown do
-        Object.send :remove_const, 'Property' if defined?(::Property)
-        Object.send :remove_const, 'Thing' if defined?(::Thing)
-      end
+    should "only remove matching documents when given conditions" do
+      @document.delete_all({:first_name => 'John'})
+      @document.count.should == 2
+    end
 
-      context "many" do
-        context "=> destroy" do
-          setup do
-            Property.key :thing_id, ObjectId
-            Property.belongs_to :thing, :dependent => :destroy
-            Thing.many :properties, :dependent => :destroy
-
-            @thing = Thing.create(:name => "Tree")
-            @property1 = Property.create
-            @property2 = Property.create
-            @property3 = Property.create
-            @thing.properties << @property1
-            @thing.properties << @property2
-            @thing.properties << @property3
-          end
-
-          should "should destroy the associated documents" do
-            @thing.properties.count.should == 3
-            @thing.destroy
-            @thing.properties.count.should == 0
-            Property.count.should == 0
-          end
-        end
-
-        context "=> delete_all" do
-          setup do
-            Property.key :thing_id, ObjectId
-            Property.belongs_to :thing
-            Thing.has_many :properties, :dependent => :delete_all
-
-            @thing = Thing.create(:name => "Tree")
-            @property1 = Property.create
-            @property2 = Property.create
-            @property3 = Property.create
-            @thing.properties << @property1
-            @thing.properties << @property2
-            @thing.properties << @property3
-          end
-
-          should "should delete associated documents" do
-            @thing.properties.count.should == 3
-            @thing.destroy
-            @thing.properties.count.should == 0
-            Property.count.should == 0
-          end
-        end
-
-        context "=> nullify" do
-          setup do
-            Property.key :thing_id, ObjectId
-            Property.belongs_to :thing
-            Thing.has_many :properties, :dependent => :nullify
-
-            @thing = Thing.create(:name => "Tree")
-            @property1 = Property.create
-            @property2 = Property.create
-            @property3 = Property.create
-            @thing.properties << @property1
-            @thing.properties << @property2
-            @thing.properties << @property3
-          end
-
-          should "should nullify relationship but not destroy associated documents" do
-            @thing.properties.count.should == 3
-            @thing.destroy
-            @thing.properties.count.should == 0
-            Property.count.should == 3
-          end
-        end
-      end
+    should "convert the conditions to mongo criteria" do
+      @document.delete_all(:age => [26, 27])
+      @document.count.should == 1
+    end
+  end
 
-      context "belongs_to" do
-        context "=> destroy" do
-          setup do
-            Property.key :thing_id, ObjectId
-            Property.belongs_to :thing, :dependent => :destroy
-            Thing.has_many :properties
-
-            @thing = Thing.create(:name => "Tree")
-            @property1 = Property.create
-            @property2 = Property.create
-            @property3 = Property.create
-            @thing.properties << @property1
-            @thing.properties << @property2
-            @thing.properties << @property3
-          end
-
-          should "not execute on a belongs_to association" do
-            Thing.count.should == 1
-            @property1.destroy
-            Thing.count.should == 1
-            @property1.should be_frozen
-          end
-        end
-      end
+  context "ClassMethods#destroy (single 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
 
-    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 "remove document from collection" do
+      @document.count.should == 1
+    end
 
-      should "count all with no arguments" do
-        @document.count.should == 3
-      end
+    should "not remove other documents" do
+      @document.find(@doc2._id).should_not be(nil)
+    end
+  end
 
-      should "return 0 if there are no documents in the collection" do
-        @document.delete_all
-        @document.count.should == 0
-      end
+  context "ClassMethods#destroy (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 "return 0 if the collection does not exist" do
-        klass = Class.new do
-          include MongoMapper::Document
-          set_collection_name 'foobarbazwickdoesnotexist'
-        end
-        @document.collection.remove
+    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])
 
-        klass.count.should == 0
-      end
+      @document.count.should == 1
+    end
+  end
 
-      should "return count for matching documents if conditions provided" do
-        @document.count(:age => 27).should == 1
-      end
+  context "ClassMethods#destroy_all" 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 "convert the conditions to mongo criteria" do
-        @document.count(:age => [26, 27]).should == 2
-      end
+    should "remove all documents when given no conditions" do
+      @document.destroy_all
+      @document.count.should == 0
     end
 
-    context "Indexing" do
-      setup do
-        @document.collection.drop_indexes
-      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 "allow creating index for a key" do
-        @document.ensure_index :first_name
-        MongoMapper.ensure_indexes!
+    should "convert the conditions to mongo criteria" do
+      @document.destroy_all(:age => [26, 27])
+      @document.count.should == 1
+    end
+  end
 
-        @document.should have_index('first_name_1')
-      end
+  context "ClassMethods#count" 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 "allow creating unique index for a key" do
-        @document.ensure_index :first_name, :unique => true
-        MongoMapper.ensure_indexes!
+    should "count all with no arguments" do
+      @document.count.should == 3
+    end
 
-        @document.should have_index('first_name_1')
-      end
+    should "return 0 if there are no documents in the collection" do
+      @document.delete_all
+      @document.count.should == 0
+    end
 
-      should "allow creating index on multiple keys" do
-        @document.ensure_index [[:first_name, 1], [:last_name, -1]]
-        MongoMapper.ensure_indexes!
-
-        # order is different for different versions of ruby so instead of
-        # just checking have_index('first_name_1_last_name_-1') I'm checking
-        # the values of the indexes to make sure the index creation was successful
-        @document.collection.index_information.detect do |index|
-          keys = index[1]
-          keys.include?(['first_name', 1]) && keys.include?(['last_name', -1])
-        end.should_not be_nil
+    should "return 0 if the collection does not exist" do
+      klass = Doc do
+        set_collection_name 'foobarbazwickdoesnotexist'
       end
 
-      should "work with :index shortcut when defining key" do
-        @document.key :father, String, :index => true
-        MongoMapper.ensure_indexes!
+      klass.count.should == 0
+    end
 
-        @document.should have_index('father_1')
-      end
+    should "return count for matching documents if conditions provided" do
+      @document.count(:age => 27).should == 1
     end
-  end # Document Class Methods
 
-  context "Saving a new document" do
+    should "convert the conditions to mongo criteria" do
+      @document.count(:age => [26, 27]).should == 2
+    end
+  end
+  
+  should "have instance method for collection" do
+    @document.new.collection.name.should == @document.collection.name
+  end
+  
+  should "have instance method for database" do
+    @document.new.database.should == @document.database
+  end
+
+  context "#save (new document)" do
     setup do
       @doc = @document.new(:first_name => 'John', :age => '27')
       @doc.save
@@ -815,7 +607,7 @@ class DocumentTest < Test::Unit::TestCase
     end
   end
 
-  context "Saving an existing document" do
+  context "#save (existing document)" do
     setup do
       @doc = @document.create(:first_name => 'John', :age => '27')
       @doc.first_name = 'Johnny'
@@ -846,7 +638,7 @@ class DocumentTest < Test::Unit::TestCase
     end
   end
 
-  context "Calling update attributes on a new document" do
+  context "#update_attributes (new document)" do
     setup do
       @doc = @document.new(:first_name => 'John', :age => '27')
       @doc.update_attributes(:first_name => 'Johnny', :age => 30)
@@ -878,7 +670,7 @@ class DocumentTest < Test::Unit::TestCase
     end
   end
 
-  context "Updating an existing document using update attributes" do
+  context "#update_attributes (existing document)" do
     setup do
       @doc = @document.create(:first_name => 'John', :age => '27')
       @doc.update_attributes(:first_name => 'Johnny', :age => 30)
@@ -900,7 +692,7 @@ class DocumentTest < Test::Unit::TestCase
     end
   end
 
-  context "update_attributes" do
+  context "#update_attributes" do
     setup do
       @document.key :foo, String, :required => true
     end
@@ -913,8 +705,54 @@ class DocumentTest < Test::Unit::TestCase
       @document.new.update_attributes({}).should be_false
     end
   end
+  
+  context "#save (with validations off)" do
+    setup do
+      @document = Doc do
+        key :name, String, :required => true
+      end
+    end
 
-  context "Destroying a document that exists" do
+    should "insert document" do
+      doc = @document.new
+      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
+    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.new(:name => 'John')
+      doc.save
+      
+      assert_raises(Mongo::OperationFailure) do
+        @document.new(:name => 'John').save(:safe => true)
+      end
+    end
+  end
+
+  context "#destroy" do
     setup do
       @doc = @document.create(:first_name => 'John', :age => '27')
       @doc.destroy
@@ -923,30 +761,35 @@ class DocumentTest < Test::Unit::TestCase
     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
-
-    should "do nothing if destroy is called again" do
-      @doc.destroy.should be_false
-    end
   end
-
-  context "Destroying a document that is a new" do
+  
+  context "#delete" 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
+      @doc1 = @document.create({:first_name => 'John', :last_name => 'Nunemaker', :age => '27'})
+      @doc2 = @document.create({:first_name => 'Steve', :last_name => 'Smith', :age => '28'})
+      
+      @document.class_eval do
+        before_destroy :before_destroy_callback
+        after_destroy :after_destroy_callback
+        
+        def history; @history ||= [] end
+        def before_destroy_callback; history << :after_destroy end
+        def after_destroy_callback;  history << :after_destroy end
       end
+      
+      @doc1.delete
+    end
 
-      should "raise error if assignment is attempted" do
-        lambda { @doc.first_name = 'Foo' }.should raise_error(TypeError)
-      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
+    
+    should "not call before/after destroy callbacks" do
+      @doc1.history.should == []
     end
   end
 
@@ -1164,6 +1007,28 @@ class DocumentTest < Test::Unit::TestCase
     end
   end
 
+  context "userstamping" do
+    setup do
+      @document.userstamps!
+    end
+    
+    should "add creator_id key" do
+      @document.keys.keys.should include('creator_id')
+    end
+    
+    should "add updater_id key" do
+      @document.keys.keys.should include('updater_id')
+    end
+    
+    should "add belongs_to creator" do
+      @document.associations.keys.should include('creator')
+    end
+    
+    should "add belongs_to updater" do
+      @document.associations.keys.should include('updater')
+    end
+  end
+
   context "#exist?" do
     setup do
       @doc = @document.create(:first_name => "James", :age => 27)
@@ -1187,16 +1052,13 @@ class DocumentTest < Test::Unit::TestCase
     end
   end
 
-  context "reload" do
+  context "#reload" do
     setup do
-      @foo_class = Class.new do
-        include MongoMapper::Document
+      @foo_class = Doc do
         key :name
       end
-      @foo_class.collection.remove
       
-      @bar_class = Class.new do
-        include MongoMapper::EmbeddedDocument
+      @bar_class = EDoc do
         key :name
       end
       
@@ -1232,4 +1094,78 @@ 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
+      @id = Mongo::ObjectID.new
+      @document.collection.insert({
+        :_id            => @id,
+        :first_name     => 'John',
+        :last_name      => 'Nunemaker',
+        :age            => 27,
+        :favorite_color => 'red',
+        :skills         => ['ruby', 'rails', 'javascript', 'xhtml', 'css']
+      })
+    end
+
+    should "assign all keys from database" do
+      doc = @document.find(@id)
+      doc.first_name.should == 'John'
+      doc.last_name.should == 'Nunemaker'
+      doc.age.should == 27
+      doc.favorite_color.should == 'red'
+      doc.skills.should == ['ruby', 'rails', 'javascript', 'xhtml', 'css']
+    end
+  end
+
+  context "Indexing" do
+    setup do
+      MongoMapper.ensured_indexes = []
+      @document.collection.drop_indexes
+    end
+
+    should "allow creating index for a key" do
+      @document.ensure_index :first_name
+      MongoMapper.ensure_indexes!
+
+      @document.should have_index('first_name_1')
+    end
+
+    should "allow creating unique index for a key" do
+      @document.ensure_index :first_name, :unique => true
+      MongoMapper.ensure_indexes!
+
+      @document.should have_index('first_name_1')
+    end
+
+    should "allow creating index on multiple keys" do
+      @document.ensure_index [[:first_name, 1], [:last_name, -1]]
+      MongoMapper.ensure_indexes!
+
+      # order is different for different versions of ruby so instead of
+      # just checking have_index('first_name_1_last_name_-1') I'm checking
+      # the values of the indexes to make sure the index creation was successful
+      @document.collection.index_information.detect do |index|
+        keys = index[1]
+        keys.include?(['first_name', 1]) && keys.include?(['last_name', -1])
+      end.should_not be_nil
+    end
+
+    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
 end