From 86b733e92900ff6549baba82a7139555ad454373 Mon Sep 17 00:00:00 2001 From: Keenan Brock Date: Tue, 22 Oct 2024 18:34:53 -0400 Subject: [PATCH] Add support for virtual depth column still need to consider whether to keep depth_cache_column as deprecated --- lib/ancestry/has_ancestry.rb | 6 +- test/concerns/depth_virtual_test.rb | 104 ++++++++++++++++++++++++++++ test/environment.rb | 15 +++- 3 files changed, 123 insertions(+), 2 deletions(-) create mode 100644 test/concerns/depth_virtual_test.rb diff --git a/lib/ancestry/has_ancestry.rb b/lib/ancestry/has_ancestry.rb index 91362925..8806cfce 100644 --- a/lib/ancestry/has_ancestry.rb +++ b/lib/ancestry/has_ancestry.rb @@ -64,7 +64,11 @@ def has_ancestry options = {} end # Create ancestry column accessor and set to option or default - if options[:cache_depth] + + if options[:cache_depth] == :virtual + # NOTE: not setting self.depth_cache_column so the code does not try to update the column + depth_cache_sql = options[:depth_cache_column]&.to_s || 'ancestry_depth' + elsif options[:cache_depth] # Create accessor for column name and set to option or default self.cattr_accessor :depth_cache_column self.depth_cache_column = diff --git a/test/concerns/depth_virtual_test.rb b/test/concerns/depth_virtual_test.rb new file mode 100644 index 00000000..41794f9c --- /dev/null +++ b/test/concerns/depth_virtual_test.rb @@ -0,0 +1,104 @@ +require_relative '../environment' + +# These are only valid for postgres +class DepthVirtualTest < ActiveSupport::TestCase + def test_depth_caching + return unless test_virtual_column? +## + AncestryTestDatabase.with_model :depth => 3, :width => 3, :cache_depth => :virtual do |_model, roots| + roots.each do |lvl0_node, lvl0_children| + assert_equal 0, lvl0_node.depth + lvl0_children.each do |lvl1_node, lvl1_children| + assert_equal 1, lvl1_node.depth + lvl1_children.each do |lvl2_node, _lvl2_children| + assert_equal 2, lvl2_node.depth + end + end + end + end + end +## + def test_depth_caching_after_subtree_movement + return unless test_virtual_column? + + AncestryTestDatabase.with_model :depth => 6, :width => 1, :cache_depth => :virtual do |model, _roots| + node = model.at_depth(3).first + node.update(:parent => model.roots.first) + assert_equal(1, node.depth) + node.children.each do |child| + assert_equal(2, child.depth) + child.children.each do |gchild| + assert_equal(3, gchild.depth) + end + end + end + end + + def test_depth_scopes + return unless test_virtual_column? + + AncestryTestDatabase.with_model :depth => 4, :width => 2, :cache_depth => true do |model, _roots| + model.before_depth(2).all? { |node| assert node.depth < 2 } + model.to_depth(2).all? { |node| assert node.depth <= 2 } + model.at_depth(2).all? { |node| assert node.depth == 2 } + model.from_depth(2).all? { |node| assert node.depth >= 2 } + model.after_depth(2).all? { |node| assert node.depth > 2 } + end + end + + def test_depth_scopes_without_depth_cache + return unless test_virtual_column? + + AncestryTestDatabase.with_model :depth => 4, :width => 2 do |model, _roots| + model.before_depth(2).all? { |node| assert node.depth < 2 } + model.to_depth(2).all? { |node| assert node.depth <= 2 } + model.at_depth(2).all? { |node| assert node.depth == 2 } + model.from_depth(2).all? { |node| assert node.depth >= 2 } + model.after_depth(2).all? { |node| assert node.depth > 2 } + end + end + + def test_exception_when_rebuilding_depth_cache_for_model_without_depth_caching + return unless test_virtual_column? + + AncestryTestDatabase.with_model do |model| + assert_raise Ancestry::AncestryException do + model.rebuild_depth_cache! + end + end + end + + def test_exception_on_unknown_depth_column + return unless test_virtual_column? + + AncestryTestDatabase.with_model :cache_depth => true do |model| + assert_raise Ancestry::AncestryException do + model.create!.subtree(:this_is_not_a_valid_depth_option => 42) + end + end + end + + # we are already testing generate and parse against static values + # this assumes those are methods are tested and working + def test_ancestry_depth_change + return unless test_virtual_column? + + AncestryTestDatabase.with_model do |model| + { + [[], [1]] => +1, + [[1], []] => -1, + [[1], [2]] => 0, + [[1], [1, 2, 3]] => +2, + [[1, 2, 3], [1]] => -2 + }.each do |(before, after), diff| + a_before = model.generate_ancestry(before) + a_after = model.generate_ancestry(after) + assert_equal(diff, model.ancestry_depth_change(a_before, a_after)) + end + end + end + + def test_virtual_column? + AncestryTestDatabase.postgres? && ActiveRecord.version >= "7.0" + end +end diff --git a/test/environment.rb b/test/environment.rb index a87f40fc..dc3e848e 100644 --- a/test/environment.rb +++ b/test/environment.rb @@ -126,7 +126,20 @@ def self.with_model options = {} ActiveRecord::Base.connection.create_table 'test_nodes', **table_options do |table| table.send(column_type, options[:ancestry_column], **column_options(force_allow_nil: skip_ancestry)) - table.integer options[:cache_depth] == true ? :ancestry_depth : options[:cache_depth] if options[:cache_depth] + case options[:cache_depth] + when true + table.integer :ancestry_depth + when :virtual + # sorry, this duplicates has_ancestry a little + path_module = Ancestry::HasAncestry.ancestry_format_module(options[:ancestry_format]) + ancestry_depth_sql = path_module.construct_depth_sql("test_nodes", options[:ancestry_column], '/') + + table.virtual :ancestry_depth, type: :integer, as: ancestry_depth_sql, stored: true + when nil, false + # no column + else + table.integer options[:cache_depth] + end if options[:counter_cache] counter_cache_column = options[:counter_cache] == true ? :children_count : options[:counter_cache] table.integer counter_cache_column, default: 0, null: false