shingara-mongomapper 0.3.3

data/test/unit/test_observing.rb

@@ -0,0 +1,101 @@
+require 'test_helper'
+
+class Comment
+  include MongoMapper::Document
+  
+  key :name, String
+  key :body, String
+  
+  attr_accessor :callers
+  before_validation :record_callers
+
+  def after_validation
+    record_callers
+  end
+
+  def record_callers
+    callers << self.class if callers
+  end
+end
+
+class Article
+  include MongoMapper::Document
+  
+  key :title, String
+  key :body, String
+end
+
+class CommentObserver < MongoMapper::Observer
+  attr_accessor :callers
+
+  def after_validation(model)
+    callers << self.class if callers
+  end
+end
+
+class AuditObserver < MongoMapper::Observer
+  observe Article, Comment
+  attr_reader :document
+  
+  def after_validation(document)
+    @document = document
+  end
+end
+
+class GlobalObserver < MongoMapper::Observer
+  observe Article, Comment
+  attr_reader :document
+  
+  def before_save(document)
+    @document = document
+  end
+end
+
+class NonAutomaticObserver < MongoMapper::Observer
+  observe Comment
+  attr_reader :comment
+  
+  def after_validation(comment)
+    @comment = comment
+  end
+end
+
+class ObserverTest < Test::Unit::TestCase  
+  should "fire model callbacks before observer" do
+    callers = []
+    comment = Comment.new
+    comment.callers = callers
+
+    CommentObserver.instance.callers = callers
+
+    comment.valid?
+    callers.should == [Comment, Comment, CommentObserver]
+  end
+  
+  should "automatically observe model based on name when possible" do
+    CommentObserver.observed_class.should == Comment
+  end
+  
+  should "be able to observe other models using observe" do
+    obs = NonAutomaticObserver.instance
+    comment = Comment.new(:name => 'John Nunemaker', :body => 'is awesome')
+    comment.valid?
+    obs.comment.name.should == 'John Nunemaker'
+    obs.comment.body.should == 'is awesome'
+  end
+  
+  should "be able to observe multiple models" do
+    obs = AuditObserver.instance
+    comment = Comment.new(:name => 'Steve Smith', :body => 'is awesome')
+    comment.valid?
+    
+    obs.document.name.should == 'Steve Smith'
+    obs.document.body.should == 'is awesome'
+    
+    article = Article.new(:title => 'Ordered List Is Awesome', :body => 'Learn to accept it!')
+    article.valid?
+    
+    obs.document.title.should == 'Ordered List Is Awesome'
+    obs.document.body.should == 'Learn to accept it!'
+  end
+end

data/test/unit/test_pagination.rb

@@ -0,0 +1,113 @@
+require 'test_helper'
+
+class PaginationTest < Test::Unit::TestCase  
+  context "Pagination proxy" do
+    include MongoMapper::Pagination
+    
+    should "should have accessors for subject" do
+      subject = [1,2,3,4,5]
+      collection = PaginationProxy.new(25, 2)
+      collection.subject = subject
+      collection.subject.should == subject
+    end
+    
+    should "delegate any methods not defined to the subject" do
+      subject = [1,2,3,4,5]
+      collection = PaginationProxy.new(25, 2, 10)
+      collection.subject = subject
+      collection.size.should == 5
+      collection.each_with_index do |value, i|
+        value.should == subject[i]
+      end
+      collection[0..2].should == [1,2,3]
+      collection.class.should == Array
+    end
+    
+    should "return correct value for total_entries" do
+      PaginationProxy.new(25, 2, 10).total_entries.should == 25
+      PaginationProxy.new('25', 2, 10).total_entries.should == 25
+    end
+    
+    should "return correct value for per_page" do
+      PaginationProxy.new(25, 2, 10).per_page.should == 10
+      PaginationProxy.new(25, 2, '10').per_page.should == 10
+    end
+    
+    should "alias limit to per_page" do
+      PaginationProxy.new(100, 1, 300).limit.should == 300
+    end
+    
+    should "set per_page to 25 if nil or blank" do
+      PaginationProxy.new(25, 2).per_page.should == 25
+      PaginationProxy.new(25, 2, '').per_page.should == 25
+    end
+    
+    should "return correct value for current_page" do
+      PaginationProxy.new(25, 2, 10).current_page.should == 2
+      PaginationProxy.new(25, '2', 10).current_page.should == 2
+    end
+    
+    should "not allow value less than 1 for current page" do
+      PaginationProxy.new(25, -1).current_page.should == 1
+    end
+    
+    should "automatically calculate total_pages from total_entries and per page" do
+      PaginationProxy.new(25, 2, 10).total_pages.should == 3
+    end
+    
+    should "know how many records to skip" do
+      PaginationProxy.new(25, 2, 10).skip.should == 10
+    end
+    
+    should "alias offset to skip" do
+      PaginationProxy.new(25, 2, 10).offset.should == 10
+    end
+    
+    context "previous_page" do
+      should "be nil if current page 1" do
+        PaginationProxy.new(25, 1, 10).previous_page.should be_nil
+      end
+      
+      should "be one less than current page if current is > 1" do
+        PaginationProxy.new(25, 2, 10).previous_page.should == 1
+      end
+    end
+    
+    context "next_page" do
+      should "be nil if current page is last page" do
+        PaginationProxy.new(25, 3, 10).next_page.should be_nil
+      end
+      
+      should "work for any page that is not last" do
+        PaginationProxy.new(25, 1, 10).next_page.should == 2
+        PaginationProxy.new(25, 2, 10).next_page.should == 3
+      end
+    end
+    
+    context "previous_page" do
+      should "be nil if current page is first page" do
+        PaginationProxy.new(25, 1, 10).previous_page.should be_nil
+      end
+      
+      should "work for any page other than first" do
+        PaginationProxy.new(25, 2, 10).previous_page.should == 1
+        PaginationProxy.new(25, 3, 10).previous_page.should == 2
+      end
+    end
+    
+    context "out_of_bounds?" do
+      should "be true if current_page is greater than total_pages" do
+        PaginationProxy.new(25, 10, 4).out_of_bounds?.should be_true
+      end
+      
+      should "be false if current_page is less than total_pages" do
+        PaginationProxy.new(25, 10, 1).out_of_bounds?.should be_false
+        PaginationProxy.new(25, 2, 10).out_of_bounds?.should be_false
+      end
+      
+      should "be false if current_page is equal to total_pages" do
+        PaginationProxy.new(25, 3, 10).out_of_bounds?.should be_false
+      end
+    end
+  end # end of pagination proxy
+end # end of test case

data/test/unit/test_rails_compatibility.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+class TestRailsCompatibility < Test::Unit::TestCase
+  class Item
+    include MongoMapper::EmbeddedDocument
+    key :for_all, String
+  end
+
+  class FirstItem < Item  
+    key :first_only, String
+    many :second_items
+  end
+
+  class SecondItem < Item
+    key :second_only, String
+  end
+  
+  context "EmbeddedDocument" do
+    should "raise error for to_param as embedded do not have id's" do
+      lambda { Item.new.to_param }.should raise_error
+    end
+    
+    should "alias many to has_many" do
+      FirstItem.should respond_to(:has_many)
+      FirstItem.method(:has_many).should == FirstItem.method(:many)
+    end
+    
+    should "have column names" do
+      Item.column_names.sort.should == ['_id', 'for_all']
+      FirstItem.column_names.sort.should == ['_id', 'first_only', 'for_all']
+      SecondItem.column_names.sort.should == ['_id', 'for_all', 'second_only']
+    end
+  end
+end

data/test/unit/test_serializations.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+class SerializationTest < Test::Unit::TestCase
+  def setup
+    @document = Class.new do
+      include MongoMapper::EmbeddedDocument
+      key :name, String
+      key :age, Integer
+      key :awesome, Boolean
+      key :preferences, Hash
+      key :created_at, Time
+    end
+    
+    @instance = @document.new(
+      :name        => 'John Doe',
+      :age         => 25,
+      :awesome     => true,
+      :preferences => {:language => 'Ruby'},
+      :created_at  => Time.now.change(:usec => 0)
+    )
+  end
+  
+  [:json].each do |format|
+    context format do
+      should "be reversable" do
+        serialized = @instance.send("to_#{format}")
+        unserialized = @document.new.send("from_#{format}", serialized)
+
+        assert_equal @instance, unserialized
+      end
+      
+      should "allow attribute only filtering" do
+        serialized = @instance.send("to_#{format}", :only => [ :age, :name ])
+        unserialized = @document.new.send("from_#{format}", serialized)
+
+        assert_equal @instance.name, unserialized.name
+        assert_equal @instance.age, unserialized.age
+        assert_nil unserialized.awesome
+        assert_nil unserialized.created_at
+      end
+      
+      should "allow attribute except filtering" do
+        serialized = @instance.send("to_#{format}", :except => [ :age, :name ])
+        unserialized = @document.new.send("from_#{format}", serialized)
+        
+        assert_nil unserialized.name
+        assert_nil unserialized.age
+        assert_equal @instance.awesome, unserialized.awesome
+      end
+    end
+  end
+end

data/test/unit/test_validations.rb

@@ -0,0 +1,259 @@
+require 'test_helper'
+
+class ValidationsTest < Test::Unit::TestCase
+  context "Validations" do
+    setup do
+      @document = Class.new do
+        include MongoMapper::Document
+      end
+    end
+
+    context "Validating acceptance of" do
+      should "work with validates_acceptance_of macro" do
+        @document.key :terms, String
+        @document.validates_acceptance_of :terms
+        doc = @document.new(:terms => '')
+        doc.should have_error_on(:terms)
+        doc.terms = '1'
+        doc.should_not have_error_on(:terms)
+      end
+    end
+
+    context "validating confirmation of" do
+      should "work with validates_confirmation_of macro" do
+        @document.key :password, String
+        @document.validates_confirmation_of :password
+        doc = @document.new
+        doc.password = 'foobar'
+        doc.should have_error_on(:password)
+        doc.password_confirmation = 'foobar'
+        doc.should_not have_error_on(:password)
+      end
+    end
+
+    context "validating format of" do
+      should "work with validates_format_of macro" do
+        @document.key :name, String
+        @document.validates_format_of :name, :with => /.+/
+        doc = @document.new
+        doc.should have_error_on(:name)
+        doc.name = 'John'
+        doc.should_not have_error_on(:name)
+      end
+
+      should "work with :format shorcut key" do
+        @document.key :name, String, :format => /.+/
+        doc = @document.new
+        doc.should have_error_on(:name)
+        doc.name = 'John'
+        doc.should_not have_error_on(:name)
+      end
+    end
+
+    context "validating length of" do
+      should "work with validates_length_of macro" do
+        @document.key :name, String
+        @document.validates_length_of :name, :minimum => 5
+        doc = @document.new
+        doc.should have_error_on(:name)
+      end
+
+      context "with :length => integer shortcut" do
+        should "set maximum of integer provided" do
+          @document.key :name, String, :length => 5
+          doc = @document.new
+          doc.name = '123456'
+          doc.should have_error_on(:name)
+          doc.name = '12345'
+          doc.should_not have_error_on(:name)
+        end
+      end
+
+      context "with :length => range shortcut" do
+        setup do
+          @document.key :name, String, :length => 5..7
+        end
+
+        should "set minimum of range min" do
+          doc = @document.new
+          doc.should have_error_on(:name)
+          doc.name = '123456'
+          doc.should_not have_error_on(:name)
+        end
+
+        should "set maximum of range max" do
+          doc = @document.new
+          doc.should have_error_on(:name)
+          doc.name = '12345678'
+          doc.should have_error_on(:name)
+          doc.name = '123456'
+          doc.should_not have_error_on(:name)
+        end
+      end
+
+      context "with :length => hash shortcut" do
+        should "pass options through" do
+          @document.key :name, String, :length => {:minimum => 2}
+          doc = @document.new
+          doc.should have_error_on(:name)
+          doc.name = '12'
+          doc.should_not have_error_on(:name)
+        end
+      end
+    end # validates_length_of
+
+    context "Validating numericality of" do
+      should "work with validates_numericality_of macro" do
+        @document.key :age, Integer
+        @document.validates_numericality_of :age
+        doc = @document.new
+        doc.age = 'String'
+        doc.should have_error_on(:age)
+        doc.age = 23
+        doc.should_not have_error_on(:age)
+      end
+
+      context "with :numeric shortcut" do
+        should "work with integer or float" do
+          @document.key :weight, Float, :numeric => true
+          doc = @document.new
+          doc.weight = 'String'
+          doc.should have_error_on(:weight)
+          doc.weight = 23.0
+          doc.should_not have_error_on(:weight)
+          doc.weight = 23
+          doc.should_not have_error_on(:weight)
+        end
+      end
+
+      context "with :numeric shortcut on Integer key" do
+        should "only work with integers" do
+          @document.key :age, Integer, :numeric => true
+          doc = @document.new
+          doc.age = 'String'
+          doc.should have_error_on(:age)
+          doc.age = 23.1
+          doc.should have_error_on(:age)
+          doc.age = 23
+          doc.should_not have_error_on(:age)
+        end
+      end
+    end # numericality of
+
+    context "validating presence of" do
+      should "work with validates_presence_of macro" do
+        @document.key :name, String
+        @document.validates_presence_of :name
+        doc = @document.new
+        doc.should have_error_on(:name)
+      end
+
+      should "work with :required shortcut on key definition" do
+        @document.key :name, String, :required => true
+        doc = @document.new
+        doc.should have_error_on(:name)
+      end
+    end
+    
+    context "validating exclusion of" do
+      should "throw error if enumerator not provided" do
+        @document.key :action, String
+        lambda {
+          @document.validates_exclusion_of :action
+        }.should raise_error(ArgumentError)
+      end
+      
+      should "work with validates_exclusion_of macro" do
+        @document.key :action, String
+        @document.validates_exclusion_of :action, :within => %w(kick run)
+        
+        doc = @document.new
+        doc.should_not have_error_on(:action)
+        
+        doc.action = 'fart'
+        doc.should_not have_error_on(:action)
+        
+        doc.action = 'kick'
+        doc.should have_error_on(:action, 'is reserved')
+      end
+      
+      should "not have error if allow nil is true and value is nil" do
+        @document.key :action, String
+        @document.validates_exclusion_of :action, :within => %w(kick run), :allow_nil => true
+        
+        doc = @document.new
+        doc.should_not have_error_on(:action)
+      end
+
+      should "not have error if allow blank is true and value is blank" do
+        @document.key :action, String
+        @document.validates_exclusion_of :action, :within => %w(kick run), :allow_nil => true
+        
+        doc = @document.new(:action => '')
+        doc.should_not have_error_on(:action)
+      end
+    end
+
+    context "validating inclusion of" do
+      should "throw error if enumerator not provided" do
+        @document.key :action, String
+        lambda {
+          @document.validates_inclusion_of :action
+        }.should raise_error(ArgumentError)
+      end
+      
+      should "work with validates_inclusion_of macro" do
+        @document.key :action, String
+        @document.validates_inclusion_of :action, :within => %w(kick run)
+        
+        doc = @document.new
+        doc.should have_error_on(:action, 'is not in the list')
+        
+        doc.action = 'fart'
+        doc.should have_error_on(:action, 'is not in the list')
+        
+        doc.action = 'kick'
+        doc.should_not have_error_on(:action)
+      end
+      
+      should "not have error if allow nil is true and value is nil" do
+        @document.key :action, String
+        @document.validates_inclusion_of :action, :within => %w(kick run), :allow_nil => true
+        
+        doc = @document.new
+        doc.should_not have_error_on(:action)
+      end
+      
+      should "not have error if allow blank is true and value is blank" do
+        @document.key :action, String
+        @document.validates_inclusion_of :action, :within => %w(kick run), :allow_blank => true
+        
+        doc = @document.new(:action => '')
+        doc.should_not have_error_on(:action)
+      end
+    end
+  end # Validations
+
+  context "Adding validation errors" do
+    setup do
+      @document = Class.new do
+        include MongoMapper::Document
+        key :action, String
+        def action_present
+          errors.add(:action, 'is invalid') if action.blank?
+        end
+      end
+    end
+
+    should "work with validate callback" do
+      @document.validate :action_present
+
+      doc = @document.new
+      doc.action = nil
+      doc.should have_error_on(:action)
+
+      doc.action = 'kick'
+      doc.should_not have_error_on(:action)
+    end
+  end
+end