honkster-mongo_mapper 0.8.4

data/test/functional/test_string_id_compatibility.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+class StringIdCompatibilityTest < Test::Unit::TestCase
+  def setup
+    @note_class = EDoc do
+      key :_id, String
+    end
+
+    @task_class = Doc do
+      key :_id, String
+      key :project_id, String
+      belongs_to :project
+    end
+
+    @project_class = Doc do
+      include MongoMapper::Document
+      key :_id, String
+    end
+
+    @task_class.belongs_to :project, :class => @project_class
+    @project_class.many :notes, :class => @note_class
+    @project_class.many :tasks, :class => @task_class, :foreign_key => 'project_id', :order => :position.asc
+  end
+
+  should "assign correct _id for documents" do
+    project = @project_class.create
+    project._id.should == project.id
+    project._id.should be_instance_of(String)
+    project.id.size.should == 24
+    lambda {
+      BSON::ObjectId.from_string(project.id)
+    }.should_not raise_error
+  end
+
+  should "assign correct _id for embedded documents" do
+    note = @note_class.new
+    note.id.should == note._id
+    note.id.size.should == 24
+  end
+
+  should "find records" do
+    project = @project_class.create
+    @project_class.find(project.id).should == project
+  end
+
+  should "save embedded docs" do
+    n1 = @note_class.new
+    n2 = @note_class.new
+    n3 = @note_class.new
+    project = @project_class.create(:notes => [n1, n2, n3])
+
+    project = project.reload
+    project.notes.size.should == 3
+    project.notes.should == [n1, n2, n3]
+  end
+
+  should "be able to associate records" do
+    t1 = @task_class.new(:body => 'First task', :position => 1)
+    t2 = @task_class.new(:body => 'Second task', :position => 2)
+    t3 = @task_class.new(:body => 'Third task', :position => 3)
+    project = @project_class.create(:name => 'MM', :tasks => [t1, t2, t3])
+
+    project = project.reload
+    project.tasks.count.should == 3
+    project.tasks.should == [t1, t2, t3]
+  end
+end

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
+      old_updated_at = doc.updated_at
+
+      Timecop.freeze(Time.now + 5.seconds) do
+        @klass.update(doc._id, { :first_name => 'Johnny' })
+      end
+
+      doc = doc.reload
+      doc.created_at.should == old_created_at
+      doc.updated_at.should_not == old_updated_at
+    end
+  end
+end

data/test/functional/test_userstamps.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class UserstampsTest < Test::Unit::TestCase
+  context "userstamping" do
+    setup do
+      @document = Doc do
+        userstamps!
+      end
+    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
+end

data/test/functional/test_validations.rb

@@ -0,0 +1,342 @@
+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 empty"]
+    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
+  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 empty"]
+    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_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 = 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 "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 "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