mark_mapper 0.0.1

data/spec/functional/associations_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'support/models'
+
+module AssociationsSpec
+  describe "Associations" do
+    it "should allow changing class names" do
+      class AwesomeUser
+        include MarkMapper::Document
+
+        many :posts, :class_name => 'AssociationsSpec::AwesomePost', :foreign_key => :creator_id
+      end
+      AwesomeUser.collection.remove
+
+      class AwesomeTag
+        include MarkMapper::EmbeddedDocument
+
+        key :name, String
+        key :post_id, ObjectId
+
+        belongs_to :post, :class_name => 'AssociationsSpec::AwesomeUser'
+      end
+
+      class AwesomePost
+        include MarkMapper::Document
+
+        key :creator_id, ObjectId
+
+        belongs_to :creator, :class_name => 'AssociationsSpec::AwesomeUser'
+        many :tags, :class_name => 'AssociationsSpec::AwesomeTag', :foreign_key => :post_id
+      end
+
+      AwesomeUser.collection.remove
+      AwesomePost.collection.remove
+
+      user = AwesomeUser.create
+      tag1 = AwesomeTag.new(:name => 'awesome')
+      tag2 = AwesomeTag.new(:name => 'grand')
+      post1 = AwesomePost.create(:creator => user, :tags => [tag1])
+      post2 = AwesomePost.create(:creator => user, :tags => [tag2])
+
+      user.reload
+      user.posts.should =~ [post1, post2]
+
+      post1 = post1.reload
+      post1.tags.should == [tag1]
+    end
+  end
+end

data/spec/functional/caching_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe "Caching" do
+  before do
+    @klass = Class.new do
+      extend MarkMapper::Plugins
+      plugin MarkMapper::Plugins::Caching
+    end
+    allow(@klass).to receive(:name).and_return('Post')
+    allow_any_instance_of(@klass).to receive(:persisted?).and_return(true)
+    allow_any_instance_of(@klass).to receive(:[]).and_return(nil)
+    allow_any_instance_of(@klass).to receive(:[]=).and_return(nil)
+  end
+
+  context "new" do
+    before do
+      @doc = @klass.new
+      allow(@doc).to receive(:persisted?).and_return(false)
+    end
+
+    it "should be class/new" do
+      @doc.cache_key.should == 'Post/new'
+    end
+
+    it "should work with suffix" do
+      @doc.cache_key(:foo).
+        should == 'Post/new/foo'
+
+      @doc.cache_key(:foo, :bar).
+        should == 'Post/new/foo/bar'
+    end
+  end
+
+  context "not new" do
+    before do
+      @object_id = MarkLogic::ObjectId.new
+      @doc = @klass.new
+      allow(@doc).to receive(:persisted).and_return(true)
+      allow(@doc).to receive(:id).and_return(@object_id)
+    end
+
+    context "with updated_at" do
+      before do
+        time = Time.utc(2010, 6, 20, 8, 10, 7)
+        allow(@doc).to receive(:[]).with(:updated_at).and_return(time)
+      end
+
+      it "should be class/id-timestamp" do
+        @doc.cache_key.should == "Post/#{@object_id}-20100620081007"
+      end
+
+      it "should work with suffix" do
+        @doc.cache_key(:foo).
+          should == "Post/#{@object_id}-20100620081007/foo"
+
+        @doc.cache_key(:foo, :bar).
+          should == "Post/#{@object_id}-20100620081007/foo/bar"
+      end
+    end
+
+    context "without updated_at" do
+      it "should be class/id" do
+        @doc.cache_key.should == "Post/#{@object_id}"
+      end
+
+      it "should work with suffix" do
+        @doc.cache_key(:foo).
+          should == "Post/#{@object_id}/foo"
+
+        @doc.cache_key(:foo, :bar, :baz).
+          should == "Post/#{@object_id}/foo/bar/baz"
+      end
+    end
+  end
+end

data/spec/functional/callbacks_spec.rb

@@ -0,0 +1,330 @@
+require 'spec_helper'
+
+module CallbacksSupport
+  def self.included base
+    base.key :name, String
+
+    [ :before_validation, :after_validation,
+      :before_create,     :after_create,
+      :before_update,     :after_update,
+      :before_save,       :after_save,
+      :before_destroy,    :after_destroy
+    ].each do |callback|
+      base.send(callback) do
+        history << callback.to_sym
+      end
+    end
+  end
+
+  def history
+    @history ||= []
+  end
+
+  def clear_history
+    embedded_associations.each { |a| self.send(a.name).each(&:clear_history) }
+    @history = nil
+  end
+end
+
+describe "Callbacks" do
+  CreateCallbackOrder = [
+    :before_validation,
+    :after_validation,
+    :before_save,
+    :before_create,
+    :after_create,
+    :after_save
+  ]
+
+  UpdateCallbackOrder = [
+    :before_validation,
+    :after_validation,
+    :before_save,
+    :before_update,
+    :after_update,
+    :after_save
+  ]
+
+  context "Defining and running callbacks on documents" do
+    before do
+      @document = Doc { include CallbacksSupport }
+    end
+
+    it "should get the order right for creating documents" do
+      doc = @document.create(:name => 'John Nunemaker')
+      doc.history.should == CreateCallbackOrder
+    end
+
+    it "should get the order right for updating documents" do
+      doc = @document.create(:name => 'John Nunemaker')
+      doc.clear_history
+      doc.name = 'John'
+      doc.save
+      doc.history.should == UpdateCallbackOrder
+    end
+
+    it "should work for before and after validation" do
+      doc = @document.new(:name => 'John Nunemaker')
+      doc.valid?
+      doc.history.should include(:before_validation)
+      doc.history.should include(:after_validation)
+    end
+
+    it "should work for before and after create" do
+      doc = @document.create(:name => 'John Nunemaker')
+      doc.history.should include(:before_create)
+      doc.history.should include(:after_create)
+    end
+
+    it "should work for before and after update" do
+      doc = @document.create(:name => 'John Nunemaker')
+      doc.name = 'John Doe'
+      doc.save
+      doc.history.should include(:before_update)
+      doc.history.should include(:after_update)
+    end
+
+    it "should work for before and after save" do
+      doc = @document.new
+      doc.name = 'John Doe'
+      doc.save
+      doc.history.should include(:before_save)
+      doc.history.should include(:after_save)
+    end
+
+    it "should work for before and after destroy" do
+      doc = @document.create(:name => 'John Nunemaker')
+      doc.destroy
+      doc.history.should include(:before_destroy)
+      doc.history.should include(:after_destroy)
+    end
+  end
+
+  context "Defining and running callbacks on many embedded documents" do
+    before do
+      @root_class        = Doc  { include CallbacksSupport }
+      @child_class       = EDoc { include CallbacksSupport }
+      @grand_child_class = EDoc { include CallbacksSupport }
+
+      @root_class.many  :children, :class => @child_class
+      @child_class.many :children, :class => @grand_child_class
+    end
+
+    it "should get the order right based on root document creation" do
+      grand = @grand_child_class.new(:name => 'Grand Child')
+      child = @child_class.new(:name => 'Child', :children => [grand])
+      root  = @root_class.create(:name => 'Parent', :children => [child])
+
+      root.children.first.history.should == CreateCallbackOrder
+      root.children.first.children.first.history.should == CreateCallbackOrder
+    end
+
+    it "should get the order right based on root document updating" do
+      grand = @grand_child_class.new(:name => 'Grand Child')
+      child = @child_class.new(:name => 'Child', :children => [grand])
+      root  = @root_class.create(:name => 'Parent', :children => [child])
+      root.clear_history
+      root.update_attributes(:name => 'Updated Parent')
+
+      root.children.first.history.should == UpdateCallbackOrder
+      root.children.first.children.first.history.should == UpdateCallbackOrder
+    end
+
+    it "should work for before and after destroy" do
+      grand = @grand_child_class.new(:name => 'Grand Child')
+      child = @child_class.new(:name => 'Child', :children => [grand])
+      root  = @root_class.create(:name => 'Parent', :children => [child])
+      root.destroy
+      child = root.children.first
+      child.history.should include(:before_destroy)
+      child.history.should include(:after_destroy)
+
+      grand = root.children.first.children.first
+      grand.history.should include(:before_destroy)
+      grand.history.should include(:after_destroy)
+    end
+
+    it "should not attempt to run callback defined on root that is not defined on embedded association" do
+      @root_class.define_callbacks :after_publish
+      @root_class.after_save { |d| d.run_callbacks(:after_publish) }
+
+      expect {
+        child = @child_class.new(:name => 'Child')
+        root  = @root_class.create(:name => 'Parent', :children => [child])
+        child.history.should_not include(:after_publish)
+      }.to_not raise_error
+    end
+  end
+
+  context "By default" do
+    it "should not run callbacks when no callbacks were explicitly defined" do
+      EDoc { key :name, String }.embedded_callbacks_off?.should == true
+    end
+
+    it "should run callbacks when a callback was explicitly defined" do
+      EDoc {
+        key :name, String
+        before_save :no_op
+        def noop; end
+      }.embedded_callbacks_on?.should == true
+    end
+  end
+
+  context "Turning embedded callbacks off" do
+    before do
+      @root_class        = Doc  { include CallbacksSupport; embedded_callbacks_off }
+      @child_class       = EDoc { include CallbacksSupport; embedded_callbacks_off }
+      @grand_child_class = EDoc { include CallbacksSupport; embedded_callbacks_off }
+
+      @root_class.many  :children, :class => @child_class
+      @child_class.many :children, :class => @grand_child_class
+    end
+
+    it "should not run create callbacks" do
+      grand = @grand_child_class.new(:name => 'Grand Child')
+      child = @child_class.new(:name => 'Child', :children => [grand])
+      root  = @root_class.create(:name => 'Parent', :children => [child])
+
+      root.children.first.history.should == []
+      root.children.first.children.first.history.should == []
+    end
+
+    it "should not run update callbacks" do
+      grand = @grand_child_class.new(:name => 'Grand Child')
+      child = @child_class.new(:name => 'Child', :children => [grand])
+      root  = @root_class.create(:name => 'Parent', :children => [child])
+      root.clear_history
+      root.update_attributes(:name => 'Updated Parent')
+
+      root.children.first.history.should == []
+      root.children.first.children.first.history.should == []
+    end
+
+    it "should not run destroy callbacks" do
+      grand = @grand_child_class.new(:name => 'Grand Child')
+      child = @child_class.new(:name => 'Child', :children => [grand])
+      root  = @root_class.create(:name => 'Parent', :children => [child])
+      root.destroy
+      child = root.children.first
+      child.history.should == []
+
+      grand = root.children.first.children.first
+      grand.history.should == []
+    end
+  end
+
+  context "Running validation callbacks with conditional execution" do
+    let(:document) do
+      Doc do
+        include CallbacksSupport
+        key :message, String
+
+        before_validation :set_message, :on => :create
+
+        def set_message
+          self['message'] = 'Hi!'
+        end
+      end
+    end
+
+    it 'should run callback on create' do
+      doc = document.create
+      doc.history.should include(:before_validation)
+      doc.message.should == 'Hi!'
+    end
+
+    it 'should skip callback on update' do
+      doc = document.create
+      doc.message = 'Ho!'
+      doc.save
+      doc.message.should == 'Ho!'
+    end
+  end
+
+  describe "after_find" do
+    before do
+      @found_objects = []
+      found_objects = @found_objects # use a local for closure
+
+      @doc_class = Doc("User") do
+        after_find :set_found_object
+
+        define_method :set_found_object do
+          found_objects << self
+        end
+      end
+    end
+
+    it "should run after finding an object with find!" do
+      @doc = @doc_class.create!
+
+      @doc_class.find!(@doc.id)
+      @found_objects.should == [@doc]
+    end
+
+    it "should not have run if nothing was queried" do
+      @found_objects.should == []
+    end
+
+    it "should run for multiple objects" do
+      @doc1 = @doc_class.create!
+      @doc2 = @doc_class.create!
+
+      @doc_class.all
+      @found_objects.should =~ [@doc1, @doc2]
+    end
+
+    it "should run after finding an object through the query proxy" do
+      @doc = @doc_class.create!
+      @doc_class.where(:_id => @doc.id).first
+      @found_objects.should == [@doc]
+    end
+
+    it "should still return the object" do
+      @doc = @doc_class.create!
+      @doc_class.where(:_id => @doc.id).first.should == @doc
+    end
+
+    it "should not bail if the method return false" do
+      @doc_class = Doc("User") do
+        after_find :set_found_object
+
+        define_method :set_found_object do
+          false
+        end
+      end
+
+      @doc = @doc_class.create!
+      @doc_class.where(:_id => @doc.id).first.should == @doc
+    end
+  end
+
+  describe "after_initialize" do
+    before do
+      @objects = []
+      objects = @objects
+
+      @doc_class = Doc("User") do
+        after_initialize :set_initialized_object
+
+        define_method :set_initialized_object do
+          objects << self
+        end
+      end
+    end
+
+    it "should be triggered for objects created with new" do
+      @objects.should == []
+      obj = @doc_class.new
+      @objects.should == [obj]
+    end
+
+    it "should be triggered for objects found in the db" do
+      @doc = @doc_class.create!
+      @objects.clear # don't re-assign as we want the operation to be in place
+
+      @doc_class.all
+      @objects.should == [@doc]
+    end
+  end
+end