Add latest changes from gitlab-org/gitlab@13-12-stable-eev13.12.0-rc42

1 files changed, 182 insertions, 49 deletions

diff --git a/spec/frontend/import_entities/import_groups/graphql/client_factory_spec.js b/spec/frontend/import_entities/import_groups/graphql/client_factory_spec.js
index 1feff861c1e..ef83c9ebbc4 100644
--- a/spec/frontend/import_entities/import_groups/graphql/client_factory_spec.js
+++ b/spec/frontend/import_entities/import_groups/graphql/client_factory_spec.js
@@ -8,10 +8,15 @@ import {
   clientTypenames,
   createResolvers,
 } from '~/import_entities/import_groups/graphql/client_factory';
-import importGroupMutation from '~/import_entities/import_groups/graphql/mutations/import_group.mutation.graphql';
+import addValidationErrorMutation from '~/import_entities/import_groups/graphql/mutations/add_validation_error.mutation.graphql';
+import importGroupsMutation from '~/import_entities/import_groups/graphql/mutations/import_groups.mutation.graphql';
+import removeValidationErrorMutation from '~/import_entities/import_groups/graphql/mutations/remove_validation_error.mutation.graphql';
+import setImportProgressMutation from '~/import_entities/import_groups/graphql/mutations/set_import_progress.mutation.graphql';
 import setNewNameMutation from '~/import_entities/import_groups/graphql/mutations/set_new_name.mutation.graphql';
 import setTargetNamespaceMutation from '~/import_entities/import_groups/graphql/mutations/set_target_namespace.mutation.graphql';
+import updateImportStatusMutation from '~/import_entities/import_groups/graphql/mutations/update_import_status.mutation.graphql';
 import availableNamespacesQuery from '~/import_entities/import_groups/graphql/queries/available_namespaces.query.graphql';
+import bulkImportSourceGroupQuery from '~/import_entities/import_groups/graphql/queries/bulk_import_source_group.query.graphql';
 import bulkImportSourceGroupsQuery from '~/import_entities/import_groups/graphql/queries/bulk_import_source_groups.query.graphql';
 import { StatusPoller } from '~/import_entities/import_groups/graphql/services/status_poller';
 
@@ -78,6 +83,31 @@ describe('Bulk import resolvers', () => {
       });
     });
 
+    describe('bulkImportSourceGroup', () => {
+      beforeEach(async () => {
+        axiosMockAdapter.onGet(FAKE_ENDPOINTS.status).reply(httpStatus.OK, statusEndpointFixture);
+        axiosMockAdapter
+          .onGet(FAKE_ENDPOINTS.availableNamespaces)
+          .reply(httpStatus.OK, availableNamespacesFixture);
+
+        return client.query({
+          query: bulkImportSourceGroupsQuery,
+        });
+      });
+
+      it('returns group', async () => {
+        const { id } = statusEndpointFixture.importable_data[0];
+        const {
+          data: { bulkImportSourceGroup: group },
+        } = await client.query({
+          query: bulkImportSourceGroupQuery,
+          variables: { id: id.toString() },
+        });
+
+        expect(group).toMatchObject(statusEndpointFixture.importable_data[0]);
+      });
+    });
+
     describe('bulkImportSourceGroups', () => {
       let results;
 
@@ -89,8 +119,12 @@ describe('Bulk import resolvers', () => {
       });
 
       it('respects cached import state when provided by group manager', async () => {
+        const FAKE_JOB_ID = '1';
         const FAKE_STATUS = 'DEMO_STATUS';
-        const FAKE_IMPORT_TARGET = {};
+        const FAKE_IMPORT_TARGET = {
+          new_name: 'test-name',
+          target_namespace: 'test-namespace',
+        };
         const TARGET_INDEX = 0;
 
         const clientWithMockedManager = createClient({
@@ -98,8 +132,11 @@ describe('Bulk import resolvers', () => {
             getImportStateFromStorageByGroupId(groupId) {
               if (groupId === statusEndpointFixture.importable_data[TARGET_INDEX].id) {
                 return {
-                  status: FAKE_STATUS,
-                  importTarget: FAKE_IMPORT_TARGET,
+                  jobId: FAKE_JOB_ID,
+                  importState: {
+                    status: FAKE_STATUS,
+                    importTarget: FAKE_IMPORT_TARGET,
+                  },
                 };
               }
 
@@ -113,8 +150,8 @@ describe('Bulk import resolvers', () => {
         });
         const clientResults = clientResponse.data.bulkImportSourceGroups.nodes;
 
-        expect(clientResults[TARGET_INDEX].import_target).toBe(FAKE_IMPORT_TARGET);
-        expect(clientResults[TARGET_INDEX].status).toBe(FAKE_STATUS);
+        expect(clientResults[TARGET_INDEX].import_target).toStrictEqual(FAKE_IMPORT_TARGET);
+        expect(clientResults[TARGET_INDEX].progress.status).toBe(FAKE_STATUS);
       });
 
       it('populates each result instance with empty import_target when there are no available namespaces', async () => {
@@ -143,8 +180,8 @@ describe('Bulk import resolvers', () => {
           ).toBe(true);
         });
 
-        it('populates each result instance with status field default to none', () => {
-          expect(results.every((r) => r.status === STATUSES.NONE)).toBe(true);
+        it('populates each result instance with status default to none', () => {
+          expect(results.every((r) => r.progress.status === STATUSES.NONE)).toBe(true);
         });
 
         it('populates each result instance with import_target defaulted to first available namespace', () => {
@@ -183,7 +220,6 @@ describe('Bulk import resolvers', () => {
   });
 
   describe('mutations', () => {
-    let results;
     const GROUP_ID = 1;
 
     beforeEach(() => {
@@ -195,7 +231,10 @@ describe('Bulk import resolvers', () => {
               {
                 __typename: clientTypenames.BulkImportSourceGroup,
                 id: GROUP_ID,
-                status: STATUSES.NONE,
+                progress: {
+                  id: `test-${GROUP_ID}`,
+                  status: STATUSES.NONE,
+                },
                 web_url: 'https://fake.host/1',
                 full_path: 'fake_group_1',
                 full_name: 'fake_name_1',
@@ -203,6 +242,7 @@ describe('Bulk import resolvers', () => {
                   target_namespace: 'root',
                   new_name: 'group1',
                 },
+                validation_errors: [],
               },
             ],
             pageInfo: {
@@ -214,35 +254,42 @@ describe('Bulk import resolvers', () => {
           },
         },
       });
-
-      client
-        .watchQuery({
-          query: bulkImportSourceGroupsQuery,
-          fetchPolicy: 'cache-only',
-        })
-        .subscribe(({ data }) => {
-          results = data.bulkImportSourceGroups.nodes;
-        });
     });
 
     it('setTargetNamespaces updates group target namespace', async () => {
       const NEW_TARGET_NAMESPACE = 'target';
-      await client.mutate({
+      const {
+        data: {
+          setTargetNamespace: {
+            id: idInResponse,
+            import_target: { target_namespace: namespaceInResponse },
+          },
+        },
+      } = await client.mutate({
         mutation: setTargetNamespaceMutation,
         variables: { sourceGroupId: GROUP_ID, targetNamespace: NEW_TARGET_NAMESPACE },
       });
 
-      expect(results[0].import_target.target_namespace).toBe(NEW_TARGET_NAMESPACE);
+      expect(idInResponse).toBe(GROUP_ID);
+      expect(namespaceInResponse).toBe(NEW_TARGET_NAMESPACE);
     });
 
     it('setNewName updates group target name', async () => {
       const NEW_NAME = 'new';
-      await client.mutate({
+      const {
+        data: {
+          setNewName: {
+            id: idInResponse,
+            import_target: { new_name: nameInResponse },
+          },
+        },
+      } = await client.mutate({
         mutation: setNewNameMutation,
         variables: { sourceGroupId: GROUP_ID, newName: NEW_NAME },
       });
 
-      expect(results[0].import_target.new_name).toBe(NEW_NAME);
+      expect(idInResponse).toBe(GROUP_ID);
+      expect(nameInResponse).toBe(NEW_NAME);
     });
 
     describe('importGroup', () => {
@@ -250,8 +297,8 @@ describe('Bulk import resolvers', () => {
         axiosMockAdapter.onPost(FAKE_ENDPOINTS.createBulkImport).reply(() => new Promise(() => {}));
 
         client.mutate({
-          mutation: importGroupMutation,
-          variables: { sourceGroupId: GROUP_ID },
+          mutation: importGroupsMutation,
+          variables: { sourceGroupIds: [GROUP_ID] },
         });
         await waitForPromises();
 
@@ -261,33 +308,49 @@ describe('Bulk import resolvers', () => {
           query: bulkImportSourceGroupsQuery,
         });
 
-        expect(intermediateResults[0].status).toBe(STATUSES.SCHEDULING);
+        expect(intermediateResults[0].progress.status).toBe(STATUSES.SCHEDULING);
       });
 
-      it('sets import status to CREATED when request completes', async () => {
-        axiosMockAdapter.onPost(FAKE_ENDPOINTS.createBulkImport).reply(httpStatus.OK, { id: 1 });
-        await client.mutate({
-          mutation: importGroupMutation,
-          variables: { sourceGroupId: GROUP_ID },
+      describe('when request completes', () => {
+        let results;
+
+        beforeEach(() => {
+          client
+            .watchQuery({
+              query: bulkImportSourceGroupsQuery,
+              fetchPolicy: 'cache-only',
+            })
+            .subscribe(({ data }) => {
+              results = data.bulkImportSourceGroups.nodes;
+            });
         });
 
-        expect(results[0].status).toBe(STATUSES.CREATED);
-      });
+        it('sets import status to CREATED when request completes', async () => {
+          axiosMockAdapter.onPost(FAKE_ENDPOINTS.createBulkImport).reply(httpStatus.OK, { id: 1 });
+          await client.mutate({
+            mutation: importGroupsMutation,
+            variables: { sourceGroupIds: [GROUP_ID] },
+          });
+          await waitForPromises();
 
-      it('resets status to NONE if request fails', async () => {
-        axiosMockAdapter
-          .onPost(FAKE_ENDPOINTS.createBulkImport)
-          .reply(httpStatus.INTERNAL_SERVER_ERROR);
+          expect(results[0].progress.status).toBe(STATUSES.CREATED);
+        });
 
-        client
-          .mutate({
-            mutation: importGroupMutation,
-            variables: { sourceGroupId: GROUP_ID },
-          })
-          .catch(() => {});
-        await waitForPromises();
+        it('resets status to NONE if request fails', async () => {
+          axiosMockAdapter
+            .onPost(FAKE_ENDPOINTS.createBulkImport)
+            .reply(httpStatus.INTERNAL_SERVER_ERROR);
+
+          client
+            .mutate({
+              mutation: [importGroupsMutation],
+              variables: { sourceGroupIds: [GROUP_ID] },
+            })
+            .catch(() => {});
+          await waitForPromises();
 
-        expect(results[0].status).toBe(STATUSES.NONE);
+          expect(results[0].progress.status).toBe(STATUSES.NONE);
+        });
       });
 
       it('shows default error message when server error is not provided', async () => {
@@ -297,8 +360,8 @@ describe('Bulk import resolvers', () => {
 
         client
           .mutate({
-            mutation: importGroupMutation,
-            variables: { sourceGroupId: GROUP_ID },
+            mutation: importGroupsMutation,
+            variables: { sourceGroupIds: [GROUP_ID] },
           })
           .catch(() => {});
         await waitForPromises();
@@ -315,8 +378,8 @@ describe('Bulk import resolvers', () => {
 
         client
           .mutate({
-            mutation: importGroupMutation,
-            variables: { sourceGroupId: GROUP_ID },
+            mutation: importGroupsMutation,
+            variables: { sourceGroupIds: [GROUP_ID] },
           })
           .catch(() => {});
         await waitForPromises();
@@ -324,5 +387,75 @@ describe('Bulk import resolvers', () => {
         expect(createFlash).toHaveBeenCalledWith({ message: CUSTOM_MESSAGE });
       });
     });
+
+    it('setImportProgress updates group progress', async () => {
+      const NEW_STATUS = 'dummy';
+      const FAKE_JOB_ID = 5;
+      const {
+        data: {
+          setImportProgress: { progress },
+        },
+      } = await client.mutate({
+        mutation: setImportProgressMutation,
+        variables: { sourceGroupId: GROUP_ID, status: NEW_STATUS, jobId: FAKE_JOB_ID },
+      });
+
+      expect(progress).toMatchObject({
+        id: FAKE_JOB_ID,
+        status: NEW_STATUS,
+      });
+    });
+
+    it('updateImportStatus returns new status', async () => {
+      const NEW_STATUS = 'dummy';
+      const FAKE_JOB_ID = 5;
+      const {
+        data: { updateImportStatus: statusInResponse },
+      } = await client.mutate({
+        mutation: updateImportStatusMutation,
+        variables: { id: FAKE_JOB_ID, status: NEW_STATUS },
+      });
+
+      expect(statusInResponse).toMatchObject({
+        id: FAKE_JOB_ID,
+        status: NEW_STATUS,
+      });
+    });
+
+    it('addValidationError adds error to group', async () => {
+      const FAKE_FIELD = 'some-field';
+      const FAKE_MESSAGE = 'some-message';
+      const {
+        data: {
+          addValidationError: { validation_errors: validationErrors },
+        },
+      } = await client.mutate({
+        mutation: addValidationErrorMutation,
+        variables: { sourceGroupId: GROUP_ID, field: FAKE_FIELD, message: FAKE_MESSAGE },
+      });
+
+      expect(validationErrors).toMatchObject([{ field: FAKE_FIELD, message: FAKE_MESSAGE }]);
+    });
+
+    it('removeValidationError removes error from group', async () => {
+      const FAKE_FIELD = 'some-field';
+      const FAKE_MESSAGE = 'some-message';
+
+      await client.mutate({
+        mutation: addValidationErrorMutation,
+        variables: { sourceGroupId: GROUP_ID, field: FAKE_FIELD, message: FAKE_MESSAGE },
+      });
+
+      const {
+        data: {
+          removeValidationError: { validation_errors: validationErrors },
+        },
+      } = await client.mutate({
+        mutation: removeValidationErrorMutation,
+        variables: { sourceGroupId: GROUP_ID, field: FAKE_FIELD },
+      });
+
+      expect(validationErrors).toMatchObject([]);
+    });
   });
 });