chore: updated test cases

Author: naman-contentstack

packages/contentstack-asset-management/test/unit/export/asset-types.test.ts

@@ -46,8 +46,7 @@ describe('ExportAssetTypes', () => {
       const exporter = new ExportAssetTypes(apiConfig, exportContext);
       await exporter.start(spaceUid);
 
-      expect(getStub.calledOnce).to.be.true;
-      expect(getStub.calledWith(spaceUid)).to.be.true;
+      expect(getStub.firstCall.args[0]).to.equal(spaceUid);
     });
 
     it('should write asset types with correct chunked JSON args', async () => {
@@ -56,7 +55,6 @@ describe('ExportAssetTypes', () => {
       await exporter.start(spaceUid);
 
       const writeStub = (AssetManagementExportAdapter.prototype as any).writeItemsToChunkedJson as sinon.SinonStub;
-      expect(writeStub.calledOnce).to.be.true;
       const args = writeStub.firstCall.args;
       expect(args[0]).to.equal(assetTypesDir);
       expect(args[1]).to.equal('asset-types.json');
@@ -75,21 +73,16 @@ describe('ExportAssetTypes', () => {
       await exporter.start(spaceUid);
 
       const writeStub = (AssetManagementExportAdapter.prototype as any).writeItemsToChunkedJson as sinon.SinonStub;
-      expect(writeStub.calledOnce).to.be.true;
       expect(writeStub.firstCall.args[4]).to.deep.equal([]);
     });
 
-    it('should call tick on success', async () => {
+    it('should tick with success=true, the asset types process name, and null error', async () => {
       sinon.stub(ExportAssetTypes.prototype, 'getWorkspaceAssetTypes').resolves(assetTypesResponse);
       const exporter = new ExportAssetTypes(apiConfig, exportContext);
       await exporter.start(spaceUid);
 
       const tickStub = (AssetManagementExportAdapter.prototype as any).tick as sinon.SinonStub;
-      expect(tickStub.called).to.be.true;
-      const args = tickStub.firstCall.args;
-      expect(args[0]).to.be.true;
-      expect(args[1]).to.equal(PROCESS_NAMES.AM_ASSET_TYPES);
-      expect(args[2]).to.be.null;
+      expect(tickStub.firstCall.args).to.deep.equal([true, PROCESS_NAMES.AM_ASSET_TYPES, null]);
     });
   });
 });

packages/contentstack-asset-management/test/unit/export/assets.test.ts

@@ -60,17 +60,15 @@ describe('ExportAssets', () => {
   });
 
   describe('start method', () => {
-    it('should fetch folders and assets in parallel', async () => {
+    it('should fetch folders and assets using the workspace space_uid', async () => {
       const foldersStub = sinon.stub(ExportAssets.prototype, 'getWorkspaceFolders').resolves(foldersData);
       const assetsStub = sinon.stub(ExportAssets.prototype, 'getWorkspaceAssets').resolves(emptyAssetsResponse);
 
       const exporter = new ExportAssets(apiConfig, exportContext);
       await exporter.start(workspace, spaceDir);
 
-      expect(foldersStub.calledOnce).to.be.true;
-      expect(foldersStub.calledWith(workspace.space_uid)).to.be.true;
-      expect(assetsStub.calledOnce).to.be.true;
-      expect(assetsStub.calledWith(workspace.space_uid)).to.be.true;
+      expect(foldersStub.firstCall.args[0]).to.equal(workspace.space_uid);
+      expect(assetsStub.firstCall.args[0]).to.equal(workspace.space_uid);
     });
 
     it('should write chunked assets metadata with correct args', async () => {
@@ -82,27 +80,27 @@ describe('ExportAssets', () => {
       await exporter.start(workspace, spaceDir);
 
       const writeStub = (AssetManagementExportAdapter.prototype as any).writeItemsToChunkedJson as sinon.SinonStub;
-      expect(writeStub.calledOnce).to.be.true;
       const args = writeStub.firstCall.args;
       expect(args[1]).to.equal('assets.json');
       expect(args[2]).to.equal('assets');
       expect(args[3]).to.deep.equal(['uid', 'url', 'filename', 'file_name', 'parent_uid']);
       expect(args[4]).to.have.length(2);
     });
 
-    it('should skip downloads when no asset items exist', async () => {
+    it('should not attempt any downloads when the asset list is empty', async () => {
       sinon.stub(ExportAssets.prototype, 'getWorkspaceFolders').resolves(foldersData);
       sinon.stub(ExportAssets.prototype, 'getWorkspaceAssets').resolves(emptyAssetsResponse);
 
       const exporter = new ExportAssets(apiConfig, exportContext);
       await exporter.start(workspace, spaceDir);
 
+      expect(fetchStub.callCount).to.equal(0);
       const tickStub = (AssetManagementExportAdapter.prototype as any).tick as sinon.SinonStub;
       const downloadTick = tickStub.getCalls().find((c) => String(c.args[1]).startsWith('downloads:'));
       expect(downloadTick).to.be.undefined;
     });
 
-    it('should handle download failures gracefully without throwing', async () => {
+    it('should tick with success=false and the error message on download failure', async () => {
       sinon.stub(ExportAssets.prototype, 'getWorkspaceFolders').resolves(foldersData);
       sinon.stub(ExportAssets.prototype, 'getWorkspaceAssets').resolves(assetsResponseWithItems);
       fetchStub.rejects(new Error('network failure'));
@@ -112,12 +110,11 @@ describe('ExportAssets', () => {
 
       const tickStub = (AssetManagementExportAdapter.prototype as any).tick as sinon.SinonStub;
       const downloadTick = tickStub.getCalls().find((c) => String(c.args[1]).startsWith('downloads:'));
-      expect(downloadTick).to.not.be.undefined;
       expect(downloadTick!.args[0]).to.be.false;
       expect(downloadTick!.args[2]).to.equal('network failure');
     });
 
-    it('should tick success for downloads when all succeed', async () => {
+    it('should tick with success=true and null error on successful downloads', async () => {
       sinon.stub(ExportAssets.prototype, 'getWorkspaceFolders').resolves(foldersData);
       sinon.stub(ExportAssets.prototype, 'getWorkspaceAssets').resolves(assetsResponseWithItems);
       fetchStub.callsFake(async () => makeFetchResponse() as any);
@@ -127,12 +124,11 @@ describe('ExportAssets', () => {
 
       const tickStub = (AssetManagementExportAdapter.prototype as any).tick as sinon.SinonStub;
       const downloadTick = tickStub.getCalls().find((c) => String(c.args[1]).startsWith('downloads:'));
-      expect(downloadTick).to.not.be.undefined;
       expect(downloadTick!.args[0]).to.be.true;
       expect(downloadTick!.args[2]).to.be.null;
     });
 
-    it('should skip assets with no url or uid', async () => {
+    it('should skip assets that have neither a url nor a uid', async () => {
       const incompleteAssets = {
         items: [
           { uid: 'a1', url: null as any },
@@ -146,10 +142,10 @@ describe('ExportAssets', () => {
       const exporter = new ExportAssets(apiConfig, exportContext);
       await exporter.start(workspace, spaceDir);
 
-      expect(fetchStub.called).to.be.false;
+      expect(fetchStub.callCount).to.equal(0);
     });
 
-    it('should use _uid when uid is not present on asset', async () => {
+    it('should process assets that have _uid instead of uid without skipping them', async () => {
       const assetsWithUnderscoreUid = {
         items: [{ _uid: 'a-uid', url: 'https://cdn.example.com/a.png', filename: 'a.png' }],
       };
@@ -160,17 +156,18 @@ describe('ExportAssets', () => {
       const exporter = new ExportAssets(apiConfig, exportContext);
       await exporter.start(workspace, spaceDir);
 
+      expect(fetchStub.firstCall.args[0]).to.equal('https://cdn.example.com/a.png');
       const tickStub = (AssetManagementExportAdapter.prototype as any).tick as sinon.SinonStub;
       const downloadTick = tickStub.getCalls().find((c) => String(c.args[1]).startsWith('downloads:'));
-      expect(downloadTick).to.not.be.undefined;
       expect(downloadTick!.args[0]).to.be.true;
+      expect(downloadTick!.args[2]).to.be.null;
     });
 
-    it('should use file_name when filename is not present, defaulting to "asset"', async () => {
+    it('should download assets that use file_name, and fall back to "asset" when both names are absent', async () => {
       const assetsNoFilename = {
         items: [
-          { uid: 'a1', url: 'https://cdn.example.com/a1', file_name: 'named.pdf' },
-          { uid: 'a2', url: 'https://cdn.example.com/a2' },
+          { uid: 'a1', url: 'https://cdn.example.com/a1.pdf', file_name: 'named.pdf' },
+          { uid: 'a2', url: 'https://cdn.example.com/a2.bin' },
         ],
       };
       sinon.stub(ExportAssets.prototype, 'getWorkspaceFolders').resolves(foldersData);
@@ -181,6 +178,11 @@ describe('ExportAssets', () => {
       await exporter.start(workspace, spaceDir);
 
       expect(fetchStub.callCount).to.equal(2);
+      expect(fetchStub.firstCall.args[0]).to.equal('https://cdn.example.com/a1.pdf');
+      expect(fetchStub.secondCall.args[0]).to.equal('https://cdn.example.com/a2.bin');
+      const tickStub = (AssetManagementExportAdapter.prototype as any).tick as sinon.SinonStub;
+      const downloadTick = tickStub.getCalls().find((c) => String(c.args[1]).startsWith('downloads:'));
+      expect(downloadTick!.args[0]).to.be.true;
     });
 
     it('should append authtoken to URL when securedAssets is true', async () => {
@@ -215,7 +217,7 @@ describe('ExportAssets', () => {
       expect(downloadUrl).to.include('?v=1&authtoken=');
     });
 
-    it('should handle non-ok HTTP response as download failure', async () => {
+    it('should tick with success=false and the HTTP status code on non-ok response', async () => {
       sinon.stub(ExportAssets.prototype, 'getWorkspaceFolders').resolves(foldersData);
       sinon.stub(ExportAssets.prototype, 'getWorkspaceAssets').resolves({
         items: [{ uid: 'a1', url: 'https://cdn.example.com/a1.png', filename: 'img.png' }],
@@ -231,7 +233,7 @@ describe('ExportAssets', () => {
       expect(downloadTick!.args[2]).to.include('403');
     });
 
-    it('should handle missing response body as download failure', async () => {
+    it('should tick with success=false and "No response body" when body is null', async () => {
       sinon.stub(ExportAssets.prototype, 'getWorkspaceFolders').resolves(foldersData);
       sinon.stub(ExportAssets.prototype, 'getWorkspaceAssets').resolves({
         items: [{ uid: 'a1', url: 'https://cdn.example.com/a1.png', filename: 'img.png' }],

packages/contentstack-asset-management/test/unit/export/base.test.ts

@@ -61,14 +61,16 @@ describe('AssetManagementExportAdapter (base)', () => {
       expect(adapter.spacesRootPathPublic).to.equal('/tmp/export/spaces');
     });
 
-    it('should build getAssetTypesDir from spacesRootPath', () => {
+    it('should build getAssetTypesDir as <spacesRootPath>/asset_types', () => {
       const adapter = new TestAdapter(apiConfig, exportContext);
-      expect(adapter.getAssetTypesDirPublic()).to.include('asset_types');
+      const expected = require('node:path').join('/tmp/export/spaces', 'asset_types');
+      expect(adapter.getAssetTypesDirPublic()).to.equal(expected);
     });
 
-    it('should build getFieldsDir from spacesRootPath', () => {
+    it('should build getFieldsDir as <spacesRootPath>/fields', () => {
       const adapter = new TestAdapter(apiConfig, exportContext);
-      expect(adapter.getFieldsDirPublic()).to.include('fields');
+      const expected = require('node:path').join('/tmp/export/spaces', 'fields');
+      expect(adapter.getFieldsDirPublic()).to.equal(expected);
     });
   });
 
@@ -97,15 +99,14 @@ describe('AssetManagementExportAdapter (base)', () => {
   });
 
   describe('createNestedProgress', () => {
-    it('should create a new CLIProgressManager when no parent is set', () => {
-      const getStub = sinon.stub(configHandler, 'get').returns({ showConsoleLogs: true });
+    it('should create a new CLIProgressManager with the given name and showConsoleLogs flag', () => {
+      sinon.stub(configHandler, 'get').returns({ showConsoleLogs: true });
       const fakeProgress = { tick: sinon.stub() } as any;
       const createNestedStub = sinon.stub(CLIProgressManager, 'createNested').returns(fakeProgress);
 
       const adapter = new TestAdapter(apiConfig, exportContext);
       const result = adapter.callCreateNestedProgress('my-module');
 
-      expect(createNestedStub.calledOnce).to.be.true;
       expect(createNestedStub.firstCall.args[0]).to.equal('my-module');
       expect(result).to.equal(fakeProgress);
     });
@@ -132,18 +133,16 @@ describe('AssetManagementExportAdapter (base)', () => {
   });
 
   describe('tick', () => {
-    it('should call tick on progressOrParent when available', () => {
+    it('should forward success, item name, and error to the progress manager tick', () => {
       const fakeParent = { tick: sinon.stub(), updateStatus: sinon.stub() } as any;
       const adapter = new TestAdapter(apiConfig, exportContext);
       adapter.setParentProgressManager(fakeParent);
 
       adapter.callTick(true, 'my-item', null);
 
-      expect(fakeParent.tick.calledOnce).to.be.true;
-      const args = fakeParent.tick.firstCall.args;
-      expect(args[0]).to.be.true;
-      expect(args[1]).to.equal('my-item');
-      expect(args[2]).to.be.null;
+      expect(fakeParent.tick.firstCall.args[0]).to.equal(true);
+      expect(fakeParent.tick.firstCall.args[1]).to.equal('my-item');
+      expect(fakeParent.tick.firstCall.args[2]).to.be.null;
     });
 
     it('should not throw when progressOrParent is null', () => {
@@ -153,14 +152,13 @@ describe('AssetManagementExportAdapter (base)', () => {
   });
 
   describe('updateStatus', () => {
-    it('should call updateStatus on progressOrParent when available', () => {
+    it('should forward the status message to the progress manager', () => {
       const fakeParent = { tick: sinon.stub(), updateStatus: sinon.stub() } as any;
       const adapter = new TestAdapter(apiConfig, exportContext);
       adapter.setParentProgressManager(fakeParent);
 
       adapter.callUpdateStatus('Fetching...');
 
-      expect(fakeParent.updateStatus.calledOnce).to.be.true;
       expect(fakeParent.updateStatus.firstCall.args[0]).to.equal('Fetching...');
     });
 
@@ -171,7 +169,7 @@ describe('AssetManagementExportAdapter (base)', () => {
   });
 
   describe('completeProcess', () => {
-    it('should call completeProcess on progressManager when no parent is set', () => {
+    it('should call completeProcess on progressManager with the given name and success flag', () => {
       sinon.stub(configHandler, 'get').returns({});
       const fakeProgress = { tick: sinon.stub(), completeProcess: sinon.stub() } as any;
       sinon.stub(CLIProgressManager, 'createNested').returns(fakeProgress);
@@ -180,7 +178,7 @@ describe('AssetManagementExportAdapter (base)', () => {
       adapter.callCreateNestedProgress('test');
       adapter.callCompleteProcess('test', true);
 
-      expect(fakeProgress.completeProcess.calledWith('test', true)).to.be.true;
+      expect(fakeProgress.completeProcess.firstCall.args).to.deep.equal(['test', true]);
     });
 
     it('should NOT call completeProcess when parentProgressManager is set', () => {
@@ -190,7 +188,7 @@ describe('AssetManagementExportAdapter (base)', () => {
 
       adapter.callCompleteProcess('test', true);
 
-      expect(fakeParent.completeProcess.called).to.be.false;
+      expect(fakeParent.completeProcess.callCount).to.equal(0);
     });
   });
 
@@ -208,16 +206,16 @@ describe('AssetManagementExportAdapter (base)', () => {
       fsReal.unlinkSync(path.join(tmpDir, 'test-empty.json'));
     });
 
-    it('should use FsUtility to write items in batches when items exist', async () => {
+    it('should write all items in a single batch and complete the file when count is below BATCH_SIZE', async () => {
       const writeIntoFileStub = sinon.stub(FsUtility.prototype, 'writeIntoFile');
       const completeFileStub = sinon.stub(FsUtility.prototype, 'completeFile');
 
       const items = Array.from({ length: 3 }, (_, i) => ({ uid: `item-${i}` }));
       const adapter = new TestAdapter(apiConfig, exportContext);
       await adapter.callWriteItemsToChunkedJson('/tmp/dir', 'items.json', 'items', ['uid'], items);
 
-      expect(writeIntoFileStub.called).to.be.true;
-      expect(completeFileStub.calledWith(true)).to.be.true;
+      expect(writeIntoFileStub.firstCall.args[0]).to.have.length(3);
+      expect(completeFileStub.firstCall.args[0]).to.be.true;
     });
 
     it('should write items in batches of BATCH_SIZE (50)', async () => {

packages/contentstack-asset-management/test/unit/export/fields.test.ts

@@ -46,8 +46,7 @@ describe('ExportFields', () => {
       const exporter = new ExportFields(apiConfig, exportContext);
       await exporter.start(spaceUid);
 
-      expect(getFieldsStub.calledOnce).to.be.true;
-      expect(getFieldsStub.calledWith(spaceUid)).to.be.true;
+      expect(getFieldsStub.firstCall.args[0]).to.equal(spaceUid);
     });
 
     it('should write fields with correct chunked JSON args', async () => {
@@ -56,7 +55,6 @@ describe('ExportFields', () => {
       await exporter.start(spaceUid);
 
       const writeStub = (AssetManagementExportAdapter.prototype as any).writeItemsToChunkedJson as sinon.SinonStub;
-      expect(writeStub.calledOnce).to.be.true;
       const args = writeStub.firstCall.args;
       expect(args[0]).to.equal(fieldsDir);
       expect(args[1]).to.equal('fields.json');
@@ -75,21 +73,16 @@ describe('ExportFields', () => {
       await exporter.start(spaceUid);
 
       const writeStub = (AssetManagementExportAdapter.prototype as any).writeItemsToChunkedJson as sinon.SinonStub;
-      expect(writeStub.calledOnce).to.be.true;
       expect(writeStub.firstCall.args[4]).to.deep.equal([]);
     });
 
-    it('should call tick on success', async () => {
+    it('should tick with success=true, the fields process name, and null error', async () => {
       sinon.stub(ExportFields.prototype, 'getWorkspaceFields').resolves(fieldsResponse);
       const exporter = new ExportFields(apiConfig, exportContext);
       await exporter.start(spaceUid);
 
       const tickStub = (AssetManagementExportAdapter.prototype as any).tick as sinon.SinonStub;
-      expect(tickStub.called).to.be.true;
-      const args = tickStub.firstCall.args;
-      expect(args[0]).to.be.true;
-      expect(args[1]).to.equal(PROCESS_NAMES.AM_FIELDS);
-      expect(args[2]).to.be.null;
+      expect(tickStub.firstCall.args).to.deep.equal([true, PROCESS_NAMES.AM_FIELDS, null]);
     });
   });
 });