test: added test for nested global fields

Vikram Kalta · Vikram Kalta · commit 24e2be8eb1d1 · 2025-02-17T20:36:10.000Z
diff --git a/packages/contentstack-audit/README.md b/packages/contentstack-audit/README.md
@@ -19,7 +19,7 @@ $ npm install -g @contentstack/cli-audit
 $ csdx COMMAND
 running command...
 $ csdx (--version|-v)
-@contentstack/cli-audit/1.7.5 darwin-arm64 node-v22.2.0
+@contentstack/cli-audit/1.7.5 darwin-arm64 node-v18.18.0
 $ csdx --help [COMMAND]
 USAGE
   $ csdx COMMAND
diff --git a/packages/contentstack-audit/test/unit/modules/entries.test.ts b/packages/contentstack-audit/test/unit/modules/entries.test.ts
@@ -22,6 +22,8 @@ import {
 
 describe('Entries module', () => {
   let constructorParam: ModuleConstructorParam & CtConstructorParam;
+  let ctStub: Sinon.SinonStub;
+  let gfStub: Sinon.SinonStub;
 
   beforeEach(() => {
     constructorParam = {
@@ -33,6 +35,17 @@ describe('Entries module', () => {
     };
   });
 
+  before(() => {
+    ctStub = Sinon.stub(ContentType.prototype, 'run').resolves({ ct1: [{}] });
+    gfStub = Sinon.stub(GlobalField.prototype, 'run').resolves({ gf1: [{}] });
+  });
+
+  after(() => {
+    Sinon.restore(); // Clears Sinon spies/stubs/mocks
+    ctStub.restore();
+    gfStub.restore();
+  });
+
   describe('run method', () => {
     fancy
       .stdout({ print: process.env.PRINT === 'true' || false })
@@ -93,16 +106,11 @@ describe('Entries module', () => {
   describe('fixPrerequisiteData method', () => {
     fancy
       .stdout({ print: process.env.PRINT === 'true' || false })
-      .stub(ContentType.prototype, 'run', async () => ({ ct1: [{}] }))
-      .stub(GlobalField.prototype, 'run', async () => ({ gf1: [{}] }))
-
       .it('should call content type and global fields fix functionality', async () => {
-        const ctRun = Sinon.spy(ContentType.prototype, 'run');
-        const gfRun = Sinon.spy(GlobalField.prototype, 'run');
         const ctInstance = new Entries(constructorParam);
         await ctInstance.fixPrerequisiteData();
-        expect(ctRun.callCount).to.be.equals(1);
-        expect(gfRun.callCount).to.be.equals(1);
+        expect(ctStub.callCount).to.be.equals(1);
+        expect(gfStub.callCount).to.be.equals(1);
         expect(ctInstance.ctSchema).deep.contain({ ct1: [{}] });
         expect(ctInstance.gfSchema).deep.contain({ gf1: [{}] });
       });
diff --git a/packages/contentstack-audit/test/unit/modules/global-field.test.ts b/packages/contentstack-audit/test/unit/modules/global-field.test.ts
@@ -1,3 +1,5 @@
+import fs from 'fs';
+import sinon from 'sinon';
 import { resolve } from 'path';
 import { fancy } from 'fancy-test';
 import { expect } from 'chai';
@@ -7,48 +9,99 @@ import { ux } from '@contentstack/cli-utilities';
 import config from '../../../src/config';
 import { GlobalField } from '../../../src/modules';
 import { $t, auditMsg } from '../../../src/messages';
-
+import { CtConstructorParam, ModuleConstructorParam } from '../../../src/types';
 
 describe('Global Fields', () => {
-  describe('run method with invalid path for global_feild', () => {
-    const gfInstance = new GlobalField({
+  let constructorParam: ModuleConstructorParam & CtConstructorParam;
+
+  class AuditFixTempClass extends GlobalField {
+    constructor(public missingRefs: Record<string, any> = {}) {
+      super({ ...constructorParam, fix: true, moduleName: 'global-fields' });
+      this.currentUid = 'audit-fix';
+      this.currentTitle = 'Audit fix';
+      this.missingRefs['audit-fix'] = [];
+    }
+  }
+
+  beforeEach(() => {
+    constructorParam = {
       log: () => {},
       moduleName: 'global-fields',
       ctSchema: cloneDeep(require('../mock/contents/content_types/schema.json')),
-      gfSchema: cloneDeep(require('../mock/contents/global_fields/Global_fields_2.json')),
+      gfSchema: cloneDeep(require('../mock/contents/global_fields/globalfields.json')),
       config: Object.assign(config, { basePath: resolve(__dirname, '..', 'mock', 'contents'), flags: {} }),
-    });
+    };
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  describe('run method', () => {
     fancy
       .stdout({ print: process.env.PRINT === 'true' || false })
       .stub(ux, 'confirm', async () => true)
-      .it('Should Validate the base path for workflows', async () => {
+      .it('Should Validate the base path for global-fields', async () => {
+        const gfInstance = new GlobalField({ ...constructorParam });
         try {
           await gfInstance.run();
         } catch (error: any) {
           expect(error).to.be.instanceOf(Error);
           expect(error.message).to.eql($t(auditMsg.NOT_VALID_PATH, { path: gfInstance.folderPath }));
         }
       });
+
+    fancy
+      .stdout({ print: process.env.PRINT === 'true' || false })
+      .stub(GlobalField.prototype, 'lookForReference', async () => {})
+      .it('should call lookForReference', async () => {
+        const gfInstance = new GlobalField(constructorParam);
+        const logSpy = sinon.spy(gfInstance, 'lookForReference');
+        await gfInstance.run();
+        expect(logSpy.callCount).to.be.equals(gfInstance.gfSchema.length);
+      });
+
+    fancy
+      .stdout({ print: process.env.PRINT === 'true' || false })
+      .stub(GlobalField.prototype, 'lookForReference', async () => {})
+      .it('should return schema', async () => {
+        const gfInstance = new GlobalField(constructorParam);
+        expect(await gfInstance.run(true)).to.deep.equals(gfInstance.gfSchema);
+      });
+
+    fancy
+      .stdout({ print: process.env.PRINT === 'true' || false })
+      .stub(GlobalField.prototype, 'lookForReference', async () => {})
+      .stub(GlobalField.prototype, 'writeFixContent', async () => {})
+      .it('should call writeFixContent', async () => {
+        const gfInstance = new GlobalField({ ...constructorParam, fix: true });
+        const logSpy = sinon.spy(gfInstance, 'writeFixContent');
+        await gfInstance.run();
+        expect(logSpy.callCount).to.be.equals(1);
+      });
   });
 
-  describe('run method with valid Path', () => {
-    const gfInstance = new GlobalField({
-      log: () => {},
-      moduleName: 'global-fields',
-      ctSchema: cloneDeep(require('../mock/contents/content_types/schema.json')),
-      gfSchema: cloneDeep(require('../mock/contents/global_fields/globalfields.json')),
-      config: Object.assign(config, { basePath: resolve(__dirname, '..', 'mock', 'contents'), flags: {} }),
-    });
+  describe('fix nested global field references', () => {
     fancy
-      .stdout({ print: process.env.PRINT === 'true' || true })
-      .stub(ux, 'confirm', async () => true)
-      .it('Should output the global feild where nested feilds are not present', async () => {
-        try {
-          const missingRefs = await gfInstance.run();
-          expect(JSON.stringify(missingRefs)).to.be.equal(
-            '{\n  nested_global_field_2: [\n    {\n      tree: [\n        {\n          uid: "nested_global_field_2",\n          name: "Nested Global Field 2",\n        },\n        {\n          uid: "global_field",\n          name: "Global",\n        },\n      ],\n      ct: "nested_global_field_2",\n      name: "Nested Global Field 2",\n      data_type: "global_field",\n      display_name: "Global",\n      missingRefs: "Referred Global Field Does not Exist",\n      treeStr: "Nested Global Field 2 ➜ Global",\n    },\n  ],\n  global_field_sample_2: [\n    {\n      tree: [\n        {\n          uid: "global_field_sample_2",\n          name: "global_field_sample_2",\n        },\n        {\n          uid: "group",\n          name: "Group",\n        },\n        {\n          uid: "group",\n          name: "Group",\n        },\n        {\n          uid: "global_field",\n          name: "Global",\n        },\n      ],\n      ct: "global_field_sample_2",\n      name: "global_field_sample_2",\n      data_type: "global_field",\n      display_name: "Global",\n      missingRefs: "Referred Global Field Does not Exist",\n      treeStr: "global_field_sample_2 ➜ Group ➜ Group ➜ Global",\n    },\n  ],\n}',
-          );
-        } catch (error) {}
+      .stub(fs, 'rmSync', () => {})
+      .stdout({ print: process.env.PRINT === 'true' || false })
+      .stub(GlobalField.prototype, 'writeFixContent', async () => {})
+      .it('perform audit operation on the given GF schema', async () => {
+        const gfInstance = new AuditFixTempClass();
+
+        await gfInstance.run();
+
+        expect(gfInstance.missingRefs).ownProperty('nested_global_field_2');
+        expect(JSON.stringify(gfInstance.missingRefs)).includes('"missingRefs":["nested_global_field_1"]');
+      });
+
+    fancy
+      .stub(fs, 'rmSync', () => {})
+      .stdout({ print: process.env.PRINT === 'true' || false })
+      .stub(GlobalField.prototype, 'writeFixContent', async () => {})
+      .it('perform audit and fix operation on the given GF schema', async () => {
+        const gfInstance = new AuditFixTempClass();
+        expect(JSON.stringify(await gfInstance.run(true))).includes('"uid":"global_field_sample_2","schema":[]');
       });
   });
 });
