numon 0.0.1

data/test/functional/test_protected.rb

@@ -0,0 +1,161 @@
+require 'test_helper'
+
+class ProtectedTest < Test::Unit::TestCase
+  context 'A document with protected attributes' do
+    setup do
+      @doc_class = Doc do
+        key :name, String
+        key :admin, Boolean, :default => false
+
+        attr_protected :admin
+      end
+
+      @doc = @doc_class.create(:name => 'Steve Sloan')
+    end
+
+    should 'have protected attributes class method' do
+      @doc_class.protected_attributes.should == [:admin].to_set
+    end
+
+    should "default protected attributes to nil" do
+      Doc().protected_attributes.should be_nil
+    end
+
+    should "have protected attributes instance method" do
+      @doc.protected_attributes.should equal(@doc_class.protected_attributes)
+    end
+
+    should "work with :protected shortcut when defining key" do
+      Doc() do
+        key :user_id, ObjectId, :protected => true
+      end.protected_attributes.should == [:user_id].to_set
+    end
+
+    should 'assign protected attribute through accessor' do
+      @doc.admin = true
+      @doc.admin.should be_true
+    end
+
+    should "ignore protected attribute on #initialize" do
+      doc = @doc_class.new(:name => 'John', :admin => true)
+      doc.admin.should be_false
+      doc.name.should == 'John'
+    end
+
+    should "not ignore protected attributes on #initialize from the database" do
+      doc = @doc_class.new(:name => 'John')
+      doc.admin = true
+      doc.save!
+
+      doc = @doc_class.first(:name => 'John')
+      doc.admin.should be_true
+      doc.name.should == 'John'
+    end
+
+    should 'ignore protected attribute on #update_attributes' do
+      @doc.update_attributes(:name => 'Ren Hoek', :admin => true)
+      @doc.name.should == 'Ren Hoek'
+      @doc.admin.should be_false
+    end
+
+    should 'ignore protected attribute on #update_attributes!' do
+      @doc.update_attributes!(:name => 'Stimpson J. Cat', :admin => true)
+      @doc.name.should == 'Stimpson J. Cat'
+      @doc.admin.should be_false
+    end
+
+    should 'be indifferent to whether the protected keys are strings or symbols' do
+      @doc.update_attributes!("name" => 'Stimpson J. Cat', "admin" => true)
+      @doc.name.should == 'Stimpson J. Cat'
+      @doc.admin.should be_false
+    end
+  end
+
+  context "Single collection inherited protected attributes" do
+    setup do
+      class ::GrandParent
+        include MongoMapper::Document
+
+        key :_type, String
+        key :site_id, ObjectId
+
+        attr_protected :site_id
+      end
+      GrandParent.collection.remove
+
+      class ::Child < ::GrandParent
+        key :position, Integer
+
+        attr_protected :position
+      end
+
+      class ::GrandChild < ::Child; end
+
+      class ::OtherChild < ::GrandParent
+        key :blog_id, ObjectId
+
+        attr_protected :blog_id
+      end
+    end
+
+    teardown do
+      Object.send :remove_const, 'GrandParent' if defined?(::GrandParent)
+      Object.send :remove_const, 'Child'       if defined?(::Child)
+      Object.send :remove_const, 'GrandChild'  if defined?(::GrandChild)
+      Object.send :remove_const, 'OtherChild'  if defined?(::OtherChild)
+    end
+
+    should "share keys down the inheritance trail" do
+      GrandParent.protected_attributes.should == [:site_id].to_set
+      Child.protected_attributes.should == [:site_id, :position].to_set
+      GrandChild.protected_attributes.should == [:site_id, :position].to_set
+      OtherChild.protected_attributes.should == [:site_id, :blog_id].to_set
+    end
+  end
+
+  context 'An embedded document with protected attributes' do
+    setup do
+      @doc_class = Doc('Project')
+      @edoc_class = EDoc('Person') do
+        key :name, String
+        key :admin, Boolean, :default => false
+
+        attr_protected :admin
+      end
+      @doc_class.many :people, :class => @edoc_class
+
+      @doc = @doc_class.create(:title => 'MongoMapper')
+      @edoc = @edoc_class.new(:name => 'Steve Sloan')
+      @doc.people << @edoc
+    end
+
+    should 'have protected attributes class method' do
+      @edoc_class.protected_attributes.should == [:admin].to_set
+    end
+
+    should "default protected attributes to nil" do
+      EDoc().protected_attributes.should be_nil
+    end
+
+    should "have protected attributes instance method" do
+      @edoc.protected_attributes.should equal(@edoc_class.protected_attributes)
+    end
+
+    should 'assign protected attribute through accessor' do
+      @edoc.admin = true
+      @edoc.admin.should be_true
+    end
+
+    should 'ignore protected attribute on #update_attributes' do
+      @edoc.update_attributes(:name => 'Ren Hoek', :admin => true)
+      @edoc.name.should == 'Ren Hoek'
+      @edoc.admin.should be_false
+    end
+
+    should 'ignore protected attribute on #update_attributes!' do
+      @edoc.update_attributes!(:name => 'Stimpson J. Cat', :admin => true)
+      @edoc.name.should == 'Stimpson J. Cat'
+      @edoc.admin.should be_false
+    end
+  end
+end

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 {
+      Mongo::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,64 @@
+require 'test_helper'
+
+class TimestampsTest < Test::Unit::TestCase
+  context "timestamping" do
+    setup do
+      @klass = Doc do
+        set_collection_name 'users'
+
+        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,28 @@
+require 'test_helper'
+
+class UserstampsTest < Test::Unit::TestCase
+  context "userstamping" do
+    setup do
+      @document = Doc do
+        set_collection_name 'users'
+        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,329 @@
+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
+    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