Move Namespace traversal queries to module

Refactor Namespace traversal queries in to their own module. Moved
related specs to a shared context.

app/models/namespace.rb

@@ -12,6 +12,7 @@ class Namespace < ApplicationRecord
   include FromUnion
   include Gitlab::Utils::StrongMemoize
   include IgnorableColumns
+  include Namespaces::Traversal::Recursive
 
   # Prevent users from creating unreasonably deep level of nesting.
   # The number 20 was taken based on maximum nesting level of
@@ -247,50 +248,6 @@ class Namespace < ApplicationRecord
     projects.with_shared_runners.any?
   end
 
-  # Returns all ancestors, self, and descendants of the current namespace.
-  def self_and_hierarchy
-    Gitlab::ObjectHierarchy
-      .new(self.class.where(id: id))
-      .all_objects
-  end
-
-  # Returns all the ancestors of the current namespaces.
-  def ancestors
-    return self.class.none unless parent_id
-
-    Gitlab::ObjectHierarchy
-      .new(self.class.where(id: parent_id))
-      .base_and_ancestors
-  end
-
-  # returns all ancestors upto but excluding the given namespace
-  # when no namespace is given, all ancestors upto the top are returned
-  def ancestors_upto(top = nil, hierarchy_order: nil)
-    Gitlab::ObjectHierarchy.new(self.class.where(id: id))
-      .ancestors(upto: top, hierarchy_order: hierarchy_order)
-  end
-
-  def self_and_ancestors(hierarchy_order: nil)
-    return self.class.where(id: id) unless parent_id
-
-    Gitlab::ObjectHierarchy
-      .new(self.class.where(id: id))
-      .base_and_ancestors(hierarchy_order: hierarchy_order)
-  end
-
-  # Returns all the descendants of the current namespace.
-  def descendants
-    Gitlab::ObjectHierarchy
-      .new(self.class.where(parent_id: id))
-      .base_and_descendants
-  end
-
-  def self_and_descendants
-    Gitlab::ObjectHierarchy
-      .new(self.class.where(id: id))
-      .base_and_descendants
-  end
-
   def user_ids_for_project_authorizations
     [owner_id]
   end
@@ -316,16 +273,6 @@ class Namespace < ApplicationRecord
     parent_id.present? || parent.present?
   end
 
-  def root_ancestor
-    return self if persisted? && parent_id.nil?
-
-    # Make sure that strong_memoize name is in sync with root_ancestor's
-    # attr_writer name
-    strong_memoize(:root_ancestor) do
-      self_and_ancestors.reorder(nil).find_by(parent_id: nil)
-    end
-  end
-
   def subgroup?
     has_parent?
   end

app/models/namespaces/traversal/recursive.rb

+# frozen_string_literal: true
+
+module Namespaces
+  module Traversal
+    module Recursive
+      extend ActiveSupport::Concern
+
+      def root_ancestor
+        return self if persisted? && parent_id.nil?
+
+        strong_memoize(:root_ancestor) do
+          self_and_ancestors.reorder(nil).find_by(parent_id: nil)
+        end
+      end
+
+      # Returns all ancestors, self, and descendants of the current namespace.
+      def self_and_hierarchy
+        Gitlab::ObjectHierarchy
+          .new(self.class.where(id: id))
+          .all_objects
+      end
+
+      # Returns all the ancestors of the current namespaces.
+      def ancestors
+        return self.class.none unless parent_id
+
+        Gitlab::ObjectHierarchy
+          .new(self.class.where(id: parent_id))
+          .base_and_ancestors
+      end
+
+      # returns all ancestors upto but excluding the given namespace
+      # when no namespace is given, all ancestors upto the top are returned
+      def ancestors_upto(top = nil, hierarchy_order: nil)
+        Gitlab::ObjectHierarchy.new(self.class.where(id: id))
+          .ancestors(upto: top, hierarchy_order: hierarchy_order)
+      end
+
+      def self_and_ancestors(hierarchy_order: nil)
+        return self.class.where(id: id) unless parent_id
+
+        Gitlab::ObjectHierarchy
+          .new(self.class.where(id: id))
+          .base_and_ancestors(hierarchy_order: hierarchy_order)
+      end
+
+      # Returns all the descendants of the current namespace.
+      def descendants
+        Gitlab::ObjectHierarchy
+          .new(self.class.where(parent_id: id))
+          .base_and_descendants
+      end
+
+      def self_and_descendants
+        Gitlab::ObjectHierarchy
+          .new(self.class.where(id: id))
+          .base_and_descendants
+      end
+    end
+  end
+end

spec/models/namespace_spec.rb

@@ -113,6 +113,7 @@ RSpec.describe Namespace do
 
   describe 'inclusions' do
     it { is_expected.to include_module(Gitlab::VisibilityLevel) }
+    it { is_expected.to include_module(Namespaces::Traversal::Recursive) }
   end
 
   describe '#visibility_level_field' do
@@ -770,80 +771,7 @@ RSpec.describe Namespace do
     end
   end
 
-  describe '#self_and_hierarchy' do
-    let!(:group) { create(:group, path: 'git_lab') }
-    let!(:nested_group) { create(:group, parent: group) }
-    let!(:deep_nested_group) { create(:group, parent: nested_group) }
-    let!(:very_deep_nested_group) { create(:group, parent: deep_nested_group) }
-    let!(:another_group) { create(:group, path: 'gitllab') }
-    let!(:another_group_nested) { create(:group, path: 'foo', parent: another_group) }
-
-    it 'returns the correct tree' do
-      expect(group.self_and_hierarchy).to contain_exactly(group, nested_group, deep_nested_group, very_deep_nested_group)
-      expect(nested_group.self_and_hierarchy).to contain_exactly(group, nested_group, deep_nested_group, very_deep_nested_group)
-      expect(very_deep_nested_group.self_and_hierarchy).to contain_exactly(group, nested_group, deep_nested_group, very_deep_nested_group)
-    end
-  end
-
-  describe '#ancestors' do
-    let(:group) { create(:group) }
-    let(:nested_group) { create(:group, parent: group) }
-    let(:deep_nested_group) { create(:group, parent: nested_group) }
-    let(:very_deep_nested_group) { create(:group, parent: deep_nested_group) }
-
-    it 'returns the correct ancestors' do
-      expect(very_deep_nested_group.ancestors).to include(group, nested_group, deep_nested_group)
-      expect(deep_nested_group.ancestors).to include(group, nested_group)
-      expect(nested_group.ancestors).to include(group)
-      expect(group.ancestors).to eq([])
-    end
-  end
-
-  describe '#self_and_ancestors' do
-    let(:group) { create(:group) }
-    let(:nested_group) { create(:group, parent: group) }
-    let(:deep_nested_group) { create(:group, parent: nested_group) }
-    let(:very_deep_nested_group) { create(:group, parent: deep_nested_group) }
-
-    it 'returns the correct ancestors' do
-      expect(very_deep_nested_group.self_and_ancestors).to contain_exactly(group, nested_group, deep_nested_group, very_deep_nested_group)
-      expect(deep_nested_group.self_and_ancestors).to contain_exactly(group, nested_group, deep_nested_group)
-      expect(nested_group.self_and_ancestors).to contain_exactly(group, nested_group)
-      expect(group.self_and_ancestors).to contain_exactly(group)
-    end
-  end
-
-  describe '#descendants' do
-    let!(:group) { create(:group, path: 'git_lab') }
-    let!(:nested_group) { create(:group, parent: group) }
-    let!(:deep_nested_group) { create(:group, parent: nested_group) }
-    let!(:very_deep_nested_group) { create(:group, parent: deep_nested_group) }
-    let!(:another_group) { create(:group, path: 'gitllab') }
-    let!(:another_group_nested) { create(:group, path: 'foo', parent: another_group) }
-
-    it 'returns the correct descendants' do
-      expect(very_deep_nested_group.descendants.to_a).to eq([])
-      expect(deep_nested_group.descendants.to_a).to include(very_deep_nested_group)
-      expect(nested_group.descendants.to_a).to include(deep_nested_group, very_deep_nested_group)
-      expect(group.descendants.to_a).to include(nested_group, deep_nested_group, very_deep_nested_group)
-    end
-  end
-
-  describe '#self_and_descendants' do
-    let!(:group) { create(:group, path: 'git_lab') }
-    let!(:nested_group) { create(:group, parent: group) }
-    let!(:deep_nested_group) { create(:group, parent: nested_group) }
-    let!(:very_deep_nested_group) { create(:group, parent: deep_nested_group) }
-    let!(:another_group) { create(:group, path: 'gitllab') }
-    let!(:another_group_nested) { create(:group, path: 'foo', parent: another_group) }
-
-    it 'returns the correct descendants' do
-      expect(very_deep_nested_group.self_and_descendants).to contain_exactly(very_deep_nested_group)
-      expect(deep_nested_group.self_and_descendants).to contain_exactly(deep_nested_group, very_deep_nested_group)
-      expect(nested_group.self_and_descendants).to contain_exactly(nested_group, deep_nested_group, very_deep_nested_group)
-      expect(group.self_and_descendants).to contain_exactly(group, nested_group, deep_nested_group, very_deep_nested_group)
-    end
-  end
+  it_behaves_like 'recursive namespace traversal'
 
   describe '#users_with_descendants' do
     let(:user_a) { create(:user) }

spec/support/shared_examples/namespaces/recursive_traversal_examples.rb

+# frozen_string_literal: true
+
+RSpec.shared_examples 'recursive namespace traversal' do
+  describe '#self_and_hierarchy' do
+    let!(:group) { create(:group, path: 'git_lab') }
+    let!(:nested_group) { create(:group, parent: group) }
+    let!(:deep_nested_group) { create(:group, parent: nested_group) }
+    let!(:very_deep_nested_group) { create(:group, parent: deep_nested_group) }
+    let!(:another_group) { create(:group, path: 'gitllab') }
+    let!(:another_group_nested) { create(:group, path: 'foo', parent: another_group) }
+
+    it 'returns the correct tree' do
+      expect(group.self_and_hierarchy).to contain_exactly(group, nested_group, deep_nested_group, very_deep_nested_group)
+      expect(nested_group.self_and_hierarchy).to contain_exactly(group, nested_group, deep_nested_group, very_deep_nested_group)
+      expect(very_deep_nested_group.self_and_hierarchy).to contain_exactly(group, nested_group, deep_nested_group, very_deep_nested_group)
+    end
+  end
+
+  describe '#ancestors' do
+    let(:group) { create(:group) }
+    let(:nested_group) { create(:group, parent: group) }
+    let(:deep_nested_group) { create(:group, parent: nested_group) }
+    let(:very_deep_nested_group) { create(:group, parent: deep_nested_group) }
+
+    it 'returns the correct ancestors' do
+      expect(very_deep_nested_group.ancestors).to include(group, nested_group, deep_nested_group)
+      expect(deep_nested_group.ancestors).to include(group, nested_group)
+      expect(nested_group.ancestors).to include(group)
+      expect(group.ancestors).to eq([])
+    end
+  end
+
+  describe '#self_and_ancestors' do
+    let(:group) { create(:group) }
+    let(:nested_group) { create(:group, parent: group) }
+    let(:deep_nested_group) { create(:group, parent: nested_group) }
+    let(:very_deep_nested_group) { create(:group, parent: deep_nested_group) }
+
+    it 'returns the correct ancestors' do
+      expect(very_deep_nested_group.self_and_ancestors).to contain_exactly(group, nested_group, deep_nested_group, very_deep_nested_group)
+      expect(deep_nested_group.self_and_ancestors).to contain_exactly(group, nested_group, deep_nested_group)
+      expect(nested_group.self_and_ancestors).to contain_exactly(group, nested_group)
+      expect(group.self_and_ancestors).to contain_exactly(group)
+    end
+  end
+
+  describe '#descendants' do
+    let!(:group) { create(:group, path: 'git_lab') }
+    let!(:nested_group) { create(:group, parent: group) }
+    let!(:deep_nested_group) { create(:group, parent: nested_group) }
+    let!(:very_deep_nested_group) { create(:group, parent: deep_nested_group) }
+    let!(:another_group) { create(:group, path: 'gitllab') }
+    let!(:another_group_nested) { create(:group, path: 'foo', parent: another_group) }
+
+    it 'returns the correct descendants' do
+      expect(very_deep_nested_group.descendants.to_a).to eq([])
+      expect(deep_nested_group.descendants.to_a).to include(very_deep_nested_group)
+      expect(nested_group.descendants.to_a).to include(deep_nested_group, very_deep_nested_group)
+      expect(group.descendants.to_a).to include(nested_group, deep_nested_group, very_deep_nested_group)
+    end
+  end
+
+  describe '#self_and_descendants' do
+    let!(:group) { create(:group, path: 'git_lab') }
+    let!(:nested_group) { create(:group, parent: group) }
+    let!(:deep_nested_group) { create(:group, parent: nested_group) }
+    let!(:very_deep_nested_group) { create(:group, parent: deep_nested_group) }
+    let!(:another_group) { create(:group, path: 'gitllab') }
+    let!(:another_group_nested) { create(:group, path: 'foo', parent: another_group) }
+
+    it 'returns the correct descendants' do
+      expect(very_deep_nested_group.self_and_descendants).to contain_exactly(very_deep_nested_group)
+      expect(deep_nested_group.self_and_descendants).to contain_exactly(deep_nested_group, very_deep_nested_group)
+      expect(nested_group.self_and_descendants).to contain_exactly(nested_group, deep_nested_group, very_deep_nested_group)
+      expect(group.self_and_descendants).to contain_exactly(group, nested_group, deep_nested_group, very_deep_nested_group)
+    end
+  end
+end