acts_as_ordered_tree 1.3.1 → 2.0.0.beta3

data/spec/counter_cache_spec.rb

@@ -0,0 +1,31 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe ActsAsOrderedTree, ':counter_cache option', :transactional do
+  describe 'Class without counter cache, #children.size' do
+    tree :factory => :default do
+      root {
+        child_1
+        child_2
+      }
+    end
+
+    it { expect(root.children.size).to eq 2 }
+    it { expect{root.children.size}.to query_database.once }
+  end
+
+  describe 'Class with counter cache, #children.size' do
+    tree :factory => :default_with_counter_cache do
+      root {
+        child_1
+        child_2
+      }
+    end
+
+    before { root.reload }
+
+    it { expect(root.children.size).to eq 2 }
+    it { expect{root.children.size}.not_to query_database }
+  end
+end

data/spec/create_spec.rb

@@ -0,0 +1,110 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe ActsAsOrderedTree, 'Create node', :transactional do
+  shared_examples 'create ordered tree node' do |model = :default|
+    let(:record) { build model }
+
+    before { record.parent = parent }
+
+    context 'when position is nil' do
+      before { record.position = nil }
+
+      it 'does not change node parent' do
+        expect{record.save}.not_to change(record, :parent)
+      end
+
+      it 'puts record to position = 1 when there are no siblings' do
+        expect{record.save}.to change(record, :position).from(nil).to(1)
+      end
+
+      it 'puts record to bottom position when there are some siblings' do
+        create model, :parent => parent
+
+        expect{record.save}.to change(record, :position).from(nil).to(2)
+      end
+
+      it 'calculates depth column' do
+        if record.ordered_tree.columns.depth?
+          expect{record.save}.to change(record, :depth).from(nil).to(parent ? parent.depth + 1 : 0)
+        end
+      end
+    end
+
+    context 'when position != nil' do
+      before { record.position = 3 }
+
+      it 'changes position to 1 if siblings is empty' do
+        expect{record.save}.to change(record, :position).from(3).to(1)
+      end
+
+      it 'changes position to highest if there are too few siblings' do
+        create model, :parent => parent
+
+        expect{record.save}.to change(record, :position).from(3).to(2)
+      end
+
+      it 'increments position of lower siblings on insert' do
+        first = create model, :parent => parent
+        second = create model, :parent => parent
+        third = create model, :parent => parent
+
+        expect(first.reload.position).to eq 1
+        expect(second.reload.position).to eq 2
+        expect(third.reload.position).to eq 3
+
+        expect{record.save and third.reload}.to change(third, :position).from(3).to(4)
+
+        expect(first.reload.position).to eq 1
+        expect(second.reload.position).to eq 2
+        expect(record.reload.position).to eq 3
+      end
+
+      it 'calculates depth column' do
+        if record.ordered_tree.columns.depth?
+          expect{record.save}.to change(record, :depth).from(nil).to(parent ? parent.depth + 1 : 0)
+        end
+      end
+    end
+  end
+
+  context 'when parent is nil' do
+    include_examples 'create ordered tree node' do
+      let(:parent) { nil }
+    end
+  end
+
+  context 'when parent exists' do
+    include_examples 'create ordered tree node' do
+      let(:parent) { create :default }
+    end
+  end
+
+  context 'when parent exists (scoped)' do
+    include_examples 'create ordered tree node', :scoped do
+      let(:type) { 'scope' }
+      let(:parent) { create :scoped, :scope_type => type }
+
+      it 'copies scope columns values from parent node' do
+        expect{record.save}.to change(record, :scope_type).to(parent.scope_type)
+      end
+    end
+  end
+
+  describe 'when counter_cache exists' do
+    include_examples 'create ordered tree node', :default_with_counter_cache do
+      let(:parent) { create :default_with_counter_cache }
+
+      it 'sets counter_cache to 0 for new record' do
+        record.save
+
+        expect(record.categories_count).to eq 0
+      end
+
+      it 'increments counter_cache of parent' do
+        expect{record.save and parent.reload}.to change(parent, :categories_count).by(1)
+      end
+    end
+  end
+end

data/spec/destroy_spec.rb

@@ -0,0 +1,57 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe ActsAsOrderedTree, 'Destroy node', :transactional do
+  shared_examples 'destroy ordered tree node' do |model = :default, attrs = {}|
+    tree :factory => model, :attributes => attrs do
+      root {
+        child_1 {
+          grandchild_1 {
+            grandchild_2
+          }
+        }
+        child_2
+        child_3
+      }
+    end
+
+    def assert_destroyed(record)
+      expect(record.class).not_to exist(record.id)
+    end
+
+    it 'destroys descendants' do
+      child_1.destroy
+
+      assert_destroyed(grandchild_1)
+      assert_destroyed(grandchild_2)
+    end
+
+    it 'decrements lower siblings positions' do
+      child_1.destroy
+
+      [child_2, child_3].each(&:reload)
+
+      expect(child_2.position).to eq 1
+      expect(child_3.position).to eq 2
+    end
+  end
+
+  context 'Default model' do
+    include_examples 'destroy ordered tree node', :default
+  end
+
+  context 'Scoped model' do
+    include_examples 'destroy ordered tree node', :scoped, :scope_type => 't'
+  end
+
+  context 'Model with counter cache' do
+    include_examples 'destroy ordered tree node', :default_with_counter_cache
+
+    before { root.reload }
+
+    it 'decrements parent children counter' do
+      expect{child_1.destroy and root.reload}.to change(root, :categories_count).from(3).to(2)
+    end
+  end
+end

data/spec/inheritance_spec.rb

@@ -0,0 +1,176 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe ActsAsOrderedTree, 'inheritance without STI', :transactional do
+  class BaseCategory < ActiveRecord::Base
+    self.table_name = 'categories'
+
+    acts_as_ordered_tree
+  end
+
+  class ConcreteCategory < BaseCategory
+  end
+
+  class ConcreteCategoryWithScope < BaseCategory
+    default_scope { where(arel_table[:name].matches('* %')) }
+  end
+
+  let!(:root) { BaseCategory.create(:name => '* root') }
+  let!(:child_1) { BaseCategory.create(:name => 'child 1', :parent => root) }
+  let!(:child_2) { BaseCategory.create(:name => 'child 2', :parent => child_1) }
+  let!(:child_3) { BaseCategory.create(:name => 'child 3', :parent => child_1) }
+  let!(:child_4) { BaseCategory.create(:name => '* child 4', :parent => root) }
+  let!(:child_5) { BaseCategory.create(:name => '* child 5', :parent => child_4) }
+  let!(:child_6) { BaseCategory.create(:name => 'child 6', :parent => child_4) }
+
+  matcher :be_of do |klass|
+    match do |relation|
+      expect(relation.map(&:class).uniq).to eq [klass]
+    end
+  end
+
+  shared_examples 'Inheritance test' do |klass|
+    describe "#{klass.name}#children" do
+      let(:root_node) { root.becomes(klass) }
+
+      it { expect(root_node).to be_a klass }
+      it { expect(root_node.children).to be_of klass }
+    end
+
+    describe "#{klass.name}#parent" do
+      let(:node) { child_5.becomes(klass) }
+
+      it { expect(node.parent).to be_an_instance_of klass }
+    end
+
+    describe "#{klass.name}#root" do
+      let(:root_node) { root.becomes(klass) }
+      let(:node) { child_5.becomes(klass) }
+
+      it { expect(node.root).to eq root_node }
+      it { expect(node.root).to be_an_instance_of klass }
+    end
+
+    describe "#{klass.name}#descendants" do
+      let(:node) { child_4.becomes(klass) }
+
+      it { expect(node.descendants).to be_of klass }
+    end
+
+    describe "#{klass.name}#ancestors" do
+      let(:node) { child_5.becomes(klass) }
+
+      it { expect(node.ancestors).to be_of klass }
+    end
+
+    describe "#{klass.name} tree validators" do
+      it 'calls validators only once' do
+        expect_any_instance_of(ActsAsOrderedTree::Validators::CyclicReferenceValidator).to receive(:validate).once
+
+        child_1.becomes(klass).save
+      end
+    end
+  end
+
+  include_examples 'Inheritance test', BaseCategory
+  include_examples 'Inheritance test', ConcreteCategory
+  include_examples 'Inheritance test', ConcreteCategoryWithScope do
+    let(:klass) { ConcreteCategoryWithScope }
+
+    describe 'ConcreteCategoryWithScope#children' do
+      let(:node) { klass.find(child_4.id) }
+
+      it { expect(node).to be_a klass }
+      it { expect(node.children).to be_of klass }
+
+      it 'applies class default scope to #children' do
+        expect(node.children.size).to eq 1
+      end
+    end
+
+    describe 'ConcreteCategoryWithScope#parent' do
+      let(:orphaned) { child_2.becomes(klass) }
+      let(:out_of_scope_with_proper_parent) { child_1.becomes(klass) }
+
+      it { expect(orphaned.parent).to be_nil }
+      it { expect(out_of_scope_with_proper_parent.parent).to eq root.becomes(klass) }
+    end
+
+    describe 'ConcreteCategoryWithScope#descendants' do
+      let(:root_node) { klass.find(root.id) }
+
+      it { expect(root_node.descendants).to be_of klass }
+      it { expect(root_node.descendants.map(&:id)).to eq [child_4.id, child_5.id] }
+    end
+  end
+end
+
+describe ActsAsOrderedTree, 'inheritance with STI', :transactional do
+  class StiRoot < StiExample
+  end
+
+  class StiExample1 < StiExample
+  end
+
+  class StiExample2 < StiExample
+  end
+
+  # build tree
+  let!(:root) { StiRoot.create(:name => 'root') }
+  let!(:child_1) { StiExample1.create(:name => 'child 1', :parent => root) }
+  let!(:child_2) { StiExample1.create(:name => 'child 2', :parent => child_1) }
+  let!(:child_3) { StiExample1.create(:name => 'child 3', :parent => child_1) }
+  let!(:child_4) { StiExample2.create(:name => 'child 4', :parent => root) }
+  let!(:child_5) { StiExample2.create(:name => 'child 5', :parent => child_4) }
+  let!(:child_6) { StiExample2.create(:name => 'child 6', :parent => child_4) }
+
+  before { [root, child_1, child_2, child_3, child_4, child_5, child_6].each(&:reload) }
+
+  describe '#children' do
+    it { expect(root.children).to eq [child_1, child_4] }
+  end
+
+  describe '#parent' do
+    it { expect(child_1.parent).to eq root }
+  end
+
+  describe '#descendants' do
+    it { expect(root.descendants).to eq [child_1, child_2, child_3, child_4, child_5, child_6] }
+  end
+
+  describe '#ancestors' do
+    it { expect(child_5.ancestors).to eq [root, child_4] }
+  end
+
+  describe '#root' do
+    it { expect(child_5.root).to eq root }
+  end
+
+  describe '#left_sibling' do
+    it { expect(child_4.left_sibling).to eq child_1 }
+  end
+
+  describe '#right_sibling' do
+    it { expect(child_1.right_sibling).to eq child_4 }
+  end
+
+  describe 'predicates' do
+    it { expect(root).to be_is_ancestor_of(child_1) }
+    it { expect(root).to be_is_or_is_ancestor_of(child_1) }
+    it { expect(child_1).to be_is_descendant_of(root) }
+    it { expect(child_1).to be_is_or_is_descendant_of(root) }
+  end
+
+  describe 'node reload' do
+    it { expect(child_1.ordered_tree_node.reload).to eq child_1 }
+  end
+
+  describe 'node moving' do
+    before { child_4.move_to_child_of(child_1) }
+
+    it { expect(child_4.parent).to eq child_1 }
+    it { expect(child_1.children).to include child_4 }
+    it { expect(child_1.descendants).to include child_4 }
+  end
+end

data/spec/move_spec.rb

@@ -0,0 +1,94 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe ActsAsOrderedTree, 'Movement via save', :transactional do
+  tree :factory => :default_with_counter_cache do
+    root {
+      child_1 {
+        child_2
+        child_3
+      }
+      child_4 {
+        child_5
+      }
+    }
+  end
+
+  def move(node, new_parent, new_position)
+    name = "category #{rand(100..1000)}"
+    node.parent = new_parent
+    node.position = new_position
+    node.name = name
+
+    node.save
+
+    expect(node.reload.parent).to eq new_parent
+    expect(node.position).to eq new_position
+    expect(node.name).to eq name
+  end
+
+  context 'when child 2 moved under child 4 to position 1' do
+    before { move child_2, child_4, 1 }
+
+    expect_tree_to_match {
+      root {
+        child_1 :categories_count => 1 do
+          child_3 :position => 1
+        end
+        child_4 :categories_count => 2 do
+          child_2 :position => 1
+          child_5 :position => 2
+        end
+      }
+    }
+  end
+
+  context 'when child 2 moved under child 4 to position 2' do
+    before { move child_2, child_4, 2 }
+
+    expect_tree_to_match {
+      root {
+        child_1 :categories_count => 1 do
+          child_3 :position => 1
+        end
+        child_4 :categories_count => 2 do
+          child_5 :position => 1
+          child_2 :position => 2
+        end
+      }
+    }
+  end
+
+  context 'when level changed' do
+    before { move child_1, child_4, 1 }
+
+    expect_tree_to_match {
+      root {
+        child_4 :categories_count => 2 do
+          child_1 :position => 1, :categories_count => 2, :depth => 2 do
+            child_2 :position => 1, :depth => 3
+            child_3 :position => 2, :depth => 3
+          end
+          child_5 :position => 2, :depth => 2
+        end
+      }
+    }
+  end
+
+  context 'when node moved to root' do
+    before { move child_1, nil, 1 }
+
+    expect_tree_to_match {
+      child_1 :position => 1, :depth => 0 do
+        child_2 :position => 1, :depth => 1
+        child_3 :position => 2, :depth => 1
+      end
+      root :position => 2, :depth => 0 do
+        child_4 :depth => 1 do
+          child_5 :depth => 2
+        end
+      end
+    }
+  end
+end