fix(import): backup git only if it exists

Author: Murat

src/__tests__/mocks/mockFs.ts

@@ -1,19 +1,24 @@
 // noinspection JSUnusedGlobalSymbols
 
 import { Constants } from '../../constants';
+import { escapeRegExp } from '../../utils/escapeRegExp';
 
 let store: Record<string, string> = {};
 const permissions = {
   read: true,
   write: true,
 };
 
+function isDirectoryMatch(path: string, directory: string): boolean {
+  return new RegExp(escapeRegExp(directory) + '(?:/|$)', 'i').test(path);
+}
+
 export const mockFs = {
   existsSync: (path: string): boolean =>
-    Object.keys(store).some(key => key.startsWith(path)),
+    Object.keys(store).some(key => isDirectoryMatch(key, path)),
   renameSync: (from: string, to: string) => {
-    Object.keys(store)
-      .filter(([key]) => key.startsWith(from))
+    Object.entries(store)
+      .filter(([key]) => isDirectoryMatch(key, from))
       .forEach(([key, value]) => {
         store[key.replace(from, to)] = value;
         delete store[key];
@@ -43,7 +48,7 @@ export const mockFs = {
   },
   rmdirSync: (_path: string) => {
     Object.keys(store)
-      .filter(key => key.startsWith(_path))
+      .filter(key => isDirectoryMatch(key, _path))
       .forEach(key => delete store[key]);
     return true;
   },
@@ -66,7 +71,7 @@ export const mockFs = {
         isFile: () => true,
         isDirectory: () => false,
       };
-    } else if (Object.keys(store).some(key => key.startsWith(p))) {
+    } else if (Object.keys(store).some(key => isDirectoryMatch(key, p))) {
       return {
         isFile: () => false,
         isDirectory: () => true,

src/__tests__/unit/utils/upgrade/other/importGitFolder.spec.ts

@@ -8,6 +8,10 @@ import { mockFs } from '../../../../mocks/mockFs';
 describe('importGitFolder', () => {
   it('should get .git', async () => {
     mockFs.writeFileSync('/oldProject/.git/some.file', 'random');
+    mockFs.writeFileSync(
+      path.join(getProjectPath(), '.git/new-project.file'),
+      'random'
+    );
 
     const importGetter = importGitFolder('/oldProject') as ImportGetter;
     expect(importGetter).toBeTruthy();
@@ -18,6 +22,9 @@ describe('importGitFolder', () => {
     expect(
       mockFs.readFileSync(path.join(getProjectPath(), '.git/some.file'))
     ).toContain('random');
+    expect(
+      mockFs.existsSync(path.join(getProjectPath(), '.git/new-project.file'))
+    ).toBeFalsy();
   });
   it('should handle errors', () => {
     mockFs.setReadPermission(false);
@@ -32,6 +39,10 @@ describe('importGitFolder', () => {
   });
   it('should handle copy error', async () => {
     mockFs.writeFileSync('/oldProject/.git/some.file', 'random');
+    mockFs.writeFileSync(
+      path.join(getProjectPath(), '.git/new-project.file'),
+      'random'
+    );
 
     mockFs.copyFile.mockImplementationOnce(
       (from: string, to: string, cb: CallableFunction) => {
@@ -40,5 +51,8 @@ describe('importGitFolder', () => {
     );
     const importGetter = importGitFolder('/oldProject') as ImportGetter;
     await expect(importGetter.apply()).rejects.toThrow('random');
+    expect(
+      mockFs.existsSync(path.join(getProjectPath(), '.git/new-project.file'))
+    ).toBeTruthy();
   });
 });

src/utils/upgrade/other/importGitFolder.ts

@@ -35,11 +35,16 @@ export function importGitFolder(projectPath: string): ImportGetter | null {
 }
 
 async function setGitFolder(oldProjectPath: string, files: string[]) {
-  fs.renameSync(
-    path.join(getProjectPath(), Constants.GIT_FOLDER_NAME),
-    path.join(getProjectPath(), Constants.GIT_FOLDER_NAME + '.backup')
+  const shouldBackup = fs.existsSync(
+    path.join(getProjectPath(), Constants.GIT_FOLDER_NAME)
   );
-  logMessage(`backed up ${color.yellow(Constants.GIT_FOLDER_NAME)}`);
+  if (shouldBackup) {
+    fs.renameSync(
+      path.join(getProjectPath(), Constants.GIT_FOLDER_NAME),
+      path.join(getProjectPath(), Constants.GIT_FOLDER_NAME + '.backup')
+    );
+    logMessage(`backed up ${color.yellow(Constants.GIT_FOLDER_NAME)}`);
+  }
 
   startSpinner(`copying ${color.yellow(Constants.GIT_FOLDER_NAME)} files`);
   let success = false;
@@ -67,17 +72,19 @@ async function setGitFolder(oldProjectPath: string, files: string[]) {
     if (success) {
       stopSpinner(`copied ${color.yellow(files.length)} files`);
 
-      startSpinner('cleaning up');
-      await new Promise(r =>
-        fs.rmdir(
-          path.join(getProjectPath(), Constants.GIT_FOLDER_NAME + '.backup'),
-          {
-            recursive: true,
-          },
-          r
-        )
-      );
-      stopSpinner('cleaned up');
+      if (shouldBackup) {
+        startSpinner('cleaning up');
+        await new Promise(r =>
+          fs.rmdir(
+            path.join(getProjectPath(), Constants.GIT_FOLDER_NAME + '.backup'),
+            {
+              recursive: true,
+            },
+            r
+          )
+        );
+        stopSpinner('cleaned up');
+      }
 
       logMessage(`imported ${color.yellow(Constants.GIT_FOLDER_NAME)}`);
     } else {
@@ -93,14 +100,16 @@ async function setGitFolder(oldProjectPath: string, files: string[]) {
         )
       );
 
-      fs.renameSync(
-        path.join(getProjectPath(), Constants.GIT_FOLDER_NAME + '.backup'),
-        path.join(getProjectPath(), Constants.GIT_FOLDER_NAME)
-      );
+      if (shouldBackup) {
+        fs.renameSync(
+          path.join(getProjectPath(), Constants.GIT_FOLDER_NAME + '.backup'),
+          path.join(getProjectPath(), Constants.GIT_FOLDER_NAME)
+        );
 
-      logWarning(
-        `restored ${color.yellow(Constants.GIT_FOLDER_NAME)}, please copy .git folder manually`
-      );
+        logWarning(`restored ${color.yellow(Constants.GIT_FOLDER_NAME)}`);
+      }
+
+      logWarning('please copy .git folder manually');
     }
   }
 }