lookout-mongo_mapper 0.11.3

data/test/functional/test_timestamps.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+class TimestampsTest < Test::Unit::TestCase
+  context "timestamping" do
+    setup do
+      @klass = Doc do
+        key :first_name, String
+        key :last_name, String
+        key :age, Integer
+        key :date, Date
+      end
+      @klass.timestamps!
+    end
+
+    should "set created_at and updated_at on create" do
+      doc = @klass.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 "not overwrite created_at if it already exists" do
+      original_created_at = 1.month.ago
+      doc = @klass.new(:first_name => 'John', :age => 27, :created_at => original_created_at)
+      doc.created_at.to_i.should == original_created_at.to_i
+      doc.updated_at.should be_nil
+      doc.save
+      doc.created_at.to_i.should == original_created_at.to_i
+      doc.updated_at.should_not be_nil
+    end
+
+    should "set updated_at on field update but leave created_at alone" do
+      doc = @klass.create(:first_name => 'John', :age => 27)
+      old_created_at = doc.created_at
+      old_updated_at = doc.updated_at
+      doc.first_name = 'Johnny'
+
+      Timecop.freeze(Time.now + 5.seconds) do
+        doc.save
+      end
+
+      doc.created_at.should == old_created_at
+      doc.updated_at.should_not == old_updated_at
+    end
+
+    should "set updated_at on document update but leave created_at alone" do
+      doc = @klass.create(:first_name => 'John', :age => 27)
+      old_created_at = doc.created_at.to_f
+
+      new_updated_at = Time.now + 5.seconds
+      Timecop.freeze(new_updated_at) do
+        @klass.update(doc._id, { :first_name => 'Johnny' })
+      end
+
+      doc = doc.reload
+      doc.created_at.to_f.should be_close(old_created_at, 0.001)
+      doc.updated_at.to_f.should be_close(new_updated_at.to_f, 0.001)
+    end
+  end
+end

data/test/functional/test_touch.rb

@@ -0,0 +1,125 @@
+require 'test_helper'
+
+class TouchTest < Test::Unit::TestCase
+  context "touch" do
+    context "document" do
+      setup do
+        @document = Doc { timestamps! }
+      end
+
+      should "update the updated_at timestamp" do
+        doc = @document.create
+        old_updated_at = doc.updated_at
+
+        Timecop.freeze(Time.now + 1.day) do
+          doc.touch
+        end
+
+        doc.reload
+        doc.updated_at.should_not == old_updated_at      
+      end
+    end
+
+    context "embedded document" do
+      should "update the updated_at timestamp" do
+        Doc = Doc("Document") { timestamps!}
+        Emdoc = EDoc("EmbeddedDocument") { timestamps! }
+        Doc.has_many :emdocs, :class => Emdoc
+
+        doc = Doc.create
+        emdoc = Emdoc.new
+        doc.emdocs << emdoc
+        doc.save
+
+        old_updated_at = emdoc.updated_at
+        document_old_updated_at = doc.updated_at
+
+        Timecop.freeze(Time.now + 1.day) do
+          emdoc.touch
+        end
+
+        doc.reload
+        emdoc.updated_at.should_not == old_updated_at
+        doc.updated_at.should_not == document_old_updated_at
+      end
+    end
+
+    context "association" do
+      setup do
+        @post_class = Doc("Post") do
+          key :touched_at, DateTime
+          timestamps!
+        end
+        @comment_class = Doc("Comment") do
+          key :post_id, ObjectId
+          key :text, String
+          timestamps!
+        end
+
+        @post_class.many :comments, :class => @comment_class
+      end
+
+      should 'not be true by default' do
+        @comment_class.belongs_to :post, :class => @post_class
+        @comment_class.associations[:post].touch?.should_not be_true
+      end
+
+      context 'touch the parent when true' do
+        setup do
+          @comment_class.belongs_to :post, :class => @post_class, :touch => true
+          @post = @post_class.create(:title => 'Hello, world!')
+          @comment = @post.comments.build
+        end
+
+        should "when the child is created" do
+          orig_updated_at = @post.updated_at
+          Timecop.freeze(Time.now + 1.day) do
+            @comment.save
+          end
+
+          @post.reload.updated_at.should_not == orig_updated_at
+        end
+        
+        should "when the child is updated" do
+          @comment.save
+          old_updated_at = @post.updated_at
+          Timecop.freeze(Time.now + 2.day) do
+            @comment.update_attributes(:text => "Something")
+          end
+          @post.reload.updated_at.should_not == old_updated_at
+        end
+        
+        should "when the child is touched" do
+          @comment.save
+          old_updated_at = @post.updated_at
+          Timecop.freeze(Time.now + 3.day) do
+            @comment.touch
+          end
+          @post.reload.updated_at.should_not == old_updated_at
+        end
+      end
+
+      context "when set to a symbol that is a key of parent" do
+        should "set that key on touch events" do
+          @comment_class.belongs_to :post, :class => @post_class, :touch => :touched_at
+          post = @post_class.create(:title => 'Hello, world!')
+          post.touched_at.should be_nil
+
+          comment = post.comments.build
+          comment.save
+          post.reload.touched_at.should_not be_nil
+        end
+      end
+
+      should 'not touch the parent when false' do
+        post = @post_class.create(:title => 'Hello, world!')
+        comment = post.comments.build
+        Timecop.freeze(Time.now + 1.day) do
+          comment.save
+        end
+      
+        post.reload.updated_at.should == post.created_at
+      end
+    end
+  end
+end

data/test/functional/test_userstamps.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+class UserstampsTest < Test::Unit::TestCase
+  class AltUser
+    include MongoMapper::Document
+  end
+
+  context "userstamping" do
+    setup do
+      @document = Doc do
+        userstamps!
+      end
+      @document_alt_user = Doc do
+        userstamps! :class_name => 'AltUser'
+      end
+      @document_alt_user_class = Doc do
+        userstamps! :class => AltUser
+      end
+      @docs = [@document, @document_alt_user, @document_alt_user_class]
+    end
+
+    should "add creator_id key" do
+      @docs.each{ |d| d.keys.should include('creator_id') }
+    end
+
+    should "add updater_id key" do
+      @docs.each{ |d| d.keys.should include('updater_id') }
+    end
+
+    should "add belongs_to creator" do
+      @docs.each{ |d| d.associations.keys.should include(:creator) }
+    end
+
+    should "add belongs_to updater" do
+      @docs.each{ |d| d.associations.keys.should include(:updater) }
+    end
+
+    should "properly set class names" do
+      @document.associations[:creator].class_name.should == 'User'
+      @document_alt_user.associations[:creator].class_name.should == 'AltUser'
+      @document_alt_user_class.associations[:creator].class_name.should == 'UserstampsTest::AltUser'
+    end
+  end
+end

data/test/functional/test_validations.rb

@@ -0,0 +1,414 @@
+require 'test_helper'
+
+class ValidationsTest < Test::Unit::TestCase
+  context "Saving a new document that is invalid" do
+    setup do
+      @document = Doc do
+        key :name, String, :required => true
+      end
+    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 blank"]
+    end
+  end
+
+  context "Saving a document that is invalid (destructive)" do
+    setup do
+      @document = Doc do
+        key :name, String, :required => true
+      end
+    end
+
+    should "raise error" do
+      doc = @document.new
+      lambda { doc.save! }.should raise_error(MongoMapper::DocumentNotValid)
+    end
+
+    should "set document on exception" do
+      doc = @document.new
+      begin
+        doc.save!
+      rescue MongoMapper::DocumentNotValid => e
+        e.document.should == doc
+      end
+    end
+  end
+
+  context "Creating a document that is invalid (destructive)" do
+    setup do
+      @document = Doc do
+        key :name, String, :required => true
+      end
+    end
+
+    should "raise error" do
+      lambda { @document.create! }.should raise_error(MongoMapper::DocumentNotValid)
+    end
+
+    should "create a new document" do
+      instance = @document.create!(:name => "James")
+      instance.new_record?.should be_false
+    end
+  end
+
+  context "Saving an existing document that is invalid" do
+    setup do
+      @document = Doc do
+        key :name, String, :required => true
+      end
+
+      @doc = @document.create(:name => 'John Nunemaker')
+    end
+
+    should "not update document" do
+      @doc.name = nil
+      @doc.save
+      @doc.reload.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 blank"]
+    end
+  end
+
+  context "Adding validation errors" do
+    setup do
+      @document = Doc do
+        key :action, String
+        def action_present
+          errors.add(:action, 'is invalid') if action.blank?
+        end
+      end
+    end
+
+    should "work with validate :on => :create callback" do
+      @document.validate :action_present, :on => :create
+
+      doc = @document.create(:action => nil)
+      doc.should have_error_on(:action)
+
+      doc.action = 'kick'
+      doc.save
+      doc.should_not have_error_on(:action)
+    end
+
+    should "work with validate :on => :update callback" do
+      @document.validate :action_present, :on => :update
+
+      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 = Doc do
+        key :name, String
+        validates_uniqueness_of :name
+      end
+    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 = Doc do
+        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 "work with i18n taken message" do
+      @document.create(:name => 'joe')
+      doc = @document.create(:name => 'joe')
+      doc.should have_error_on(:name, 'has already been taken')
+    end
+
+    should "allow to update an object" do
+      doc = @document.new("name" => "joe")
+      doc.save.should be_true
+
+      @document \
+        .stubs(:first) \
+        .with(:name => 'joe') \
+        .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(:first) \
+        .with(:name => 'joe') \
+        .returns(doc)
+
+      doc2 = @document.new("name" => "joe")
+      doc2.should have_error_on(:name)
+    end
+
+    should "allow multiple blank entries if :allow_blank => true" do
+      document = Doc do
+        key :name
+        validates_uniqueness_of :name, :allow_blank => :true
+      end
+
+      doc = document.new("name" => "")
+      doc.save.should be_true
+
+      document \
+        .stubs(:first) \
+        .with(:name => '') \
+        .returns(doc)
+
+      doc2 = document.new("name" => "")
+      doc2.should_not have_error_on(:name)
+    end
+
+    should "allow multiple nil entries if :allow_nil => true" do
+      document = Doc do
+        key :name
+        validates_uniqueness_of :name, :allow_nil => :true
+      end
+
+      doc = document.new('name' => nil)
+      doc.save.should be_true
+
+      doc2 = document.new('name' => nil)
+      doc2.should_not have_error_on(:name)
+    end
+
+    should "allow entries that differ only in case by default" do
+      document = Doc do
+        key :name
+        validates_uniqueness_of :name
+      end
+
+      doc = document.new("name" => "BLAMMO")
+      doc.save.should be_true
+
+      doc2 = document.new("name" => "blammo")
+      doc2.should_not have_error_on(:name)
+    end
+
+    context "with :case_sensitive => false" do
+      setup do
+        @document = Doc do
+          key :name
+          validates_uniqueness_of :name, :case_sensitive => false
+        end
+      end
+
+      should "fail on entries that differ only in case" do
+        doc = @document.new("name" => "BLAMMO")
+        doc.save.should be_true
+
+        doc2 = @document.new("name" => "blammo")
+        doc2.should have_error_on(:name)
+      end
+
+      should "not raise an error if value is nil" do
+        doc = @document.new("name" => nil)
+        lambda { doc.valid? }.should_not raise_error
+      end
+
+      should "not raise an error if special Regexp characters used" do
+        doc = @document.new("name" => '?')
+        lambda { doc.valid? }.should_not raise_error
+      end
+
+      should "check for uniqueness using entire string" do
+        doc = @document.new("name" => "John Doe")
+        doc.save.should be_true
+
+        doc2 = @document.new("name" => "John")
+        doc2.valid?.should be_true
+      end
+    end
+
+    context "scoped by a single attribute" do
+      setup do
+        @document = Doc do
+          key :name, String
+          key :scope, String
+          validates_uniqueness_of :name, :scope => :scope
+        end
+      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(:first) \
+          .with(:name => 'joe', :scope => "one") \
+          .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(:first) \
+          .with(:name => 'joe', :scope => 'two') \
+          .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 = Doc do
+          key :name, String
+          key :first_scope, String
+          key :second_scope, String
+          validates_uniqueness_of :name, :scope => [:first_scope, :second_scope]
+        end
+      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(:first) \
+          .with(:name => 'joe', :first_scope => 'one', :second_scope => 'two') \
+          .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(:first) \
+          .with(:name => 'joe', :first_scope => 'one', :second_scope => 'one') \
+          .returns(nil)
+
+        doc2 = @document.new("name" => "joe", "first_scope" => "one", "second_scope" => "one")
+        doc2.should_not have_error_on(:name)
+      end
+    end
+  end
+
+  context "validating associated docs" do
+    setup do
+      @child_class = EDoc do
+        key :name, :required => true
+      end
+
+      @root_class = Doc { }
+      @root_class.many :children, :class => @child_class
+      @root_class.validates_associated :children, :message => 'are invalid'
+    end
+    
+    should "pass if there are no associated docs" do
+      doc = @root_class.new
+      doc.save.should be_true
+    end
+    
+    should "pass if the associated doc is valid" do
+      doc = @root_class.new
+      doc.children.build(:name => 'Joe')
+      doc.save.should be_true
+    end
+
+    should "fail if the associated doc is invalid" do
+      doc = @root_class.new
+      doc.children.build
+      doc.should have_error_on(:children, 'are invalid')
+    end
+
+  end
+
+  context "validating associated docs with custom context" do
+    setup do
+      @child_class = EDoc do
+        key :name
+
+        validates_length_of :name, :minimum => 5, :on => :custom_context
+      end
+
+      @root_class = Doc { }
+      @root_class.many :children, :class => @child_class
+      @root_class.validates_associated :children, :context => :custom_context
+    end
+
+    should "pass if there are no associated docs" do
+      doc = @root_class.new
+      doc.valid?(:custom_context).should be_true
+    end
+
+    should "pass if the associated doc is valid" do
+      doc = @root_class.new
+      doc.children.build(:name => 'George')
+      doc.valid?(:custom_context).should be_true
+    end
+
+    should "fail if the associated doc is invalid" do
+      doc = @root_class.new
+      doc.children.build(:name => 'Bob')
+      doc.valid?(:custom_context).should_not be_true
+    end
+
+  end
+  # context "validates uniqueness of with :unique shortcut" do
+  #   should "work" do
+  #     @document = Doc do
+  #       key :name, String, :unique => true
+  #     end
+  #
+  #     doc = @document.create(:name => 'John')
+  #     doc.should_not have_error_on(:name)
+  #
+  #     @document \
+  #       .stubs(:first) \
+  #       .with(:name => 'John') \
+  #       .returns(doc)
+  #
+  #     second_john = @document.create(:name => 'John')
+  #     second_john.should have_error_on(:name, 'has already been taken')
+  #   end
+  # end
+end