test: fix export & import ct, entries test cases

Author: aman19K

packages/contentstack-export/test/unit/export/modules/content-types.test.ts

@@ -317,6 +317,7 @@ describe('ExportContentTypes', () => {
 
     it('should handle empty content types', async () => {
       const writeFileStub = FsUtility.prototype.writeFile as sinon.SinonStub;
+      const completeProgressStub = sinon.stub(exportContentTypes as any, 'completeProgress');
 
       mockStackClient.contentType.returns({
         query: sinon.stub().returns({
@@ -330,8 +331,10 @@ describe('ExportContentTypes', () => {
       exportContentTypes.contentTypes = [];
       await exportContentTypes.start();
 
-      // Verify writeFile was called even with empty array
-      expect(writeFileStub.called).to.be.true;
+      // With empty content types, writeFile is not called (no files to write)
+      // But completeProgress should be called to mark the process as complete
+      expect(completeProgressStub.called).to.be.true;
+      expect(completeProgressStub.calledWith(true)).to.be.true;
     });
 
     it('should handle errors during export without throwing', async () => {

packages/contentstack-export/test/unit/export/modules/entries.test.ts

@@ -1061,11 +1061,19 @@ describe('EntriesExport', () => {
     it('should process all request objects and complete file writing', async () => {
       const locales = [{ code: 'en-us' }];
       const contentTypes = [
-        { uid: 'ct-1', title: 'Content Type 1' },
-        { uid: 'ct-2', title: 'Content Type 2' },
+        { uid: 'ct-1', title: 'Content Type 1', schema: [] as any },
+        { uid: 'ct-2', title: 'Content Type 2', schema: [] as any },
       ];
 
-      mockFsUtil.readFile.onFirstCall().returns(locales).onSecondCall().returns(contentTypes);
+      mockFsUtil.readFile.returns(locales); // For locales file
+      
+      // Stub FsUtility.prototype for readContentTypeSchemas
+      (FsUtility.prototype.readdir as sinon.SinonStub).returns(['ct-1.json', 'ct-2.json']);
+      (FsUtility.prototype.readFile as sinon.SinonStub).callsFake((filePath: string) => {
+        if (filePath.includes('ct-1.json')) return contentTypes[0];
+        if (filePath.includes('ct-2.json')) return contentTypes[1];
+        return undefined;
+      });
 
       const mockEntryQuery = {
         query: sandbox.stub().returns({
@@ -1104,9 +1112,13 @@ describe('EntriesExport', () => {
 
     it('should handle errors during entry processing gracefully', async () => {
       const locales = [{ code: 'en-us' }];
-      const contentTypes = [{ uid: 'ct-1', title: 'Content Type 1' }];
+      const contentTypes = [{ uid: 'ct-1', title: 'Content Type 1', schema: [] as any }];
 
-      mockFsUtil.readFile.onFirstCall().returns(locales).onSecondCall().returns(contentTypes);
+      mockFsUtil.readFile.returns(locales); // For locales file
+      
+      // Stub FsUtility.prototype for readContentTypeSchemas
+      (FsUtility.prototype.readdir as sinon.SinonStub).returns(['ct-1.json']);
+      (FsUtility.prototype.readFile as sinon.SinonStub).returns(contentTypes[0]);
 
       const processingError = new Error('Entry processing failed');
       const getEntriesStub = sandbox.stub(entriesExport, 'getEntries').rejects(processingError);

packages/contentstack-import/test/unit/import/modules/entries.test.ts

@@ -578,11 +578,14 @@ describe('EntriesImport', () => {
           if (path.includes('schema.json')) {
             return [contentTypeWithoutFieldRules];
           }
-          return {};
+          if (path.includes('field_rules_ct.json')) {
+            return contentTypeWithoutFieldRules;
+          }
+          return undefined;
         });
 
-        // Override FsUtility.readFile for this test
-        (FsUtility.prototype.readFile as sinon.SinonStub).returns(contentTypeWithoutFieldRules);
+        // Override FsUtility.readdir for this test
+        (FsUtility.prototype.readdir as sinon.SinonStub).returns(['field_rules_ct.json']);
 
         await entriesImport['updateFieldRules']();
 
@@ -3124,25 +3127,17 @@ describe('EntriesImport', () => {
       it('should handle content type fetch error', async () => {
         const mockContentTypes = [mockData.simpleContentType, mockData.contentTypeWithReferences];
 
-        // Configure FsUtility.readFile to return the right content type based on file name
-        (FsUtility.prototype.readFile as sinon.SinonStub).callsFake((filePath: string) => {
-          if (filePath.includes('simple_ct.json')) return JSON.stringify(mockData.simpleContentType);
-          if (filePath.includes('ref_ct.json')) return JSON.stringify(mockData.contentTypeWithReferences);
-          return '{}';
-        });
-
+        // Configure FsUtility.readFile to handle all file reads (for both fsUtil and readContentTypeSchemas)
         fsUtilityReadFileStub.callsFake((filePath) => {
-          console.log('fsUtil.readFile called with path:', filePath);
           if (filePath.includes('field_rules_uid.json')) {
-            console.log('Returning field rules data');
             return ['simple_ct', 'ref_ct']; // array of strings
           }
+          if (filePath.includes('simple_ct.json')) return mockData.simpleContentType;
+          if (filePath.includes('ref_ct.json')) return mockData.contentTypeWithReferences;
           if (filePath.includes('schema.json')) {
-            console.log('Returning schema data');
             return mockContentTypes;
           }
-          console.log('Returning empty array');
-          return [];
+          return undefined;
         });
 
         const mockContentType = {
@@ -3166,16 +3161,17 @@ describe('EntriesImport', () => {
       it('should handle content type update error', async () => {
         const mockContentTypes = [mockData.simpleContentType, mockData.contentTypeWithReferences];
 
-        (FsUtility.prototype.readFile as sinon.SinonStub).returns(JSON.stringify(mockData.simpleContentType));
+        (FsUtility.prototype.readdir as sinon.SinonStub).returns(['simple_ct.json']);
 
         fsUtilityReadFileStub.callsFake((path) => {
           if (path.includes('field_rules_uid.json')) {
             return ['simple_ct']; // array of strings
           }
+          if (path.includes('simple_ct.json')) return mockData.simpleContentType;
           if (path.includes('schema.json')) {
             return mockContentTypes;
           }
-          return [];
+          return undefined;
         });
 
         const mockUpdate = sinon.stub().rejects(new Error('Update failed'));
@@ -3205,16 +3201,17 @@ describe('EntriesImport', () => {
       it('should skip when content type not found', async () => {
         const mockContentTypes = [mockData.simpleContentType, mockData.contentTypeWithReferences];
 
-        (FsUtility.prototype.readFile as sinon.SinonStub).returns(JSON.stringify(mockData.simpleContentType));
+        (FsUtility.prototype.readdir as sinon.SinonStub).returns(['simple_ct.json']);
 
         fsUtilityReadFileStub.callsFake((path) => {
           if (path.includes('field_rules_uid.json')) {
             return ['simple_ct']; // array of strings
           }
+          if (path.includes('simple_ct.json')) return mockData.simpleContentType;
           if (path.includes('schema.json')) {
             return mockContentTypes;
           }
-          return [];
+          return undefined;
         });
 
         const mockContentType = {
@@ -3249,16 +3246,17 @@ describe('EntriesImport', () => {
         delete contentTypeWithoutRules.field_rules;
         const mockContentTypes = [contentTypeWithoutRules];
 
-        (FsUtility.prototype.readFile as sinon.SinonStub).returns(JSON.stringify(contentTypeWithoutRules));
+        (FsUtility.prototype.readdir as sinon.SinonStub).returns(['simple_ct.json']);
 
         fsUtilityReadFileStub.callsFake((path) => {
           if (path.includes('field_rules_uid.json')) {
             return ['simple_ct']; // array of strings
           }
+          if (path.includes('simple_ct.json')) return contentTypeWithoutRules;
           if (path.includes('schema.json')) {
             return mockContentTypes;
           }
-          return [];
+          return undefined;
         });
 
         const mockLog = {