added test cases

Author: shafeeqd959

packages/contentstack-import/src/import/modules/entries.ts

@@ -1202,13 +1202,19 @@ export default class EntriesImport extends BaseClass {
     log.debug(`Found ${cTsWithFieldRules.length} content types with field rules to update`, this.importConfig.context);
 
     try {
+      // Read content types from individual files
+      const cTs = readContentTypeSchemas(this.cTsPath) || [];
       for (let cTUid of cTsWithFieldRules) {
         log.debug(`Processing field rules for content type: ${cTUid}`, this.importConfig.context);
 
-        // Read content types from individual files
-        const cTs = readContentTypeSchemas(this.cTsPath);
+
         const contentType: any = find(cTs, { uid: cTUid });
 
+        if (!contentType) {
+          log.debug(`Content type ${cTUid} not found in schemas`, this.importConfig.context);
+          continue;
+        }
+
         if (contentType.field_rules) {
           log.debug(
             `Found ${contentType.field_rules.length} field rules for content type: ${cTUid}`,

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

@@ -6,6 +6,7 @@ import { fsUtil } from '../../../../src/utils';
 import * as contentTypeHelper from '../../../../src/utils/content-type-helper';
 import * as extensionHelper from '../../../../src/utils/extension-helper';
 import * as taxonomiesHelper from '../../../../src/utils/taxonomies-helper';
+import { FsUtility } from '@contentstack/cli-utilities';
 
 describe('ImportContentTypes', () => {
   let importContentTypes: ImportContentTypes;
@@ -16,6 +17,8 @@ describe('ImportContentTypes', () => {
   let lookupExtensionStub: sinon.SinonStub;
   let lookUpTaxonomyStub: sinon.SinonStub;
   let makeConcurrentCallStub: sinon.SinonStub;
+  let fsUtilityReaddirStub: sinon.SinonStub;
+  let fsUtilityReadFileStub: sinon.SinonStub;
 
   beforeEach(() => {
     fsUtilStub = {
@@ -27,6 +30,46 @@ describe('ImportContentTypes', () => {
     sinon.stub(fsUtil, 'writeFile').callsFake(fsUtilStub.writeFile);
     sinon.stub(fsUtil, 'makeDirectory').callsFake(fsUtilStub.makeDirectory);
 
+    // Stub FsUtility prototype to make readContentTypeSchemas work
+    // readContentTypeSchemas reads individual JSON files (ignoring schema.json)
+    // We'll check what fsUtilStub.readFile returns for schema.json and use that to populate individual files
+    fsUtilityReaddirStub = sinon.stub(FsUtility.prototype, 'readdir').callsFake((dirPath: string) => {
+      // Try to get mock CTs from the test's fsUtilStub setup for schema.json
+      // This allows tests to continue using schema.json pattern
+      try {
+        const mockCTs = fsUtilStub.readFile(dirPath + '/schema.json');
+        if (Array.isArray(mockCTs) && mockCTs.length > 0) {
+          return mockCTs.map((ct: any) => `${ct.uid}.json`);
+        }
+      } catch (e) {
+        // If schema.json isn't stubbed, return empty
+      }
+      return [];
+    });
+    
+    fsUtilityReadFileStub = sinon.stub(FsUtility.prototype, 'readFile').callsFake((filePath: string) => {
+      // Extract the UID from the file path and return matching content type
+      const match = filePath.match(/([^\/]+)\.json$/);
+      if (match) {
+        const uid = match[1];
+        const dirPath = filePath.substring(0, filePath.lastIndexOf('/'));
+        try {
+          // Check if test has stubbed schema.json with mock content types
+          const mockCTs = fsUtilStub.readFile(dirPath + '/schema.json');
+          if (Array.isArray(mockCTs)) {
+            const ct = mockCTs.find((ct: any) => ct.uid === uid);
+            if (ct) {
+              // FsUtility.readFile returns parsed JSON (object), not string
+              return ct;
+            }
+          }
+        } catch (e) {
+          // If schema.json isn't stubbed, return undefined (file doesn't exist)
+        }
+      }
+      return undefined;
+    });
+
     updateFieldRulesStub = sinon.stub(contentTypeHelper, 'updateFieldRules');
     lookupExtensionStub = sinon.stub(extensionHelper, 'lookupExtension');
     lookUpTaxonomyStub = sinon.stub(taxonomiesHelper, 'lookUpTaxonomy');
@@ -1168,13 +1211,17 @@ describe('ImportContentTypes', () => {
   describe('analyzeImportData() with individual content type files', () => {
     it('should read content types from individual files', async () => {
       const mockContentTypes = [
-        { uid: 'ct-1', title: 'CT 1', schema: [] },
-        { uid: 'ct-2', title: 'CT 2', schema: [] },
+        { uid: 'ct-1', title: 'CT 1', schema: [] as any },
+        { uid: 'ct-2', title: 'CT 2', schema: [] as any },
       ];
 
-      // Stub readContentTypeSchemas to return mock content types
-      const readContentTypeSchemasStub = sinon.stub().returns(mockContentTypes);
-      sinon.stub(require('@contentstack/cli-utilities'), 'readContentTypeSchemas').value(readContentTypeSchemasStub);
+      // Configure FsUtility stubs to make readContentTypeSchemas return mock content types
+      (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 JSON.stringify(mockContentTypes[0]);
+        if (filePath.includes('ct-2.json')) return JSON.stringify(mockContentTypes[1]);
+        return '{}';
+      });
 
       fsUtilStub.readFile.returns([]);
 
@@ -1184,10 +1231,7 @@ describe('ImportContentTypes', () => {
     });
 
     it('should return empty array when no individual files are found', async () => {
-      // Stub readContentTypeSchemas to return empty array (no individual files)
-      const readContentTypeSchemasStub = sinon.stub().returns([]);
-      sinon.stub(require('@contentstack/cli-utilities'), 'readContentTypeSchemas').value(readContentTypeSchemasStub);
-
+      // readdir returns [] by default, so readContentTypeSchemas will return []
       fsUtilStub.readFile.returns([]);
 
       await (importContentTypes as any).analyzeImportData();

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

@@ -27,6 +27,12 @@ describe('EntriesImport', () => {
     sinon.stub(FsUtility.prototype, 'createFolderIfNotExist').callsFake(() => {
       return Promise.resolve();
     });
+    
+    // Stub FsUtility prototype to support readContentTypeSchemas
+    // readContentTypeSchemas reads individual JSON files and returns parsed objects
+    sinon.stub(FsUtility.prototype, 'readdir').returns([]);
+    sinon.stub(FsUtility.prototype, 'readFile').returns(undefined);
+    
     fsUtilityReadFileStub = sinon.stub(fsUtil, 'readFile');
     fsUtilityWriteFileStub = sinon.stub(fsUtil, 'writeFile').callsFake(() => {
       return Promise.resolve();
@@ -505,6 +511,10 @@ describe('EntriesImport', () => {
           }
           return {};
         });
+        
+        // Override FsUtility stubs to return field_rules_ct
+        (FsUtility.prototype.readdir as sinon.SinonStub).returns(['field_rules_ct.json']);
+        (FsUtility.prototype.readFile as sinon.SinonStub).returns(mockData.contentTypeWithFieldRules);
       });
 
       it('should update field rules with new UIDs', async () => {
@@ -539,6 +549,9 @@ describe('EntriesImport', () => {
       });
 
       it('should handle content type not found', async () => {
+        // This test expects the content type to be in schemas but API fetch returns null
+        // The beforeEach already sets up field_rules_ct, so this should work
+        
         mockStackClient.contentType.returns({
           fetch: sinon.stub().resolves(null),
         });
@@ -563,6 +576,9 @@ describe('EntriesImport', () => {
           }
           return {};
         });
+        
+        // Override FsUtility.readFile for this test
+        (FsUtility.prototype.readFile as sinon.SinonStub).returns(contentTypeWithoutFieldRules);
 
         await entriesImport['updateFieldRules']();
 
@@ -3096,9 +3112,21 @@ describe('EntriesImport', () => {
     });
 
     describe('updateFieldRules() Method Error Handling', () => {
+      beforeEach(() => {
+        // Override FsUtility stubs to return mock content types
+        (FsUtility.prototype.readdir as sinon.SinonStub).returns(['simple_ct.json', 'ref_ct.json']);
+      });
+
       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 '{}';
+        });
+
         fsUtilityReadFileStub.callsFake((filePath) => {
           console.log('fsUtil.readFile called with path:', filePath);
           if (filePath.includes('field_rules_uid.json')) {
@@ -3134,6 +3162,8 @@ 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));
+
         fsUtilityReadFileStub.callsFake((path) => {
           if (path.includes('field_rules_uid.json')) {
             return ['simple_ct']; // array of strings
@@ -3171,6 +3201,8 @@ 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));
+
         fsUtilityReadFileStub.callsFake((path) => {
           if (path.includes('field_rules_uid.json')) {
             return ['simple_ct']; // array of strings
@@ -3213,6 +3245,8 @@ describe('EntriesImport', () => {
         delete contentTypeWithoutRules.field_rules;
         const mockContentTypes = [contentTypeWithoutRules];
 
+        (FsUtility.prototype.readFile as sinon.SinonStub).returns(JSON.stringify(contentTypeWithoutRules));
+
         fsUtilityReadFileStub.callsFake((path) => {
           if (path.includes('field_rules_uid.json')) {
             return ['simple_ct']; // array of strings

packages/contentstack-utilities/src/content-type-utils.ts

@@ -10,12 +10,12 @@ import { FsUtility } from './fs-utility';
 export function readContentTypeSchemas(
   dirPath: string,
   ignoredFiles: string[] = ['schema.json', '.DS_Store', '__master.json', '__priority.json'],
-): Record<string, unknown>[] {
+): Record<string, unknown>[] | null {
   const fsUtil = new FsUtility();
   const files = fsUtil.readdir(dirPath);
 
   if (!files || files.length === 0) {
-    return [];
+    return null;
   }
 
   const contentTypes: Record<string, unknown>[] = [];