acts_as_ordered_tree 1.3.1 → 2.0.0.beta3

data/spec/node/movements/concurrent_movements_spec.rb

@@ -0,0 +1,354 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe ActsAsOrderedTree::Node::Movements, :non_transactional, :unless => ENV['DB'] == 'sqlite3' do
+  class ConcurrentTasks < Array
+    def task(&block)
+      push block
+    end
+
+    def spawn(suite)
+      map do |task|
+        thread { suite.instance_eval(&task) }
+      end.each(&:join)
+    end
+
+    private
+    def thread(&block)
+      Thread.start do
+        ActiveRecord::Base.connection_pool.with_connection(&block)
+      end
+    end
+  end
+
+  def self.concurrent(&block)
+    tasks = ConcurrentTasks.new
+    tasks.instance_eval(&block)
+
+    before do
+      tasks.spawn(self)
+    end
+  end
+
+  shared_examples 'Concurrency support' do |factory, attrs = {}|
+    context 'create root nodes in empty tree simultaneously' do
+      let(:current_tree) { FactoryGirl.factory_by_name(factory).build_class }
+
+      concurrent do
+        3.times { task { create factory, attrs } }
+      end
+
+      expect_tree_to_match {
+        any
+        any
+        any
+      }
+    end
+
+    context 'add root nodes to existing tree simultaneously' do
+      tree :factory => factory, :attributes => attrs do
+        root
+      end
+
+      concurrent do
+        3.times { task { create factory, attrs } }
+      end
+
+      expect_tree_to_match {
+        root
+        any
+        any
+        any
+      }
+    end
+
+    context 'create nodes on the same level simultaneously' do
+      tree :factory => factory do
+        root
+      end
+
+      concurrent do
+        3.times do
+          task { create factory, :parent => root }
+        end
+      end
+
+      expect_tree_to_match {
+        root {
+          any
+          any
+          any
+        }
+      }
+    end
+
+    context 'move same node simultaneously' do
+      tree :factory => factory, :attributes => attrs do
+        node_1
+        node_2
+        node_3
+        node_4
+      end
+
+      # node itself isn't thread safe
+      def moved_node
+        current_tree.find(node_2.id)
+      end
+
+      concurrent do
+        task { moved_node.move_higher }
+        task { moved_node.move_lower }
+        task { moved_node.move_to_right_of(node_4) }
+      end
+
+      expect_tree_to_match {
+        any
+        any
+        any
+        any
+      }
+    end
+
+    context 'move nodes to same parent simultaneously' do
+      tree :factory => factory, :attributes => attrs do
+        root
+        node_1
+        node_2
+        node_3
+      end
+
+      concurrent do
+        task { node_1.move_to_child_of(root) }
+        task { node_2.move_to_child_of(root) }
+        task { node_3.move_to_child_of(root) }
+      end
+
+      expect_tree_to_match {
+        root {
+          any
+          any
+          any
+        }
+      }
+    end
+
+    context 'move nodes to left of same root node simultaneously' do
+      tree :factory => factory, :attributes => attrs do
+        root_1
+        root_2 {
+          node_1
+          node_2
+          node_3
+        }
+      end
+
+      concurrent do
+        task { node_1.move_to_left_of(root_2) }
+        task { node_2.move_to_left_of(root_2) }
+        task { node_3.move_to_left_of(root_2) }
+      end
+
+      expect_tree_to_match {
+        root_1
+        any
+        any
+        any
+        root_2
+      }
+    end
+
+    context 'move nodes to left of same non-root node simultaneously' do
+      tree :factory => factory do
+        root {
+          child_1
+          child_2 {
+            node_1
+            node_2
+            node_3
+          }
+        }
+      end
+
+      concurrent do
+        task { node_1.move_to_left_of(child_2) }
+        task { node_2.move_to_left_of(child_2) }
+        task { node_3.move_to_left_of(child_2) }
+      end
+
+      expect_tree_to_match {
+        root {
+          child_1
+          any
+          any
+          any
+          child_2
+        }
+      }
+    end
+
+    context 'move node to right of same root node simultaneously' do
+      tree :factory => factory, :attributes => attrs do
+        root_1 {
+          node_1
+          node_2
+          node_3
+        }
+        root_2
+      end
+
+      concurrent do
+        task { node_1.move_to_right_of(root_1) }
+        task { node_2.move_to_right_of(root_1) }
+        task { node_3.move_to_right_of(root_1) }
+      end
+
+      expect_tree_to_match {
+        root_1
+        any
+        any
+        any
+        root_2
+      }
+    end
+
+    context 'move nodes to right of same non-root node simultaneously' do
+      tree :factory => factory do
+        root {
+          child_1 {
+            node_1
+            node_2
+            node_3
+          }
+          child_2
+        }
+      end
+
+      concurrent do
+        task { node_1.move_to_right_of(child_1) }
+        task { node_2.move_to_right_of(child_1) }
+        task { node_3.move_to_right_of(child_1) }
+      end
+
+      expect_tree_to_match {
+        root {
+          child_1
+          any
+          any
+          any
+          child_2
+        }
+      }
+    end
+
+    context 'move nodes to root simultaneously' do
+      tree :factory => factory do
+        root {
+          node_1
+          node_2
+          node_3
+        }
+      end
+
+      concurrent do
+        task { node_1.move_to_root }
+        task { node_2.move_to_root }
+        task { node_3.move_to_root }
+      end
+
+      expect_tree_to_match {
+        root
+        any
+        any
+        any
+      }
+    end
+
+    context 'move nodes left simultaneously' do
+      tree :factory => factory do
+        root {
+          node_1
+          node_2
+          node_3
+          node_4
+        }
+      end
+
+      concurrent do
+        task { node_2.move_left }
+        task { node_3.move_left }
+      end
+
+      expect_tree_to_match {
+        root {
+          any
+          any
+          any
+          node_4
+        }
+      }
+    end
+
+    context 'move nodes right simultaneously' do
+      tree :factory => factory do
+        root {
+          node_1
+          node_2
+          node_3
+          node_4
+        }
+      end
+
+      concurrent do
+        task { node_2.move_right }
+        task { node_3.move_right }
+      end
+
+      expect_tree_to_match {
+        root {
+          node_1
+          any
+          any
+          any
+        }
+      }
+    end
+
+    context 'swap nodes between different branches simultaneously' do
+      tree :factory => factory do
+        root {
+          child_1 {
+            swap_1
+            other_1
+          }
+          child_2 {
+            other_2
+            swap_2
+          }
+        }
+      end
+
+      concurrent do
+        task { swap_1.move_to_child_with_position(child_2, 2) }
+        task { swap_2.move_to_child_with_position(child_1, 1) }
+      end
+
+      expect_tree_to_match {
+        root {
+          child_1 {
+            swap_2
+            other_1
+          }
+          child_2 {
+            other_2
+            swap_1
+          }
+        }
+      }
+    end
+  end
+
+  include_examples 'Concurrency support', :default
+  include_examples 'Concurrency support', :default_with_counter_cache
+  include_examples 'Concurrency support', :scoped, :scope_type => 's'
+end

data/spec/node/movements/move_higher_spec.rb

@@ -0,0 +1,46 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe ActsAsOrderedTree::Node::Movements, '#move_higher', :transactional do
+  shared_examples '#move_higher' do |factory, attrs = {}|
+    describe "#move_higher #{factory}" do
+      tree :factory => factory, :attributes => attrs do
+        node_1
+        node_2
+        node_3
+      end
+
+      context 'trying to move highest node up' do
+        before { node_1.move_higher }
+
+        expect_tree_to_match {
+          node_1
+          node_2
+          node_3
+        }
+      end
+
+      context 'trying to move node with position > 1' do
+        before { node_2.move_higher }
+
+        expect_tree_to_match {
+          node_2
+          node_1
+          node_3
+        }
+      end
+
+      context 'when attribute, not related to tree changed' do
+        before { @old_name = node_3.name }
+        before { node_3.name = 'new name' }
+
+        it { expect{node_3.move_higher}.to change(node_3, :name).to(@old_name) }
+      end
+    end
+  end
+
+  include_examples '#move_higher', :default
+  include_examples '#move_higher', :default_with_counter_cache
+  include_examples '#move_higher', :scoped, :scope_type => 's'
+end

data/spec/node/movements/move_lower_spec.rb

@@ -0,0 +1,46 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe ActsAsOrderedTree::Node::Movements, '#move_lower', :transactional do
+  shared_examples '#move_lower' do |factory, attrs = {}|
+    describe "#move_lower #{factory}" do
+      tree :factory => factory, :attributes => attrs do
+        node_1
+        node_2
+        node_3
+      end
+
+      context 'trying to lowest node down' do
+        before { node_3.move_lower }
+
+        expect_tree_to_match {
+          node_1
+          node_2
+          node_3
+        }
+      end
+
+      context 'trying to move node with not lowest position' do
+        before { node_2.move_lower }
+
+        expect_tree_to_match {
+          node_1
+          node_3
+          node_2
+        }
+      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_lower}.to change(node_2, :name).to(@old_name) }
+      end
+    end
+  end
+
+  include_examples '#move_lower', :default
+  include_examples '#move_lower', :default_with_counter_cache
+  include_examples '#move_lower', :scoped, :scope_type => 's'
+end

data/spec/node/movements/move_to_child_of_spec.rb

@@ -0,0 +1,147 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe ActsAsOrderedTree::Node::Movements, '#move_to_child_of', :transactional do
+  shared_examples '#move_to_child_of' do |factory|
+    describe "#move_to_child_of #{factory}" do
+      tree :factory => factory do
+        root {
+          child_1
+          child_2
+          child_3 {
+            child_4
+          }
+        }
+      end
+
+      context 'when AR object given' do
+        it 'moves node' do
+          expect {
+            child_3.move_to_child_of(child_1)
+          }.to change(child_3, :parent).from(root).to(child_1)
+        end
+
+        it 'does not change attributes unrelated to tree' do
+          old, child_4.name = child_4.name, 'new name'
+
+          expect {
+            child_4.move_to_child_of(root)
+          }.to change(child_4, :name).to(old)
+        end
+
+        context 'moving to child of self' do
+          it { expect(child_3.move_to_child_of(child_3)).to be false }
+
+          it 'does not move node' do
+            expect {
+              child_3.move_to_child_of(child_3)
+            }.not_to change(child_3, :reload)
+          end
+
+          it 'invalidates node' do
+            expect {
+              child_3.move_to_child_of(child_3)
+            }.to change(child_3, :valid?).from(true).to(false)
+          end
+        end
+
+        context 'moving to child of current parent' do
+          it 'does not move node' do
+            expect {
+              child_2.move_to_child_of(root)
+            }.not_to change(child_2, :reload)
+          end
+        end
+
+        context 'moving to child of descendant' do
+          it { expect(root.move_to_child_of(child_1)).to be false }
+
+          it 'does node move node' do
+            expect {
+              root.move_to_child_of(child_1)
+            }.not_to change(root, :reload)
+          end
+
+          it 'invalidates node' do
+            expect {
+              root.move_to_child_of(child_1)
+            }.to change(root, :valid?).from(true).to(false)
+          end
+        end
+
+        context 'moving node deeper' do
+          before { child_3.move_to_child_of(child_2) }
+
+          expect_tree_to_match {
+            root {
+              child_1
+              child_2 {
+                child_3 {
+                  child_4
+                }
+              }
+            }
+          }
+        end
+
+        context 'moving node upper' do
+          before { child_4.move_to_child_of(root) }
+
+          expect_tree_to_match {
+            root {
+              child_1
+              child_2
+              child_3
+              child_4
+            }
+          }
+        end
+      end
+
+      context 'when ID given' do
+        it 'moves node' do
+          expect {
+            child_3.move_to_child_of(child_1.id)
+          }.to change(child_3, :parent).from(root).to(child_1)
+        end
+
+        it 'does not move node if parent was not changed' do
+          expect {
+            child_2.move_to_child_of(root.id)
+          }.not_to change(child_2, :reload)
+        end
+
+        context 'moving to non-existent ID' do
+          before { allow(child_3).to receive(:valid?).and_return(false) }
+
+          it { expect(child_3.move_to_child_of(-1)).to be false }
+
+          it 'does not move node' do
+            expect {
+              child_3.move_to_child_of(-1)
+            }.not_to change(child_3, :reload)
+          end
+        end
+      end
+
+      context 'when nil given' do
+        before { child_2.move_to_child_of(nil) }
+
+        expect_tree_to_match {
+          root {
+            child_1
+            child_3 {
+              child_4
+            }
+          }
+          child_2
+        }
+      end
+    end
+  end
+
+  include_examples '#move_to_child_of', :default
+  include_examples '#move_to_child_of', :default_with_counter_cache
+  include_examples '#move_to_child_of', :scoped
+end