closure_tree 7.4.0 → 8.0.0

data/test/closure_tree/metal_test.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+describe Metal do
+  describe '#find_or_create_by_path' do
+    def assert_correctness(grandchild)
+      assert(Metal, grandchild)
+      assert_equal 'slag', grandchild.description
+      child = grandchild.parent
+      assert(Unobtanium, child)
+      assert_equal 'frames', child.description
+      assert_equal 'child', child.value
+      parent = child.parent
+      assert(Adamantium, parent)
+      assert_equal 'claws', parent.description
+      assert_equal 'parent', parent.value
+    end
+
+    let(:attr_path) do
+      [
+        { value: 'parent', description: 'claws', metal_type: 'Adamantium' },
+        { value: 'child', description: 'frames', metal_type: 'Unobtanium' },
+        { value: 'grandchild', description: 'slag', metal_type: 'Metal' }
+      ]
+    end
+
+    if false
+      before do
+        # ensure the correct root is used in find_or_create_by_path:
+        [Metal, Adamantium, Unobtanium].each do |metal|
+          metal.find_or_create_by_path(%w[parent child grandchild])
+        end
+      end
+    end
+
+    it 'creates children from the proper root' do
+      assert_correctness(Metal.find_or_create_by_path(attr_path))
+    end
+
+    it 'supports STI from the base class' do
+      assert_correctness(Metal.find_or_create_by_path(attr_path))
+    end
+
+    it 'supports STI from a subclass' do
+      parent = Adamantium.create!(value: 'parent', description: 'claws')
+      assert_correctness(parent.find_or_create_by_path(attr_path.last(2)))
+    end
+
+    it 'maintains the current STI subclass if attributes are not specified' do
+      leaf = Unobtanium.find_or_create_by_path(%w[a b c d])
+      assert(Unobtanium, leaf)
+      assert_equal %w[c b a], leaf.ancestors.map(&:value)
+      leaf.ancestors.each do |anc|
+        assert(Unobtanium, anc)
+      end
+    end
+  end
+end

data/test/closure_tree/model_test.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+describe '#_ct' do
+  it 'should delegate to the Support instance on the class' do
+    assert_equal Tag._ct, Tag.new._ct
+  end
+end

data/test/closure_tree/namespace_type_test.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+describe Namespace::Type do
+  describe 'class injection' do
+    it 'should build hierarchy classname correctly' do
+      assert_equal 'Namespace::TypeHierarchy', Namespace::Type.hierarchy_class.to_s
+      assert_equal 'Namespace::TypeHierarchy', Namespace::Type._ct.hierarchy_class_name
+      assert_equal 'TypeHierarchy', Namespace::Type._ct.short_hierarchy_class_name
+    end
+  end
+end

data/test/closure_tree/parallel_test.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# We don't need to run the expensive parallel tests for every combination of prefix/suffix.
+# Those affect SQL generation, not parallelism.
+# SQLite doesn't support concurrency reliably, either.
+def run_parallel_tests?
+  !sqlite? &&
+    ActiveRecord::Base.table_name_prefix.empty? &&
+    ActiveRecord::Base.table_name_suffix.empty?
+end
+
+def max_threads
+  5
+end
+
+class WorkerBase
+  extend Forwardable
+  attr_reader :name
+
+  def_delegators :@thread, :join, :wakeup, :status, :to_s
+
+  def log(msg)
+    puts("#{Thread.current}: #{msg}") if ENV["VERBOSE"]
+  end
+
+  def initialize(target, name)
+    @target = target
+    @name = name
+    @thread = Thread.new do
+      ActiveRecord::Base.connection_pool.with_connection { before_work } if respond_to? :before_work
+      log "going to sleep..."
+      sleep
+      log "woke up..."
+      ActiveRecord::Base.connection_pool.with_connection { work }
+      log "done."
+    end
+  end
+end
+
+class FindOrCreateWorker < WorkerBase
+  def work
+    path = [name, :a, :b, :c]
+    log "making #{path}..."
+    t = (@target || Tag).find_or_create_by_path(path)
+    log "made #{t.id}, #{t.ancestry_path}"
+  end
+end
+
+class SiblingPrependerWorker < WorkerBase
+  def before_work
+    @target.reload
+    @sibling = Label.new(name: SecureRandom.hex(10))
+  end
+
+  def work
+    @target.prepend_sibling @sibling
+  end
+end
+
+describe "Concurrent creation" do
+  before do
+    @target = nil
+    @iterations = 5
+  end
+
+  def log(msg)
+    puts(msg) if ENV["VERBOSE"]
+  end
+
+  def run_workers(worker_class = FindOrCreateWorker)
+    @names = @iterations.times.map { |iter| "iteration ##{iter}" }
+    @names.each do |name|
+      workers = max_threads.times.map { worker_class.new(@target, name) }
+      # Wait for all the threads to get ready:
+      while true
+        unready_workers = workers.select { |ea| ea.status != "sleep" }
+        if unready_workers.empty?
+          break
+        else
+          log "Not ready to wakeup: #{unready_workers.map { |ea| [ea.to_s, ea.status] }}"
+          sleep(0.1)
+        end
+      end
+      sleep(0.25)
+      # OK, GO!
+      log "Calling .wakeup on all workers..."
+      workers.each(&:wakeup)
+      sleep(0.25)
+      # Then wait for them to finish:
+      log "Calling .join on all workers..."
+      workers.each(&:join)
+    end
+    # Ensure we're still connected:
+    ActiveRecord::Base.connection_pool.connection
+  end
+
+  it "will not create dupes from class methods" do
+    skip("unsupported") unless run_parallel_tests?
+
+    run_workers
+    assert_equal @names.sort, Tag.roots.collect { |ea| ea.name }.sort
+    # No dupe children:
+    %w[a b c].each do |ea|
+      assert_equal @iterations, Tag.where(name: ea).size
+    end
+  end
+
+  it "will not create dupes from instance methods" do
+    skip("unsupported") unless run_parallel_tests?
+
+    @target = Tag.create!(name: "root")
+    run_workers
+    assert_equal @names.sort, @target.reload.children.collect { |ea| ea.name }.sort
+    assert_equal @iterations, Tag.where(name: @names).size
+    %w[a b c].each do |ea|
+      assert_equal @iterations, Tag.where(name: ea).size
+    end
+  end
+
+  it "creates dupe roots without advisory locks" do
+    skip("unsupported") unless run_parallel_tests?
+
+    # disable with_advisory_lock:
+    Tag.stub(:with_advisory_lock, ->(_lock_name, &block) { block.call }) do
+      run_workers
+      # duplication from at least one iteration:
+      assert Tag.where(name: @names).size > @iterations
+    end
+  end
+
+  it "fails to deadlock while simultaneously deleting items from the same hierarchy" do
+    skip("unsupported") unless run_parallel_tests?
+
+    target = User.find_or_create_by_path((1..200).to_a.map { |ea| ea.to_s })
+    emails = target.self_and_ancestors.to_a.map(&:email).shuffle
+    Parallel.map(emails, in_threads: max_threads) do |email|
+      ActiveRecord::Base.connection_pool.with_connection do
+        User.transaction do
+          log "Destroying #{email}..."
+          User.where(email: email).destroy_all
+        end
+      end
+    end
+    User.connection.reconnect!
+    assert User.all.empty?
+  end
+
+  it "fails to deadlock from prepending siblings" do
+    skip("unsupported") unless run_parallel_tests?
+
+    @target = Label.find_or_create_by_path %w[root parent]
+    run_workers(SiblingPrependerWorker)
+    children = Label.roots
+    uniq_order_values = children.collect { |ea| ea.order_value }.uniq
+    assert_equal uniq_order_values.size, children.size
+
+    # The only non-root node should be "root":
+    assert_equal([@target.parent], Label.all.select { |ea| ea.root? })
+  end
+end

data/test/closure_tree/pool_test.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+describe 'Configuration' do
+  it 'returns connection to the pool after has_closure_tree setup' do
+    class TypeDuplicate < ActiveRecord::Base
+      self.table_name = "namespace_type#{table_name_suffix}"
+      has_closure_tree
+    end
+
+    refute ActiveRecord::Base.connection_pool.active_connection?
+    # +false+ in AR 4, +nil+ in AR 5
+  end
+
+  it 'returns connection to the pool after has_closure_tree setup with order' do
+    class MetalDuplicate < ActiveRecord::Base
+      self.table_name = "#{table_name_prefix}metal#{table_name_suffix}"
+      has_closure_tree order: 'sort_order', name_column: 'value'
+    end
+
+    refute ActiveRecord::Base.connection_pool.active_connection?
+  end
+
+  it 'returns connection to the pool after has_closure_tree_root setup' do
+    class GroupDuplicate < ActiveRecord::Base
+      self.table_name = "#{table_name_prefix}group#{table_name_suffix}"
+      has_closure_tree_root :root_user
+    end
+
+    refute ActiveRecord::Base.connection_pool.active_connection?
+  end
+end

data/test/closure_tree/support_test.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+describe ClosureTree::Support do
+  let(:sut) { Tag._ct }
+
+  it 'passes through table names without prefix and suffix' do
+    expected = 'some_random_table_name'
+    assert_equal expected, sut.remove_prefix_and_suffix(expected)
+  end
+
+  it 'extracts through table name with prefix and suffix' do
+    expected = 'some_random_table_name'
+    tn = ActiveRecord::Base.table_name_prefix + expected + ActiveRecord::Base.table_name_suffix
+    assert_equal expected, sut.remove_prefix_and_suffix(tn)
+  end
+end

data/test/closure_tree/tag_test.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'support/tag_examples'
+
+describe Tag do
+  include TagExamples
+end

data/test/closure_tree/user_test.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "empty db" do
+  describe "empty db" do
+    it "should return no entities" do
+      assert User.roots.empty?
+      assert User.leaves.empty?
+    end
+  end
+
+  describe "1 user db" do
+    it "should return the only entity as a root and leaf" do
+      a = User.create!(email: "me@domain.com")
+      assert_equal [a], User.roots
+      assert_equal [a], User.leaves
+    end
+  end
+
+  describe "2 user db" do
+    it "should return a simple root and leaf" do
+      root = User.create!(email: "first@t.co")
+      leaf = root.children.create!(email: "second@t.co")
+      assert_equal [root], User.roots
+      assert_equal [leaf], User.leaves
+    end
+  end
+
+  describe "3 User collection.create db" do
+    before do
+      @root = User.create! email: "poppy@t.co"
+      @mid = @root.children.create! email: "matt@t.co"
+      @leaf = @mid.children.create! email: "james@t.co"
+      @root_id = @root.id
+    end
+
+    it "should create all Users" do
+      assert_equal [@root, @mid, @leaf], User.all.to_a.sort
+    end
+
+    it "orders self_and_ancestor_ids nearest generation first" do
+      assert_equal [@leaf.id, @mid.id, @root.id], @leaf.self_and_ancestor_ids
+    end
+
+    it "orders self_and_descendant_ids nearest generation first" do
+      assert_equal [@root.id, @mid.id, @leaf.id], @root.self_and_descendant_ids
+    end
+
+    it "should have children" do
+      assert_equal [@mid], @root.children.to_a
+      assert_equal [@leaf], @mid.children.to_a
+      assert_equal [], @leaf.children.to_a
+    end
+
+    it "roots should have children" do
+      assert_equal [@mid], User.roots.first.children.to_a
+    end
+
+    it "should return a root and leaf without middle User" do
+      assert_equal [@root], User.roots.to_a
+      assert_equal [@leaf], User.leaves.to_a
+    end
+
+    it "should delete leaves" do
+      User.leaves.destroy_all
+      assert_equal [@root], User.roots.to_a # untouched
+      assert_equal [@mid], User.leaves.to_a
+    end
+
+    it "should delete roots and maintain hierarchies" do
+      User.roots.destroy_all
+      assert_mid_and_leaf_remain
+    end
+
+    it "should root all children" do
+      @root.destroy
+      assert_mid_and_leaf_remain
+    end
+
+    def assert_mid_and_leaf_remain
+      assert ReferralHierarchy.where(ancestor_id: @root_id).empty?
+      assert ReferralHierarchy.where(descendant_id: @root_id).empty?
+      assert_equal %w[matt@t.co], @mid.ancestry_path
+      assert_equal %w[matt@t.co james@t.co], @leaf.ancestry_path
+      assert_equal [@mid, @leaf].sort, @mid.self_and_descendants.to_a.sort
+      assert_equal [@mid], User.roots
+      assert_equal [@leaf], User.leaves
+    end
+  end
+
+  it "supports users with contracts" do
+    u = User.find_or_create_by_path(%w[a@t.co b@t.co c@t.co])
+    assert_equal [], u.descendant_ids
+    assert_equal [u.parent.id, u.root.id], u.ancestor_ids
+    assert_equal [u.id, u.parent.id, u.root.id], u.self_and_ancestor_ids
+    assert_equal [u.parent.id, u.id], u.root.descendant_ids
+    assert_equal [], u.root.ancestor_ids
+    assert_equal [u.root.id], u.root.self_and_ancestor_ids
+    c1 = u.contracts.create!
+    c2 = u.parent.contracts.create!
+    assert_equal [c1, c2].sort, u.root.indirect_contracts.to_a.sort
+  end
+
+  it "supports << on shallow unsaved hierarchies" do
+    a = User.new(email: "a")
+    b = User.new(email: "b")
+    a.children << b
+    a.save
+    assert_equal [a], User.roots
+    assert_equal [b], User.leaves
+    assert_equal %w[a b], b.ancestry_path
+  end
+
+  it "supports << on deep unsaved hierarchies" do
+    a = User.new(email: "a")
+    b1 = User.new(email: "b1")
+    a.children << b1
+    b2 = User.new(email: "b2")
+    a.children << b2
+    c1 = User.new(email: "c1")
+    b2.children << c1
+    c2 = User.new(email: "c2")
+    b2.children << c2
+    d = User.new(email: "d")
+    c2.children << d
+
+    a.save
+    assert_equal [a], User.roots.to_a
+    assert_equal [b1, c1, d].sort, User.leaves.to_a.sort
+    assert_equal %w[a b2 c2 d], d.ancestry_path
+  end
+
+  it "supports siblings" do
+    refute User._ct.order_option?
+    a = User.create(email: "a")
+    b1 = a.children.create(email: "b1")
+    b2 = a.children.create(email: "b2")
+    b3 = a.children.create(email: "b3")
+    assert a.siblings.empty?
+    assert_equal [b2, b3].sort, b1.siblings.to_a.sort
+  end
+
+  describe "when a user is not yet saved" do
+    it "supports siblings" do
+      refute User._ct.order_option?
+      a = User.create(email: "a")
+      b1 = a.children.new(email: "b1")
+      b2 = a.children.create(email: "b2")
+      b3 = a.children.create(email: "b3")
+      assert a.siblings.empty?
+      assert_equal [b2, b3].sort, b1.siblings.to_a.sort
+    end
+  end
+
+  it "properly nullifies descendents" do
+    c = User.find_or_create_by_path %w[a b c]
+    b = c.parent
+    c.root.destroy
+    assert b.reload.root?
+    assert_equal [c.id], b.child_ids
+  end
+
+  describe "roots" do
+    it "works on models without ordering" do
+      expected = ("a".."z").to_a
+      expected.shuffle.each do |ea|
+        User.create! do |u|
+          u.email = ea
+        end
+      end
+      assert_equal(expected, User.roots.collect { |ea| ea.email }.sort)
+    end
+  end
+end

data/test/closure_tree/uuid_tag_test.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'support/tag_examples'
+
+describe UUIDTag do
+  include TagExamples
+end

data/test/support/query_counter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# https://stackoverflow.com/a/43810063/1683557
+
+module QueryCounter
+  def sql_queries(&block)
+    queries = []
+    counter = lambda { |*, payload|
+      queries << payload.fetch(:sql) unless %w[CACHE SCHEMA].include?(payload.fetch(:name))
+    }
+
+    ActiveSupport::Notifications.subscribed(counter, "sql.active_record", &block)
+
+    queries
+  end
+
+  def assert_database_queries_count(expected, &block)
+    queries = sql_queries(&block)
+    assert_equal(
+      expected,
+      queries.count,
+      "Expected #{expected} queries, but found #{queries.count}:\n#{queries.join("\n")}"
+    )
+  end
+end