acts_as_ordered_tree 1.3.1 → 2.0.0.beta3

data/spec/node/traversals_spec.rb

@@ -0,0 +1,71 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe ActsAsOrderedTree::Node::Traversals, :transactional do
+  shared_examples 'ActsAsOrderedTree::Node traversals' do |model, attrs = {}|
+    let(:root_1) { create model, attrs }
+    let(:child_1) { create model, attrs.merge(:parent => root_1) }
+    let(:grandchild_1) { create model, attrs.merge(:parent => child_1) }
+    let(:root_2) { create model, attrs }
+    let(:child_2) { create model, attrs.merge(:parent => root_2) }
+    let(:grandchild_2) { create model, attrs.merge(:parent => child_2) }
+
+    before { [root_1, child_1, grandchild_1].each(&:reload) }
+    before { [root_2, child_2, grandchild_2].each(&:reload) }
+
+    describe '#root' do
+      it { expect(root_1.root).to eq root_1 }
+      it { expect{root_1.root}.not_to query_database }
+      it { expect(child_1.root).to eq root_1 }
+      it { expect(grandchild_1.root).to eq root_1 }
+
+      it { expect(root_2.root).to eq root_2 }
+      it { expect{root_2.root}.not_to query_database }
+      it { expect(child_2.root).to eq root_2 }
+      it { expect(grandchild_2.root).to eq root_2 }
+    end
+
+    describe '#self_and_ancestors' do
+      it { expect(root_1.self_and_ancestors).to eq [root_1] }
+      it { expect{root_1.self_and_ancestors}.not_to query_database }
+      it { expect(child_1.self_and_ancestors).to eq [root_1, child_1] }
+      it { expect(grandchild_1.self_and_ancestors).to eq [root_1, child_1, grandchild_1] }
+
+      it { expect(child_1.self_and_ancestors).to respond_to :each_with_level }
+      it { expect(child_1.self_and_ancestors).to respond_to :each_without_orphans }
+    end
+
+    describe '#ancestors' do
+      it { expect(root_1.ancestors).to eq [] }
+      it { expect{root_1.ancestors}.not_to query_database }
+      it { expect(child_1.ancestors).to eq [root_1] }
+      it { expect(grandchild_1.ancestors).to eq [root_1, child_1] }
+
+      it { expect(child_1.ancestors).to respond_to :each_with_level }
+      it { expect(child_1.ancestors).to respond_to :each_without_orphans }
+    end
+
+    describe '#self_and_descendants' do
+      it { expect(root_1.self_and_descendants).to eq [root_1, child_1, grandchild_1] }
+      it { expect(child_1.self_and_descendants).to eq [child_1, grandchild_1] }
+      it { expect(grandchild_1.self_and_descendants).to eq [grandchild_1] }
+
+      it { expect(root_1.self_and_descendants).to respond_to :each_with_level }
+      it { expect(root_1.self_and_descendants).to respond_to :each_without_orphans }
+    end
+
+    describe '#descendants' do
+      it { expect(root_1.descendants).to eq [child_1, grandchild_1] }
+      it { expect(child_1.descendants).to eq [grandchild_1] }
+      it { expect(grandchild_1.descendants).to eq [] }
+
+      it { expect(root_1.descendants).to respond_to :each_with_level }
+      it { expect(root_1.descendants).to respond_to :each_without_orphans }
+    end
+  end
+
+  include_examples 'ActsAsOrderedTree::Node traversals', :default
+  include_examples 'ActsAsOrderedTree::Node traversals', :default_with_counter_cache
+  include_examples 'ActsAsOrderedTree::Node traversals', :scoped, :scope_type => 'a'
+end

data/spec/persevering_transaction_spec.rb

@@ -0,0 +1,98 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+require 'acts_as_ordered_tree/persevering_transaction'
+
+describe ActsAsOrderedTree::PerseveringTransaction, :non_transactional do
+  def create_transaction(connection = ActiveRecord::Base.connection)
+    described_class.new(connection)
+  end
+
+  describe 'Transaction state' do
+    def transaction
+      @transaction ||= create_transaction
+    end
+
+    it 'becomes committed only when real transaction ends' do
+      transaction.start do
+        nested_transaction = create_transaction
+
+        nested_transaction.start { }
+
+        expect(nested_transaction).not_to be_committed
+        expect(transaction).not_to be_committed
+      end
+
+      expect(transaction).to be_committed
+    end
+
+    it 'becomes rolledback when real transaction is rolledback' do
+      transaction.start do
+        raise ActiveRecord::Rollback
+      end
+
+      expect(transaction).to be_rolledback
+    end
+  end
+
+  describe 'After commit callbacks' do
+    it 'executes callbacks only when real transaction commits' do
+      executed = []
+
+      outer = create_transaction
+      outer.after_commit { executed << 1 }
+
+      outer.start do
+        inner = create_transaction
+        inner.after_commit { executed << 2 }
+
+        inner.start { }
+
+        expect(executed).to be_empty
+      end
+
+      expect(executed).to eq [1, 2]
+    end
+  end
+
+  describe 'Deadlock handling' do
+    def start_in_thread(&block)
+      Thread.start do
+        ActiveRecord::Base.connection_pool.with_connection do |connection|
+          trans = create_transaction(connection)
+          trans.start(&block)
+          trans
+        end
+      end
+    end
+
+    let!(:resource1) { Default.create!(:name => 'resource 1') }
+    let!(:resource2) { Default.create!(:name => 'resource 2') }
+
+    # this test randomly fails on Rails 3.1
+    it 'Restarts transaction when deadlock occurred' do
+      threads = []
+
+      threads << start_in_thread do
+        resource1.lock!
+        sleep 0.1
+        resource2.lock!
+        sleep 0.1
+      end
+
+      threads << start_in_thread do
+        resource2.lock!
+        sleep 0.1
+        resource1.lock!
+        sleep 0.1
+      end
+
+      transactions = threads.map(&:value)
+
+      expect(transactions[0]).to be_committed
+      expect(transactions[1]).to be_committed
+    end
+  end
+
+end

data/spec/relation/arrangeable_spec.rb

@@ -0,0 +1,88 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe ActsAsOrderedTree::Relation::Arrangeable, :transactional do
+  tree :factory => :default do
+    root {
+      child_1 {
+        grandchild_11
+        grandchild_12
+      }
+      child_2 {
+        grandchild_21
+        grandchild_22
+      }
+    }
+  end
+
+  specify '#descendants scope should be arrangeable' do
+    expect(root.descendants.arrange).to eq Hash[
+      child_1 => {
+        grandchild_11 => {},
+        grandchild_12 => {}
+      },
+      child_2 => {
+        grandchild_21 => {},
+        grandchild_22 => {}
+      }
+    ]
+  end
+
+  specify '#self_and_descendants should be arrangeable' do
+    expect(root.self_and_descendants.arrange).to eq Hash[
+      root => {
+        child_1 => {
+          grandchild_11 => {},
+          grandchild_12 => {}
+        },
+        child_2 => {
+          grandchild_21 => {},
+          grandchild_22 => {}
+        }
+      }
+    ]
+  end
+
+  specify '#ancestors should be arrangeable' do
+    expect(grandchild_11.ancestors.arrange).to eq Hash[
+      root => {
+        child_1 => {}
+      }
+    ]
+  end
+
+  specify '#self_and_ancestors should be arrangeable' do
+    expect(grandchild_11.self_and_ancestors.arrange).to eq Hash[
+      root => {
+        child_1 => {
+          grandchild_11 => {}
+        }
+      }
+    ]
+  end
+
+  it 'should not discard orphaned nodes by default' do
+    relation = root.descendants.where(root.class.arel_table[:id].not_eq(child_1.id))
+
+    expect(relation.arrange).to eq Hash[
+      grandchild_11 => {},
+      grandchild_12 => {},
+      child_2 => {
+        grandchild_21 => {},
+        grandchild_22 => {}
+      }
+    ]
+  end
+
+  it 'should discard orphans if option :discard passed' do
+    relation = root.descendants.where(root.class.arel_table[:id].not_eq(child_1.id))
+
+    expect(relation.arrange(:orphans => :discard)).to eq Hash[
+      child_2 => {
+        grandchild_21 => {},
+        grandchild_22 => {}
+      }
+    ]
+  end
+end

data/spec/relation/iterable_spec.rb

@@ -0,0 +1,104 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+require 'acts_as_ordered_tree/relation/iterable'
+
+describe ActsAsOrderedTree::Relation::Iterable, :transactional do
+  shared_examples 'iterable' do |model|
+    tree :factory => model do
+      root_1 {
+        child_1 {
+          child_2
+        }
+        child_3 {
+          child_4
+          child_5
+        }
+      }
+      root_2 {
+        child_6
+      }
+    end
+
+    describe '#each_with_level' do
+      it 'iterates over collection and yields level' do
+        relation = current_tree.order(:id).extending(described_class)
+
+        expect { |b|
+          relation.each_with_level(&b)
+        }.to yield_successive_args [root_1, 0],
+                                   [child_1, 1],
+                                   [child_2, 2],
+                                   [child_3, 1],
+                                   [child_4, 2],
+                                   [child_5, 2],
+                                   [root_2, 0],
+                                   [child_6, 1]
+      end
+
+      it 'computes level relative to first selected node' do
+        expect { |b|
+          root_1.descendants.extending(described_class).each_with_level(&b)
+        }.to yield_successive_args [child_1, 1],
+                                   [child_2, 2],
+                                   [child_3, 1],
+                                   [child_4, 2],
+                                   [child_5, 2]
+      end
+    end
+
+    describe '#each_without_orphans' do
+      let(:relation) { current_tree.order(:id).extending(described_class) }
+
+      it 'iterates over collection' do
+        expect { |b|
+          relation.each_without_orphans(&b)
+        }.to yield_successive_args root_1,
+                                   child_1,
+                                   child_2,
+                                   child_3,
+                                   child_4,
+                                   child_5,
+                                   root_2,
+                                   child_6
+      end
+
+      it 'iterates over collection and discards orphans' do
+        expect { |b|
+          relation.where('id != ?', child_3.id).each_without_orphans(&b)
+        }.to yield_successive_args root_1,
+                                   child_1,
+                                   child_2,
+                                   root_2,
+                                   child_6
+      end
+
+      it 'iterates over collection and discards orphans' do
+        expect { |b|
+          relation.where('id != ?', root_2.id).each_without_orphans(&b)
+        }.to yield_successive_args root_1,
+                                   child_1,
+                                   child_2,
+                                   child_3,
+                                   child_4,
+                                   child_5
+      end
+
+      it 'iterates over collection and discards orphans' do
+        expect { |b|
+          relation.where('id != ?', root_1.id).each_without_orphans(&b)
+        }.to yield_successive_args root_2,
+                                   child_6
+      end
+    end
+  end
+
+  describe 'Model with cached level' do
+    it_behaves_like 'iterable', :default
+  end
+
+  describe 'Model without cached level' do
+    it_behaves_like 'iterable', :default_without_depth
+  end
+end

data/spec/relation/preloaded_spec.rb

@@ -0,0 +1,57 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+require 'acts_as_ordered_tree/relation/preloaded'
+
+describe ActsAsOrderedTree::Relation::Preloaded, :transactional do
+  let!(:records) { create_list :default, 2 }
+
+  def relation
+    Default.where(nil).extending(described_class)
+  end
+
+  context 'when preloaded records were not set' do
+    it { expect(relation).to match_array records }
+    it { expect(relation.to_a).not_to be records }
+    it { expect{relation.to_a}.to query_database.once }
+  end
+
+  context 'when preloaded records were set directly' do
+    let(:preloaded) { relation.records(records) }
+
+    it { expect(preloaded).to eq records }
+
+    it { expect(preloaded.to_a).to be records }
+    it { expect{preloaded.to_a}.not_to query_database }
+
+    it { expect(preloaded.size).to eq 2 }
+    it { expect{preloaded.size}.not_to query_database }
+
+    context 'when preloaded relation was extended' do
+      let(:extended) { preloaded.extending(Module.new) }
+
+      it { expect(extended).to eq records }
+
+      it { expect(extended.to_a).to be records }
+      it { expect{extended.to_a}.not_to query_database }
+
+      it { expect(extended.size).to eq 2 }
+      it { expect{extended.size}.not_to query_database }
+    end
+
+    describe '#reverse_order' do
+      it { expect(preloaded.reverse_order).not_to be preloaded }
+      it { expect(preloaded.reverse_order.size).to eq 2 }
+      it { expect(preloaded.reverse_order).to eq records.reverse }
+      it { expect{preloaded.reverse_order.to_a}.not_to query_database }
+    end
+
+    describe '#reverse_order!' do
+      it { expect(preloaded.reverse_order!).to be preloaded }
+      it { expect(preloaded.reverse_order!.size).to eq 2 }
+      it { expect(preloaded.reverse_order!.to_a).to eq records.reverse }
+      it { expect{preloaded.reverse_order!.to_a}.not_to query_database }
+    end
+  end
+end

data/spec/reorder_spec.rb

@@ -0,0 +1,83 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe ActsAsOrderedTree, 'Reorder via save', :transactional do
+  tree :factory => :default do
+    root {
+      child_1
+      child_2
+      child_3
+    }
+  end
+
+  def reorder(node, position)
+    name = "category #{rand(100..1000)}"
+    node.position = position
+    node.name = name
+    expect { node.save! }.not_to raise_error
+    expect(node.name).to eq name
+  end
+
+  def assert_order(*nodes)
+    nodes.each_with_index do |node, index|
+      expect(node.reload.position).to eq index + 1
+    end
+  end
+
+  context 'when I change position to lower' do
+    before { reorder child_2, 1 }
+
+    it 'moves node up' do
+      assert_order child_2, child_1, child_3
+    end
+  end
+
+  context 'when I change position to lower' do
+    before { reorder child_2, 3 }
+
+    it 'moves node down' do
+      assert_order child_1, child_3, child_2
+    end
+  end
+
+  context 'when I move highest node lower' do
+    before { reorder child_1, 3 }
+
+    it 'moves node down' do
+      assert_order child_2, child_3, child_1
+    end
+  end
+
+  context 'when I move lowest node upper' do
+    before { reorder child_3, 1 }
+
+    it 'moves node down' do
+      assert_order child_3, child_1, child_2
+    end
+  end
+
+  context 'when I move to very high position' do
+    before { reorder child_1, 5 }
+
+    it 'moves node to bottom' do
+      assert_order child_2, child_3, child_1
+    end
+  end
+
+  context 'when I move to zero position' do
+    before { reorder child_2, 0 }
+
+    it 'moves it to top' do
+      assert_order child_2, child_1, child_3
+    end
+  end
+
+  context 'when I move to same position' do
+    before { reorder child_2, 2 }
+
+    specify 'order remains the same' do
+      assert_order child_1, child_2, child_3
+    end
+  end
+end