Fix: Update the unit test cases

Author: cs-raj

packages/contentstack-import/test/unit/import/module-importer.test.ts

@@ -509,7 +509,8 @@ describe('ModuleImporter', () => {
 
         await importer.start();
 
-        expect(importer['stackAPIClient'].locale.calledOnce).to.be.true;
+        expect(masterLocalDetailsStub.calledOnce).to.be.true;
+        expect(masterLocalDetailsStub.firstCall.args[0]).to.equal(importer['stackAPIClient']);
         expect(importer['importConfig'].master_locale).to.deep.equal({ code: 'en-us' });
         expect(importer['importConfig'].masterLocale).to.deep.equal({ code: 'en-us' });
       });
@@ -534,13 +535,7 @@ describe('ModuleImporter', () => {
 
       it('should set both master_locale and masterLocale', async () => {
         mockImportConfig.master_locale = undefined;
-
-        const localeMock = {
-          query: sandbox.stub().returnsThis(),
-          find: sandbox.stub().resolves({ items: [{ code: 'de-de' }] }),
-        };
-        mockStackClient.locale = sandbox.stub().returns(localeMock);
-        mockStackClient._localeMock = localeMock;
+        masterLocalDetailsStub.resolves({ code: 'de-de' });
 
         const importer = new ModuleImporter(mockManagementClient as any, mockImportConfig);
 
@@ -552,23 +547,19 @@ describe('ModuleImporter', () => {
 
       it('should handle error when masterLocalDetails fails', async () => {
         mockImportConfig.master_locale = undefined;
-
-        const localeMock = {
-          query: sandbox.stub().returnsThis(),
-          find: sandbox.stub().rejects(new Error('Master locale fetch failed')),
-        };
-        mockStackClient.locale = sandbox.stub().returns(localeMock);
-        mockStackClient._localeMock = localeMock;
+        masterLocalDetailsStub.rejects(new Error('Master locale fetch failed'));
 
         const importer = new ModuleImporter(mockManagementClient as any, mockImportConfig);
 
+        let caught: unknown;
         try {
           await importer.start();
-          expect.fail('Should have thrown an error');
-        } catch (error: any) {
-          expect(error).to.be.an('error');
-          expect(error.message).to.equal('Master locale fetch failed');
+        } catch (e) {
+          caught = e;
         }
+
+        expect(caught).to.be.instanceOf(Error);
+        expect((caught as Error).message).to.equal('Master locale fetch failed');
       });
     });
 

packages/contentstack-import/test/unit/utils/backup-handler.test.ts

@@ -14,7 +14,6 @@ describe('Backup Handler', () => {
   let cliuxStub: any;
   let tempDir: string;
   let sourceDir: string;
-  let backupDir: string;
   let originalCwd: string;
   let processCwdStub: sinon.SinonStub;
 
@@ -27,7 +26,6 @@ describe('Backup Handler', () => {
     // In CI, os.tmpdir() returns a safe temp directory that's cleaned up automatically
     tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'backup-handler-test-'));
     sourceDir = path.join(tempDir, 'source');
-    backupDir = path.join(tempDir, 'backup');
 
     // Stub process.cwd() to return tempDir so backups are created there, not in actual working directory
     // This is critical for CI - prevents creating files in the workspace during tests
@@ -47,7 +45,6 @@ describe('Backup Handler', () => {
         module: 'all',
       },
       masterLocale: { code: 'en-us' },
-      backupDir: backupDir,
       region: 'us',
       modules: {} as any,
       host: 'https://api.contentstack.io',
@@ -132,25 +129,7 @@ describe('Backup Handler', () => {
       expect(logStub.debug.calledWith(`Using existing backup directory: ${existingBackupPath}`)).to.be.true;
     });
 
-    it('should use branchDir over contentDir when both are provided', async () => {
-      const branchDir = path.join(tempDir, 'branch');
-      fs.mkdirSync(branchDir);
-      fs.writeFileSync(path.join(branchDir, 'branch-file.json'), '{}');
-
-      const config = {
-        ...mockImportConfig,
-        branchDir: branchDir,
-        contentDir: sourceDir,
-      };
-
-      const result = await backupHandler(config);
-
-      expect(result).to.be.a('string');
-      expect(fs.existsSync(result)).to.be.true;
-      expect(logStub.debug.called).to.be.true;
-    });
-
-    it('should use contentDir when branchDir is not provided', async () => {
+    it('should copy from contentDir', async () => {
       const config = {
         ...mockImportConfig,
         contentDir: sourceDir,

packages/contentstack-import/test/unit/utils/import-config-handler.test.ts

@@ -332,7 +332,7 @@ describe('Import Config Handler', () => {
       expect(result.branchAlias).to.equal('my-branch');
     });
 
-    it('should set branchName and branchDir from branch flag', async () => {
+    it('should set branchName from branch flag', async () => {
       const importCmdFlags = {
         data: '/test/content',
         branch: 'my-branch',
@@ -341,7 +341,7 @@ describe('Import Config Handler', () => {
       const result = await setupConfig(importCmdFlags);
 
       expect(result.branchName).to.equal('my-branch');
-      expect(result.branchDir).to.equal(path.resolve('/test/content'));
+      expect(result.contentDir).to.equal(path.resolve('/test/content'));
     });
 
     it('should set moduleName and singleModuleImport from module flag', async () => {

packages/contentstack-import/test/unit/utils/import-path-resolver.test.ts

@@ -2,35 +2,25 @@ import { expect } from 'chai';
 import sinon from 'sinon';
 import * as path from 'path';
 import {
-  selectBranchFromDirectory,
   resolveImportPath,
   updateImportConfigWithResolvedPath,
   executeImportPathLogic,
 } from '../../../src/utils/import-path-resolver';
 import { ImportConfig } from '../../../src/types';
 import * as fileHelper from '../../../src/utils/file-helper';
-import * as interactive from '../../../src/utils/interactive';
 import * as cliUtilities from '@contentstack/cli-utilities';
 import defaultConfig from '../../../src/config';
 
 describe('Import Path Resolver', () => {
   let sandbox: sinon.SinonSandbox;
   let fileExistsSyncStub: sinon.SinonStub;
-  let readFileStub: sinon.SinonStub;
-  let askBranchSelectionStub: sinon.SinonStub;
   let logStub: any;
 
   beforeEach(() => {
     sandbox = sinon.createSandbox();
 
-    // Mock file-helper
     fileExistsSyncStub = sandbox.stub(fileHelper, 'fileExistsSync');
-    readFileStub = sandbox.stub(fileHelper, 'readFile');
 
-    // Mock interactive
-    askBranchSelectionStub = sandbox.stub(interactive, 'askBranchSelection');
-
-    // Mock log
     logStub = {
       debug: sandbox.stub(),
       warn: sandbox.stub(),
@@ -43,95 +33,6 @@ describe('Import Path Resolver', () => {
     sandbox.restore();
   });
 
-  describe('selectBranchFromDirectory', () => {
-    const contentDir = '/test/content';
-
-    it('should return null when branches.json does not exist', async () => {
-      const branchesJsonPath = path.join(contentDir, 'branches.json');
-      fileExistsSyncStub.withArgs(branchesJsonPath).returns(false);
-
-      const result = await selectBranchFromDirectory(contentDir);
-
-      expect(result).to.be.null;
-      expect(fileExistsSyncStub.calledWith(branchesJsonPath)).to.be.true;
-      expect(readFileStub.called).to.be.false;
-    });
-
-    it('should return null when branches.json is empty array', async () => {
-      const branchesJsonPath = path.join(contentDir, 'branches.json');
-      fileExistsSyncStub.withArgs(branchesJsonPath).returns(true);
-      readFileStub.withArgs(branchesJsonPath).resolves([]);
-
-      const result = await selectBranchFromDirectory(contentDir);
-
-      expect(result).to.be.null;
-    });
-
-    it('should return null when branches.json is not an array', async () => {
-      const branchesJsonPath = path.join(contentDir, 'branches.json');
-      fileExistsSyncStub.withArgs(branchesJsonPath).returns(true);
-      readFileStub.withArgs(branchesJsonPath).resolves({ invalid: 'data' });
-
-      const result = await selectBranchFromDirectory(contentDir);
-
-      expect(result).to.be.null;
-    });
-
-    it('should return null when branches.json is null', async () => {
-      const branchesJsonPath = path.join(contentDir, 'branches.json');
-      fileExistsSyncStub.withArgs(branchesJsonPath).returns(true);
-      readFileStub.withArgs(branchesJsonPath).resolves(null);
-
-      const result = await selectBranchFromDirectory(contentDir);
-
-      expect(result).to.be.null;
-    });
-
-    it('should return branchName for single branch (content at root)', async () => {
-      const branchesJsonPath = path.join(contentDir, 'branches.json');
-      const branchesData = [{ uid: 'branch1' }];
-
-      fileExistsSyncStub.withArgs(branchesJsonPath).returns(true);
-      readFileStub.withArgs(branchesJsonPath).resolves(branchesData);
-
-      const result = await selectBranchFromDirectory(contentDir);
-
-      expect(result).to.deep.equal({ branchName: 'branch1' });
-      expect(askBranchSelectionStub.called).to.be.false;
-    });
-
-    it('should prompt user when multiple branches exist and return selected branchName', async () => {
-      const branchesJsonPath = path.join(contentDir, 'branches.json');
-      const branchesData = [{ uid: 'branch1' }, { uid: 'branch2' }, { uid: 'branch3' }];
-
-      fileExistsSyncStub.withArgs(branchesJsonPath).returns(true);
-      readFileStub.withArgs(branchesJsonPath).resolves(branchesData);
-      askBranchSelectionStub.withArgs(['branch1', 'branch2', 'branch3']).resolves('branch2');
-
-      const result = await selectBranchFromDirectory(contentDir);
-
-      expect(result).to.deep.equal({ branchName: 'branch2' });
-      expect(askBranchSelectionStub.calledOnce).to.be.true;
-      expect(askBranchSelectionStub.calledWith(['branch1', 'branch2', 'branch3'])).to.be.true;
-    });
-
-    it('should throw error when readFile fails', async () => {
-      const branchesJsonPath = path.join(contentDir, 'branches.json');
-      const error = new Error('Read file error');
-
-      fileExistsSyncStub.withArgs(branchesJsonPath).returns(true);
-      readFileStub.withArgs(branchesJsonPath).rejects(error);
-
-      try {
-        await selectBranchFromDirectory(contentDir);
-        expect.fail('Should have thrown an error');
-      } catch (err: any) {
-        expect(err).to.equal(error);
-        expect(logStub.error.called).to.be.true;
-      }
-    });
-  });
-
   describe('resolveImportPath', () => {
     let mockConfig: ImportConfig;
     let mockStackAPIClient: any;
@@ -155,83 +56,26 @@ describe('Import Path Resolver', () => {
       }
     });
 
-    it('should use contentDir from importConfig when set', async () => {
-      mockConfig.contentDir = '/test/data';
-      fileExistsSyncStub.withArgs('/test/data').returns(true);
-
-      // Mock module types check
-      defaultConfig.modules.types.forEach((moduleType) => {
-        fileExistsSyncStub.withArgs(path.join('/test/data', moduleType)).returns(false);
-      });
-
-      const result = await resolveImportPath(mockConfig, mockStackAPIClient);
-
-      expect(result).to.equal('/test/data');
-    });
-
-    it('should return contentDir when branchName matches current directory name', async () => {
-      mockConfig.branchName = 'content';
-      fileExistsSyncStub.withArgs('/test/content').returns(true);
-
-      const result = await resolveImportPath(mockConfig, mockStackAPIClient);
-
-      expect(result).to.equal('/test/content');
-    });
-
-    it('should return contentDir when branchName is specified (content always at root)', async () => {
-      mockConfig.branchName = 'branch1';
+    it('should return contentDir when module folders exist at export root', async () => {
       fileExistsSyncStub.withArgs('/test/content').returns(true);
-
-      const result = await resolveImportPath(mockConfig, mockStackAPIClient);
-
-      expect(result).to.equal('/test/content');
-    });
-
-    it('should return contentDir when module folders exist', async () => {
       const modulePath = path.join('/test/content', defaultConfig.modules.types[0]);
-
-      fileExistsSyncStub.withArgs('/test/content').returns(true);
       fileExistsSyncStub.withArgs(modulePath).returns(true);
 
       const result = await resolveImportPath(mockConfig, mockStackAPIClient);
 
       expect(result).to.equal('/test/content');
     });
 
-    it('should use contentDir and set branchName from selectBranchFromDirectory when no branch name', async () => {
-      fileExistsSyncStub.withArgs('/test/content').returns(true);
-
-      // Mock module types check - all return false
-      defaultConfig.modules.types.forEach((moduleType) => {
-        fileExistsSyncStub.withArgs(path.join('/test/content', moduleType)).returns(false);
-      });
-
-      // Mock branches.json - single branch
-      const branchesJsonPath = path.join('/test/content', 'branches.json');
-      fileExistsSyncStub.withArgs(branchesJsonPath).returns(true);
-      readFileStub.withArgs(branchesJsonPath).resolves([{ uid: 'branch1' }]);
-
-      const result = await resolveImportPath(mockConfig, mockStackAPIClient);
-
-      expect(result).to.equal('/test/content');
-      expect(mockConfig.branchName).to.equal('branch1');
-    });
-
-    it('should return contentDir when selectBranchFromDirectory returns null', async () => {
-      fileExistsSyncStub.withArgs('/test/content').returns(true);
-
-      // Mock module types check - all return false
+    it('should return contentDir when no module folders exist', async () => {
+      mockConfig.contentDir = '/test/data';
+      fileExistsSyncStub.withArgs('/test/data').returns(true);
       defaultConfig.modules.types.forEach((moduleType) => {
-        fileExistsSyncStub.withArgs(path.join('/test/content', moduleType)).returns(false);
+        fileExistsSyncStub.withArgs(path.join('/test/data', moduleType)).returns(false);
       });
 
-      // Mock branches.json not found
-      const branchesJsonPath = path.join('/test/content', 'branches.json');
-      fileExistsSyncStub.withArgs(branchesJsonPath).returns(false);
-
       const result = await resolveImportPath(mockConfig, mockStackAPIClient);
 
-      expect(result).to.equal('/test/content');
+      expect(result).to.equal('/test/data');
     });
   });
 
@@ -251,18 +95,15 @@ describe('Import Path Resolver', () => {
 
       await updateImportConfigWithResolvedPath(mockConfig, resolvedPath);
 
-      expect(mockConfig.branchDir).to.be.undefined;
       expect(mockConfig.contentDir).to.equal('/test/content');
     });
 
-    it('should update config with resolved path', async () => {
+    it('should update contentDir with resolved path when it exists', async () => {
       const resolvedPath = '/test/resolved';
-
       fileExistsSyncStub.withArgs(resolvedPath).returns(true);
 
       await updateImportConfigWithResolvedPath(mockConfig, resolvedPath);
 
-      expect(mockConfig.branchDir).to.equal(resolvedPath);
       expect(mockConfig.contentDir).to.equal(resolvedPath);
     });
   });
@@ -279,25 +120,16 @@ describe('Import Path Resolver', () => {
       } as ImportConfig;
     });
 
-    it('should execute complete path resolution logic (content at root)', async () => {
+    it('should resolve path and set contentDir on config', async () => {
       fileExistsSyncStub.withArgs('/test/content').returns(true);
-
-      // Mock module types check - no module folders at root
       defaultConfig.modules.types.forEach((moduleType) => {
         fileExistsSyncStub.withArgs(path.join('/test/content', moduleType)).returns(false);
       });
 
-      // Mock branches.json - single branch
-      const branchesJsonPath = path.join('/test/content', 'branches.json');
-      fileExistsSyncStub.withArgs(branchesJsonPath).returns(true);
-      readFileStub.withArgs(branchesJsonPath).resolves([{ uid: 'branch1' }]);
-
       const result = await executeImportPathLogic(mockConfig, mockStackAPIClient);
 
       expect(result).to.equal('/test/content');
-      expect(mockConfig.branchDir).to.equal('/test/content');
       expect(mockConfig.contentDir).to.equal('/test/content');
-      expect(mockConfig.branchName).to.equal('branch1');
     });
   });
 });