add test cases in stack.test

Author: naman-contentstack

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

@@ -1,6 +1,6 @@
 import { expect } from 'chai';
 import sinon from 'sinon';
-import { log, FsUtility } from '@contentstack/cli-utilities';
+import { FsUtility } from '@contentstack/cli-utilities';
 import ExportStack from '../../../../src/export/modules/stack';
 import ExportConfig from '../../../../src/types/export-config';
 
@@ -276,40 +276,166 @@ describe('ExportStack', () => {
 
       expect(locale).to.exist;
       expect(locale.code).to.equal('en-us');
+      expect(locale.name).to.equal('English (United States)');
+    });
+
+    it('should recursively search for master locale across multiple pages', async () => {
+      let callCount = 0;
+      const localeStub = {
+        query: sinon.stub().returns({
+          find: sinon.stub().callsFake(() => {
+            callCount++;
+            if (callCount === 1) {
+              // First batch without master locale
+              return Promise.resolve({
+                items: new Array(100).fill({ uid: 'locale-test', code: 'en', fallback_locale: 'en-us' }),
+                count: 150
+              });
+            } else {
+              // Second batch with master locale
+              return Promise.resolve({
+                items: [{ uid: 'locale-master', code: 'en-us', fallback_locale: null, name: 'English' }],
+                count: 150
+              });
+            }
+          })
+        })
+      };
+      
+      mockStackClient.locale.returns(localeStub);
+      const locale = await exportStack.getLocales();
+      
+      expect(callCount).to.be.greaterThan(1);
+      expect(locale.code).to.equal('en-us');
     });
 
     it('should handle error when fetching locales', async () => {
-      // Test error handling
+      const localeStub = {
+        query: sinon.stub().returns({
+          find: sinon.stub().rejects(new Error('API Error'))
+        })
+      };
+      
+      mockStackClient.locale.returns(localeStub);
+      
+      try {
+        await exportStack.getLocales();
+        expect.fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).to.exist;
+      }
+    });
+
+    it('should handle no items response and skip searching', async () => {
+      const localeStub = {
+        query: sinon.stub().returns({
+          find: sinon.stub().resolves({
+            items: [],
+            count: 0
+          })
+        })
+      };
+      
+      mockStackClient.locale.returns(localeStub);
       const locale = await exportStack.getLocales();
 
-      expect(locale).to.exist;
+      expect(locale).to.be.undefined;
+    });
+
+    it('should find master locale in first batch when present', async () => {
+      const localeStub = {
+        query: sinon.stub().returns({
+          find: sinon.stub().resolves({
+            items: [
+              { uid: 'locale-1', code: 'es-es', fallback_locale: 'en-us' },
+              { uid: 'locale-master', code: 'en-us', fallback_locale: null, name: 'English' }
+            ],
+            count: 2
+          })
+        })
+      };
+      
+      mockStackClient.locale.returns(localeStub);
+      const locale = await exportStack.getLocales();
+      
+      expect(locale.code).to.equal('en-us');
     });
   });
 
   describe('exportStack() method', () => {
-    it('should export stack successfully', async () => {
+    it('should export stack successfully and write to file', async () => {
+      const writeFileStub = FsUtility.prototype.writeFile as sinon.SinonStub;
+      const makeDirectoryStub = FsUtility.prototype.makeDirectory as sinon.SinonStub;
+      
       await exportStack.exportStack();
 
-      // Should complete without error
+      expect(writeFileStub.called).to.be.true;
+      expect(makeDirectoryStub.called).to.be.true;
     });
 
-    it('should handle errors when exporting stack', async () => {
-      // Should handle error gracefully
+    it('should handle errors when exporting stack without throwing', async () => {
+      mockStackClient.fetch = sinon.stub().rejects(new Error('Stack fetch failed'));
+      
+      // Should complete without throwing despite error
+      // The assertion is that await doesn't throw
       await exportStack.exportStack();
     });
   });
 
   describe('exportStackSettings() method', () => {
-    it('should export stack settings successfully', async () => {
+    it('should export stack settings successfully and write to file', async () => {
+      const writeFileStub = FsUtility.prototype.writeFile as sinon.SinonStub;
+      const makeDirectoryStub = FsUtility.prototype.makeDirectory as sinon.SinonStub;
+      
       await exportStack.exportStackSettings();
 
-      // Should complete without error
+      expect(writeFileStub.called).to.be.true;
+      expect(makeDirectoryStub.called).to.be.true;
     });
 
-    it('should handle errors when exporting settings', async () => {
-      // Should handle error gracefully
+    it('should handle errors when exporting settings without throwing', async () => {
+      mockStackClient.settings = sinon.stub().rejects(new Error('Settings fetch failed'));
+
+      // Should complete without throwing despite error
+      // The assertion is that await doesn't throw
       await exportStack.exportStackSettings();
     });
   });
+
+  describe('start() method', () => {
+    it('should export stack when preserveStackVersion is true', async () => {
+      const exportStackStub = sinon.stub(exportStack, 'exportStack').resolves({ name: 'test-stack' });
+      const exportStackSettingsStub = sinon.stub(exportStack, 'exportStackSettings').resolves();
+      const getStackStub = sinon.stub(exportStack, 'getStack').resolves({});
+      
+      exportStack.exportConfig.preserveStackVersion = true;
+      
+      await exportStack.start();
+      
+      expect(exportStackStub.called).to.be.true;
+      
+      exportStackStub.restore();
+      exportStackSettingsStub.restore();
+      getStackStub.restore();
+    });
+
+    it('should skip exportStackSettings when management_token is present', async () => {
+      const getStackStub = sinon.stub(exportStack, 'getStack').resolves({});
+      const exportStackSettingsSpy = sinon.spy(exportStack, 'exportStackSettings');
+      
+      exportStack.exportConfig.management_token = 'some-token';
+      exportStack.exportConfig.preserveStackVersion = false;
+      exportStack.exportConfig.master_locale = { code: 'en-us' };
+      exportStack.exportConfig.hasOwnProperty = sinon.stub().returns(true);
+      
+      await exportStack.start();
+      
+      // Verify exportStackSettings was NOT called
+      expect(exportStackSettingsSpy.called).to.be.false;
+      
+      getStackStub.restore();
+      exportStackSettingsSpy.restore();
+    });
+  });
 });