chore: add test cases for utils

Author: naman-contentstack

.github/workflows/unit-test.yml

@@ -27,6 +27,10 @@ jobs:
       - name: Run tests for Contentstack Import Plugin
         working-directory: ./packages/contentstack-import
         run: npm run test:unit
+      
+      - name: Run tests for Contentstack Export Plugin
+        working-directory: ./packages/contentstack-export
+        run: npm run test:unit
 
       - name: Run tests for Audit plugin
         working-directory: ./packages/contentstack-audit

.talismanrc

@@ -1,8 +1,8 @@
 fileignoreconfig:
 - filename: package-lock.json
-  checksum: 6ff9c8334d085a39cbda0377f9b36f1af3f3735f62d9372c0e51efaa4f4a960e
+  checksum: 020710f2cd2ac9715ed34fe6f5412b6bed6a5db96fa5722defc0374b06388a63
 - filename: pnpm-lock.yaml
-  checksum: d02a60a70a50b191dcb746ce9644b01202957e6b5fb56cdaa564d7105623bb9d
+  checksum: 9b3d466b8de5bcb3a1319ebfe90c6003a1c7e7450fb7f529be27b554c16d28e9
 - filename: packages/contentstack-import-setup/test/unit/backup-handler.test.ts
   checksum: 0582d62b88834554cf12951c8690a73ef3ddbb78b82d2804d994cf4148e1ef93
 - filename: packages/contentstack-import-setup/test/config.json
@@ -151,4 +151,10 @@ fileignoreconfig:
   checksum: 457912f0f1ad3cadabbdf19cff6c325164e76063f12b968a00af37ec15a875e9
 - filename: packages/contentstack-export/test/unit/export/modules/global-fields.test.ts
   checksum: 64d204d0ff6232d161275b1df5b2ea5612b53c72d9ba2c22bd13564229353c4d
+- filename: packages/contentstack-export/test/unit/utils/common-helper.test.ts
+  checksum: 276e850e4caddc89372f09f4eee5832cc4ab5b513da2a662a821f5feb8561349
+- filename: packages/contentstack-export/test/unit/utils/file-helper.test.ts
+  checksum: a16f5833515ececd93c582b35d19b8a5df4880f22126fba18f110692c679025b
+- filename: packages/contentstack-export/test/unit/utils/export-config-handler.test.ts
+  checksum: ba02c3d580e02fc4ecd5e6a0fc59e6c7d56d7de735339aa00e2c2241ffe22176
 version: "1.0"

package-lock.json

@@ -31,6 +31,7 @@
     "@types/mkdirp": "^1.0.2",
     "@types/mocha": "^10.0.6",
     "@types/progress-stream": "^2.0.5",
+    "@types/proxyquire": "^1.3.30",
     "@types/sinon": "^17.0.2",
     "chai": "^4.4.1",
     "dotenv": "^16.5.0",
@@ -40,6 +41,7 @@
     "mocha": "10.8.2",
     "nyc": "^15.1.0",
     "oclif": "^4.17.46",
+    "proxyquire": "^2.1.3",
     "sinon": "^17.0.1",
     "source-map-support": "^0.5.21",
     "ts-node": "^10.9.2",

packages/contentstack-export/package.json

@@ -0,0 +1,255 @@
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { validateConfig, formatError, executeTask, writeExportMetaFile } from '../../../src/utils/common-helper';
+import { ExternalConfig, ExportConfig } from '../../../src/types';
+
+describe('Common Helper Utils', () => {
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  describe('validateConfig', () => {
+    it('should throw error when host and cdn are missing', () => {
+      const config: ExternalConfig = {} as any;
+      
+      expect(() => validateConfig(config)).to.throw('Host/CDN end point is missing from config');
+    });
+
+    it('should validate correctly with all credentials provided', () => {
+      const config: ExternalConfig = {
+        host: 'https://api.contentstack.io',
+        cdn: 'https://cdn.contentstack.io',
+        email: '[email protected]',
+        password: 'password',
+        management_token: 'token',
+        access_token: 'token'
+      } as any;
+      
+      expect(() => validateConfig(config)).to.not.throw();
+    });
+
+    it('should validate email and password with access_token', () => {
+      const config: ExternalConfig = {
+        host: 'https://api.contentstack.io',
+        cdn: 'https://cdn.contentstack.io',
+        email: '[email protected]',
+        password: 'password',
+        access_token: 'token',
+        source_stack: 'stack-key'
+      } as any;
+      
+      // Should not throw with access token
+      expect(() => validateConfig(config)).to.not.throw();
+    });
+
+    it('should throw error when authentication credentials are missing', () => {
+      const config: ExternalConfig = {
+        host: 'https://api.contentstack.io',
+        cdn: 'https://cdn.contentstack.io',
+        email: '',
+        password: '',
+        source_stack: 'stack-key'
+      } as any;
+      
+      // This will throw when no valid credentials provided
+      try {
+        validateConfig(config);
+        // If it doesn't throw, check if email/password path throws
+        const config2 = { ...config, email: 'test', password: '' };
+        validateConfig(config2);
+        expect.fail('Should have thrown an error');
+      } catch (error: any) {
+        expect(error.message).to.exist;
+      }
+    });
+
+    it('should validate preserveStackVersion requires email and password', () => {
+      const config: ExternalConfig = {
+        host: 'https://api.contentstack.io',
+        cdn: 'https://cdn.contentstack.io',
+        preserveStackVersion: true
+      } as any;
+      
+      expect(() => validateConfig(config)).to.throw('Kindly provide Email and password for stack details');
+    });
+
+    it('should validate with management token', () => {
+      const config: ExternalConfig = {
+        host: 'https://api.contentstack.io',
+        cdn: 'https://cdn.contentstack.io',
+        management_token: 'token',
+        source_stack: 'stack-key'
+      } as any;
+      
+      expect(() => validateConfig(config)).to.not.throw();
+    });
+  });
+
+  describe('formatError', () => {
+    it('should format string error correctly', () => {
+      const errorStr = 'Simple error message';
+      const result = formatError(errorStr);
+      expect(result).to.equal(errorStr);
+    });
+
+    it('should parse and format JSON error string', () => {
+      const errorJson = JSON.stringify({ errorMessage: 'Test error' });
+      const result = formatError(errorJson);
+      expect(result).to.equal('Test error');
+    });
+
+    it('should format error message from Error object', () => {
+      const error = { message: 'Error occurred' };
+      const result = formatError(error);
+      expect(result).to.equal('Error occurred');
+    });
+
+    it('should include error details when available', () => {
+      const error = {
+        errorMessage: 'Main error',
+        errors: {
+          authorization: 'Invalid token',
+          api_key: 'Invalid key'
+        }
+      };
+      const result = formatError(error);
+      expect(result).to.include('Main error');
+      expect(result).to.include('Management Token Invalid token');
+      expect(result).to.include('Stack API key Invalid key');
+    });
+
+    it('should map entity names correctly', () => {
+      const error = {
+        errors: {
+          authorization: 'fail',
+          api_key: 'fail',
+          uid: 'fail',
+          access_token: 'fail'
+        }
+      };
+      const result = formatError(error);
+      expect(result).to.include('Management Token');
+      expect(result).to.include('Stack API key');
+      expect(result).to.include('Content Type');
+      expect(result).to.include('Delivery Token');
+    });
+
+    it('should handle null or undefined error gracefully', () => {
+      // formatError doesn't handle null gracefully, so we expect it to throw
+      expect(() => formatError(null as any)).to.throw();
+    });
+  });
+
+  describe('executeTask', () => {
+    it('should execute tasks with concurrency limit', async () => {
+      const tasks = [1, 2, 3, 4, 5];
+      const handler = async (task: unknown) => (task as number) * 2;
+      
+      const results = await executeTask(tasks, handler, { concurrency: 2 });
+      
+      expect(results).to.deep.equal([2, 4, 6, 8, 10]);
+    });
+
+    it('should handle empty tasks array', async () => {
+      const tasks: any[] = [];
+      const handler = async (): Promise<void> => { return; };
+      
+      const results = await executeTask(tasks, handler, { concurrency: 1 });
+      
+      expect(results).to.be.an('array');
+      expect(results.length).to.equal(0);
+    });
+
+    it('should throw error when handler is not a function', () => {
+      const tasks = [1, 2, 3];
+      const handler = 'not a function' as any;
+      
+      expect(() => executeTask(tasks, handler, { concurrency: 1 })).to.throw('Invalid handler');
+    });
+
+    it('should execute tasks sequentially when concurrency is 1', async () => {
+      const order: number[] = [];
+      const tasks = [1, 2, 3];
+      const handler = async (task: unknown) => {
+        order.push(task as number);
+        return task;
+      };
+      
+      await executeTask(tasks, handler, { concurrency: 1 });
+      
+      expect(order).to.deep.equal([1, 2, 3]);
+    });
+
+    it('should handle task errors gracefully', async () => {
+      const tasks = [1, 2, 3];
+      const handler = async (task: unknown) => {
+        if ((task as number) === 2) throw new Error('Task failed');
+        return task;
+      };
+      
+      try {
+        await executeTask(tasks, handler, { concurrency: 1 });
+        expect.fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).to.exist;
+      }
+    });
+  });
+
+  describe('writeExportMetaFile', () => {
+    it('should write export meta file with correct data', () => {
+      const exportConfig: ExportConfig = {
+        contentVersion: 1,
+        exportDir: '/test/export'
+      } as ExportConfig;
+      
+      // Stub FsUtility constructor to avoid fs operations
+      const FsUtility = require('@contentstack/cli-utilities').FsUtility;
+      const originalWriteFile = FsUtility.prototype.writeFile;
+      const writeFileStub = sinon.stub().resolves();
+      FsUtility.prototype.writeFile = writeFileStub;
+      
+      writeExportMetaFile(exportConfig);
+      
+      // Verify that writeFile was called with correct data
+      expect(writeFileStub.called).to.be.true;
+      const filePath = writeFileStub.firstCall.args[0];
+      const metaData = writeFileStub.firstCall.args[1];
+      
+      expect(filePath).to.include('export-info.json');
+      expect(metaData.contentVersion).to.equal(1);
+      expect(metaData.logsPath).to.exist;
+      
+      // Restore original
+      FsUtility.prototype.writeFile = originalWriteFile;
+    });
+
+    it('should accept custom meta file path', () => {
+      const exportConfig: ExportConfig = {
+        contentVersion: 2,
+        exportDir: '/test/export'
+      } as ExportConfig;
+      
+      // Stub FsUtility constructor to avoid fs operations
+      const FsUtility = require('@contentstack/cli-utilities').FsUtility;
+      const originalWriteFile = FsUtility.prototype.writeFile;
+      const writeFileStub = sinon.stub().resolves();
+      FsUtility.prototype.writeFile = writeFileStub;
+      
+      writeExportMetaFile(exportConfig, '/custom/path');
+      
+      // Verify that writeFile was called with custom path and correct data
+      expect(writeFileStub.called).to.be.true;
+      const filePath = writeFileStub.firstCall.args[0];
+      const metaData = writeFileStub.firstCall.args[1];
+      
+      expect(filePath).to.include('/custom/path');
+      expect(filePath).to.include('export-info.json');
+      expect(metaData.contentVersion).to.equal(2);
+      
+      // Restore original
+      FsUtility.prototype.writeFile = originalWriteFile;
+    });
+  });
+});
+