1 files changed, 284 insertions, 15 deletions

diff --git a/spec/frontend/import_projects/store/mutations_spec.js b/spec/frontend/import_projects/store/mutations_spec.js
index 505545f7aa5..3672ec9f2c0 100644
--- a/spec/frontend/import_projects/store/mutations_spec.js
+++ b/spec/frontend/import_projects/store/mutations_spec.js
@@ -1,34 +1,303 @@
 import * as types from '~/import_projects/store/mutation_types';
 import mutations from '~/import_projects/store/mutations';
+import { STATUSES } from '~/import_projects/constants';
 
 describe('import_projects store mutations', () => {
-  describe(`${types.RECEIVE_IMPORT_SUCCESS}`, () => {
-    it('removes repoId from reposBeingImported and providerRepos, adds to importedProjects', () => {
-      const repoId = 1;
-      const state = {
-        reposBeingImported: [repoId],
-        providerRepos: [{ id: repoId }],
+  let state;
+  const SOURCE_PROJECT = {
+    id: 1,
+    full_name: 'full/name',
+    sanitized_name: 'name',
+    provider_link: 'https://demo.link/full/name',
+  };
+  const IMPORTED_PROJECT = {
+    name: 'demo',
+    importSource: 'something',
+    providerLink: 'custom-link',
+    importStatus: 'status',
+    fullName: 'fullName',
+  };
+
+  describe(`${types.SET_FILTER}`, () => {
+    it('overwrites current filter value', () => {
+      state = { filter: 'some-value' };
+      const NEW_VALUE = 'new-value';
+
+      mutations[types.SET_FILTER](state, NEW_VALUE);
+
+      expect(state.filter).toBe(NEW_VALUE);
+    });
+  });
+
+  describe(`${types.REQUEST_REPOS}`, () => {
+    it('sets repos loading flag to true', () => {
+      state = {};
+
+      mutations[types.REQUEST_REPOS](state);
+
+      expect(state.isLoadingRepos).toBe(true);
+    });
+  });
+
+  describe(`${types.RECEIVE_REPOS_SUCCESS}`, () => {
+    describe('for imported projects', () => {
+      const response = {
+        importedProjects: [IMPORTED_PROJECT],
+        providerRepos: [],
+      };
+
+      it('picks import status from response', () => {
+        state = {};
+
+        mutations[types.RECEIVE_REPOS_SUCCESS](state, response);
+
+        expect(state.repositories[0].importStatus).toBe(IMPORTED_PROJECT.importStatus);
+      });
+
+      it('recreates importSource from response', () => {
+        state = {};
+
+        mutations[types.RECEIVE_REPOS_SUCCESS](state, response);
+
+        expect(state.repositories[0].importSource).toStrictEqual(
+          expect.objectContaining({
+            fullName: IMPORTED_PROJECT.importSource,
+            sanitizedName: IMPORTED_PROJECT.name,
+            providerLink: IMPORTED_PROJECT.providerLink,
+          }),
+        );
+      });
+
+      it('passes project to importProject', () => {
+        state = {};
+
+        mutations[types.RECEIVE_REPOS_SUCCESS](state, response);
+
+        expect(IMPORTED_PROJECT).toStrictEqual(
+          expect.objectContaining(state.repositories[0].importedProject),
+        );
+      });
+    });
+
+    describe('for importable projects', () => {
+      beforeEach(() => {
+        state = {};
+        const response = {
+          importedProjects: [],
+          providerRepos: [SOURCE_PROJECT],
+        };
+        mutations[types.RECEIVE_REPOS_SUCCESS](state, response);
+      });
+
+      it('sets import status to none', () => {
+        expect(state.repositories[0].importStatus).toBe(STATUSES.NONE);
+      });
+
+      it('sets importSource to project', () => {
+        expect(state.repositories[0].importSource).toBe(SOURCE_PROJECT);
+      });
+    });
+
+    describe('for incompatible projects', () => {
+      const response = {
         importedProjects: [],
+        providerRepos: [],
+        incompatibleRepos: [SOURCE_PROJECT],
       };
-      const importedProject = { id: repoId };
 
-      mutations[types.RECEIVE_IMPORT_SUCCESS](state, { importedProject, repoId });
+      beforeEach(() => {
+        state = {};
+        mutations[types.RECEIVE_REPOS_SUCCESS](state, response);
+      });
+
+      it('sets incompatible flag', () => {
+        expect(state.repositories[0].importSource.incompatible).toBe(true);
+      });
+
+      it('sets importSource to project', () => {
+        expect(state.repositories[0].importSource).toStrictEqual(
+          expect.objectContaining(SOURCE_PROJECT),
+        );
+      });
+    });
+
+    it('sets repos loading flag to false', () => {
+      const response = {
+        importedProjects: [],
+        providerRepos: [],
+      };
+      state = {};
+
+      mutations[types.RECEIVE_REPOS_SUCCESS](state, response);
+
+      expect(state.isLoadingRepos).toBe(false);
+    });
+  });
+
+  describe(`${types.RECEIVE_REPOS_ERROR}`, () => {
+    it('sets repos loading flag to false', () => {
+      state = {};
+
+      mutations[types.RECEIVE_REPOS_ERROR](state);
+
+      expect(state.isLoadingRepos).toBe(false);
+    });
+  });
+
+  describe(`${types.REQUEST_IMPORT}`, () => {
+    beforeEach(() => {
+      const REPO_ID = 1;
+      const importTarget = { targetNamespace: 'ns', newName: 'name ' };
+      state = { repositories: [{ importSource: { id: REPO_ID } }] };
+
+      mutations[types.REQUEST_IMPORT](state, { repoId: REPO_ID, importTarget });
+    });
+
+    it(`sets status to ${STATUSES.SCHEDULING}`, () => {
+      expect(state.repositories[0].importStatus).toBe(STATUSES.SCHEDULING);
+    });
+  });
+
+  describe(`${types.RECEIVE_IMPORT_SUCCESS}`, () => {
+    beforeEach(() => {
+      const REPO_ID = 1;
+      state = { repositories: [{ importSource: { id: REPO_ID } }] };
+
+      mutations[types.RECEIVE_IMPORT_SUCCESS](state, {
+        repoId: REPO_ID,
+        importedProject: IMPORTED_PROJECT,
+      });
+    });
 
-      expect(state.reposBeingImported.includes(repoId)).toBe(false);
-      expect(state.providerRepos.some(repo => repo.id === repoId)).toBe(false);
-      expect(state.importedProjects.some(repo => repo.id === repoId)).toBe(true);
+    it('sets import status', () => {
+      expect(state.repositories[0].importStatus).toBe(IMPORTED_PROJECT.importStatus);
+    });
+
+    it('sets imported project', () => {
+      expect(IMPORTED_PROJECT).toStrictEqual(
+        expect.objectContaining(state.repositories[0].importedProject),
+      );
+    });
+  });
+
+  describe(`${types.RECEIVE_IMPORT_ERROR}`, () => {
+    beforeEach(() => {
+      const REPO_ID = 1;
+      state = { repositories: [{ importSource: { id: REPO_ID } }] };
+
+      mutations[types.RECEIVE_IMPORT_ERROR](state, REPO_ID);
+    });
+
+    it(`resets import status to ${STATUSES.NONE}`, () => {
+      expect(state.repositories[0].importStatus).toBe(STATUSES.NONE);
     });
   });
 
   describe(`${types.RECEIVE_JOBS_SUCCESS}`, () => {
-    it('updates importStatus of existing importedProjects', () => {
+    it('updates import status of existing project', () => {
       const repoId = 1;
-      const state = { importedProjects: [{ id: repoId, importStatus: 'started' }] };
-      const updatedProjects = [{ id: repoId, importStatus: 'finished' }];
+      state = {
+        repositories: [{ importedProject: { id: repoId }, importStatus: STATUSES.STARTED }],
+      };
+      const updatedProjects = [{ id: repoId, importStatus: STATUSES.FINISHED }];
 
       mutations[types.RECEIVE_JOBS_SUCCESS](state, updatedProjects);
 
-      expect(state.importedProjects[0].importStatus).toBe(updatedProjects[0].importStatus);
+      expect(state.repositories[0].importStatus).toBe(updatedProjects[0].importStatus);
+    });
+  });
+
+  describe(`${types.REQUEST_NAMESPACES}`, () => {
+    it('sets namespaces loading flag to true', () => {
+      state = {};
+
+      mutations[types.REQUEST_NAMESPACES](state);
+
+      expect(state.isLoadingNamespaces).toBe(true);
+    });
+  });
+
+  describe(`${types.RECEIVE_NAMESPACES_SUCCESS}`, () => {
+    const response = [{ fullPath: 'some/path' }];
+
+    beforeEach(() => {
+      state = {};
+      mutations[types.RECEIVE_NAMESPACES_SUCCESS](state, response);
+    });
+
+    it('stores namespaces to state', () => {
+      expect(state.namespaces).toStrictEqual(response);
+    });
+
+    it('sets namespaces loading flag to false', () => {
+      expect(state.isLoadingNamespaces).toBe(false);
+    });
+  });
+
+  describe(`${types.RECEIVE_NAMESPACES_ERROR}`, () => {
+    it('sets namespaces loading flag to false', () => {
+      state = {};
+
+      mutations[types.RECEIVE_NAMESPACES_ERROR](state);
+
+      expect(state.isLoadingNamespaces).toBe(false);
+    });
+  });
+
+  describe(`${types.SET_IMPORT_TARGET}`, () => {
+    const PROJECT = {
+      id: 2,
+      sanitizedName: 'sanitizedName',
+    };
+
+    it('stores custom target if it differs from defaults', () => {
+      state = { customImportTargets: {}, repositories: [{ importSource: PROJECT }] };
+      const importTarget = { targetNamespace: 'ns', newName: 'name ' };
+
+      mutations[types.SET_IMPORT_TARGET](state, { repoId: PROJECT.id, importTarget });
+      expect(state.customImportTargets[PROJECT.id]).toBe(importTarget);
+    });
+
+    it('removes custom target if it is equal to defaults', () => {
+      const importTarget = { targetNamespace: 'ns', newName: 'name ' };
+      state = {
+        defaultTargetNamespace: 'default',
+        customImportTargets: {
+          [PROJECT.id]: importTarget,
+        },
+        repositories: [{ importSource: PROJECT }],
+      };
+
+      mutations[types.SET_IMPORT_TARGET](state, {
+        repoId: PROJECT.id,
+        importTarget: {
+          targetNamespace: state.defaultTargetNamespace,
+          newName: PROJECT.sanitizedName,
+        },
+      });
+
+      expect(state.customImportTargets[SOURCE_PROJECT.id]).toBeUndefined();
+    });
+  });
+
+  describe(`${types.SET_PAGE_INFO}`, () => {
+    it('sets passed page info', () => {
+      state = {};
+      const pageInfo = { page: 1, total: 10 };
+
+      mutations[types.SET_PAGE_INFO](state, pageInfo);
+
+      expect(state.pageInfo).toBe(pageInfo);
+    });
+  });
+
+  describe(`${types.SET_PAGE}`, () => {
+    it('sets page number', () => {
+      const NEW_PAGE = 4;
+      state = { pageInfo: { page: 5 } };
+
+      mutations[types.SET_PAGE](state, NEW_PAGE);
+      expect(state.pageInfo.page).toBe(NEW_PAGE);
     });
   });
 });