acts_as_ordered_tree 1.3.1 → 2.0.0.beta3

data/spec/node/movements/move_to_root_spec.rb

@@ -0,0 +1,67 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe ActsAsOrderedTree::Node::Movements, '#move_to_root', :transactional do
+  shared_examples '#move_to_root' do |factory, attrs = {}|
+    describe "#move_to_root #{factory}" do
+      tree :factory => factory, :attributes => attrs do
+        root_1 {
+          node_1
+          node_2
+          node_3 {
+            node_4
+          }
+        }
+        root_2 {
+          node_5
+        }
+      end
+
+      context 'moving root node to root' do
+        before { root_2.move_to_root }
+
+        expect_tree_to_match {
+          root_1 {
+            node_1
+            node_2
+            node_3 {
+              node_4
+            }
+          }
+          root_2 {
+            node_5
+          }
+        }
+      end
+
+      context 'moving inner node to root' do
+        before { node_3.move_to_root }
+
+        expect_tree_to_match {
+          root_1 {
+            node_1
+            node_2
+          }
+          root_2 {
+            node_5
+          }
+          node_3 {
+            node_4
+          }
+        }
+      end
+
+      context 'when attribute, not related to tree changed' do
+        before { @old_name = node_2.name }
+        before { node_2.name = 'new name' }
+
+        it { expect{node_2.move_to_root}.to change(node_2, :name).to(@old_name) }
+      end
+    end
+  end
+
+  include_examples '#move_to_root', :default
+  include_examples '#move_to_root', :default_with_counter_cache
+  include_examples '#move_to_root', :scoped, :scope_type => 's'
+end

data/spec/node/predicates_spec.rb

@@ -0,0 +1,211 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe ActsAsOrderedTree::Node::Predicates, :transactional do
+  shared_examples 'ActsAsOrderedTree::Node predicates' do |model, attrs = {}|
+    describe model do
+      let!(:root) { create model, attrs }
+      let!(:child) { create model, attrs.merge(:parent => root) }
+      let!(:grandchild) { create model, attrs.merge(:parent => child) }
+
+      let(:counter_cached?) { root.class.ordered_tree.columns.counter_cache? }
+
+      before { [root, child, grandchild].each(&:reload) }
+
+      describe '#root?' do
+        it { expect(root).to be_root }
+        it { expect(child).not_to be_root }
+        it { expect(grandchild).not_to be_root }
+
+        it { expect{root.root?}.not_to query_database }
+        it { expect{child.root?}.not_to query_database }
+        it { expect{grandchild.root?}.not_to query_database }
+      end
+
+      describe '#has_parent?' do
+        it { expect(root).not_to have_parent }
+        it { expect(child).to have_parent }
+        it { expect(grandchild).to have_parent }
+
+        it { expect{root.has_parent?}.not_to query_database }
+        it { expect{child.has_parent?}.not_to query_database }
+        it { expect{grandchild.has_parent?}.not_to query_database }
+
+        it 'should be aliased but deprecated as #child?' do
+          expect(ActiveSupport::Deprecation).to receive(:warn)
+          expect(root).to receive(:has_parent?)
+          ActiveSupport::Deprecation.silence{root.child?}
+        end
+      end
+
+      describe '#leaf?' do
+        it { expect(root).not_to be_leaf }
+        it { expect(child).not_to be_leaf }
+        it { expect(grandchild).to be_leaf }
+
+        context 'when new record given' do
+          let(:record) { build model, attrs }
+
+          it { expect(record).not_to be_leaf }
+          it { expect{record.leaf?}.not_to query_database }
+        end
+
+        context 'when :children association is loaded' do
+          before { root.children << build(model, attrs) }
+          before { root.children.reload }
+
+          it { expect(root).not_to be_leaf }
+          it { expect{root.leaf?}.not_to query_database }
+        end
+
+        context 'when :children association is not loaded' do
+          before { root.children << build(model, attrs) }
+          before { root.reload }
+
+          it { expect(root).not_to be_leaf }
+          it do
+            if counter_cached?
+              expect{root.leaf?}.not_to query_database
+            else
+              # we must check that #leaf? is optimized
+              expect{root.leaf?}.not_to query_database(/COUNT/)
+              expect{root.leaf?}.to query_database(/LIMIT 1/i)
+            end
+          end
+        end
+      end
+
+      describe '#has_children?' do
+        # opposite of #leaf?
+        it { expect(root).to have_children }
+        it { expect(child).to have_children }
+        it { expect(grandchild).not_to have_children }
+
+        it 'should be aliased but deprecated as #branch?' do
+          expect(ActiveSupport::Deprecation).to receive(:warn)
+          expect(root).to receive(:has_children?)
+          ActiveSupport::Deprecation.silence{root.branch?}
+        end
+      end
+
+      describe '#is_descendant_of?' do
+        it { expect(root) }
+      end
+
+      describe '#is_(or_is)_(descendant|ancestor)_of?' do
+        matrix3d = Hash[
+            :is_descendant_of? => Hash[
+                :root => {:root => false, :child => false, :grandchild => false},
+                :child => {:root => true, :child => false, :grandchild => false},
+                :grandchild => {:root => true, :child => true, :grandchild => false}
+            ],
+            :is_or_is_descendant_of? => Hash[
+                :root => {:root => true, :child => false, :grandchild => false},
+                :child => {:root => true, :child => true, :grandchild => false},
+                :grandchild => {:root => true, :child => true, :grandchild => true}
+            ],
+            :is_ancestor_of? => Hash[
+                :root => {:root => false, :child => true, :grandchild => true},
+                :child => {:root => false, :child => false, :grandchild => true},
+                :grandchild => {:root => false, :child => false, :grandchild => false}
+            ],
+            :is_or_is_ancestor_of? => Hash[
+                :root => {:root => true, :child => true, :grandchild => true},
+                :child => {:root => false, :child => true, :grandchild => true},
+                :grandchild => {:root => false, :child => false, :grandchild => true}
+            ]
+        ]
+
+        matrix3d.each do |method, matrix|
+          matrix.each do |node, examples|
+            examples.each do |target, expectation|
+              it "expect that #{node}.#{method}(#{target}) == #{expectation.inspect}" do
+                expect(send(node).send(method, send(target))).to eq expectation
+              end
+            end
+          end
+        end
+
+      end
+    end
+
+    describe model do
+      let!(:list) { create_list model, 3, attrs }
+      let(:first) { list[0] }
+      let(:second) { list[1] }
+      let(:third) { list[2] }
+
+      describe '#first?' do
+        it { expect(first).to be_first }
+        it { expect(second).not_to be_first }
+        it { expect(third).not_to be_first }
+
+        it 'does not query database' do
+          list.each do |node|
+            expect{node.first?}.not_to query_database
+          end
+        end
+      end
+
+      describe '#last?' do
+        it { expect(first).not_to be_last }
+        it { expect(second).not_to be_last }
+        it { expect(third).to be_last }
+
+        it { expect{first.last?}.to query_database(/LIMIT 1/i).once }
+      end
+    end
+  end
+
+  include_examples 'ActsAsOrderedTree::Node predicates', :default
+  include_examples 'ActsAsOrderedTree::Node predicates', :default_with_counter_cache do
+    describe '#last?' do
+      context 'when node is child' do
+        let(:root) { create :default_with_counter_cache }
+        let!(:node) { create :default_with_counter_cache, :parent => root }
+
+        context 'when parent is loaded' do
+          before { node.association(:parent).reload }
+
+          it { expect(node).to be_last }
+          it { expect{node.last?}.not_to query_database }
+        end
+
+        context 'when parent is not loaded' do
+          before { node.reload }
+          it { expect(node).to be_last }
+          it { expect{node.last?}.to query_database.once }
+        end
+      end
+    end
+  end
+
+  include_examples 'ActsAsOrderedTree::Node predicates', :scoped, :scope_type => 's' do
+    describe '#is_(or_is)_(descendant|ancestor)_of?' do
+      context 'when nodes belong to different scopes' do
+        let(:root) { create :scoped, :scope_type => 'a' }
+        let(:child) { create :scoped, :parent => root }
+        # hack it
+        before { child.scope_type = 'b' }
+        before { child.class.where(:id => child.id).update_all(['scope_type = ?', 'b']) }
+
+        context 'when parent association is cached and cache is stale' do
+          it { expect(root.is_ancestor_of?(child)).to be false }
+          it { expect(root.is_or_is_ancestor_of?(child)).to be false }
+          it { expect(child.is_descendant_of?(root)).to be false }
+          it { expect(child.is_or_is_descendant_of?(root)).to be false }
+        end
+
+        context 'when parent association is not loaded' do
+          before { child.reload }
+
+          it { expect(root.is_ancestor_of?(child)).to be false }
+          it { expect(root.is_or_is_ancestor_of?(child)).to be false }
+          it { expect(child.is_descendant_of?(root)).to be false }
+          it { expect(child.is_or_is_descendant_of?(root)).to be false }
+        end
+      end
+    end
+  end
+end

data/spec/node/reloading_spec.rb

@@ -0,0 +1,42 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe ActsAsOrderedTree::Node::Reloading, :transactional do
+  shared_examples 'ActsAsOrderedTree::Node#reload' do |model, attrs = {}|
+    describe model.to_s.camelize, '#reload' do
+      let(:record) { create model, attrs }
+      let(:node) { record.ordered_tree_node }
+
+      # change all attributes
+      before { node.parent_id = create(model, attrs).id }
+      before { node.position = 3 }
+      before { node.depth = 2 if record.ordered_tree.columns.depth? }
+      before { record[record.ordered_tree.columns.counter_cache] = 5 if record.ordered_tree.columns.counter_cache? }
+      before { record.name = 'another name' }
+
+      it 'reloads attributes related to tree' do
+        node.reload
+
+        expect(node.parent_id).to eq nil
+        expect(node.position).to eq 1
+
+        if record.ordered_tree.columns.depth?
+          expect(node.depth).to eq 0
+        end
+
+        if record.class.ordered_tree.columns.counter_cache?
+          expect(record.children.size).to eq 0
+        end
+      end
+
+      it 'does not reload another attributes' do
+        expect{node.reload}.not_to change(record, :name)
+      end
+    end
+  end
+
+  include_examples 'ActsAsOrderedTree::Node#reload', :default
+  include_examples 'ActsAsOrderedTree::Node#reload', :default_with_counter_cache
+  include_examples 'ActsAsOrderedTree::Node#reload', :scoped
+end

data/spec/node/siblings_spec.rb

@@ -0,0 +1,193 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe ActsAsOrderedTree::Node::Siblings, :transactional do
+  shared_examples 'siblings' do |model|
+    # silence pending examples
+    #
+    # @todo fix all xits
+    def self.xit(*) end
+
+    let(:root) { create model }
+    let(:items) { create_list model, 3, :parent => root }
+
+    # first
+    it { expect(items.first.self_and_siblings).to eq items }
+    it { expect(items.first.siblings).to eq [items.second, items.last] }
+
+    it { expect(items.first.left_sibling).to be nil }
+    it { expect(items.first.right_sibling).to eq items.second }
+
+    it { expect(items.first.left_siblings).to be_empty }
+    it { expect(items.first.right_siblings).to eq [items.second, items.last] }
+
+    # second
+    it { expect(items.second.self_and_siblings).to eq items }
+    it { expect(items.second.siblings).to eq [items.first, items.last] }
+
+    it { expect(items.second.left_sibling).to eq items.first }
+    it { expect(items.second.right_sibling).to eq items.last }
+
+    it { expect(items.second.left_siblings).to eq [items.first] }
+    it { expect(items.second.right_siblings).to eq [items.last] }
+
+    # last
+    it { expect(items.last.self_and_siblings).to eq items }
+    it { expect(items.last.siblings).to eq [items.first, items.second] }
+
+    it { expect(items.last.left_sibling).to eq items.second }
+    it { expect(items.last.right_sibling).to be nil }
+
+    it { expect(items.last.left_siblings).to eq [items.first, items.second] }
+    it { expect(items.last.right_siblings).to be_empty }
+
+    context 'trying to set left or right sibling with random object' do
+      def self.expect_type_mismatch_on(value)
+        it "throws error when #{value.class} given" do
+          expect {
+            items.first.left_sibling = value
+          }.to raise_error ActiveRecord::AssociationTypeMismatch
+
+          expect {
+            items.first.right_sibling = value
+          }.to raise_error ActiveRecord::AssociationTypeMismatch
+        end
+      end
+
+      def self.generate_class
+        Class.new(ActiveRecord::Base){ self.table_name = 'categories' }
+      end
+
+      expect_type_mismatch_on(generate_class.new)
+      expect_type_mismatch_on(nil)
+    end
+
+    context 'when left sibling is set' do
+      context 'and new left sibling has same parent' do
+        context 'and new left sibling is higher' do
+          let(:item) { items.last }
+          before { item.left_sibling = items.first }
+
+          it { expect(item.parent).to eq items.first.parent }
+          it { expect(item.position).to eq 2 }
+
+          xit { expect(item.left_sibling).to eq items.first }
+          xit { expect(item.right_siblings).to eq [items.second] }
+        end
+
+        context 'and new left sibling is lower' do
+          let(:item) { items.first }
+          before { item.left_sibling = items.last }
+
+          it { expect(item.parent).to eq items.first.parent }
+          it { expect(item.position).to eq 3 }
+
+          xit { expect(item.left_sibling).to eq items.last }
+          xit { expect(item.left_siblings).to eq [items.second, items.last] }
+        end
+      end
+
+      context 'and new left sibling has other parent' do
+        let(:item) { items.first }
+        before { item.left_sibling = root }
+
+        it { expect(item.parent).to be nil }
+        it { expect(item.position).to eq 2 }
+
+        xit { expect(item.left_sibling).to eq root }
+      end
+
+      context 'via #left_sibling_id=' do
+        let(:item) { items.first }
+
+        it 'throws error when non-existent ID given' do
+          expect {
+            item.left_sibling_id = -1
+          }.to raise_error ActiveRecord::RecordNotFound
+        end
+
+        it 'delegates to #left_sibling=' do
+          new_sibling = items.last
+
+          expect(item.ordered_tree_node).to receive(:left_sibling=).with(new_sibling)
+          item.left_sibling_id = new_sibling.id
+        end
+      end
+    end
+
+    context 'when right sibling is set' do
+      context 'and new right sibling has same parent' do
+        context 'and new right sibling is higher' do
+          let(:item) { items.last }
+          before { item.right_sibling = items.first }
+
+          it { expect(item.parent).to eq items.first.parent }
+          it { expect(item.position).to eq 1 }
+
+          xit { expect(item.right_sibling).to eq item.first }
+          xit { expect(item.left_siblings).to be_empty }
+          xit { expect(item.right_siblings).to eq [items.first, items.second] }
+        end
+
+        context 'and new right sibling is lower' do
+          let(:item) { items.first }
+          before { item.right_sibling = items.last }
+
+          it { expect(item.parent).to eq items.first.parent }
+          it { expect(item.position).to eq 2 }
+
+          xit { expect(item.right_sibling).to eq items.last }
+          xit { expect(item.right_siblings).to eq [items.last] }
+
+          xit { expect(item.left_sibling).to eq items.first }
+          xit { expect(item.left_siblings).to eq [items.first] }
+        end
+      end
+
+      context 'and new right sibling has other parent' do
+        let(:item) { items.first }
+        before { item.right_sibling = root }
+
+        it { expect(item.parent).to be nil }
+        it { expect(item.position).to eq 1 }
+
+        xit { expect(item.right_sibling).to eq root }
+      end
+
+      context 'via #right_sibling_id=' do
+        let(:item) { items.first }
+
+        it 'throws error when non-existent ID given' do
+          expect {
+            item.right_sibling_id = -1
+          }.to raise_error ActiveRecord::RecordNotFound
+        end
+
+        it 'delegates to #right_sibling=' do
+          new_sibling = items.last
+
+          expect(item.ordered_tree_node).to receive(:right_sibling=).with(new_sibling)
+          item.right_sibling_id = new_sibling.id
+        end
+      end
+    end
+  end
+
+  context 'Tree without scopes' do
+    include_examples 'siblings', :default
+    include_examples 'siblings', :default_with_counter_cache
+  end
+
+  context 'Tree with scope' do
+    let!(:items_1) { create_list :scoped, 3, :scope_type => 's1' }
+    let!(:items_2) { create_list :scoped, 3, :scope_type => 's2' }
+
+    include_examples 'siblings', :scoped do
+      let(:items) { items_1 }
+    end
+    include_examples 'siblings', :scoped do
+      let(:items) { items_2 }
+    end
+  end
+end