mark_mapper 0.0.1

data/spec/functional/static_keys_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe MarkMapper::Plugins::Keys::Static do
+  before do
+    @klass = Class.new do
+      include MarkMapper::Document
+    end
+  end
+
+  it "is off by default" do
+    @klass.static_keys.should == false
+  end
+
+  it "can be turned on" do
+    @klass.static_keys = true
+    @klass.static_keys.should == true
+  end
+
+  describe "a class with static keys" do
+    before do
+      @klass = Class.new do
+        include MarkMapper::Document
+
+        self.static_keys = true
+
+        attr_accessor :an_accessor
+
+        key "valid_key", String
+      end
+
+      @obj = @klass.new
+    end
+
+    it "should be able to assign to a valid key" do
+      @obj.valid_key = "foo"
+      @obj.valid_key.should == "foo"
+    end
+
+    it "should raise a MissingKeyError if trying to assign to a field that does not exist" do
+      lambda {
+        @obj['foo'] = "foo"
+      }.should raise_error(MarkMapper::Plugins::Keys::Static::MissingKeyError)
+    end
+
+    it "should raise a MissingKeyError if trying to read from a field that does not exist" do
+      lambda {
+        @obj['foo']
+      }.should raise_error(MarkMapper::Plugins::Keys::Static::MissingKeyError)
+    end
+
+    it "should raise a MissingKeyError if trying to set attributes= to a field that does not exist" do
+      lambda {
+        @obj.attributes = {:foo => "foo"}
+      }.should raise_error(MarkMapper::Plugins::Keys::Static::MissingKeyError)
+    end
+
+    it "should be able to call a method" do
+      @obj.an_accessor = :bar
+      @obj.an_accessor.should == :bar
+    end
+
+    it "should raise a NoMethodError if trying to call the non-existant key method" do
+      lambda {
+        @obj.foo
+      }.should raise_error(NoMethodError)
+    end
+
+    it "should raise for read_key" do
+      lambda {
+        @obj.read_key('foo')
+      }.should raise_error(MarkMapper::Plugins::Keys::Static::MissingKeyError)
+    end
+
+    it "should raise for attribute" do
+      lambda {
+        @obj.attribute('foo')
+      }.should raise_error(MarkMapper::Plugins::Keys::Static::MissingKeyError)
+    end
+
+    it "should not raise if trying to assign to a field that exists (but with a symbol instead of a string)" do
+      lambda {
+        @obj.write_key(:valid_key, "foo")
+      }.should_not raise_error
+
+      @obj.valid_key.should == "foo"
+    end
+
+    it "should not raise a MissingKeyError if trying to read from a field that exists (but with a symbol instead of a string)" do
+      lambda {
+        @obj[:valid_key]
+      }.should_not raise_error
+    end
+
+    it "should not blow up when loading if there is a key defined in the db that has not been defined (but it should not load it)" do
+      @klass.collection.insert({ :foo => "bar", :valid_key => "something" })
+      @obj = @klass.first
+      @obj.valid_key.should == "something"
+
+      lambda {
+        @obj.foo
+      }.should raise_error(NoMethodError)
+    end
+  end
+
+  describe "a class without static keys" do
+    before do
+      @klass = Class.new do
+        include MarkMapper::Document
+        key :valid_key, String
+      end
+
+      @obj = @klass.new
+    end
+
+    it "should be able to assign to a valid key" do
+      @obj.valid_key = "foo"
+      @obj.valid_key.should == "foo"
+    end
+
+    it "should be able to read and assign a dynamic key" do
+      @obj['foo'].should be_nil
+      @obj['foo'] = "bar"
+      @obj['foo'].should == "bar"
+    end
+  end
+
+  describe "with mixed static + non static models" do
+    before do
+      @static_model = Class.new do
+        include MarkMapper::Document
+        self.static_keys = true
+      end
+
+      @non_static_model = Class.new do
+        include MarkMapper::Document
+        self.static_keys = false
+      end
+
+      @static_key_object = @static_model.new
+      @non_static_key_object = @non_static_model.new
+    end
+
+    it "should allow non-static key assignment to one, only static assignment to the other" do
+      @non_static_key_object['foo'] = 'bar'
+      @non_static_key_object.foo.should == 'bar'
+      @non_static_key_object['foo'].should == 'bar'
+
+      lambda {
+        @static_key_object['foo'] = 'bar'
+      }.should raise_error
+    end
+  end
+end

data/spec/functional/timestamps_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe "Timestamps" do
+  context "included" do
+    before do
+      @klass = Doc do
+        key :first_name, String
+      end
+      @klass.timestamps!
+    end
+
+    it "should set record_timestamps to true" do
+      @klass.record_timestamps.should be(true)
+    end
+  end
+
+  context "timestamping" do
+    before do
+      @klass = Doc do
+        key :first_name, String
+        key :last_name, String
+        key :age, Integer
+        key :date, Date
+      end
+      @klass.timestamps!
+    end
+
+    context "when #record_timestamps is set to true" do
+      it "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
+
+      it "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
+
+      it "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
+
+      it "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_i
+
+        new_updated_at = Time.at(Time.now.to_i + 5.seconds)
+        Timecop.freeze(new_updated_at) do
+          @klass.update(doc._id, { :first_name => 'Johnny' })
+        end
+
+        doc = doc.reload
+        doc.created_at.to_i.should be_within(1).of(old_created_at.to_i)
+        doc.updated_at.to_i.should be_within(1).of(new_updated_at.to_i)
+      end
+    end
+
+    context "when #record_timestamps is set to false" do
+      before do
+        @klass.record_timestamps = false
+      end
+
+      after do
+        @klass.record_timestamps = true
+      end
+
+      it "should not set created_at on document create" do
+        doc = @klass.create(:first_name => "John")
+        doc.created_at.should be_nil
+      end
+
+      it "should not set updated_at on document create" do
+        doc = @klass.create(:first_name => "John")
+        doc.updated_at.should be_nil
+      end
+    end
+  end
+end

data/spec/functional/touch_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe "Touch" do
+  context "touch" do
+    context "document" do
+      before do
+        @document = Doc { timestamps! }
+      end
+
+      it "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
+      it "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
+      before 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
+
+      it 'should not be true by default' do
+        @comment_class.belongs_to :post, :class => @post_class
+        @comment_class.associations[:post].touch?.should_not be_truthy
+      end
+
+      context 'touch the parent when true' do
+        before do
+          @comment_class.belongs_to :post, :class => @post_class, :touch => true
+          @post = @post_class.create(:title => 'Hello, world!')
+          @comment = @post.comments.build
+        end
+
+        it "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
+
+        it "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
+
+        it "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
+        it "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
+
+      it '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/spec/functional/userstamps_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+module Userstamps
+  describe "Userstamps" do
+    class AltUser
+      include MarkMapper::Document
+    end
+
+    context "userstamping" do
+      before do
+        @document = Doc do
+          userstamps!
+        end
+        @document_alt_user = Doc do
+          userstamps! :class_name => 'Userstamps::AltUser'
+        end
+        @document_alt_user_class = Doc do
+          userstamps! :class => Userstamps::AltUser
+        end
+        @docs = [@document, @document_alt_user, @document_alt_user_class]
+      end
+
+      it "should add creator_id key" do
+        @docs.each{ |d| d.keys.should include('creator_id') }
+      end
+
+      it "should add updater_id key" do
+        @docs.each{ |d| d.keys.should include('updater_id') }
+      end
+
+      it "should add belongs_to creator" do
+        @docs.each{ |d| d.associations.keys.should include(:creator) }
+      end
+
+      it "should add belongs_to updater" do
+        @docs.each{ |d| d.associations.keys.should include(:updater) }
+      end
+
+      it "should properly set class names" do
+        @document.associations[:creator].class_name.should == 'User'
+        @document_alt_user.associations[:creator].class_name.should == 'Userstamps::AltUser'
+        @document_alt_user_class.associations[:creator].class_name.should == 'Userstamps::AltUser'
+      end
+    end
+  end
+end

data/spec/functional/validations_spec.rb

@@ -0,0 +1,416 @@
+require 'spec_helper'
+
+describe "Validations" do
+  context "Saving a new document that is invalid" do
+    before do
+      @document = Doc do
+        key :name, String, :required => true
+      end
+    end
+
+    it "should not insert document" do
+      doc = @document.new
+      doc.save
+      @document.count.should == 0
+    end
+
+    it "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
+    before do
+      @document = Doc do
+        key :name, String, :required => true
+      end
+    end
+
+    it "should raise error" do
+      doc = @document.new
+      lambda { doc.save! }.should raise_error(MarkMapper::DocumentNotValid)
+    end
+
+    it "should set document on exception" do
+      doc = @document.new
+      begin
+        doc.save!
+      rescue MarkMapper::DocumentNotValid => e
+        e.document.should == doc
+      end
+    end
+  end
+
+  context "Creating a document that is invalid (destructive)" do
+    before do
+      @document = Doc do
+        key :name, String, :required => true
+      end
+    end
+
+    it "should raise error" do
+      lambda { @document.create! }.should raise_error(MarkMapper::DocumentNotValid)
+    end
+
+    it "should create a new document" do
+      instance = @document.create!(:name => "James")
+      instance.new_record?.should be_falsey
+    end
+  end
+
+  context "Saving an existing document that is invalid" do
+    before do
+      @document = Doc do
+        key :name, String, :required => true
+      end
+
+      @doc = @document.create(:name => 'John Nunemaker')
+    end
+
+    it "should not update document" do
+      @doc.name = nil
+      @doc.save
+      @doc.reload.name.should == 'John Nunemaker'
+    end
+
+    it "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
+    before do
+      @document = Doc do
+        key :action, String
+        def action_present
+          errors.add(:action, 'is invalid') if action.blank?
+        end
+      end
+    end
+
+    it "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
+
+    it "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
+    before do
+      @document = Doc do
+        key :name, String
+        validates_uniqueness_of :name
+      end
+    end
+
+    it "should not fail if object is new" do
+      doc = @document.new
+      doc.should_not have_error_on(:name)
+    end
+
+    it "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_truthy
+
+      doc2 = document.new("name" => "joe", :adult => false)
+      doc2.should be_valid
+    end
+
+    it "should work with i18n taken message" do
+      @document.create(:name => 'joe')
+      doc = @document.create(:name => 'joe')
+      doc.should have_error_on(:name)
+      doc.errors[:name].should == ['has already been taken']
+    end
+
+    it "should allow to update an object" do
+      doc = @document.new("name" => "joe")
+      doc.save.should be_truthy
+
+      allow(@document).to \
+        receive(:first).
+        with(:name => 'joe').
+        and_return(doc)
+
+      doc.name = "joe"
+      doc.valid?.should be_truthy
+      doc.should_not have_error_on(:name)
+    end
+
+    it "should fail if object name is not unique" do
+      doc = @document.new("name" => "joe")
+      doc.save.should be_truthy
+
+      allow(@document).to \
+        receive(:first).
+        with(:name => 'joe').
+        and_return(doc)
+
+      doc2 = @document.new("name" => "joe")
+      doc2.should have_error_on(:name)
+    end
+
+    it "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_truthy
+
+      allow(@document).to \
+        receive(:first).
+        with(:name => '').
+        and_return(doc)
+
+      doc2 = document.new("name" => "")
+      doc2.should_not have_error_on(:name)
+    end
+
+    it "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_truthy
+
+      doc2 = document.new('name' => nil)
+      doc2.should_not have_error_on(:name)
+    end
+
+    it "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_truthy
+
+      doc2 = document.new("name" => "Blammo")
+      doc2.should_not have_error_on(:name)
+    end
+
+    context "with :case_sensitive => false" do
+      before do
+        @document = Doc do
+          key :name
+          validates_uniqueness_of :name, :case_sensitive => false
+        end
+      end
+
+      it "should fail on entries that differ only in case" do
+        doc = @document.new("name" => "BLAMMO")
+        doc.save.should be_truthy
+
+        doc2 = @document.new("name" => "blammo")
+        doc2.should have_error_on(:name)
+      end
+
+      it "should not raise an error if value is nil" do
+        doc = @document.new("name" => nil)
+        lambda { doc.valid? }.should_not raise_error
+      end
+
+      it "should not raise an error if special Regexp characters used" do
+        doc = @document.new("name" => '?')
+        lambda { doc.valid? }.should_not raise_error
+      end
+
+      it "should check for uniqueness using entire string" do
+        doc = @document.new("name" => "John Doe")
+        doc.save.should be_truthy
+
+        doc2 = @document.new("name" => "John")
+        doc2.valid?.should be_truthy
+      end
+    end
+
+    context "scoped by a single attribute" do
+      before do
+        @document = Doc do
+          key :name, String
+          key :scope, String
+          validates_uniqueness_of :name, :scope => :scope
+        end
+      end
+
+      it "should fail if the same name exists in the scope" do
+        doc = @document.new("name" => "joe", "scope" => "one")
+        doc.save.should be_truthy
+
+        allow(@document).to \
+          receive(:first).
+          with(:name => 'joe', :scope => "one").
+          and_return(doc)
+
+        doc2 = @document.new("name" => "joe", "scope" => "one")
+        doc2.should have_error_on(:name)
+      end
+
+      it "should pass if the same name exists in a different scope" do
+        doc = @document.new("name" => "joe", "scope" => "one")
+        doc.save.should be_truthy
+
+        allow(@document).to \
+          receive(:first).
+          with(:name => 'joe', :scope => 'two').
+          and_return(nil)
+
+        doc2 = @document.new("name" => "joe", "scope" => "two")
+        doc2.should_not have_error_on(:name)
+      end
+    end
+
+    context "scoped by a multiple attributes" do
+      before 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
+
+      it "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_truthy
+
+        allow(@document).to \
+          receive(:first).
+          with(:name => 'joe', :first_scope => 'one', :second_scope => 'two').
+          and_return(doc)
+
+        doc2 = @document.new("name" => "joe", "first_scope" => "one", "second_scope" => "two")
+        doc2.should have_error_on(:name)
+      end
+
+      it "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_truthy
+
+        allow(@document).to \
+          receive(:first).
+          with(:name => 'joe', :first_scope => 'one', :second_scope => 'one').
+          and_return(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
+    before 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
+
+    it "should pass if there are no associated docs" do
+      doc = @root_class.new
+      doc.save.should be_truthy
+    end
+
+    it "should pass if the associated doc is valid" do
+      doc = @root_class.new
+      doc.children.build(:name => 'Joe')
+      doc.save.should be_truthy
+    end
+
+    it "should fail if the associated doc is invalid" do
+      doc = @root_class.new
+      doc.children.build
+      doc.should have_error_on(:children)
+      doc.errors[:children].should == ['are invalid']
+    end
+  end
+
+  context "validating associated docs with custom context" do
+    before 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
+
+    it "should pass if there are no associated docs" do
+      doc = @root_class.new
+      doc.valid?(:custom_context).should be_truthy
+    end
+
+    it "should pass if the associated doc is valid" do
+      doc = @root_class.new
+      doc.children.build(:name => 'George')
+      doc.valid?(:custom_context).should be_truthy
+    end
+
+    it "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_truthy
+    end
+  end
+
+  # context "validates uniqueness of with :unique shortcut" do
+  #   it "should work" do
+  #     @document = Doc do
+  #       key :name, String, :unique => true
+  #     end
+  #
+  #     doc = @document.create(:name => 'John')
+  #     doc.should_not have_error_on(:name)
+  #
+  #     allow(@document).to \
+  #       receive(:first).
+  #       with(:name => 'John').
+  #       and_return(doc)
+  #
+  #     second_john = @document.create(:name => 'John')
+  #     second_john.should have_error_on(:name)
+  #     second_john.errors[:name].should == ['has already been taken']
+  #   end
+  # end
+end