mongo_mapper 0.5.0

data/test/functional/test_embedded_document.rb

@@ -0,0 +1,97 @@
+require 'test_helper'
+require 'models'
+
+class EmbeddedDocumentTest < Test::Unit::TestCase
+  def setup
+    @document = Class.new do
+      include MongoMapper::Document
+      set_collection_name 'users'
+
+      key :first_name, String
+      key :last_name, String
+    end
+    @document.collection.clear
+  end
+  
+  context "Saving a document with an embedded document" do
+    setup do
+      @document.class_eval do
+        key :foo, Address
+      end
+      
+      @address = Address.new(:city => 'South Bend', :state => 'IN')
+      @doc = @document.new(:foo => @address)
+    end
+    
+    should "embed embedded document" do
+      @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 "new?" do
+    setup do
+      @document.class_eval do
+        key :foo, Address
+      end
+    end
+
+    should "be new until document is saved" do
+      address = Address.new(:city => 'South Bend', :state => 'IN')
+      doc = @document.new(:foo => address)
+      address.new?.should == true
+    end
+    
+    should "not be new after document is saved" do
+      address = Address.new(:city => 'South Bend', :state => 'IN')
+      doc = @document.new(:foo => address)
+      doc.save
+      doc.foo.new?.should == false
+    end
+    
+    should "not be new when document is read back" do
+      address = Address.new(:city => 'South Bend', :state => 'IN')
+      doc = @document.new(:foo => address)
+      doc.save
+      read_doc = @document.find(doc.id)
+      read_doc.foo.new?.should == false
+    end
+  end
+  
+  context "save" do
+    should "save the root document" do
+      person = RealPerson.create
+
+      pet = Pet.new :name => 'sparky'
+      person.pets << pet
+      pet.save
+
+      doc = RealPerson.find(person.id)
+      doc.pets.first.should == pet
+    end
+  end
+  
+  context "update_attributes" do
+    should "save the root document" do
+      person = RealPerson.create
+
+      pet = Pet.new(:name => 'sparky')
+      person.pets << pet
+      pet.save
+
+      doc = RealPerson.find(person.id)
+      pet = doc.pets.first
+      pet.update_attributes :name => 'koda'
+
+      doc = RealPerson.find(person.id)
+      embedded = doc.pets.first
+      embedded.id.should == pet.id
+      embedded.name.should == 'koda'
+    end
+  end  
+end

data/test/functional/test_pagination.rb

@@ -0,0 +1,87 @@
+require 'test_helper'
+
+class PaginationTest < Test::Unit::TestCase
+  context "Paginating" do
+    setup do
+      @document = Class.new do
+        include MongoMapper::Document
+        set_collection_name 'users'
+
+        key :first_name, String
+        key :last_name, String
+        key :age, Integer
+        
+        def self.per_page; 1 end
+      end
+      @document.collection.clear
+      
+      @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 the total pages" do
+      result = @document.paginate(:per_page => 2, :page => 1)
+      result.total_pages.should == 2
+    end
+    
+    should "return the total pages when defaulting to the document class per_page" do
+      result = @document.paginate(:page => 1)
+      result.total_pages.should == 3
+    end
+    
+    should "return the total of records" do
+      result = @document.paginate(:per_page => 2, :page => 1)
+      result.total_entries.should == 3
+    end
+
+    should "return the items" do
+      result = @document.paginate(:per_page => 2, :page => 1, :order => 'first_name')
+      result.size.should == 2
+      result.should == [@doc1, @doc3]
+    end
+
+    should "accept conditions" do
+      result = @document.paginate({
+        :conditions => {:last_name => 'Nunemaker'},
+        :order      => "age DESC",
+        :per_page   => 2, 
+        :page       => 1,
+      })
+      result.should == [@doc1, @doc3]
+      result.first.age.should == 27
+    end
+    
+    should "withstand rigor" do
+      result = @document.paginate({
+        :per_page   => 1, 
+        :page       => 1,
+        :order      => 'age desc', 
+        :conditions => {:last_name => 'Nunemaker'}
+      })
+      result.should == [@doc1]
+      result.total_entries.should == 2
+      result.total_pages.should == 2
+      
+      result = @document.paginate({
+        :per_page   => 1,
+        :page       => 2,
+        :order      => 'age desc',
+        :conditions => {:last_name => 'Nunemaker'}
+      })
+      result.should == [@doc3]
+      result.total_entries.should == 2
+      result.total_pages.should == 2
+      
+      result = @document.paginate({
+        :per_page   => 2, 
+        :page       => 1, 
+        :order      => 'age desc',
+        :conditions => {:last_name => 'Nunemaker'}
+      })
+      result.should == [@doc1, @doc3]
+      result.total_entries.should == 2
+      result.total_pages.should == 1
+    end
+  end
+end

data/test/functional/test_rails_compatibility.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+class TestRailsCompatibility < Test::Unit::TestCase
+  class Item
+    include MongoMapper::EmbeddedDocument
+    key :for_all, String
+  end
+  
+  class Order
+    include MongoMapper::Document
+    many :items, :class_name => 'TestRailsCompatibility::Item'
+    key :order_only, String
+  end
+  
+  context "Document" do
+    setup do
+      Order.collection.clear
+    end
+  
+    should "have to_param that returns id" do
+      instance = Order.create('_id' => 1234)
+      instance.to_param.should == '1234'
+    end
+
+    should "alias new to new_record?" do
+      instance = Order.new
+      instance.new_record?.should == instance.new?
+    end
+  end
+end

data/test/functional/test_validations.rb

@@ -0,0 +1,279 @@
+require 'test_helper'
+
+class ValidationsTest < Test::Unit::TestCase  
+  context "Saving a new document that is invalid" do
+    setup do
+      @document = Class.new do
+        include MongoMapper::Document
+        set_collection_name 'test'
+        key :name, String, :required => true
+      end
+      @document.collection.clear
+    end
+    
+    should "not insert document" do
+      doc = @document.new
+      doc.save
+      @document.count.should == 0
+    end
+    
+    should "populate document's errors" do
+      doc = @document.new
+      doc.errors.size.should == 0
+      doc.save
+      doc.errors.full_messages.should == ["Name can't be empty"]
+    end
+  end
+  
+  context "Saving a document that is invalid (destructive)" do
+    setup do
+      @document = Class.new do
+        include MongoMapper::Document
+        set_collection_name 'test'
+        key :name, String, :required => true
+      end
+      @document.collection.clear
+    end
+    
+    should "raise error" do
+      doc = @document.new
+      lambda { doc.save! }.should raise_error(MongoMapper::DocumentNotValid)
+    end
+  end
+  
+  context "Saving an existing document that is invalid" do
+    setup do
+      @document = Class.new do
+        include MongoMapper::Document
+        set_collection_name 'test'
+        key :name, String, :required => true
+      end
+      @document.collection.clear
+      
+      @doc = @document.create(:name => 'John Nunemaker')
+    end
+    
+    should "not update document" do
+      @doc.name = nil
+      @doc.save
+      @document.find(@doc.id).name.should == 'John Nunemaker'
+    end
+    
+    should "populate document's errors" do
+      @doc.name = nil
+      @doc.save
+      @doc.errors.full_messages.should == ["Name can't be empty"]
+    end
+  end
+  
+  context "Adding validation errors" do
+    setup do
+      @document = Class.new do
+        include MongoMapper::Document
+        set_collection_name 'test'
+        
+        key :action, String
+        def action_present
+          errors.add(:action, 'is invalid') if action.blank?
+        end
+      end
+      @document.collection.clear
+    end
+    
+    should "work with validate_on_create callback" do
+      @document.validate_on_create :action_present
+      
+      doc = @document.new
+      doc.action = nil
+      doc.should have_error_on(:action)
+      
+      doc.action = 'kick'
+      doc.should_not have_error_on(:action)
+      doc.save
+      
+      doc.action = nil
+      doc.should_not have_error_on(:action)
+    end
+    
+    should "work with validate_on_update callback" do
+      @document.validate_on_update :action_present
+      
+      doc = @document.new
+      doc.action = nil
+      doc.should_not have_error_on(:action)
+      doc.save
+      
+      doc.action = nil
+      doc.should have_error_on(:action)
+      
+      doc.action = 'kick'
+      doc.should_not have_error_on(:action)
+    end
+  end
+  
+  context "validating uniqueness of" do
+    setup do
+      @document = Class.new do
+        include MongoMapper::Document
+        set_collection_name 'test'
+        
+        key :name, String
+        validates_uniqueness_of :name
+      end
+      @document.collection.clear
+    end
+
+    should "not fail if object is new" do
+      doc = @document.new
+      doc.should_not have_error_on(:name)
+    end
+
+    should "not fail when new object is out of scope" do
+      document = Class.new do
+        include MongoMapper::Document
+        set_collection_name 'test'
+        
+        key :name
+        key :adult
+        validates_uniqueness_of :name, :scope => :adult
+      end
+      doc = document.new("name" => "joe", :adult => true)
+      doc.save.should be_true
+
+      doc2 = document.new("name" => "joe", :adult => false)
+      doc2.should be_valid
+
+    end
+
+    should "allow to update an object" do
+      doc = @document.new("name" => "joe")
+      doc.save.should be_true
+
+      @document \
+        .stubs(:find) \
+        .with(:first, :conditions => {:name => 'joe'}, :limit => 1) \
+        .returns(doc)
+
+      doc.name = "joe"
+      doc.valid?.should be_true
+      doc.should_not have_error_on(:name)
+    end
+
+    should "fail if object name is not unique" do
+      doc = @document.new("name" => "joe")
+      doc.save.should be_true
+
+      @document \
+        .stubs(:find) \
+        .with(:first, :conditions => {:name => 'joe'}, :limit => 1) \
+        .returns(doc)
+
+      doc2 = @document.new("name" => "joe")
+      doc2.should have_error_on(:name)
+    end
+    
+    context "scoped by a single attribute" do
+      setup do
+        @document = Class.new do
+          include MongoMapper::Document
+          set_collection_name 'test'
+          
+          key :name, String
+          key :scope, String
+          validates_uniqueness_of :name, :scope => :scope
+        end
+        @document.collection.clear
+      end
+      
+      should "fail if the same name exists in the scope" do
+        doc = @document.new("name" => "joe", "scope" => "one")
+        doc.save.should be_true
+        
+        @document \
+          .stubs(:find) \
+          .with(:first, :conditions => {:name => 'joe', :scope => "one"}, :limit => 1) \
+          .returns(doc)
+
+        doc2 = @document.new("name" => "joe", "scope" => "one")
+        doc2.should have_error_on(:name)
+      end
+      
+      should "pass if the same name exists in a different scope" do
+        doc = @document.new("name" => "joe", "scope" => "one")
+        doc.save.should be_true
+        
+        @document \
+          .stubs(:find) \
+          .with(:first, :conditions => {:name => 'joe', :scope => "two"}, :limit => 1) \
+          .returns(nil)
+
+        doc2 = @document.new("name" => "joe", "scope" => "two")
+        doc2.should_not have_error_on(:name)
+      end
+    end
+    
+    context "scoped by a multiple attributes" do
+      setup do
+        @document = Class.new do
+          include MongoMapper::Document
+          set_collection_name 'test'
+          
+          key :name, String
+          key :first_scope, String
+          key :second_scope, String
+          validates_uniqueness_of :name, :scope => [:first_scope, :second_scope]
+        end
+        @document.collection.clear
+      end
+      
+      should "fail if the same name exists in the scope" do
+        doc = @document.new("name" => "joe", "first_scope" => "one", "second_scope" => "two")
+        doc.save.should be_true
+        
+        @document \
+          .stubs(:find) \
+          .with(:first, :conditions => {:name => 'joe', :first_scope => "one", :second_scope => "two"}, :limit => 1) \
+          .returns(doc)
+
+        doc2 = @document.new("name" => "joe", "first_scope" => "one", "second_scope" => "two")
+        doc2.should have_error_on(:name)
+      end
+      
+      should "pass if the same name exists in a different scope" do
+        doc = @document.new("name" => "joe", "first_scope" => "one", "second_scope" => "two")
+        doc.save.should be_true
+        
+        @document \
+          .stubs(:find) \
+          .with(:first, :conditions => {:name => 'joe', :first_scope => "one", :second_scope => "one"}, :limit => 1) \
+          .returns(nil)
+
+        doc2 = @document.new("name" => "joe", "first_scope" => "one", "second_scope" => "one")
+        doc2.should_not have_error_on(:name)
+      end
+    end
+  end
+  
+  context "validates uniqueness of with :unique shortcut" do
+    should "work" do
+      @document = Class.new do
+        include MongoMapper::Document
+        set_collection_name 'test'
+        
+        key :name, String, :unique => true
+      end
+      @document.collection.clear
+      
+      doc = @document.create(:name => 'John')
+      doc.should_not have_error_on(:name)
+      
+      @document \
+        .stubs(:find) \
+        .with(:first, :conditions => {:name => 'John'}, :limit => 1) \
+        .returns(doc)
+      
+      second_john = @document.create(:name => 'John')
+      second_john.should have_error_on(:name, 'has already been taken')
+    end
+  end
+end