Add latest changes from gitlab-org/gitlab@master

6 files changed, 234 insertions, 18 deletions

diff --git a/spec/db/schema_spec.rb b/spec/db/schema_spec.rb
index 7fb2723dd01..7785233875c 100644
--- a/spec/db/schema_spec.rb
+++ b/spec/db/schema_spec.rb
@@ -48,7 +48,6 @@ RSpec.describe 'Database schema' do
     geo_node_statuses: %w[last_event_id cursor_last_event_id],
     geo_nodes: %w[oauth_application_id],
     geo_repository_deleted_events: %w[project_id],
-    geo_upload_deleted_events: %w[upload_id model_id],
     gitlab_subscription_histories: %w[gitlab_subscription_id hosted_plan_id namespace_id],
     identities: %w[user_id],
     import_failures: %w[project_id],
diff --git a/spec/frontend/crm/mock_data.js b/spec/frontend/crm/mock_data.js
index 86c5c48cf03..4197621aaa6 100644
--- a/spec/frontend/crm/mock_data.js
+++ b/spec/frontend/crm/mock_data.js
@@ -45,3 +45,37 @@ export const getGroupContactsQueryResponse = {
     },
   },
 };
+
+export const getGroupOrganizationsQueryResponse = {
+  data: {
+    group: {
+      __typename: 'Group',
+      id: 'gid://gitlab/Group/26',
+      organizations: {
+        nodes: [
+          {
+            __typename: 'CustomerRelationsOrganization',
+            id: 'gid://gitlab/CustomerRelations::Organization/1',
+            name: 'Test Inc',
+            defaultRate: 100,
+            description: null,
+          },
+          {
+            __typename: 'CustomerRelationsOrganization',
+            id: 'gid://gitlab/CustomerRelations::Organization/2',
+            name: 'ABC Company',
+            defaultRate: 110,
+            description: 'VIP',
+          },
+          {
+            __typename: 'CustomerRelationsOrganization',
+            id: 'gid://gitlab/CustomerRelations::Organization/3',
+            name: 'GitLab',
+            defaultRate: 120,
+            description: null,
+          },
+        ],
+      },
+    },
+  },
+};
diff --git a/spec/frontend/crm/organizations_root_spec.js b/spec/frontend/crm/organizations_root_spec.js
new file mode 100644
index 00000000000..a69a099e03d
--- /dev/null
+++ b/spec/frontend/crm/organizations_root_spec.js
@@ -0,0 +1,60 @@
+import { GlLoadingIcon } from '@gitlab/ui';
+import Vue from 'vue';
+import VueApollo from 'vue-apollo';
+import { mountExtended, shallowMountExtended } from 'helpers/vue_test_utils_helper';
+import createMockApollo from 'helpers/mock_apollo_helper';
+import waitForPromises from 'helpers/wait_for_promises';
+import createFlash from '~/flash';
+import OrganizationsRoot from '~/crm/components/organizations_root.vue';
+import getGroupOrganizationsQuery from '~/crm/components/queries/get_group_organizations.query.graphql';
+import { getGroupOrganizationsQueryResponse } from './mock_data';
+
+jest.mock('~/flash');
+
+describe('Customer relations organizations root app', () => {
+  Vue.use(VueApollo);
+  let wrapper;
+  let fakeApollo;
+
+  const findLoadingIcon = () => wrapper.findComponent(GlLoadingIcon);
+  const findRowByName = (rowName) => wrapper.findAllByRole('row', { name: rowName });
+  const successQueryHandler = jest.fn().mockResolvedValue(getGroupOrganizationsQueryResponse);
+
+  const mountComponent = ({
+    queryHandler = successQueryHandler,
+    mountFunction = shallowMountExtended,
+  } = {}) => {
+    fakeApollo = createMockApollo([[getGroupOrganizationsQuery, queryHandler]]);
+    wrapper = mountFunction(OrganizationsRoot, {
+      provide: { groupFullPath: 'flightjs' },
+      apolloProvider: fakeApollo,
+    });
+  };
+
+  afterEach(() => {
+    wrapper.destroy();
+    fakeApollo = null;
+  });
+
+  it('should render loading spinner', () => {
+    mountComponent();
+
+    expect(findLoadingIcon().exists()).toBe(true);
+  });
+
+  it('should render error message on reject', async () => {
+    mountComponent({ queryHandler: jest.fn().mockRejectedValue('ERROR') });
+    await waitForPromises();
+
+    expect(createFlash).toHaveBeenCalled();
+  });
+
+  it('renders correct results', async () => {
+    mountComponent({ mountFunction: mountExtended });
+    await waitForPromises();
+
+    expect(findRowByName(/Test Inc/i)).toHaveLength(1);
+    expect(findRowByName(/VIP/i)).toHaveLength(1);
+    expect(findRowByName(/120/i)).toHaveLength(1);
+  });
+});
diff --git a/spec/models/preloaders/group_policy_preloader_spec.rb b/spec/models/preloaders/group_policy_preloader_spec.rb
new file mode 100644
index 00000000000..f6e40d1f033
--- /dev/null
+++ b/spec/models/preloaders/group_policy_preloader_spec.rb
@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Preloaders::GroupPolicyPreloader do
+  let_it_be(:user) { create(:user) }
+  let_it_be(:root_parent) { create(:group, :private, name: 'root-1', path: 'root-1') }
+  let_it_be(:guest_group) { create(:group, name: 'public guest', path: 'public-guest') }
+  let_it_be(:private_maintainer_group) { create(:group, :private, name: 'b private maintainer', path: 'b-private-maintainer', parent: root_parent) }
+  let_it_be(:private_developer_group) { create(:group, :private, project_creation_level: nil, name: 'c public developer', path: 'c-public-developer') }
+  let_it_be(:public_maintainer_group) { create(:group, :private, name: 'a public maintainer', path: 'a-public-maintainer') }
+
+  let(:base_groups) { [guest_group, private_maintainer_group, private_developer_group, public_maintainer_group] }
+
+  before_all do
+    guest_group.add_guest(user)
+    private_maintainer_group.add_maintainer(user)
+    private_developer_group.add_developer(user)
+    public_maintainer_group.add_maintainer(user)
+  end
+
+  it 'avoids N+1 queries when authorizing a list of groups', :request_store do
+    preload_groups_for_policy(user)
+    control = ActiveRecord::QueryRecorder.new { authorize_all_groups(user) }
+
+    new_group1 = create(:group, :private).tap { |group| group.add_maintainer(user) }
+    new_group2 = create(:group, :private, parent: private_maintainer_group)
+
+    another_root = create(:group, :private, name: 'root-3', path: 'root-3')
+    new_group3 = create(:group, :private, parent: another_root).tap { |group| group.add_maintainer(user) }
+
+    pristine_groups = Group.where(id: base_groups + [new_group1, new_group2, new_group3])
+
+    preload_groups_for_policy(user, pristine_groups)
+    expect { authorize_all_groups(user, pristine_groups) }.not_to exceed_query_limit(control)
+  end
+
+  def authorize_all_groups(current_user, group_list = base_groups)
+    group_list.each { |group| current_user.can?(:read_group, group) }
+  end
+
+  def preload_groups_for_policy(current_user, group_list = base_groups)
+    described_class.new(group_list, current_user).execute
+  end
+end
diff --git a/spec/models/preloaders/group_root_ancestor_preloader_spec.rb b/spec/models/preloaders/group_root_ancestor_preloader_spec.rb
new file mode 100644
index 00000000000..0d622e84ef1
--- /dev/null
+++ b/spec/models/preloaders/group_root_ancestor_preloader_spec.rb
@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Preloaders::GroupRootAncestorPreloader do
+  let_it_be(:user) { create(:user) }
+  let_it_be(:root_parent1) { create(:group, :private, name: 'root-1', path: 'root-1') }
+  let_it_be(:root_parent2) { create(:group, :private, name: 'root-2', path: 'root-2') }
+  let_it_be(:guest_group) { create(:group, name: 'public guest', path: 'public-guest') }
+  let_it_be(:private_maintainer_group) { create(:group, :private, name: 'b private maintainer', path: 'b-private-maintainer', parent: root_parent1) }
+  let_it_be(:private_developer_group) { create(:group, :private, project_creation_level: nil, name: 'c public developer', path: 'c-public-developer') }
+  let_it_be(:public_maintainer_group) { create(:group, :private, name: 'a public maintainer', path: 'a-public-maintainer', parent: root_parent2) }
+
+  let(:root_query_regex) { /\ASELECT.+FROM "namespaces" WHERE "namespaces"."id" = \d+/ }
+  let(:additional_preloads) { [] }
+  let(:groups) { [guest_group, private_maintainer_group, private_developer_group, public_maintainer_group] }
+  let(:pristine_groups) { Group.where(id: groups) }
+
+  shared_examples 'executes N matching DB queries' do |expected_query_count, query_method = nil|
+    it 'executes the specified root_ancestor queries' do
+      expect do
+        pristine_groups.each do |group|
+          root_ancestor = group.root_ancestor
+
+          root_ancestor.public_send(query_method) if query_method.present?
+        end
+      end.to make_queries_matching(root_query_regex, expected_query_count)
+    end
+
+    it 'strong_memoizes the correct root_ancestor' do
+      pristine_groups.each do |group|
+        expected_parent_id = group.root_ancestor.id == group.id ? nil : group.root_ancestor.id
+
+        expect(group.parent_id).to eq(expected_parent_id)
+      end
+    end
+  end
+
+  context 'when the preloader is used' do
+    before do
+      preload_ancestors
+    end
+
+    context 'when no additional preloads are provided' do
+      it_behaves_like 'executes N matching DB queries', 0
+    end
+
+    context 'when additional preloads are provided' do
+      let(:additional_preloads) { [:route] }
+      let(:root_query_regex) { /\ASELECT.+FROM "routes" WHERE "routes"."source_id" = \d+/ }
+
+      it_behaves_like 'executes N matching DB queries', 0, :full_path
+    end
+  end
+
+  context 'when the preloader is not used' do
+    it_behaves_like 'executes N matching DB queries', 2
+  end
+
+  def preload_ancestors
+    described_class.new(pristine_groups, additional_preloads).execute
+  end
+end
diff --git a/spec/models/preloaders/user_max_access_level_in_groups_preloader_spec.rb b/spec/models/preloaders/user_max_access_level_in_groups_preloader_spec.rb
index 8144e1ad233..5fc7bfb1f62 100644
--- a/spec/models/preloaders/user_max_access_level_in_groups_preloader_spec.rb
+++ b/spec/models/preloaders/user_max_access_level_in_groups_preloader_spec.rb
@@ -13,32 +13,47 @@ RSpec.describe Preloaders::UserMaxAccessLevelInGroupsPreloader do
 
   shared_examples 'executes N max member permission queries to the DB' do
     it 'executes the specified max membership queries' do
-      queries = ActiveRecord::QueryRecorder.new do
-        groups.each { |group| user.can?(:read_group, group) }
-      end
+      expect { groups.each { |group| user.can?(:read_group, group) } }.to make_queries_matching(max_query_regex, expected_query_count)
+    end
 
-      max_queries = queries.log.grep(max_query_regex)
+    it 'caches the correct access_level for each group' do
+      groups.each do |group|
+        access_level_from_db = group.members_with_parents.where(user_id: user.id).group(:user_id).maximum(:access_level)[user.id] || Gitlab::Access::NO_ACCESS
+        cached_access_level = group.max_member_access_for_user(user)
 
-      expect(max_queries.count).to eq(expected_query_count)
+        expect(cached_access_level).to eq(access_level_from_db)
+      end
     end
   end
 
   context 'when the preloader is used', :request_store do
-    before do
-      described_class.new(groups, user).execute
-    end
+    context 'when user has indirect access to groups' do
+      let_it_be(:child_maintainer) { create(:group, :private, parent: group1).tap {|g| g.add_maintainer(user)} }
+      let_it_be(:child_indirect_access) { create(:group, :private, parent: group1) }
 
-    it_behaves_like 'executes N max member permission queries to the DB' do
-      # Will query all groups where the user is not already a member
-      let(:expected_query_count) { 1 }
-    end
+      let(:groups) { [group1, group2, group3, child_maintainer, child_indirect_access] }
+
+      context 'when traversal_ids feature flag is disabled' do
+        it_behaves_like 'executes N max member permission queries to the DB' do
+          before do
+            stub_feature_flags(use_traversal_ids: false)
+            described_class.new(groups, user).execute
+          end
+
+          # One query for group with no access and another one per group where the user is not a direct member
+          let(:expected_query_count) { 2 }
+        end
+      end
 
-    context 'when user has access but is not a direct member of the group' do
-      let(:groups) { [group1, group2, group3, create(:group, :private, parent: group1)] }
+      context 'when traversal_ids feature flag is enabled' do
+        it_behaves_like 'executes N max member permission queries to the DB' do
+          before do
+            stub_feature_flags(use_traversal_ids: true)
+            described_class.new(groups, user).execute
+          end
 
-      it_behaves_like 'executes N max member permission queries to the DB' do
-        # One query for group with no access and another one where the user is not a direct member
-        let(:expected_query_count) { 2 }
+          let(:expected_query_count) { 0 }
+        end
       end
     end
   end