Add latest changes from gitlab-org/gitlab@master

39 files changed, 1379 insertions, 139 deletions

diff --git a/spec/controllers/admin/users_controller_spec.rb b/spec/controllers/admin/users_controller_spec.rb
index 2d5125c9d5e..015c36c9335 100644
--- a/spec/controllers/admin/users_controller_spec.rb
+++ b/spec/controllers/admin/users_controller_spec.rb
@@ -146,7 +146,7 @@ RSpec.describe Admin::UsersController do
 
       it 'sends the user a rejection email' do
         expect_next_instance_of(NotificationService) do |notification|
-          allow(notification).to receive(:user_admin_rejection).with(user.name, user.notification_email)
+          allow(notification).to receive(:user_admin_rejection).with(user.name, user.notification_email_or_default)
         end
 
         subject
diff --git a/spec/factories/namespaces/project_namespaces.rb b/spec/factories/namespaces/project_namespaces.rb
index 97c03ca8b8a..10b86f48090 100644
--- a/spec/factories/namespaces/project_namespaces.rb
+++ b/spec/factories/namespaces/project_namespaces.rb
@@ -7,5 +7,6 @@ FactoryBot.define do
     path { project.path }
     type { Namespaces::ProjectNamespace.sti_name }
     owner { nil }
+    parent factory: :group
   end
 end
diff --git a/spec/features/groups/members/request_access_spec.rb b/spec/features/groups/members/request_access_spec.rb
index 827962fee61..f806c7d3704 100644
--- a/spec/features/groups/members/request_access_spec.rb
+++ b/spec/features/groups/members/request_access_spec.rb
@@ -24,7 +24,7 @@ RSpec.describe 'Groups > Members > Request access' do
   it 'user can request access to a group' do
     perform_enqueued_jobs { click_link 'Request Access' }
 
-    expect(ActionMailer::Base.deliveries.last.to).to eq [owner.notification_email]
+    expect(ActionMailer::Base.deliveries.last.to).to eq [owner.notification_email_or_default]
     expect(ActionMailer::Base.deliveries.last.subject).to match "Request to join the #{group.name} group"
 
     expect(group.requesters.exists?(user_id: user)).to be_truthy
diff --git a/spec/features/issues/csv_spec.rb b/spec/features/issues/csv_spec.rb
index 51e0d54ca5e..b4c737495b4 100644
--- a/spec/features/issues/csv_spec.rb
+++ b/spec/features/issues/csv_spec.rb
@@ -44,7 +44,7 @@ RSpec.describe 'Issues csv', :js do
     request_csv
 
     expect(page).to have_content 'CSV export has started'
-    expect(page).to have_content "emailed to #{user.notification_email}"
+    expect(page).to have_content "emailed to #{user.notification_email_or_default}"
   end
 
   it 'includes a csv attachment', :sidekiq_might_not_need_inline do
diff --git a/spec/features/projects/members/user_requests_access_spec.rb b/spec/features/projects/members/user_requests_access_spec.rb
index 94543290050..113ba692497 100644
--- a/spec/features/projects/members/user_requests_access_spec.rb
+++ b/spec/features/projects/members/user_requests_access_spec.rb
@@ -23,7 +23,7 @@ RSpec.describe 'Projects > Members > User requests access', :js do
   it 'user can request access to a project' do
     perform_enqueued_jobs { click_link 'Request Access' }
 
-    expect(ActionMailer::Base.deliveries.last.to).to eq [maintainer.notification_email]
+    expect(ActionMailer::Base.deliveries.last.to).to eq [maintainer.notification_email_or_default]
     expect(ActionMailer::Base.deliveries.last.subject).to eq "Request to join the #{project.full_name} project"
 
     expect(project.requesters.exists?(user_id: user)).to be_truthy
diff --git a/spec/frontend/content_editor/services/markdown_sourcemap_spec.js b/spec/frontend/content_editor/services/markdown_sourcemap_spec.js
index a6ebe204078..6f908f468f6 100644
--- a/spec/frontend/content_editor/services/markdown_sourcemap_spec.js
+++ b/spec/frontend/content_editor/services/markdown_sourcemap_spec.js
@@ -28,8 +28,7 @@ const SourcemapExtension = Extension.create({
           source: {
             parseHTML: (element) => {
               const source = getMarkdownSource(element);
-              if (source) return { source };
-              return {};
+              return source;
             },
           },
         },
diff --git a/spec/frontend/content_editor/test_utils.js b/spec/frontend/content_editor/test_utils.js
index b5a2abc2389..cf5aa3f2938 100644
--- a/spec/frontend/content_editor/test_utils.js
+++ b/spec/frontend/content_editor/test_utils.js
@@ -98,9 +98,7 @@ export const createTestContentEditorExtension = ({ commands = [] } = {}) => {
         return {
           labelName: {
             default: null,
-            parseHTML: (element) => {
-              return { labelName: element.dataset.labelName };
-            },
+            parseHTML: (element) => element.dataset.labelName,
           },
         };
       },
diff --git a/spec/frontend/packages_and_registries/package_registry/components/list/__snapshots__/packages_list_app_spec.js.snap b/spec/frontend/packages_and_registries/package_registry/components/list/__snapshots__/packages_list_app_spec.js.snap
new file mode 100644
index 00000000000..dbebdeeb452
--- /dev/null
+++ b/spec/frontend/packages_and_registries/package_registry/components/list/__snapshots__/packages_list_app_spec.js.snap
@@ -0,0 +1,68 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`packages_list_app renders 1`] = `
+<div>
+  <div
+    help-url="foo"
+  />
+   
+  <div />
+   
+  <div>
+    <section
+      class="row empty-state text-center"
+    >
+      <div
+        class="col-12"
+      >
+        <div
+          class="svg-250 svg-content"
+        >
+          <img
+            alt=""
+            class="gl-max-w-full"
+            role="img"
+            src="helpSvg"
+          />
+        </div>
+      </div>
+       
+      <div
+        class="col-12"
+      >
+        <div
+          class="text-content gl-mx-auto gl-my-0 gl-p-5"
+        >
+          <h1
+            class="h4"
+          >
+            There are no packages yet
+          </h1>
+           
+          <p>
+            Learn how to 
+            <b-link-stub
+              class="gl-link"
+              event="click"
+              href="helpUrl"
+              routertag="a"
+              target="_blank"
+            >
+              publish and share your packages
+            </b-link-stub>
+             with GitLab.
+          </p>
+           
+          <div
+            class="gl-display-flex gl-flex-wrap gl-justify-content-center"
+          >
+            <!---->
+             
+            <!---->
+          </div>
+        </div>
+      </div>
+    </section>
+  </div>
+</div>
+`;
diff --git a/spec/frontend/packages_and_registries/package_registry/components/list/packages_list_app_spec.js b/spec/frontend/packages_and_registries/package_registry/components/list/packages_list_app_spec.js
new file mode 100644
index 00000000000..6c871a34d50
--- /dev/null
+++ b/spec/frontend/packages_and_registries/package_registry/components/list/packages_list_app_spec.js
@@ -0,0 +1,273 @@
+import { GlEmptyState, GlSprintf, GlLink } from '@gitlab/ui';
+import { shallowMount, createLocalVue } from '@vue/test-utils';
+import Vuex from 'vuex';
+import setWindowLocation from 'helpers/set_window_location_helper';
+import createFlash from '~/flash';
+import * as commonUtils from '~/lib/utils/common_utils';
+import { DELETE_PACKAGE_SUCCESS_MESSAGE } from '~/packages/list/constants';
+import { SHOW_DELETE_SUCCESS_ALERT } from '~/packages/shared/constants';
+import PackageListApp from '~/packages_and_registries/package_registry/components/list/packages_list_app.vue';
+import { FILTERED_SEARCH_TERM } from '~/packages_and_registries/shared/constants';
+import * as packageUtils from '~/packages_and_registries/shared/utils';
+
+jest.mock('~/lib/utils/common_utils');
+jest.mock('~/flash');
+
+const localVue = createLocalVue();
+localVue.use(Vuex);
+
+describe('packages_list_app', () => {
+  let wrapper;
+  let store;
+
+  const PackageList = {
+    name: 'package-list',
+    template: '<div><slot name="empty-state"></slot></div>',
+  };
+  const GlLoadingIcon = { name: 'gl-loading-icon', template: '<div>loading</div>' };
+
+  // we need to manually stub dynamic imported components because shallowMount is not able to stub them automatically. See: https://github.com/vuejs/vue-test-utils/issues/1279
+  const PackageSearch = { name: 'PackageSearch', template: '<div></div>' };
+  const PackageTitle = { name: 'PackageTitle', template: '<div></div>' };
+  const InfrastructureTitle = { name: 'InfrastructureTitle', template: '<div></div>' };
+  const InfrastructureSearch = { name: 'InfrastructureSearch', template: '<div></div>' };
+
+  const emptyListHelpUrl = 'helpUrl';
+  const findEmptyState = () => wrapper.find(GlEmptyState);
+  const findListComponent = () => wrapper.find(PackageList);
+  const findPackageSearch = () => wrapper.find(PackageSearch);
+  const findPackageTitle = () => wrapper.find(PackageTitle);
+  const findInfrastructureTitle = () => wrapper.find(InfrastructureTitle);
+  const findInfrastructureSearch = () => wrapper.find(InfrastructureSearch);
+
+  const createStore = (filter = []) => {
+    store = new Vuex.Store({
+      state: {
+        isLoading: false,
+        config: {
+          resourceId: 'project_id',
+          emptyListIllustration: 'helpSvg',
+          emptyListHelpUrl,
+          packageHelpUrl: 'foo',
+        },
+        filter,
+      },
+    });
+    store.dispatch = jest.fn();
+  };
+
+  const mountComponent = (provide) => {
+    wrapper = shallowMount(PackageListApp, {
+      localVue,
+      store,
+      stubs: {
+        GlEmptyState,
+        GlLoadingIcon,
+        PackageList,
+        GlSprintf,
+        GlLink,
+        PackageSearch,
+        PackageTitle,
+        InfrastructureTitle,
+        InfrastructureSearch,
+      },
+      provide,
+    });
+  };
+
+  beforeEach(() => {
+    createStore();
+    jest.spyOn(packageUtils, 'getQueryParams').mockReturnValue({});
+  });
+
+  afterEach(() => {
+    wrapper.destroy();
+  });
+
+  it('renders', () => {
+    mountComponent();
+    expect(wrapper.element).toMatchSnapshot();
+  });
+
+  it('call requestPackagesList on page:changed', () => {
+    mountComponent();
+    store.dispatch.mockClear();
+
+    const list = findListComponent();
+    list.vm.$emit('page:changed', 1);
+    expect(store.dispatch).toHaveBeenCalledWith('requestPackagesList', { page: 1 });
+  });
+
+  it('call requestDeletePackage on package:delete', () => {
+    mountComponent();
+
+    const list = findListComponent();
+    list.vm.$emit('package:delete', 'foo');
+    expect(store.dispatch).toHaveBeenCalledWith('requestDeletePackage', 'foo');
+  });
+
+  it('does call requestPackagesList only one time on render', () => {
+    mountComponent();
+
+    expect(store.dispatch).toHaveBeenCalledTimes(3);
+    expect(store.dispatch).toHaveBeenNthCalledWith(1, 'setSorting', expect.any(Object));
+    expect(store.dispatch).toHaveBeenNthCalledWith(2, 'setFilter', expect.any(Array));
+    expect(store.dispatch).toHaveBeenNthCalledWith(3, 'requestPackagesList');
+  });
+
+  describe('url query string handling', () => {
+    const defaultQueryParamsMock = {
+      search: [1, 2],
+      type: 'npm',
+      sort: 'asc',
+      orderBy: 'created',
+    };
+
+    it('calls setSorting with the query string based sorting', () => {
+      jest.spyOn(packageUtils, 'getQueryParams').mockReturnValue(defaultQueryParamsMock);
+
+      mountComponent();
+
+      expect(store.dispatch).toHaveBeenNthCalledWith(1, 'setSorting', {
+        orderBy: defaultQueryParamsMock.orderBy,
+        sort: defaultQueryParamsMock.sort,
+      });
+    });
+
+    it('calls setFilter with the query string based filters', () => {
+      jest.spyOn(packageUtils, 'getQueryParams').mockReturnValue(defaultQueryParamsMock);
+
+      mountComponent();
+
+      expect(store.dispatch).toHaveBeenNthCalledWith(2, 'setFilter', [
+        { type: 'type', value: { data: defaultQueryParamsMock.type } },
+        { type: FILTERED_SEARCH_TERM, value: { data: defaultQueryParamsMock.search[0] } },
+        { type: FILTERED_SEARCH_TERM, value: { data: defaultQueryParamsMock.search[1] } },
+      ]);
+    });
+
+    it('calls setSorting and setFilters with the results of extractFilterAndSorting', () => {
+      jest
+        .spyOn(packageUtils, 'extractFilterAndSorting')
+        .mockReturnValue({ filters: ['foo'], sorting: { sort: 'desc' } });
+
+      mountComponent();
+
+      expect(store.dispatch).toHaveBeenNthCalledWith(1, 'setSorting', { sort: 'desc' });
+      expect(store.dispatch).toHaveBeenNthCalledWith(2, 'setFilter', ['foo']);
+    });
+  });
+
+  describe('empty state', () => {
+    it('generate the correct empty list link', () => {
+      mountComponent();
+
+      const link = findListComponent().find(GlLink);
+
+      expect(link.attributes('href')).toBe(emptyListHelpUrl);
+      expect(link.text()).toBe('publish and share your packages');
+    });
+
+    it('includes the right content on the default tab', () => {
+      mountComponent();
+
+      const heading = findEmptyState().find('h1');
+
+      expect(heading.text()).toBe('There are no packages yet');
+    });
+  });
+
+  describe('filter without results', () => {
+    beforeEach(() => {
+      createStore([{ type: 'something' }]);
+      mountComponent();
+    });
+
+    it('should show specific empty message', () => {
+      expect(findEmptyState().text()).toContain('Sorry, your filter produced no results');
+      expect(findEmptyState().text()).toContain(
+        'To widen your search, change or remove the filters above',
+      );
+    });
+  });
+
+  describe('Package Search', () => {
+    it('exists', () => {
+      mountComponent();
+
+      expect(findPackageSearch().exists()).toBe(true);
+    });
+
+    it('on update fetches data from the store', () => {
+      mountComponent();
+      store.dispatch.mockClear();
+
+      findPackageSearch().vm.$emit('update');
+
+      expect(store.dispatch).toHaveBeenCalledWith('requestPackagesList');
+    });
+  });
+
+  describe('Infrastructure config', () => {
+    it('defaults to package registry components', () => {
+      mountComponent();
+
+      expect(findPackageSearch().exists()).toBe(true);
+      expect(findPackageTitle().exists()).toBe(true);
+
+      expect(findInfrastructureTitle().exists()).toBe(false);
+      expect(findInfrastructureSearch().exists()).toBe(false);
+    });
+
+    it('mount different component based on the provided values', () => {
+      mountComponent({
+        titleComponent: 'InfrastructureTitle',
+        searchComponent: 'InfrastructureSearch',
+      });
+
+      expect(findPackageSearch().exists()).toBe(false);
+      expect(findPackageTitle().exists()).toBe(false);
+
+      expect(findInfrastructureTitle().exists()).toBe(true);
+      expect(findInfrastructureSearch().exists()).toBe(true);
+    });
+  });
+
+  describe('delete alert handling', () => {
+    const originalLocation = window.location.href;
+    const search = `?${SHOW_DELETE_SUCCESS_ALERT}=true`;
+
+    beforeEach(() => {
+      createStore();
+      jest.spyOn(commonUtils, 'historyReplaceState').mockImplementation(() => {});
+      setWindowLocation(search);
+    });
+
+    afterEach(() => {
+      setWindowLocation(originalLocation);
+    });
+
+    it(`creates a flash if the query string contains ${SHOW_DELETE_SUCCESS_ALERT}`, () => {
+      mountComponent();
+
+      expect(createFlash).toHaveBeenCalledWith({
+        message: DELETE_PACKAGE_SUCCESS_MESSAGE,
+        type: 'notice',
+      });
+    });
+
+    it('calls historyReplaceState with a clean url', () => {
+      mountComponent();
+
+      expect(commonUtils.historyReplaceState).toHaveBeenCalledWith(originalLocation);
+    });
+
+    it(`does nothing if the query string does not contain ${SHOW_DELETE_SUCCESS_ALERT}`, () => {
+      setWindowLocation('?');
+      mountComponent();
+
+      expect(createFlash).not.toHaveBeenCalled();
+      expect(commonUtils.historyReplaceState).not.toHaveBeenCalled();
+    });
+  });
+});
diff --git a/spec/frontend/packages_and_registries/package_registry/components/list/packages_list_spec.js b/spec/frontend/packages_and_registries/package_registry/components/list/packages_list_spec.js
new file mode 100644
index 00000000000..b624e66482d
--- /dev/null
+++ b/spec/frontend/packages_and_registries/package_registry/components/list/packages_list_spec.js
@@ -0,0 +1,217 @@
+import { GlTable, GlPagination, GlModal } from '@gitlab/ui';
+import { mount, createLocalVue } from '@vue/test-utils';
+import { last } from 'lodash';
+import Vuex from 'vuex';
+import stubChildren from 'helpers/stub_children';
+import { packageList } from 'jest/packages/mock_data';
+import PackagesListRow from '~/packages/shared/components/package_list_row.vue';
+import PackagesListLoader from '~/packages/shared/components/packages_list_loader.vue';
+import { TrackingActions } from '~/packages/shared/constants';
+import * as SharedUtils from '~/packages/shared/utils';
+import PackagesList from '~/packages_and_registries/package_registry/components/list/packages_list.vue';
+import Tracking from '~/tracking';
+
+const localVue = createLocalVue();
+localVue.use(Vuex);
+
+describe('packages_list', () => {
+  let wrapper;
+  let store;
+
+  const EmptySlotStub = { name: 'empty-slot-stub', template: '<div>bar</div>' };
+
+  const findPackagesListLoader = () => wrapper.find(PackagesListLoader);
+  const findPackageListPagination = () => wrapper.find(GlPagination);
+  const findPackageListDeleteModal = () => wrapper.find(GlModal);
+  const findEmptySlot = () => wrapper.find(EmptySlotStub);
+  const findPackagesListRow = () => wrapper.find(PackagesListRow);
+
+  const createStore = (isGroupPage, packages, isLoading) => {
+    const state = {
+      isLoading,
+      packages,
+      pagination: {
+        perPage: 1,
+        total: 1,
+        page: 1,
+      },
+      config: {
+        isGroupPage,
+      },
+      sorting: {
+        orderBy: 'version',
+        sort: 'desc',
+      },
+    };
+    store = new Vuex.Store({
+      state,
+      getters: {
+        getList: () => packages,
+      },
+    });
+    store.dispatch = jest.fn();
+  };
+
+  const mountComponent = ({
+    isGroupPage = false,
+    packages = packageList,
+    isLoading = false,
+    ...options
+  } = {}) => {
+    createStore(isGroupPage, packages, isLoading);
+
+    wrapper = mount(PackagesList, {
+      localVue,
+      store,
+      stubs: {
+        ...stubChildren(PackagesList),
+        GlTable,
+        GlModal,
+      },
+      ...options,
+    });
+  };
+
+  afterEach(() => {
+    wrapper.destroy();
+    wrapper = null;
+  });
+
+  describe('when is loading', () => {
+    beforeEach(() => {
+      mountComponent({
+        packages: [],
+        isLoading: true,
+      });
+    });
+
+    it('shows skeleton loader when loading', () => {
+      expect(findPackagesListLoader().exists()).toBe(true);
+    });
+  });
+
+  describe('when is not loading', () => {
+    beforeEach(() => {
+      mountComponent();
+    });
+
+    it('does not show skeleton loader when not loading', () => {
+      expect(findPackagesListLoader().exists()).toBe(false);
+    });
+  });
+
+  describe('layout', () => {
+    beforeEach(() => {
+      mountComponent();
+    });
+
+    it('contains a pagination component', () => {
+      const sorting = findPackageListPagination();
+      expect(sorting.exists()).toBe(true);
+    });
+
+    it('contains a modal component', () => {
+      const sorting = findPackageListDeleteModal();
+      expect(sorting.exists()).toBe(true);
+    });
+  });
+
+  describe('when the user can destroy the package', () => {
+    beforeEach(() => {
+      mountComponent();
+    });
+
+    it('setItemToBeDeleted sets itemToBeDeleted and open the modal', () => {
+      const mockModalShow = jest.spyOn(wrapper.vm.$refs.packageListDeleteModal, 'show');
+      const item = last(wrapper.vm.list);
+
+      findPackagesListRow().vm.$emit('packageToDelete', item);
+
+      return wrapper.vm.$nextTick().then(() => {
+        expect(wrapper.vm.itemToBeDeleted).toEqual(item);
+        expect(mockModalShow).toHaveBeenCalled();
+      });
+    });
+
+    it('deleteItemConfirmation resets itemToBeDeleted', () => {
+      wrapper.setData({ itemToBeDeleted: 1 });
+      wrapper.vm.deleteItemConfirmation();
+      expect(wrapper.vm.itemToBeDeleted).toEqual(null);
+    });
+
+    it('deleteItemConfirmation emit package:delete', () => {
+      const itemToBeDeleted = { id: 2 };
+      wrapper.setData({ itemToBeDeleted });
+      wrapper.vm.deleteItemConfirmation();
+      return wrapper.vm.$nextTick(() => {
+        expect(wrapper.emitted('package:delete')[0]).toEqual([itemToBeDeleted]);
+      });
+    });
+
+    it('deleteItemCanceled resets itemToBeDeleted', () => {
+      wrapper.setData({ itemToBeDeleted: 1 });
+      wrapper.vm.deleteItemCanceled();
+      expect(wrapper.vm.itemToBeDeleted).toEqual(null);
+    });
+  });
+
+  describe('when the list is empty', () => {
+    beforeEach(() => {
+      mountComponent({
+        packages: [],
+        slots: {
+          'empty-state': EmptySlotStub,
+        },
+      });
+    });
+
+    it('show the empty slot', () => {
+      const emptySlot = findEmptySlot();
+      expect(emptySlot.exists()).toBe(true);
+    });
+  });
+
+  describe('pagination component', () => {
+    let pagination;
+    let modelEvent;
+
+    beforeEach(() => {
+      mountComponent();
+      pagination = findPackageListPagination();
+      // retrieve the event used by v-model, a more sturdy approach than hardcoding it
+      modelEvent = pagination.vm.$options.model.event;
+    });
+
+    it('emits page:changed events when the page changes', () => {
+      pagination.vm.$emit(modelEvent, 2);
+      expect(wrapper.emitted('page:changed')).toEqual([[2]]);
+    });
+  });
+
+  describe('tracking', () => {
+    let eventSpy;
+    let utilSpy;
+    const category = 'foo';
+
+    beforeEach(() => {
+      mountComponent();
+      eventSpy = jest.spyOn(Tracking, 'event');
+      utilSpy = jest.spyOn(SharedUtils, 'packageTypeToTrackCategory').mockReturnValue(category);
+      wrapper.setData({ itemToBeDeleted: { package_type: 'conan' } });
+    });
+
+    it('tracking category calls packageTypeToTrackCategory', () => {
+      expect(wrapper.vm.tracking.category).toBe(category);
+      expect(utilSpy).toHaveBeenCalledWith('conan');
+    });
+
+    it('deleteItemConfirmation calls event', () => {
+      wrapper.vm.deleteItemConfirmation();
+      expect(eventSpy).toHaveBeenCalledWith(
+        category,
+        TrackingActions.DELETE_PACKAGE,
+        expect.any(Object),
+      );
+    });
+  });
+});
diff --git a/spec/frontend/packages_and_registries/package_registry/components/list/packages_search_spec.js b/spec/frontend/packages_and_registries/package_registry/components/list/packages_search_spec.js
new file mode 100644
index 00000000000..42bc9fa3a9e
--- /dev/null
+++ b/spec/frontend/packages_and_registries/package_registry/components/list/packages_search_spec.js
@@ -0,0 +1,128 @@
+import { shallowMount, createLocalVue } from '@vue/test-utils';
+import Vuex from 'vuex';
+import { sortableFields } from '~/packages/list/utils';
+import component from '~/packages_and_registries/package_registry/components/list/package_search.vue';
+import PackageTypeToken from '~/packages_and_registries/package_registry/components/list/tokens/package_type_token.vue';
+import RegistrySearch from '~/vue_shared/components/registry/registry_search.vue';
+import UrlSync from '~/vue_shared/components/url_sync.vue';
+
+const localVue = createLocalVue();
+localVue.use(Vuex);
+
+describe('Package Search', () => {
+  let wrapper;
+  let store;
+
+  const findRegistrySearch = () => wrapper.findComponent(RegistrySearch);
+  const findUrlSync = () => wrapper.findComponent(UrlSync);
+
+  const createStore = (isGroupPage) => {
+    const state = {
+      config: {
+        isGroupPage,
+      },
+      sorting: {
+        orderBy: 'version',
+        sort: 'desc',
+      },
+      filter: [],
+    };
+    store = new Vuex.Store({
+      state,
+    });
+    store.dispatch = jest.fn();
+  };
+
+  const mountComponent = (isGroupPage = false) => {
+    createStore(isGroupPage);
+
+    wrapper = shallowMount(component, {
+      localVue,
+      store,
+      stubs: {
+        UrlSync,
+      },
+    });
+  };
+
+  afterEach(() => {
+    wrapper.destroy();
+    wrapper = null;
+  });
+
+  it('has a registry search component', () => {
+    mountComponent();
+
+    expect(findRegistrySearch().exists()).toBe(true);
+    expect(findRegistrySearch().props()).toMatchObject({
+      filter: store.state.filter,
+      sorting: store.state.sorting,
+      tokens: expect.arrayContaining([
+        expect.objectContaining({ token: PackageTypeToken, type: 'type', icon: 'package' }),
+      ]),
+      sortableFields: sortableFields(),
+    });
+  });
+
+  it.each`
+    isGroupPage | page
+    ${false}    | ${'project'}
+    ${true}     | ${'group'}
+  `('in a $page page binds the right props', ({ isGroupPage }) => {
+    mountComponent(isGroupPage);
+
+    expect(findRegistrySearch().props()).toMatchObject({
+      filter: store.state.filter,
+      sorting: store.state.sorting,
+      tokens: expect.arrayContaining([
+        expect.objectContaining({ token: PackageTypeToken, type: 'type', icon: 'package' }),
+      ]),
+      sortableFields: sortableFields(isGroupPage),
+    });
+  });
+
+  it('on sorting:changed emits update event and calls vuex setSorting', () => {
+    const payload = { sort: 'foo' };
+
+    mountComponent();
+
+    findRegistrySearch().vm.$emit('sorting:changed', payload);
+
+    expect(store.dispatch).toHaveBeenCalledWith('setSorting', payload);
+    expect(wrapper.emitted('update')).toEqual([[]]);
+  });
+
+  it('on filter:changed calls vuex setFilter', () => {
+    const payload = ['foo'];
+
+    mountComponent();
+
+    findRegistrySearch().vm.$emit('filter:changed', payload);
+
+    expect(store.dispatch).toHaveBeenCalledWith('setFilter', payload);
+  });
+
+  it('on filter:submit emits update event', () => {
+    mountComponent();
+
+    findRegistrySearch().vm.$emit('filter:submit');
+
+    expect(wrapper.emitted('update')).toEqual([[]]);
+  });
+
+  it('has a UrlSync component', () => {
+    mountComponent();
+
+    expect(findUrlSync().exists()).toBe(true);
+  });
+
+  it('on query:changed calls updateQuery from UrlSync', () => {
+    jest.spyOn(UrlSync.methods, 'updateQuery').mockImplementation(() => {});
+
+    mountComponent();
+
+    findRegistrySearch().vm.$emit('query:changed');
+
+    expect(UrlSync.methods.updateQuery).toHaveBeenCalled();
+  });
+});
diff --git a/spec/frontend/packages_and_registries/package_registry/components/list/packages_title_spec.js b/spec/frontend/packages_and_registries/package_registry/components/list/packages_title_spec.js
new file mode 100644
index 00000000000..3fa96ce1d29
--- /dev/null
+++ b/spec/frontend/packages_and_registries/package_registry/components/list/packages_title_spec.js
@@ -0,0 +1,71 @@
+import { shallowMount } from '@vue/test-utils';
+import { LIST_INTRO_TEXT, LIST_TITLE_TEXT } from '~/packages/list/constants';
+import PackageTitle from '~/packages_and_registries/package_registry/components/list/package_title.vue';
+import MetadataItem from '~/vue_shared/components/registry/metadata_item.vue';
+import TitleArea from '~/vue_shared/components/registry/title_area.vue';
+
+describe('PackageTitle', () => {
+  let wrapper;
+  let store;
+
+  const findTitleArea = () => wrapper.find(TitleArea);
+  const findMetadataItem = () => wrapper.find(MetadataItem);
+
+  const mountComponent = (propsData = { helpUrl: 'foo' }) => {
+    wrapper = shallowMount(PackageTitle, {
+      store,
+      propsData,
+      stubs: {
+        TitleArea,
+      },
+    });
+  };
+
+  afterEach(() => {
+    wrapper.destroy();
+    wrapper = null;
+  });
+
+  describe('title area', () => {
+    it('exists', () => {
+      mountComponent();
+
+      expect(findTitleArea().exists()).toBe(true);
+    });
+
+    it('has the correct props', () => {
+      mountComponent();
+
+      expect(findTitleArea().props()).toMatchObject({
+        title: LIST_TITLE_TEXT,
+        infoMessages: [{ text: LIST_INTRO_TEXT, link: 'foo' }],
+      });
+    });
+  });
+
+  describe.each`
+    count        | exist    | text
+    ${null}      | ${false} | ${''}
+    ${undefined} | ${false} | ${''}
+    ${0}         | ${true}  | ${'0 Packages'}
+    ${1}         | ${true}  | ${'1 Package'}
+    ${2}         | ${true}  | ${'2 Packages'}
+  `('when count is $count metadata item', ({ count, exist, text }) => {
+    beforeEach(() => {
+      mountComponent({ count, helpUrl: 'foo' });
+    });
+
+    it(`is ${exist} that it exists`, () => {
+      expect(findMetadataItem().exists()).toBe(exist);
+    });
+
+    if (exist) {
+      it('has the correct props', () => {
+        expect(findMetadataItem().props()).toMatchObject({
+          icon: 'package',
+          text,
+        });
+      });
+    }
+  });
+});
diff --git a/spec/frontend/packages_and_registries/package_registry/components/list/tokens/package_type_token_spec.js b/spec/frontend/packages_and_registries/package_registry/components/list/tokens/package_type_token_spec.js
new file mode 100644
index 00000000000..b0cbe34f0b9
--- /dev/null
+++ b/spec/frontend/packages_and_registries/package_registry/components/list/tokens/package_type_token_spec.js
@@ -0,0 +1,48 @@
+import { GlFilteredSearchToken, GlFilteredSearchSuggestion } from '@gitlab/ui';
+import { shallowMount } from '@vue/test-utils';
+import component from '~/packages/list/components/tokens/package_type_token.vue';
+import { PACKAGE_TYPES } from '~/packages/list/constants';
+
+describe('packages_filter', () => {
+  let wrapper;
+
+  const findFilteredSearchToken = () => wrapper.find(GlFilteredSearchToken);
+  const findFilteredSearchSuggestions = () => wrapper.findAll(GlFilteredSearchSuggestion);
+
+  const mountComponent = ({ attrs, listeners } = {}) => {
+    wrapper = shallowMount(component, {
+      attrs,
+      listeners,
+    });
+  };
+
+  afterEach(() => {
+    wrapper.destroy();
+    wrapper = null;
+  });
+
+  it('it binds all of his attrs to filtered search token', () => {
+    mountComponent({ attrs: { foo: 'bar' } });
+
+    expect(findFilteredSearchToken().attributes('foo')).toBe('bar');
+  });
+
+  it('it binds all of his events to filtered search token', () => {
+    const clickListener = jest.fn();
+    mountComponent({ listeners: { click: clickListener } });
+
+    findFilteredSearchToken().vm.$emit('click');
+
+    expect(clickListener).toHaveBeenCalled();
+  });
+
+  it.each(PACKAGE_TYPES.map((p, index) => [p, index]))(
+    'displays a suggestion for %p',
+    (packageType, index) => {
+      mountComponent();
+      const item = findFilteredSearchSuggestions().at(index);
+      expect(item.text()).toBe(packageType.title);
+      expect(item.props('value')).toBe(packageType.type);
+    },
+  );
+});
diff --git a/spec/frontend/vue_shared/components/user_popover/user_popover_spec.js b/spec/frontend/vue_shared/components/user_popover/user_popover_spec.js
index 3080045e0b1..926223e0670 100644
--- a/spec/frontend/vue_shared/components/user_popover/user_popover_spec.js
+++ b/spec/frontend/vue_shared/components/user_popover/user_popover_spec.js
@@ -248,6 +248,13 @@ describe('User Popover Component', () => {
       const securityBotDocsLink = findSecurityBotDocsLink();
       expect(securityBotDocsLink.exists()).toBe(true);
       expect(securityBotDocsLink.attributes('href')).toBe(SECURITY_BOT_USER.websiteUrl);
+      expect(securityBotDocsLink.text()).toBe('Learn more about GitLab Security Bot');
+    });
+
+    it("doesn't escape user's name", () => {
+      createWrapper({ user: { ...SECURITY_BOT_USER, name: '%<>\';"' } });
+      const securityBotDocsLink = findSecurityBotDocsLink();
+      expect(securityBotDocsLink.text()).toBe('Learn more about %<>\';"');
     });
   });
 });
diff --git a/spec/helpers/issues_helper_spec.rb b/spec/helpers/issues_helper_spec.rb
index 261037ccceb..f5f26d306fb 100644
--- a/spec/helpers/issues_helper_spec.rb
+++ b/spec/helpers/issues_helper_spec.rb
@@ -310,7 +310,7 @@ RSpec.describe IssuesHelper do
         can_bulk_update: 'true',
         can_edit: 'true',
         can_import_issues: 'true',
-        email: current_user&.notification_email,
+        email: current_user&.notification_email_or_default,
         emails_help_page_path: help_page_path('development/emails', anchor: 'email-namespace'),
         empty_state_svg_path: '#',
         export_csv_path: export_csv_project_issues_path(project),
diff --git a/spec/lib/gitlab/background_migration/extract_project_topics_into_separate_table_spec.rb b/spec/lib/gitlab/background_migration/extract_project_topics_into_separate_table_spec.rb
index 05f40ee2501..a111007a984 100644
--- a/spec/lib/gitlab/background_migration/extract_project_topics_into_separate_table_spec.rb
+++ b/spec/lib/gitlab/background_migration/extract_project_topics_into_separate_table_spec.rb
@@ -22,8 +22,9 @@ RSpec.describe Gitlab::BackgroundMigration::ExtractProjectTopicsIntoSeparateTabl
     other_tagging = taggings.create!(taggable_type: 'Other', taggable_id: project.id, context: 'topics', tag_id: tag_1.id)
     tagging_3 = taggings.create!(taggable_type: 'Project', taggable_id: project.id, context: 'topics', tag_id: tag_3.id)
     tagging_4 = taggings.create!(taggable_type: 'Project', taggable_id: -1, context: 'topics', tag_id: tag_1.id)
+    tagging_5 = taggings.create!(taggable_type: 'Project', taggable_id: project.id, context: 'topics', tag_id: -1)
 
-    subject.perform(tagging_1.id, tagging_4.id)
+    subject.perform(tagging_1.id, tagging_5.id)
 
     # Tagging records
     expect { tagging_1.reload }.to raise_error(ActiveRecord::RecordNotFound)
@@ -31,6 +32,7 @@ RSpec.describe Gitlab::BackgroundMigration::ExtractProjectTopicsIntoSeparateTabl
     expect { other_tagging.reload }.not_to raise_error(ActiveRecord::RecordNotFound)
     expect { tagging_3.reload }.to raise_error(ActiveRecord::RecordNotFound)
     expect { tagging_4.reload }.to raise_error(ActiveRecord::RecordNotFound)
+    expect { tagging_5.reload }.to raise_error(ActiveRecord::RecordNotFound)
 
     # Topic records
     topic_1 = topics.find_by(name: 'Topic1')
diff --git a/spec/lib/gitlab/database/load_balancing/sidekiq_server_middleware_spec.rb b/spec/lib/gitlab/database/load_balancing/sidekiq_server_middleware_spec.rb
index 1fe348bbf2e..9f23eb0094f 100644
--- a/spec/lib/gitlab/database/load_balancing/sidekiq_server_middleware_spec.rb
+++ b/spec/lib/gitlab/database/load_balancing/sidekiq_server_middleware_spec.rb
@@ -98,6 +98,16 @@ RSpec.describe Gitlab::Database::LoadBalancing::SidekiqServerMiddleware do
         it_behaves_like 'replica is up to date', 'replica'
       end
 
+      context 'when deduplication wal location is set' do
+        let(:job) { { 'job_id' => 'a180b47c-3fd6-41b8-81e9-34da61c3400e', 'dedup_wal_locations' => wal_locations } }
+
+        before do
+          allow(load_balancer).to receive(:select_up_to_date_host).with(wal_locations[:main]).and_return(true)
+        end
+
+        it_behaves_like 'replica is up to date', 'replica'
+      end
+
       context 'when legacy wal location is set' do
         let(:job) { { 'job_id' => 'a180b47c-3fd6-41b8-81e9-34da61c3400e', 'database_write_location' => '0/D525E3A8' } }
 
diff --git a/spec/lib/gitlab/database/migration_helpers/loose_foreign_key_helpers_spec.rb b/spec/lib/gitlab/database/migration_helpers/loose_foreign_key_helpers_spec.rb
new file mode 100644
index 00000000000..708d1be6e00
--- /dev/null
+++ b/spec/lib/gitlab/database/migration_helpers/loose_foreign_key_helpers_spec.rb
@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Gitlab::Database::MigrationHelpers::LooseForeignKeyHelpers do
+  let_it_be(:migration) do
+    ActiveRecord::Migration.new.extend(described_class)
+  end
+
+  let(:model) do
+    Class.new(ApplicationRecord) do
+      self.table_name = 'loose_fk_test_table'
+    end
+  end
+
+  before(:all) do
+    migration.create_table :loose_fk_test_table do |t|
+      t.timestamps
+    end
+  end
+
+  before do
+    3.times { model.create! }
+  end
+
+  context 'when the record deletion tracker trigger is not installed' do
+    it 'does store record deletions' do
+      model.delete_all
+
+      expect(LooseForeignKeys::DeletedRecord.count).to eq(0)
+    end
+  end
+
+  context 'when the record deletion tracker trigger is installed' do
+    before do
+      migration.track_record_deletions(:loose_fk_test_table)
+    end
+
+    it 'stores the record deletion' do
+      records = model.all
+      record_to_be_deleted = records.last
+
+      record_to_be_deleted.delete
+
+      expect(LooseForeignKeys::DeletedRecord.count).to eq(1)
+      deleted_record = LooseForeignKeys::DeletedRecord.all.first
+
+      expect(deleted_record.deleted_table_primary_key_value).to eq(record_to_be_deleted.id)
+      expect(deleted_record.deleted_table_name).to eq('loose_fk_test_table')
+    end
+
+    it 'stores multiple record deletions' do
+      model.delete_all
+
+      expect(LooseForeignKeys::DeletedRecord.count).to eq(3)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/instrumentation/redis_spec.rb b/spec/lib/gitlab/instrumentation/redis_spec.rb
index 6cddf958f2a..ebc2e92a0dd 100644
--- a/spec/lib/gitlab/instrumentation/redis_spec.rb
+++ b/spec/lib/gitlab/instrumentation/redis_spec.rb
@@ -28,6 +28,13 @@ RSpec.describe Gitlab::Instrumentation::Redis do
 
   describe '.payload', :request_store do
     before do
+      # If this is the first spec in a spec run that uses Redis, there
+      # will be an extra SELECT command to choose the right database. We
+      # don't want to make the spec less precise, so we force that to
+      # happen (if needed) first, then clear the counts.
+      Gitlab::Redis::Cache.with { |redis| redis.info }
+      RequestStore.clear!
+
       Gitlab::Redis::Cache.with { |redis| redis.set('cache-test', 321) }
       Gitlab::Redis::SharedState.with { |redis| redis.set('shared-state-test', 123) }
     end
diff --git a/spec/lib/gitlab/sidekiq_middleware/duplicate_jobs/duplicate_job_spec.rb b/spec/lib/gitlab/sidekiq_middleware/duplicate_jobs/duplicate_job_spec.rb
index d67cb95f483..cc69a11f7f8 100644
--- a/spec/lib/gitlab/sidekiq_middleware/duplicate_jobs/duplicate_job_spec.rb
+++ b/spec/lib/gitlab/sidekiq_middleware/duplicate_jobs/duplicate_job_spec.rb
@@ -9,7 +9,14 @@ RSpec.describe Gitlab::SidekiqMiddleware::DuplicateJobs::DuplicateJob, :clean_gi
     described_class.new(job, queue)
   end
 
-  let(:job) { { 'class' => 'AuthorizedProjectsWorker', 'args' => [1], 'jid' => '123' } }
+  let(:wal_locations) do
+    {
+      main: '0/D525E3A8',
+      ci: 'AB/12345'
+    }
+  end
+
+  let(:job) { { 'class' => 'AuthorizedProjectsWorker', 'args' => [1], 'jid' => '123', 'wal_locations' => wal_locations } }
   let(:queue) { 'authorized_projects' }
 
   let(:idempotency_key) do
@@ -74,13 +81,39 @@ RSpec.describe Gitlab::SidekiqMiddleware::DuplicateJobs::DuplicateJob, :clean_gi
     context 'when there was no job in the queue yet' do
       it { expect(duplicate_job.check!).to eq('123') }
 
-      it "adds a key with ttl set to #{described_class::DUPLICATE_KEY_TTL}" do
+      it "adds a idempotency key with ttl set to #{described_class::DUPLICATE_KEY_TTL}" do
         expect { duplicate_job.check! }
           .to change { read_idempotency_key_with_ttl(idempotency_key) }
                 .from([nil, -2])
                 .to(['123', be_within(1).of(described_class::DUPLICATE_KEY_TTL)])
       end
 
+      context 'when wal locations is not empty' do
+        it "adds a existing wal locations key with ttl set to #{described_class::DUPLICATE_KEY_TTL}" do
+          expect { duplicate_job.check! }
+            .to change { read_idempotency_key_with_ttl(existing_wal_location_key(idempotency_key, :main)) }
+                  .from([nil, -2])
+                  .to([wal_locations[:main], be_within(1).of(described_class::DUPLICATE_KEY_TTL)])
+            .and change { read_idempotency_key_with_ttl(existing_wal_location_key(idempotency_key, :ci)) }
+                  .from([nil, -2])
+                  .to([wal_locations[:ci], be_within(1).of(described_class::DUPLICATE_KEY_TTL)])
+        end
+      end
+
+      context 'when preserve_latest_wal_locations_for_idempotent_jobs feature flag is disabled' do
+        before do
+          stub_feature_flags(preserve_latest_wal_locations_for_idempotent_jobs: false)
+        end
+
+        it "does not change the existing wal locations key's TTL" do
+          expect { duplicate_job.check! }
+            .to not_change { read_idempotency_key_with_ttl(existing_wal_location_key(idempotency_key, :main)) }
+                  .from([nil, -2])
+            .and not_change { read_idempotency_key_with_ttl(existing_wal_location_key(idempotency_key, :ci)) }
+                  .from([nil, -2])
+        end
+      end
+
       it "adds the idempotency key to the jobs payload" do
         expect { duplicate_job.check! }.to change { job['idempotency_key'] }.from(nil).to(idempotency_key)
       end
@@ -89,6 +122,9 @@ RSpec.describe Gitlab::SidekiqMiddleware::DuplicateJobs::DuplicateJob, :clean_gi
     context 'when there was already a job with same arguments in the same queue' do
       before do
         set_idempotency_key(idempotency_key, 'existing-key')
+        wal_locations.each do |config_name, location|
+          set_idempotency_key(existing_wal_location_key(idempotency_key, config_name), location)
+        end
       end
 
       it { expect(duplicate_job.check!).to eq('existing-key') }
@@ -99,6 +135,14 @@ RSpec.describe Gitlab::SidekiqMiddleware::DuplicateJobs::DuplicateJob, :clean_gi
                 .from(['existing-key', -1])
       end
 
+      it "does not change the existing wal locations key's TTL" do
+        expect { duplicate_job.check! }
+          .to not_change { read_idempotency_key_with_ttl(existing_wal_location_key(idempotency_key, :main)) }
+                .from([wal_locations[:main], -1])
+          .and not_change { read_idempotency_key_with_ttl(existing_wal_location_key(idempotency_key, :ci)) }
+                .from([wal_locations[:ci], -1])
+      end
+
       it 'sets the existing jid' do
         duplicate_job.check!
 
@@ -107,6 +151,117 @@ RSpec.describe Gitlab::SidekiqMiddleware::DuplicateJobs::DuplicateJob, :clean_gi
     end
   end
 
+  describe '#update_latest_wal_location!' do
+    let(:offset) { '1024' }
+
+    before do
+      allow(duplicate_job).to receive(:pg_wal_lsn_diff).with(:main).and_return(offset)
+      allow(duplicate_job).to receive(:pg_wal_lsn_diff).with(:ci).and_return(offset)
+    end
+
+    shared_examples 'updates wal location' do
+      it 'updates a wal location to redis with an offset' do
+        expect { duplicate_job.update_latest_wal_location! }
+          .to change { read_range_from_redis(wal_location_key(idempotency_key, :main)) }
+                .from(existing_wal_with_offset[:main])
+                .to(new_wal_with_offset[:main])
+          .and change { read_range_from_redis(wal_location_key(idempotency_key, :ci)) }
+                .from(existing_wal_with_offset[:ci])
+                .to(new_wal_with_offset[:ci])
+      end
+    end
+
+    context 'when preserve_latest_wal_locations_for_idempotent_jobs feature flag is disabled' do
+      before do
+        stub_feature_flags(preserve_latest_wal_locations_for_idempotent_jobs: false)
+      end
+
+      it "doesn't call Sidekiq.redis" do
+        expect(Sidekiq).not_to receive(:redis)
+
+        duplicate_job.update_latest_wal_location!
+      end
+
+      it "doesn't update a wal location to redis with an offset" do
+        expect { duplicate_job.update_latest_wal_location! }
+          .to not_change { read_range_from_redis(wal_location_key(idempotency_key, :main)) }
+                .from([])
+         .and not_change { read_range_from_redis(wal_location_key(idempotency_key, :ci)) }
+                .from([])
+      end
+    end
+
+    context "when the key doesn't exists in redis" do
+      include_examples 'updates wal location' do
+        let(:existing_wal_with_offset) { { main: [], ci: [] } }
+        let(:new_wal_with_offset) { wal_locations.transform_values { |v| [v, offset] } }
+      end
+    end
+
+    context "when the key exists in redis" do
+      let(:existing_offset) { '1023'}
+      let(:existing_wal_locations) do
+        {
+          main: '0/D525E3NM',
+          ci: 'AB/111112'
+        }
+      end
+
+      before do
+        rpush_to_redis_key(wal_location_key(idempotency_key, :main), existing_wal_locations[:main], existing_offset)
+        rpush_to_redis_key(wal_location_key(idempotency_key, :ci), existing_wal_locations[:ci], existing_offset)
+      end
+
+      context "when the new offset is bigger then the existing one" do
+        include_examples 'updates wal location' do
+          let(:existing_wal_with_offset) { existing_wal_locations.transform_values { |v| [v, existing_offset] } }
+          let(:new_wal_with_offset) { wal_locations.transform_values { |v| [v, offset] } }
+        end
+      end
+
+      context "when the old offset is not bigger then the existing one" do
+        let(:existing_offset) { offset }
+
+        it "does not update a wal location to redis with an offset" do
+          expect { duplicate_job.update_latest_wal_location! }
+            .to not_change { read_range_from_redis(wal_location_key(idempotency_key, :main)) }
+                  .from([existing_wal_locations[:main], existing_offset])
+            .and not_change { read_range_from_redis(wal_location_key(idempotency_key, :ci)) }
+                   .from([existing_wal_locations[:ci], existing_offset])
+        end
+      end
+    end
+  end
+
+  describe '#latest_wal_locations' do
+    context 'when job was deduplicated and wal locations were already persisted' do
+      before do
+        rpush_to_redis_key(wal_location_key(idempotency_key, :main), wal_locations[:main], 1024)
+        rpush_to_redis_key(wal_location_key(idempotency_key, :ci), wal_locations[:ci], 1024)
+      end
+
+      it { expect(duplicate_job.latest_wal_locations).to eq(wal_locations) }
+    end
+
+    context 'when job is not deduplication and wal locations were not persisted' do
+      it { expect(duplicate_job.latest_wal_locations).to be_empty }
+    end
+
+    context 'when preserve_latest_wal_locations_for_idempotent_jobs feature flag is disabled' do
+      before do
+        stub_feature_flags(preserve_latest_wal_locations_for_idempotent_jobs: false)
+      end
+
+      it "doesn't call Sidekiq.redis" do
+        expect(Sidekiq).not_to receive(:redis)
+
+        duplicate_job.latest_wal_locations
+      end
+
+      it { expect(duplicate_job.latest_wal_locations).to eq({}) }
+    end
+  end
+
   describe '#delete!' do
     context "when we didn't track the definition" do
       it { expect { duplicate_job.delete! }.not_to raise_error }
@@ -115,14 +270,79 @@ RSpec.describe Gitlab::SidekiqMiddleware::DuplicateJobs::DuplicateJob, :clean_gi
     context 'when the key exists in redis' do
       before do
         set_idempotency_key(idempotency_key, 'existing-jid')
+        wal_locations.each do |config_name, location|
+          set_idempotency_key(existing_wal_location_key(idempotency_key, config_name), location)
+          set_idempotency_key(wal_location_key(idempotency_key, config_name), location)
+        end
       end
 
       shared_examples 'deleting the duplicate job' do
-        it 'removes the key from redis' do
-          expect { duplicate_job.delete! }
-            .to change { read_idempotency_key_with_ttl(idempotency_key) }
-                  .from(['existing-jid', -1])
-                  .to([nil, -2])
+        shared_examples 'deleting keys from redis' do |key_name|
+          it "removes the #{key_name} from redis" do
+            expect { duplicate_job.delete! }
+              .to change { read_idempotency_key_with_ttl(key) }
+                    .from([from_value, -1])
+                    .to([nil, -2])
+          end
+        end
+
+        shared_examples 'does not delete key from redis' do |key_name|
+          it "does not remove the #{key_name} from redis" do
+            expect { duplicate_job.delete! }
+              .to not_change { read_idempotency_key_with_ttl(key) }
+                    .from([from_value, -1])
+          end
+        end
+
+        it_behaves_like 'deleting keys from redis', 'idempotent key' do
+          let(:key) { idempotency_key }
+          let(:from_value) { 'existing-jid' }
+        end
+
+        it_behaves_like 'deleting keys from redis', 'existing wal location keys for main database' do
+          let(:key) { existing_wal_location_key(idempotency_key, :main) }
+          let(:from_value) { wal_locations[:main] }
+        end
+
+        it_behaves_like 'deleting keys from redis', 'existing wal location keys for ci database' do
+          let(:key) { existing_wal_location_key(idempotency_key, :ci) }
+          let(:from_value) { wal_locations[:ci] }
+        end
+
+        it_behaves_like 'deleting keys from redis', 'latest wal location keys for main database' do
+          let(:key) { wal_location_key(idempotency_key, :main) }
+          let(:from_value) { wal_locations[:main] }
+        end
+
+        it_behaves_like 'deleting keys from redis', 'latest wal location keys for ci database' do
+          let(:key) { wal_location_key(idempotency_key, :ci) }
+          let(:from_value) { wal_locations[:ci] }
+        end
+
+        context 'when preserve_latest_wal_locations_for_idempotent_jobs feature flag is disabled' do
+          before do
+            stub_feature_flags(preserve_latest_wal_locations_for_idempotent_jobs: false)
+          end
+
+          it_behaves_like 'does not delete key from redis', 'latest wal location keys for main database' do
+            let(:key) { existing_wal_location_key(idempotency_key, :main) }
+            let(:from_value) { wal_locations[:main] }
+          end
+
+          it_behaves_like 'does not delete key from redis', 'latest wal location keys for ci database' do
+            let(:key) { existing_wal_location_key(idempotency_key, :ci) }
+            let(:from_value) { wal_locations[:ci] }
+          end
+
+          it_behaves_like 'does not delete key from redis', 'latest wal location keys for main database' do
+            let(:key) { wal_location_key(idempotency_key, :main) }
+            let(:from_value) { wal_locations[:main] }
+          end
+
+          it_behaves_like 'does not delete key from redis', 'latest wal location keys for ci database' do
+            let(:key) { wal_location_key(idempotency_key, :ci) }
+            let(:from_value) { wal_locations[:ci] }
+          end
         end
       end
 
@@ -254,10 +474,22 @@ RSpec.describe Gitlab::SidekiqMiddleware::DuplicateJobs::DuplicateJob, :clean_gi
     end
   end
 
+  def existing_wal_location_key(idempotency_key, config_name)
+    "#{idempotency_key}:#{config_name}:existing_wal_location"
+  end
+
+  def wal_location_key(idempotency_key, config_name)
+    "#{idempotency_key}:#{config_name}:wal_location"
+  end
+
   def set_idempotency_key(key, value = '1')
     Sidekiq.redis { |r| r.set(key, value) }
   end
 
+  def rpush_to_redis_key(key, wal, offset)
+    Sidekiq.redis { |r| r.rpush(key, [wal, offset]) }
+  end
+
   def read_idempotency_key_with_ttl(key)
     Sidekiq.redis do |redis|
       redis.pipelined do |p|
@@ -266,4 +498,10 @@ RSpec.describe Gitlab::SidekiqMiddleware::DuplicateJobs::DuplicateJob, :clean_gi
       end
     end
   end
+
+  def read_range_from_redis(key)
+    Sidekiq.redis do |redis|
+      redis.lrange(key, 0, -1)
+    end
+  end
 end
diff --git a/spec/lib/gitlab/sidekiq_middleware/duplicate_jobs/strategies/until_executed_spec.rb b/spec/lib/gitlab/sidekiq_middleware/duplicate_jobs/strategies/until_executed_spec.rb
index b3d463b6f6b..9772255fc50 100644
--- a/spec/lib/gitlab/sidekiq_middleware/duplicate_jobs/strategies/until_executed_spec.rb
+++ b/spec/lib/gitlab/sidekiq_middleware/duplicate_jobs/strategies/until_executed_spec.rb
@@ -7,6 +7,10 @@ RSpec.describe Gitlab::SidekiqMiddleware::DuplicateJobs::Strategies::UntilExecut
     describe '#perform' do
       let(:proc) { -> {} }
 
+      before do
+        allow(fake_duplicate_job).to receive(:latest_wal_locations).and_return( {} )
+      end
+
       it 'deletes the lock after executing' do
         expect(proc).to receive(:call).ordered
         expect(fake_duplicate_job).to receive(:delete!).ordered
diff --git a/spec/lib/gitlab/sidekiq_middleware/duplicate_jobs/strategies/until_executing_spec.rb b/spec/lib/gitlab/sidekiq_middleware/duplicate_jobs/strategies/until_executing_spec.rb
index d45b6c5fcd1..c4045b8c63b 100644
--- a/spec/lib/gitlab/sidekiq_middleware/duplicate_jobs/strategies/until_executing_spec.rb
+++ b/spec/lib/gitlab/sidekiq_middleware/duplicate_jobs/strategies/until_executing_spec.rb
@@ -7,6 +7,10 @@ RSpec.describe Gitlab::SidekiqMiddleware::DuplicateJobs::Strategies::UntilExecut
     describe '#perform' do
       let(:proc) { -> {} }
 
+      before do
+        allow(fake_duplicate_job).to receive(:latest_wal_locations).and_return( {} )
+      end
+
       it 'deletes the lock before executing' do
         expect(fake_duplicate_job).to receive(:delete!).ordered
         expect(proc).to receive(:call).ordered
diff --git a/spec/mailers/emails/in_product_marketing_spec.rb b/spec/mailers/emails/in_product_marketing_spec.rb
index 74354630ade..99beef92dea 100644
--- a/spec/mailers/emails/in_product_marketing_spec.rb
+++ b/spec/mailers/emails/in_product_marketing_spec.rb
@@ -23,7 +23,7 @@ RSpec.describe Emails::InProductMarketing do
 
     it 'sends to the right user with a link to unsubscribe' do
       aggregate_failures do
-        expect(subject).to deliver_to(user.notification_email)
+        expect(subject).to deliver_to(user.notification_email_or_default)
         expect(subject).to have_body_text(profile_notifications_url)
       end
     end
diff --git a/spec/mailers/notify_spec.rb b/spec/mailers/notify_spec.rb
index dd1b08b506f..f39037cf744 100644
--- a/spec/mailers/notify_spec.rb
+++ b/spec/mailers/notify_spec.rb
@@ -71,7 +71,7 @@ RSpec.describe Notify do
       it 'is sent to the assignee as the author' do
         aggregate_failures do
           expect_sender(current_user)
-          expect(subject).to deliver_to(recipient.notification_email)
+          expect(subject).to deliver_to(recipient.notification_email_or_default)
         end
       end
     end
@@ -710,7 +710,7 @@ RSpec.describe Notify do
 
       it 'contains all the useful information' do
         to_emails = subject.header[:to].addrs.map(&:address)
-        expect(to_emails).to eq([recipient.notification_email])
+        expect(to_emails).to eq([recipient.notification_email_or_default])
 
         is_expected.to have_subject "Request to join the #{project.full_name} project"
         is_expected.to have_body_text project.full_name
@@ -1047,7 +1047,7 @@ RSpec.describe Notify do
         it 'is sent to the given recipient as the author' do
           aggregate_failures do
             expect_sender(note_author)
-            expect(subject).to deliver_to(recipient.notification_email)
+            expect(subject).to deliver_to(recipient.notification_email_or_default)
           end
         end
 
@@ -1204,7 +1204,7 @@ RSpec.describe Notify do
         it 'is sent to the given recipient as the author' do
           aggregate_failures do
             expect_sender(note_author)
-            expect(subject).to deliver_to(recipient.notification_email)
+            expect(subject).to deliver_to(recipient.notification_email_or_default)
           end
         end
 
@@ -1341,7 +1341,7 @@ RSpec.describe Notify do
 
       it 'contains all the useful information' do
         to_emails = subject.header[:to].addrs.map(&:address)
-        expect(to_emails).to eq([recipient.notification_email])
+        expect(to_emails).to eq([recipient.notification_email_or_default])
 
         is_expected.to have_subject "Request to join the #{group.name} group"
         is_expected.to have_body_text group.name
diff --git a/spec/models/group_spec.rb b/spec/models/group_spec.rb
index d177f5380fb..d536a0783bc 100644
--- a/spec/models/group_spec.rb
+++ b/spec/models/group_spec.rb
@@ -82,7 +82,7 @@ RSpec.describe Group do
           group = build(:group, parent: build(:namespace))
 
           expect(group).not_to be_valid
-          expect(group.errors[:parent_id].first).to eq('a group cannot have a user namespace as its parent')
+          expect(group.errors[:parent_id].first).to eq('user namespace cannot be the parent of another namespace')
         end
 
         it 'allows a group to have another group as its parent' do
diff --git a/spec/models/integrations/pipelines_email_spec.rb b/spec/models/integrations/pipelines_email_spec.rb
index 761049f25fe..afd9d71ebc4 100644
--- a/spec/models/integrations/pipelines_email_spec.rb
+++ b/spec/models/integrations/pipelines_email_spec.rb
@@ -48,7 +48,7 @@ RSpec.describe Integrations::PipelinesEmail, :mailer do
     end
 
     it 'sends email' do
-      emails = receivers.map { |r| double(notification_email: r) }
+      emails = receivers.map { |r| double(notification_email_or_default: r) }
 
       should_only_email(*emails, kind: :bcc)
     end
diff --git a/spec/models/loose_foreign_keys/deleted_record_spec.rb b/spec/models/loose_foreign_keys/deleted_record_spec.rb
new file mode 100644
index 00000000000..db2f8b4d2d3
--- /dev/null
+++ b/spec/models/loose_foreign_keys/deleted_record_spec.rb
@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LooseForeignKeys::DeletedRecord do
+  let_it_be(:deleted_record_1) { described_class.create!(created_at: 1.day.ago, deleted_table_name: 'projects', deleted_table_primary_key_value: 5) }
+  let_it_be(:deleted_record_2) { described_class.create!(created_at: 3.days.ago, deleted_table_name: 'projects', deleted_table_primary_key_value: 1) }
+  let_it_be(:deleted_record_3) { described_class.create!(created_at: 5.days.ago, deleted_table_name: 'projects', deleted_table_primary_key_value: 3) }
+  let_it_be(:deleted_record_4) { described_class.create!(created_at: 10.days.ago, deleted_table_name: 'projects', deleted_table_primary_key_value: 1) } # duplicate
+
+  # skip created_at because it gets truncated after insert
+  def map_attributes(records)
+    records.pluck(:deleted_table_name, :deleted_table_primary_key_value)
+  end
+
+  describe 'partitioning strategy' do
+    it 'has retain_non_empty_partitions option' do
+      expect(described_class.partitioning_strategy.retain_non_empty_partitions).to eq(true)
+    end
+  end
+
+  describe '.load_batch' do
+    it 'loads records and orders them by creation date' do
+      records = described_class.load_batch(4)
+
+      expect(map_attributes(records)).to eq([['projects', 1], ['projects', 3], ['projects', 1], ['projects', 5]])
+    end
+
+    it 'supports configurable batch size' do
+      records = described_class.load_batch(2)
+
+      expect(map_attributes(records)).to eq([['projects', 1], ['projects', 3]])
+    end
+  end
+
+  describe '.delete_records' do
+    it 'deletes exactly one record' do
+      described_class.delete_records([deleted_record_2])
+
+      expect(described_class.count).to eq(3)
+      expect(described_class.find_by(created_at: deleted_record_2.created_at)).to eq(nil)
+    end
+
+    it 'deletes two records' do
+      described_class.delete_records([deleted_record_2, deleted_record_4])
+
+      expect(described_class.count).to eq(2)
+    end
+
+    it 'deletes all records' do
+      described_class.delete_records([deleted_record_1, deleted_record_2, deleted_record_3, deleted_record_4])
+
+      expect(described_class.count).to eq(0)
+    end
+  end
+end
diff --git a/spec/models/namespace_spec.rb b/spec/models/namespace_spec.rb
index 9744d58abb9..51a26d82daa 100644
--- a/spec/models/namespace_spec.rb
+++ b/spec/models/namespace_spec.rb
@@ -36,27 +36,34 @@ RSpec.describe Namespace do
     it { is_expected.to validate_numericality_of(:max_artifacts_size).only_integer.is_greater_than(0) }
 
     context 'validating the parent of a namespace' do
-      context 'when the namespace has no parent' do
-        it 'allows a namespace to have no parent associated with it' do
-          namespace = build(:namespace)
-
-          expect(namespace).to be_valid
-        end
+      using RSpec::Parameterized::TableSyntax
+
+      where(:parent_type, :child_type, :error) do
+        nil         | 'User'      | nil
+        nil         | 'Group'     | nil
+        nil         | 'Project'   | 'must be set for a project namespace'
+        'Project'   | 'User'      | 'project namespace cannot be the parent of another namespace'
+        'Project'   | 'Group'     | 'project namespace cannot be the parent of another namespace'
+        'Project'   | 'Project'   | 'project namespace cannot be the parent of another namespace'
+        'Group'     | 'User'      | 'cannot not be used for user namespace'
+        'Group'     | 'Group'     | nil
+        'Group'     | 'Project'   | nil
+        'User'      | 'User'      | 'cannot not be used for user namespace'
+        'User'      | 'Group'     | 'user namespace cannot be the parent of another namespace'
+        'User'      | 'Project'   | nil
       end
 
-      context 'when the namespace has a parent' do
-        it 'does not allow a namespace to have a group as its parent' do
-          namespace = build(:namespace, parent: build(:group))
-
-          expect(namespace).not_to be_valid
-          expect(namespace.errors[:parent_id].first).to eq('a user namespace cannot have a parent')
-        end
-
-        it 'does not allow a namespace to have another namespace as its parent' do
-          namespace = build(:namespace, parent: build(:namespace))
-
-          expect(namespace).not_to be_valid
-          expect(namespace.errors[:parent_id].first).to eq('a user namespace cannot have a parent')
+      with_them do
+        it 'validates namespace parent' do
+          parent = build(:namespace, type: parent_type) if parent_type
+          namespace = build(:namespace, type: child_type, parent: parent)
+
+          if error
+            expect(namespace).not_to be_valid
+            expect(namespace.errors[:parent_id].first).to eq(error)
+          else
+            expect(namespace).to be_valid
+          end
         end
       end
 
@@ -159,7 +166,8 @@ RSpec.describe Namespace do
 
   describe 'handling STI', :aggregate_failures do
     let(:namespace_type) { nil }
-    let(:namespace) { Namespace.find(create(:namespace, type: namespace_type).id) }
+    let(:parent) { nil }
+    let(:namespace) { Namespace.find(create(:namespace, type: namespace_type, parent: parent).id) }
 
     context 'creating a Group' do
       let(:namespace_type) { 'Group' }
@@ -173,6 +181,7 @@ RSpec.describe Namespace do
 
     context 'creating a ProjectNamespace' do
       let(:namespace_type) { 'Project' }
+      let(:parent) { create(:group) }
 
       it 'is valid' do
         expect(Namespace.find(namespace.id)).to be_a(Namespaces::ProjectNamespace)
diff --git a/spec/models/repository_spec.rb b/spec/models/repository_spec.rb
index 9c2f269de46..dc55214c1dd 100644
--- a/spec/models/repository_spec.rb
+++ b/spec/models/repository_spec.rb
@@ -1826,7 +1826,7 @@ RSpec.describe Repository do
 
       expect(merge_commit.message).to eq('Custom message')
       expect(merge_commit.author_name).to eq(user.name)
-      expect(merge_commit.author_email).to eq(user.commit_email)
+      expect(merge_commit.author_email).to eq(user.commit_email_or_default)
       expect(repository.blob_at(merge_commit.id, 'files/ruby/feature.rb')).to be_present
     end
   end
diff --git a/spec/models/user_spec.rb b/spec/models/user_spec.rb
index c9644b0e67a..334f9b4ae30 100644
--- a/spec/models/user_spec.rb
+++ b/spec/models/user_spec.rb
@@ -435,12 +435,12 @@ RSpec.describe User do
       subject { create(:user).tap { |user| user.emails << build(:email, email: email_value, confirmed_at: Time.current) } }
     end
 
-    describe '#commit_email' do
+    describe '#commit_email_or_default' do
       subject(:user) { create(:user) }
 
       it 'defaults to the primary email' do
         expect(user.email).to be_present
-        expect(user.commit_email).to eq(user.email)
+        expect(user.commit_email_or_default).to eq(user.email)
       end
 
       it 'defaults to the primary email when the column in the database is null' do
@@ -448,14 +448,18 @@ RSpec.describe User do
 
         found_user = described_class.find_by(id: user.id)
 
-        expect(found_user.commit_email).to eq(user.email)
+        expect(found_user.commit_email_or_default).to eq(user.email)
       end
 
       it 'returns the private commit email when commit_email has _private' do
         user.update_column(:commit_email, Gitlab::PrivateCommitEmail::TOKEN)
 
-        expect(user.commit_email).to eq(user.private_commit_email)
+        expect(user.commit_email_or_default).to eq(user.private_commit_email)
       end
+    end
+
+    describe '#commit_email=' do
+      subject(:user) { create(:user) }
 
       it 'can be set to a confirmed email' do
         confirmed = create(:email, :confirmed, user: user)
@@ -699,6 +703,15 @@ RSpec.describe User do
           expect(user).to be_valid
         end
       end
+
+      context 'when commit_email is changed to _private' do
+        it 'passes user validations' do
+          user = create(:user)
+          user.commit_email = '_private'
+
+          expect(user).to be_valid
+        end
+      end
     end
   end
 
@@ -1246,53 +1259,57 @@ RSpec.describe User do
       end
     end
 
-    describe '#update_notification_email' do
-      # Regression: https://gitlab.com/gitlab-org/gitlab-foss/issues/22846
-      context 'when changing :email' do
-        let(:user) { create(:user) }
-        let(:new_email) { 'new-email@example.com' }
+    describe 'when changing email' do
+      let(:user) { create(:user) }
+      let(:new_email) { 'new-email@example.com' }
 
+      context 'if notification_email was nil' do
         it 'sets :unconfirmed_email' do
           expect do
             user.tap { |u| u.update!(email: new_email) }.reload
           end.to change(user, :unconfirmed_email).to(new_email)
         end
-        it 'does not change :notification_email' do
+
+        it 'does not change notification_email or notification_email_or_default before email is confirmed' do
           expect do
             user.tap { |u| u.update!(email: new_email) }.reload
-          end.not_to change(user, :notification_email)
+          end.not_to change(user, :notification_email_or_default)
+
+          expect(user.notification_email).to be_nil
         end
 
-        it 'updates :notification_email to the new email once confirmed' do
+        it 'updates notification_email_or_default to the new email once confirmed' do
           user.update!(email: new_email)
 
           expect do
             user.tap(&:confirm).reload
-          end.to change(user, :notification_email).to eq(new_email)
+          end.to change(user, :notification_email_or_default).to eq(new_email)
+
+          expect(user.notification_email).to be_nil
         end
+      end
 
-        context 'and :notification_email is set to a secondary email' do
-          let!(:email_attrs) { attributes_for(:email, :confirmed, user: user) }
-          let(:secondary) { create(:email, :confirmed, email: 'secondary@example.com', user: user) }
+      context 'when notification_email is set to a secondary email' do
+        let!(:email_attrs) { attributes_for(:email, :confirmed, user: user) }
+        let(:secondary) { create(:email, :confirmed, email: 'secondary@example.com', user: user) }
 
-          before do
-            user.emails.create!(email_attrs)
-            user.tap { |u| u.update!(notification_email: email_attrs[:email]) }.reload
-          end
+        before do
+          user.emails.create!(email_attrs)
+          user.tap { |u| u.update!(notification_email: email_attrs[:email]) }.reload
+        end
 
-          it 'does not change :notification_email to :email' do
-            expect do
-              user.tap { |u| u.update!(email: new_email) }.reload
-            end.not_to change(user, :notification_email)
-          end
+        it 'does not change notification_email to email before email is confirmed' do
+          expect do
+            user.tap { |u| u.update!(email: new_email) }.reload
+          end.not_to change(user, :notification_email)
+        end
 
-          it 'does not change :notification_email to :email once confirmed' do
-            user.update!(email: new_email)
+        it 'does not change notification_email to email once confirmed' do
+          user.update!(email: new_email)
 
-            expect do
-              user.tap(&:confirm).reload
-            end.not_to change(user, :notification_email)
-          end
+          expect do
+            user.tap(&:confirm).reload
+          end.not_to change(user, :notification_email)
         end
       end
     end
@@ -1878,6 +1895,7 @@ RSpec.describe User do
         end
         it 'does not send deactivated user an email' do
           expect(NotificationService).not_to receive(:new)
+
           user.deactivate
         end
       end
@@ -1885,7 +1903,7 @@ RSpec.describe User do
       context "when user deactivation emails are enabled" do
         it 'sends deactivated user an email' do
           expect_next_instance_of(NotificationService) do |notification|
-            allow(notification).to receive(:user_deactivated).with(user.name, user.notification_email)
+            allow(notification).to receive(:user_deactivated).with(user.name, user.notification_email_or_default)
           end
 
           user.deactivate
@@ -3084,15 +3102,15 @@ RSpec.describe User do
     end
   end
 
-  describe '#notification_email' do
+  describe '#notification_email_or_default' do
     let(:email) { 'gonzo@muppets.com' }
 
     context 'when the column in the database is null' do
       subject { create(:user, email: email, notification_email: nil) }
 
       it 'defaults to the primary email' do
-        expect(subject.read_attribute(:notification_email)).to be nil
-        expect(subject.notification_email).to eq(email)
+        expect(subject.notification_email).to be nil
+        expect(subject.notification_email_or_default).to eq(email)
       end
     end
   end
@@ -5335,7 +5353,7 @@ RSpec.describe User do
       let(:group) { nil }
 
       it 'returns global notification email' do
-        is_expected.to eq(user.notification_email)
+        is_expected.to eq(user.notification_email_or_default)
       end
     end
 
@@ -5343,7 +5361,7 @@ RSpec.describe User do
       it 'returns global notification email' do
         create(:notification_setting, user: user, source: group, notification_email: '')
 
-        is_expected.to eq(user.notification_email)
+        is_expected.to eq(user.notification_email_or_default)
       end
     end
 
@@ -6132,7 +6150,7 @@ RSpec.describe User do
       it 'does nothing' do
         expect(subject).not_to receive(:save)
         subject.unset_secondary_emails_matching_deleted_email!(deleted_email)
-        expect(subject.read_attribute(:commit_email)).to eq commit_email
+        expect(subject.commit_email).to eq commit_email
       end
     end
 
@@ -6142,7 +6160,7 @@ RSpec.describe User do
       it 'un-sets the secondary email' do
         expect(subject).to receive(:save)
         subject.unset_secondary_emails_matching_deleted_email!(deleted_email)
-        expect(subject.read_attribute(:commit_email)).to be nil
+        expect(subject.commit_email).to be nil
       end
     end
   end
diff --git a/spec/requests/api/notification_settings_spec.rb b/spec/requests/api/notification_settings_spec.rb
index 7b4a58e63da..b5551c21738 100644
--- a/spec/requests/api/notification_settings_spec.rb
+++ b/spec/requests/api/notification_settings_spec.rb
@@ -13,7 +13,7 @@ RSpec.describe API::NotificationSettings do
 
       expect(response).to have_gitlab_http_status(:ok)
       expect(json_response).to be_a Hash
-      expect(json_response['notification_email']).to eq(user.notification_email)
+      expect(json_response['notification_email']).to eq(user.notification_email_or_default)
       expect(json_response['level']).to eq(user.global_notification_setting.level)
     end
   end
diff --git a/spec/requests/api/users_spec.rb b/spec/requests/api/users_spec.rb
index 8b864346c5d..ac86c922813 100644
--- a/spec/requests/api/users_spec.rb
+++ b/spec/requests/api/users_spec.rb
@@ -1202,7 +1202,7 @@ RSpec.describe API::Users do
 
     it 'updates user with a new email' do
       old_email = user.email
-      old_notification_email = user.notification_email
+      old_notification_email = user.notification_email_or_default
       put api("/users/#{user.id}", admin), params: { email: 'new@email.com' }
 
       user.reload
@@ -1210,7 +1210,7 @@ RSpec.describe API::Users do
       expect(response).to have_gitlab_http_status(:ok)
       expect(user).to be_confirmed
       expect(user.email).to eq(old_email)
-      expect(user.notification_email).to eq(old_notification_email)
+      expect(user.notification_email_or_default).to eq(old_notification_email)
       expect(user.unconfirmed_email).to eq('new@email.com')
     end
 
diff --git a/spec/services/notification_service_spec.rb b/spec/services/notification_service_spec.rb
index 3c4d7d50002..a03f1f17b39 100644
--- a/spec/services/notification_service_spec.rb
+++ b/spec/services/notification_service_spec.rb
@@ -2623,7 +2623,7 @@ RSpec.describe NotificationService, :mailer do
     let_it_be(:user) { create(:user) }
 
     it 'sends the user an email' do
-      notification.user_deactivated(user.name, user.notification_email)
+      notification.user_deactivated(user.name, user.notification_email_or_default)
 
       should_only_email(user)
     end
diff --git a/spec/services/suggestions/apply_service_spec.rb b/spec/services/suggestions/apply_service_spec.rb
index d3dcbf0b668..dc330a5546f 100644
--- a/spec/services/suggestions/apply_service_spec.rb
+++ b/spec/services/suggestions/apply_service_spec.rb
@@ -70,7 +70,7 @@ RSpec.describe Suggestions::ApplyService do
       author = suggestions.first.note.author
 
       expect(user.commit_email).not_to eq(user.email)
-      expect(commit.author_email).to eq(author.commit_email)
+      expect(commit.author_email).to eq(author.commit_email_or_default)
       expect(commit.committer_email).to eq(user.commit_email)
       expect(commit.author_name).to eq(author.name)
       expect(commit.committer_name).to eq(user.name)
@@ -333,9 +333,9 @@ RSpec.describe Suggestions::ApplyService do
           end
 
           it 'created commit by same author and committer' do
-            expect(user.commit_email).to eq(author.commit_email)
+            expect(user.commit_email).to eq(author.commit_email_or_default)
             expect(author).to eq(user)
-            expect(commit.author_email).to eq(author.commit_email)
+            expect(commit.author_email).to eq(author.commit_email_or_default)
             expect(commit.committer_email).to eq(user.commit_email)
             expect(commit.author_name).to eq(author.name)
             expect(commit.committer_name).to eq(user.name)
@@ -350,7 +350,7 @@ RSpec.describe Suggestions::ApplyService do
           it 'created commit has authors info and commiters info' do
             expect(user.commit_email).not_to eq(user.email)
             expect(author).not_to eq(user)
-            expect(commit.author_email).to eq(author.commit_email)
+            expect(commit.author_email).to eq(author.commit_email_or_default)
             expect(commit.committer_email).to eq(user.commit_email)
             expect(commit.author_name).to eq(author.name)
             expect(commit.committer_name).to eq(user.name)
@@ -359,7 +359,7 @@ RSpec.describe Suggestions::ApplyService do
       end
 
       context 'multiple suggestions' do
-        let(:author_emails) { suggestions.map {|s| s.note.author.commit_email } }
+        let(:author_emails) { suggestions.map {|s| s.note.author.commit_email_or_default } }
         let(:first_author) { suggestion.note.author }
         let(:commit) { project.repository.commit }
 
@@ -369,8 +369,8 @@ RSpec.describe Suggestions::ApplyService do
           end
 
           it 'uses first authors information' do
-            expect(author_emails).to include(first_author.commit_email).exactly(3)
-            expect(commit.author_email).to eq(first_author.commit_email)
+            expect(author_emails).to include(first_author.commit_email_or_default).exactly(3)
+            expect(commit.author_email).to eq(first_author.commit_email_or_default)
           end
         end
 
diff --git a/spec/services/users/reject_service_spec.rb b/spec/services/users/reject_service_spec.rb
index 0e34f0e67ba..5a243e876ac 100644
--- a/spec/services/users/reject_service_spec.rb
+++ b/spec/services/users/reject_service_spec.rb
@@ -44,7 +44,7 @@ RSpec.describe Users::RejectService do
 
         it 'emails the user on rejection' do
           expect_next_instance_of(NotificationService) do |notification|
-            allow(notification).to receive(:user_admin_rejection).with(user.name, user.notification_email)
+            allow(notification).to receive(:user_admin_rejection).with(user.name, user.notification_email_or_default)
           end
 
           subject
diff --git a/spec/support/helpers/email_helpers.rb b/spec/support/helpers/email_helpers.rb
index 6df33e68629..d0f6fd466d0 100644
--- a/spec/support/helpers/email_helpers.rb
+++ b/spec/support/helpers/email_helpers.rb
@@ -2,7 +2,7 @@
 
 module EmailHelpers
   def sent_to_user(user, recipients: email_recipients)
-    recipients.count { |to| to == user.notification_email }
+    recipients.count { |to| to == user.notification_email_or_default }
   end
 
   def reset_delivered_emails!
@@ -45,7 +45,7 @@ module EmailHelpers
   end
 
   def find_email_for(user)
-    ActionMailer::Base.deliveries.find { |d| d.to.include?(user.notification_email) }
+    ActionMailer::Base.deliveries.find { |d| d.to.include?(user.notification_email_or_default) }
   end
 
   def have_referable_subject(referable, include_project: true, reply: false)
diff --git a/spec/support/shared_examples/lib/gitlab/sidekiq_middleware/strategy_shared_examples.rb b/spec/support/shared_examples/lib/gitlab/sidekiq_middleware/strategy_shared_examples.rb
index 89b793d5e16..708bc71ae96 100644
--- a/spec/support/shared_examples/lib/gitlab/sidekiq_middleware/strategy_shared_examples.rb
+++ b/spec/support/shared_examples/lib/gitlab/sidekiq_middleware/strategy_shared_examples.rb
@@ -39,6 +39,7 @@ RSpec.shared_examples 'deduplicating jobs when scheduling' do |strategy_name|
         allow(fake_duplicate_job).to receive(:scheduled?).and_return(false)
         allow(fake_duplicate_job).to receive(:check!).and_return('the jid')
         allow(fake_duplicate_job).to receive(:idempotent?).and_return(true)
+        allow(fake_duplicate_job).to receive(:update_latest_wal_location!)
         allow(fake_duplicate_job).to receive(:options).and_return({})
         job_hash = {}
 
@@ -63,6 +64,7 @@ RSpec.shared_examples 'deduplicating jobs when scheduling' do |strategy_name|
                 .with(Gitlab::SidekiqMiddleware::DuplicateJobs::DuplicateJob::DUPLICATE_KEY_TTL)
                 .and_return('the jid'))
             allow(fake_duplicate_job).to receive(:idempotent?).and_return(true)
+            allow(fake_duplicate_job).to receive(:update_latest_wal_location!)
             job_hash = {}
 
             expect(fake_duplicate_job).to receive(:duplicate?).and_return(true)
@@ -83,6 +85,7 @@ RSpec.shared_examples 'deduplicating jobs when scheduling' do |strategy_name|
               allow(fake_duplicate_job).to(
                 receive(:check!).with(time_diff.to_i).and_return('the jid'))
               allow(fake_duplicate_job).to receive(:idempotent?).and_return(true)
+              allow(fake_duplicate_job).to receive(:update_latest_wal_location!)
               job_hash = {}
 
               expect(fake_duplicate_job).to receive(:duplicate?).and_return(true)
@@ -105,6 +108,13 @@ RSpec.shared_examples 'deduplicating jobs when scheduling' do |strategy_name|
         allow(fake_duplicate_job).to receive(:options).and_return({})
         allow(fake_duplicate_job).to receive(:existing_jid).and_return('the jid')
         allow(fake_duplicate_job).to receive(:idempotent?).and_return(true)
+        allow(fake_duplicate_job).to receive(:update_latest_wal_location!)
+      end
+
+      it 'updates latest wal location' do
+        expect(fake_duplicate_job).to receive(:update_latest_wal_location!)
+
+        strategy.schedule({ 'jid' => 'new jid' }) {}
       end
 
       it 'drops the job' do
@@ -136,4 +146,46 @@ RSpec.shared_examples 'deduplicating jobs when scheduling' do |strategy_name|
       end
     end
   end
+
+  describe '#perform' do
+    let(:proc) { -> {} }
+    let(:job) { { 'jid' => 'new jid', 'wal_locations' => { 'main' => '0/1234', 'ci' => '0/1234' } } }
+    let(:wal_locations) do
+      {
+        main: '0/D525E3A8',
+        ci: 'AB/12345'
+      }
+    end
+
+    before do
+      allow(fake_duplicate_job).to receive(:delete!)
+      allow(fake_duplicate_job).to receive(:latest_wal_locations).and_return( wal_locations )
+    end
+
+    it 'updates job hash with dedup_wal_locations' do
+      strategy.perform(job) do
+        proc.call
+      end
+
+      expect(job['dedup_wal_locations']).to eq(wal_locations)
+    end
+
+    shared_examples 'does not update job hash' do
+      it 'does not update job hash with dedup_wal_locations' do
+        strategy.perform(job) do
+          proc.call
+        end
+
+        expect(job).not_to include('dedup_wal_locations')
+      end
+    end
+
+    context 'when latest_wal_location is empty' do
+      before do
+        allow(fake_duplicate_job).to receive(:latest_wal_locations).and_return( {} )
+      end
+
+      include_examples 'does not update job hash'
+    end
+  end
 end
diff --git a/spec/support/shared_examples/mailers/notify_shared_examples.rb b/spec/support/shared_examples/mailers/notify_shared_examples.rb
index b10ebb4d2a3..e1f7a9030e2 100644
--- a/spec/support/shared_examples/mailers/notify_shared_examples.rb
+++ b/spec/support/shared_examples/mailers/notify_shared_examples.rb
@@ -2,7 +2,7 @@
 
 RSpec.shared_examples 'a multiple recipients email' do
   it 'is sent to the given recipient' do
-    is_expected.to deliver_to recipient.notification_email
+    is_expected.to deliver_to recipient.notification_email_or_default
   end
 end
 
@@ -21,7 +21,7 @@ end
 
 RSpec.shared_examples 'an email sent to a user' do
   it 'is sent to user\'s global notification email address' do
-    expect(subject).to deliver_to(recipient.notification_email)
+    expect(subject).to deliver_to(recipient.notification_email_or_default)
   end
 
   context 'with group notification email' do
@@ -227,7 +227,7 @@ RSpec.shared_examples 'a note email' do
     aggregate_failures do
       expect(sender.display_name).to eq("#{note_author.name} (@#{note_author.username})")
       expect(sender.address).to eq(gitlab_sender)
-      expect(subject).to deliver_to(recipient.notification_email)
+      expect(subject).to deliver_to(recipient.notification_email_or_default)
     end
   end
 
diff --git a/spec/workers/concerns/worker_attributes_spec.rb b/spec/workers/concerns/worker_attributes_spec.rb
index d4b17c65f46..ad9d5eeccbe 100644
--- a/spec/workers/concerns/worker_attributes_spec.rb
+++ b/spec/workers/concerns/worker_attributes_spec.rb
@@ -35,45 +35,17 @@ RSpec.describe WorkerAttributes do
       end
     end
 
-    context 'when job is idempotent' do
-      context 'when data_consistency is not :always' do
-        it 'raise exception' do
-          worker.idempotent!
-
-          expect { worker.data_consistency(:sticky) }
-            .to raise_error("Class can't be marked as idempotent if data_consistency is not set to :always")
-        end
-      end
-
-      context 'when feature_flag is provided' do
-        before do
-          stub_feature_flags(test_feature_flag: false)
-          skip_feature_flags_yaml_validation
-          skip_default_enabled_yaml_check
-        end
-
-        it 'returns correct feature flag value' do
-          worker.data_consistency(:sticky, feature_flag: :test_feature_flag)
-
-          expect(worker.get_data_consistency_feature_flag_enabled?).not_to be_truthy
-        end
+    context 'when feature_flag is provided' do
+      before do
+        stub_feature_flags(test_feature_flag: false)
+        skip_feature_flags_yaml_validation
+        skip_default_enabled_yaml_check
       end
-    end
-  end
-
-  describe '.idempotent!' do
-    it 'sets `idempotent` attribute of the worker class to true' do
-      worker.idempotent!
 
-      expect(worker.send(:class_attributes)[:idempotent]).to eq(true)
-    end
-
-    context 'when data consistency is not :always' do
-      it 'raise exception' do
-        worker.data_consistency(:sticky)
+      it 'returns correct feature flag value' do
+        worker.data_consistency(:sticky, feature_flag: :test_feature_flag)
 
-        expect { worker.idempotent! }
-          .to raise_error("Class can't be marked as idempotent if data_consistency is not set to :always")
+        expect(worker.get_data_consistency_feature_flag_enabled?).not_to be_truthy
       end
     end
   end