closure_tree 4.5.0 → 4.6.0

data/lib/closure_tree/numeric_order_support.rb

@@ -13,49 +13,56 @@ module ClosureTree
     end
 
     module MysqlAdapter
-      def reorder_with_parent_id(parent_id, minimum_sort_order_value = nil, delta = 0)
+      def reorder_with_parent_id(parent_id, minimum_sort_order_value = nil)
         min_where = if minimum_sort_order_value
           "AND #{quoted_order_column} >= #{minimum_sort_order_value}"
         else
           ""
         end
-        connection.execute "SET @i = 0"
-        connection.execute <<-SQL
+        connection.execute 'SET @i = 0'
+        connection.execute <<-SQL.strip_heredoc
           UPDATE #{quoted_table_name}
-            SET #{quoted_order_column} = (@i := @i + 1) + #{minimum_sort_order_value.to_i + delta - 1}
-          WHERE #{quoted_parent_column_name} = #{quoted_value(parent_id)} #{min_where}
-          ORDER BY #{order_by}
+            SET #{quoted_order_column} = (@i := @i + 1) + #{minimum_sort_order_value.to_i - 1}
+          WHERE #{where_eq(parent_column_name, parent_id)} #{min_where}
+          ORDER BY #{nulls_last_order_by}
         SQL
       end
     end
 
     module PostgreSQLAdapter
-      def reorder_with_parent_id(parent_id, minimum_sort_order_value = nil, delta = 0)
+      def reorder_with_parent_id(parent_id, minimum_sort_order_value = nil)
         min_where = if minimum_sort_order_value
           "AND #{quoted_order_column} >= #{minimum_sort_order_value}"
         else
           ""
         end
-        connection.execute <<-SQL
+        connection.execute <<-SQL.strip_heredoc
           UPDATE #{quoted_table_name}
-          SET #{quoted_order_column(false)} = t.seq + #{minimum_sort_order_value.to_i + delta - 1}
+          SET #{quoted_order_column(false)} = t.seq + #{minimum_sort_order_value.to_i - 1}
           FROM (
             SELECT #{quoted_id_column_name} AS id, row_number() OVER(ORDER BY #{order_by}) AS seq
             FROM #{quoted_table_name}
-            WHERE #{quoted_parent_column_name} = #{quoted_value(parent_id)} #{min_where}) AS t
+            WHERE #{where_eq(parent_column_name, parent_id)} #{min_where}
+          ) AS t
           WHERE #{quoted_table_name}.#{quoted_id_column_name} = t.id
         SQL
       end
+
+      def rows_updated(result)
+        result.cmd_status.sub(/\AUPDATE /, '').to_i
+      end
     end
 
     module GenericAdapter
-      def reorder_with_parent_id(parent_id, minimum_sort_order_value = nil, delta = 0)
-        scope = model_class.where(parent_column_sym => parent_id)
+      def reorder_with_parent_id(parent_id, minimum_sort_order_value = nil)
+        scope = model_class.
+          where(parent_column_sym => parent_id).
+          order(nulls_last_order_by)
         if minimum_sort_order_value
           scope = scope.where("#{quoted_order_column} >= #{minimum_sort_order_value}")
         end
         scope.each_with_index do |ea, idx|
-          ea.update_attribute(order_column_sym, idx + minimum_sort_order_value.to_i + delta)
+          ea.update_order_value(idx + minimum_sort_order_value.to_i)
         end
       end
     end

data/lib/closure_tree/support.rb

@@ -106,6 +106,14 @@ module ClosureTree
       scope.pluck(model_class.primary_key)
     end
 
+    def where_eq(column_name, value)
+      if value.nil?
+        "#{connection.quote_column_name(column_name)} IS NULL"
+      else
+        "#{connection.quote_column_name(column_name)} = #{quoted_value(value)}"
+      end
+    end
+
     def with_advisory_lock(&block)
       if options[:with_advisory_lock]
         model_class.with_advisory_lock("closure_tree") do

data/lib/closure_tree/support_attributes.rb

@@ -73,6 +73,16 @@ module ClosureTree
       options[:order]
     end
 
+    def nulls_last_order_by
+      "-#{quoted_order_column} #{order_by_order(reverse = true)}"
+    end
+
+    def order_by_order(reverse = false)
+      desc = !!(order_by.to_s =~ /DESC\z/)
+      desc = !desc if reverse
+      desc ? 'DESC' : 'ASC'
+    end
+
     def order_column
       o = order_by
       if o.nil?

data/lib/closure_tree/test/matcher.rb

@@ -0,0 +1,85 @@
+module ClosureTree
+  module Test
+    module Matcher
+      def be_a_closure_tree
+        ClosureTree.new
+      end
+
+      class ClosureTree
+        def matches?(subject)
+          @subject = subject
+          # OPTIMIZE
+          if @subject.respond_to?(:_ct)
+
+            unless @subject.column_names.include?(@subject._ct.parent_column_name)
+              @message = "expected #{@subject.class.name} to respond to #{@subject._ct.parent_column_name}"
+              return false
+            end
+
+            # Checking if hierarchy table exists (common error)
+            unless  @subject.hierarchy_class.table_exists?
+              @message = "expected #{@subject.class.name}'s hierarchy table '#{@subject.hierarchy_class.table_name}' to exist"
+              return false
+            end
+
+            if @ordered
+              unless  @subject._ct.options.include?(:order)
+                @message = "expected #{@subject.class.name} to be an ordered closure tree"
+                return false
+              end
+              unless @subject.column_names.include?(@subject._ct.options[:order].to_s)
+                @message = "expected #{@subject.class.name} to have #{@subject._ct.options[:order]} as column"
+                return false
+              end
+            end
+
+            if @with_advisory_lock && !@subject._ct.options[:with_advisory_lock]
+                @message = "expected #{@subject.class.name} to have advisory lock"
+                return false
+            end
+
+            if @without_advisory_lock && @subject._ct.options[:with_advisory_lock]
+                @message = "expected #{@subject.class.name} to not have advisory lock"
+                return false
+            end
+
+            return true
+          end
+          false
+        end
+
+        def ordered(column = nil)
+          @ordered = 'n ordered'
+          @order_colum = column
+          self
+        end
+
+        def with_advisory_lock
+          @with_advisory_lock = ' with advisory lock'
+          self
+        end
+
+        def without_advisory_lock
+          @without_advisory_lock = ' without advisory lock'
+          self
+        end
+
+        def failure_message
+          @message || "expected #{@subject.class.name} to #{description}"
+        end
+
+        alias_method :failure_message_for_should, :failure_message
+
+        def failure_message_when_negated
+          "expected #{@subject.class.name} not be a closure tree, but it is."
+        end
+
+        alias_method :failure_message_for_should_not, :failure_message_when_negated
+
+        def description
+          "be a#{@ordered} closure tree#{@with_advisory_lock}"
+        end
+      end
+    end
+  end
+end

data/lib/closure_tree/version.rb

@@ -1,3 +1,3 @@
 module ClosureTree
-  VERSION = Gem::Version.new('4.5.0') unless defined?(::ClosureTree::VERSION)
+  VERSION = Gem::Version.new('4.6.0') unless defined?(::ClosureTree::VERSION)
 end

data/lib/closure_tree.rb

@@ -1,6 +1,19 @@
 require 'active_support'
 
+module ClosureTree
+  extend ActiveSupport::Autoload
+
+  autoload :ActsAsTree
+  autoload :Support
+  autoload :HierarchyMaintenance
+  autoload :Model
+  autoload :Finders
+  autoload :HashTree
+  autoload :Digraphs
+  autoload :DeterministicOrdering
+  autoload :NumericDeterministicOrdering
+end
+
 ActiveSupport.on_load :active_record do
-  require 'closure_tree/acts_as_tree'
   ActiveRecord::Base.send :extend, ClosureTree::ActsAsTree
 end

data/spec/cache_invalidation_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+
+describe 'cache invalidation', cache: true do
+  before do
+    Timecop.travel(10.seconds.ago) do
+      #create a long tree with 2 branch
+      @root = MenuItem.create(
+        name: SecureRandom.hex(10)
+      )
+      2.times do
+        parent = @root
+        10.times do
+          parent = parent.children.create(
+            name: SecureRandom.hex(10)
+          )
+        end
+      end
+      @first_leaf = MenuItem.leaves.first
+      @second_leaf = MenuItem.leaves.last
+    end
+  end
+
+  describe 'touch option' do
+    it 'should invalidate cache for all it ancestors' do
+      old_time_stamp = @first_leaf.ancestors.pluck(:updated_at)
+      @first_leaf.touch
+      new_time_stamp = @first_leaf.ancestors.pluck(:updated_at)
+      expect(old_time_stamp).to_not eq(new_time_stamp)
+    end
+
+    it 'should not invalidate cache for another branch' do
+      old_time_stamp = @second_leaf.updated_at
+      @first_leaf.touch
+      new_time_stamp = @second_leaf.updated_at
+      expect(old_time_stamp).to eq(new_time_stamp)
+    end
+  end
+end

data/spec/{support → db}/models.rb

@@ -4,9 +4,11 @@ class Tag < ActiveRecord::Base
   acts_as_tree :dependent => :destroy, :order => :name
   before_destroy :add_destroyed_tag
   attr_accessible :name, :title if _ct.use_attr_accessible?
+
   def to_s
     name
   end
+
   def add_destroyed_tag
     # Proof for the tests that the destroy rather than the delete method was called:
     DestroyedTag.create(:name => name)
@@ -99,3 +101,7 @@ class Metal < ActiveRecord::Base
   acts_as_tree :order => 'sort_order'
   self.inheritance_column = 'metal_type'
 end
+
+class MenuItem < ActiveRecord::Base
+  acts_as_tree(touch: true, with_advisory_lock: false)
+end

data/spec/db/schema.rb

@@ -124,4 +124,22 @@ ActiveRecord::Schema.define(:version => 0) do
 
   add_foreign_key(:metal_hierarchies, :metal, :column => 'ancestor_id')
   add_foreign_key(:metal_hierarchies, :metal, :column => 'descendant_id')
+
+  create_table 'menu_items' do |t|
+    t.string 'name'
+    t.integer 'parent_id'
+    t.timestamps
+  end
+
+  add_foreign_key(:menu_items, :menu_items, :column => 'parent_id')
+
+  create_table 'menu_item_hierarchies', :id => false do |t|
+    t.integer 'ancestor_id', :null => false
+    t.integer 'descendant_id', :null => false
+    t.integer 'generations', :null => false
+  end
+
+  add_foreign_key(:menu_item_hierarchies, :menu_items, :column => 'ancestor_id')
+  add_foreign_key(:menu_item_hierarchies, :menu_items, :column => 'descendant_id')
+
 end

data/spec/label_spec.rb

@@ -44,12 +44,36 @@ end
 describe Label do
 
   context "destruction" do
-    it "properly destroys descendents" do
+    it "properly destroys descendents created with find_or_create_by_path" do
       c = Label.find_or_create_by_path %w(a b c)
       b = c.parent
       a = c.root
       a.destroy
-      Label.exists?(id: [a.id,b.id,c.id]).should be_false
+      Label.exists?(id: [a.id, b.id, c.id]).should be_false
+    end
+
+    it "properly destroys descendents created with add_child" do
+      a = Label.create(name: 'a')
+      b = Label.new(name: 'b')
+      a.add_child b
+      c = Label.new(name: 'c')
+      b.add_child c
+      a.destroy
+      Label.exists?(a).should be_false
+      Label.exists?(b).should be_false
+      Label.exists?(c).should be_false
+    end
+
+    it "properly destroys descendents created with <<" do
+      a = Label.create(name: 'a')
+      b = Label.new(name: 'b')
+      a.children << b
+      c = Label.new(name: 'c')
+      b.children << c
+      a.destroy
+      Label.exists?(a).should be_false
+      Label.exists?(b).should be_false
+      Label.exists?(c).should be_false
     end
   end
 
@@ -131,7 +155,7 @@ describe Label do
       end
 
       it "returns descendents regardless of subclass" do
-        Label.root.descendants.map{|ea|ea.class.to_s}.uniq.should =~
+        Label.root.descendants.map { |ea| ea.class.to_s }.uniq.should =~
           %w(Label DateLabel DirectoryLabel EventLabel)
       end
     end
@@ -199,57 +223,79 @@ describe Label do
     end
 
     it "self_and_descendants should result in one select" do
-      DB_QUERIES.clear
-      a1_array = @a1.self_and_descendants
-      a1_array.collect { |ea| ea.name }.should == %w(a1 b1 c1 c2 d1 d2)
-      DB_QUERIES.size.should == 1
+      count_queries do
+        a1_array = @a1.self_and_descendants
+        a1_array.collect { |ea| ea.name }.should == %w(a1 b1 c1 c2 d1 d2)
+      end.should == 1
     end
 
     it "self_and_ancestors should result in one select" do
-      DB_QUERIES.clear
-      d1_array = @d1.self_and_ancestors
-      d1_array.collect { |ea| ea.name }.should == %w(d1 c1 b1 a1)
-      DB_QUERIES.size.should == 1
+      count_queries do
+        d1_array = @d1.self_and_ancestors
+        d1_array.collect { |ea| ea.name }.should == %w(d1 c1 b1 a1)
+      end.should == 1
     end
   end
 
   context "deterministically orders with polymorphic siblings" do
     before :each do
-      @parent = Label.create!(:name => "parent")
-      @a = EventLabel.new(:name => "a")
-      @b = DirectoryLabel.new(:name => "b")
-      @c = DateLabel.new(:name => "c")
-      @d = Label.new(:name => "d")
+      @parent = Label.create!(:name => 'parent')
+      @a, @b, @c, @d, @e, @f = ('a'..'f').map { |ea| EventLabel.new(:name => ea) }
       @parent.children << @a
       @a.append_sibling(@b)
       @b.append_sibling(@c)
       @c.append_sibling(@d)
+      @parent.append_sibling(@e)
+      @e.append_sibling(@f)
+    end
+
+    def name_and_order(enum)
+      enum.map { |ea| [ea.name, ea.sort_order] }
     end
 
     def children_name_and_order
-      @parent.reload.children.map { |ea| [ea.name, ea.sort_order] }
+      name_and_order(@parent.children(reload = true))
+    end
+
+    def roots_name_and_order
+      name_and_order(Label.roots)
     end
 
-    it "sort_orders properly" do
+    it 'sort_orders properly' do
       children_name_and_order.should == [['a', 0], ['b', 1], ['c', 2], ['d', 3]]
     end
 
-    it "when inserted before" do
+    it 'when inserted before' do
       @b.append_sibling(@a)
       children_name_and_order.should == [['b', 0], ['a', 1], ['c', 2], ['d', 3]]
     end
 
-    it "when inserted after" do
+    it 'when inserted after' do
       @a.append_sibling(@c)
       children_name_and_order.should == [['a', 0], ['c', 1], ['b', 2], ['d', 3]]
     end
+
+    it 'when inserted before the first' do
+      @a.prepend_sibling(@d)
+      children_name_and_order.should == [['d', 0], ['a', 1], ['b', 2], ['c', 3]]
+    end
+
+    it 'when inserted after the last' do
+      @d.append_sibling(@b)
+      children_name_and_order.should == [['a', 0], ['c', 1], ['d', 2], ['b', 3]]
+    end
+
+    it 'prepends to root nodes' do
+      @parent.prepend_sibling(@f)
+      roots_name_and_order.should == [['f', 0], ['parent', 1], ['e', 2]]
+    end
   end
 
-  it "behaves like the readme" do
-    root = Label.create(:name => "root")
-    a = Label.create(:name => "a", :parent => root)
-    b = Label.create(:name => "b")
-    c = Label.create(:name => "c")
+  it 'behaves like the readme' do
+    root = Label.create(name: 'root')
+    a = root.append_child(Label.new(name: 'a'))
+    b = Label.create(name: 'b')
+    c = Label.create(name: 'c')
 
     a.append_sibling(b)
     a.self_and_siblings.collect(&:name).should == %w(a b)
@@ -277,6 +323,30 @@ describe Label do
     d.self_and_siblings.collect(&:sort_order).should == [0, 1, 2, 3]
   end
 
+  # https://github.com/mceachen/closure_tree/issues/84
+  it "properly appends children with <<" do
+    root = Label.create(:name => "root")
+    a = Label.create(:name => "a", :parent => root)
+    b = Label.create(:name => "b", :parent => root)
+    a.sort_order.should == 0
+    b.sort_order.should == 1
+    #c = Label.create(:name => "c")
+
+    # should the sort_order for roots be set?
+    root.sort_order.should_not be_nil
+    root.sort_order.should == 0
+
+    # sort_order should never be nil on a child.
+    a.sort_order.should_not be_nil
+    a.sort_order.should == 0
+    # Add a child to root at end of children.
+    root.children << b
+    b.parent.should == root
+    a.self_and_siblings.collect(&:name).should == %w(a b)
+    root.reload.children.collect(&:name).should == %w(a b)
+    root.children.collect(&:sort_order).should == [0, 1]
+  end
+
   context "#add_sibling" do
     it "should move a node before another node which has an uninitialized sort_order" do
       f = Label.find_or_create_by_path %w(a b c d e fa)
@@ -290,16 +360,16 @@ describe Label do
       f.self_and_siblings.should == [f0, f]
     end
 
+    let(:f1) { Label.find_or_create_by_path %w(a1 b1 c1 d1 e1 f1) }
+
     it "should move a node to another tree" do
-      f1 = Label.find_or_create_by_path %w(a1 b1 c1 d1 e1 f1)
       f2 = Label.find_or_create_by_path %w(a2 b2 c2 d2 e2 f2)
       f1.add_sibling(f2)
       f2.ancestry_path.should == %w(a1 b1 c1 d1 e1 f2)
-      f1.parent.children.should == [f1, f2]
+      f1.parent.reload.children.should == [f1, f2]
     end
 
     it "should reorder old-parent siblings when a node moves to another tree" do
-      f1 = Label.find_or_create_by_path %w(a1 b1 c1 d1 e1 f1)
       f2 = Label.find_or_create_by_path %w(a2 b2 c2 d2 e2 f2)
       f3 = f2.prepend_sibling(Label.new(:name => "f3"))
       f4 = f2.append_sibling(Label.new(:name => "f4"))
@@ -311,32 +381,87 @@ describe Label do
     end
   end
 
+  context "sort_order must be set" do
+
+    before do
+      @root = Label.create(name: 'root')
+      @a, @b, @c = %w(a b c).map { |n| @root.children.create(name: n) }
+    end
+
+    it 'should set sort_order on roots' do
+      @root.sort_order.should == 0
+    end
+
+    it 'should set sort_order with siblings' do
+      @a.sort_order.should == 0
+      @b.sort_order.should == 1
+      @c.sort_order.should == 2
+    end
+
+    it 'should reset sort_order when a node is moved to another location' do
+      root2 = Label.create(name: 'root2')
+      root2.add_child @b
+      @a.sort_order.should == 0
+      @b.sort_order.should == 0
+      @c.reload.sort_order.should == 1
+    end
+  end
+
   context "destructive reordering" do
     before :each do
       # to make sure sort_order isn't affected by additional nodes:
       create_preorder_tree
-      @root = Label.create(:name => "root")
-      @a = @root.children.create!(:name => "a")
-      @b = @a.append_sibling(Label.new(:name => "b"))
-      @c = @b.append_sibling(Label.new(:name => "c"))
+      @root = Label.create(:name => 'root')
+      @a = @root.children.create!(:name => 'a')
+      @b = @a.append_sibling(Label.new(:name => 'b'))
+      @c = @b.append_sibling(Label.new(:name => 'c'))
     end
-    context "doesn't create sort order gaps from" do
-      it "from head" do
+    context "doesn't create sort order gaps" do
+      it 'from head' do
         @a.destroy
         @root.reload.children.should == [@b, @c]
         @root.children.map { |ea| ea.sort_order }.should == [0, 1]
       end
-      it "from mid" do
+      it 'from mid' do
         @b.destroy
         @root.reload.children.should == [@a, @c]
         @root.children.map { |ea| ea.sort_order }.should == [0, 1]
       end
-      it "from tail" do
+      it 'from tail' do
         @c.destroy
         @root.reload.children.should == [@a, @b]
         @root.children.map { |ea| ea.sort_order }.should == [0, 1]
       end
     end
+
+    context 'add_sibling moves descendant nodes' do
+      let(:roots) { (0..10).map { |ea| Label.create(name: ea) } }
+      let(:first_root) { roots.first }
+      let(:last_root) { roots.last }
+      it 'should retain sort orders of descendants when moving to a new parent' do
+        expected_order = ('a'..'z').to_a.shuffle
+        expected_order.map { |ea| first_root.add_child(Label.new(name: ea)) }
+        actual_order = first_root.children(reload = true).pluck(:name)
+        actual_order.should == expected_order
+        last_root.append_child(first_root)
+        last_root.self_and_descendants.pluck(:name).should == %w(10 0) + expected_order
+      end
+
+      it 'should retain sort orders of descendants when moving within the same new parent' do
+        path = ('a'..'z').to_a
+        z = first_root.find_or_create_by_path(path)
+        z_children_names = (100..150).to_a.shuffle.map { |ea| ea.to_s }
+        z_children_names.reverse.each { |ea| z.prepend_child(Label.new(name: ea)) }
+        z.children(reload = true).pluck(:name).should == z_children_names
+        a = first_root.find_by_path(['a'])
+        # move b up to a's level:
+        b = a.children.first
+        a.add_sibling(b)
+        b.parent.should == first_root
+        z.children(reload = true).pluck(:name).should == z_children_names
+      end
+    end
+
     it "shouldn't fail if all children are destroyed" do
       roots = Label.roots.to_a
       roots.each { |ea| ea.children.destroy_all }
@@ -344,33 +469,33 @@ describe Label do
     end
   end
 
-  context "descendent destruction" do
-    it "properly destroys descendents created with add_child" do
+  context 'descendent destruction' do
+    it 'properly destroys descendents created with add_child' do
       a = Label.create(name: 'a')
       b = Label.new(name: 'b')
       a.add_child b
       c = Label.new(name: 'c')
       b.add_child c
       a.destroy
-      Label.exists?(id: [a.id,b.id,c.id]).should be_false
+      Label.exists?(id: [a.id, b.id, c.id]).should be_false
     end
 
-    it "properly destroys descendents created with <<" do
+    it 'properly destroys descendents created with <<' do
       a = Label.create(name: 'a')
       b = Label.new(name: 'b')
       a.children << b
       c = Label.new(name: 'c')
       b.children << c
       a.destroy
-      Label.exists?(id: [a.id,b.id,c.id]).should be_false
+      Label.exists?(id: [a.id, b.id, c.id]).should be_false
     end
   end
 
-  context "preorder" do
-    it "returns descendants in proper order" do
+  context 'preorder' do
+    it 'returns descendants in proper order' do
       create_preorder_tree
       a = Label.root
-      a.name.should == "a"
+      a.name.should == 'a'
       expected = ('a'..'r').to_a
       a.self_and_descendants_preordered.collect { |ea| ea.name }.should == expected
       Label.roots_and_descendants_preordered.collect { |ea| ea.name }.should == expected
@@ -379,11 +504,11 @@ describe Label do
         l.name = "a1"
         l.sort_order = a.sort_order + 1
       end
-      create_preorder_tree("1")
+      create_preorder_tree('1')
       # Should be no change:
       a.reload.self_and_descendants_preordered.collect { |ea| ea.name }.should == expected
       expected += ('a'..'r').collect { |ea| "#{ea}1" }
       Label.roots_and_descendants_preordered.collect { |ea| ea.name }.should == expected
     end
-  end unless ENV["DB"] == "sqlite"
+  end unless ENV['DB'] == 'sqlite' # sqlite doesn't have a power function.
 end

data/spec/matcher_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe 'ClosureTree::Test::Matcher' do
+
+  describe 'be_a_closure_tree' do
+    it { UUIDTag.should be_a_closure_tree }
+    it { User.should be_a_closure_tree }
+    it { Label.should be_a_closure_tree.ordered }
+    it { Metal.should be_a_closure_tree.ordered(:sort_order) }
+    it { MenuItem.should be_a_closure_tree }
+    it { Contract.should_not be_a_closure_tree }
+  end
+
+  describe 'ordered' do
+    it { Label.should be_a_closure_tree.ordered }
+    it { UUIDTag.should be_a_closure_tree.ordered }
+    it { Metal.should be_a_closure_tree.ordered(:sort_order) }
+  end
+
+  describe 'advisory_lock' do
+    it 'should use advisory lock' do
+      User.should be_a_closure_tree.with_advisory_lock
+      Label.should be_a_closure_tree.ordered.with_advisory_lock
+      Metal.should be_a_closure_tree.ordered(:sort_order).with_advisory_lock
+    end
+
+    it 'should not use advisory lock' do
+      MenuItem.should be_a_closure_tree.without_advisory_lock
+    end
+  end
+
+end