adding some tests

Author: charithaT07

packages/b2c-cli/src/commands/ods/create.ts

@@ -152,7 +152,7 @@ export default class OdsCreate extends OdsCommand<typeof OdsCreate> {
     this.logger.info({sandboxId: sandbox.id}, t('commands.ods.create.success', 'Sandbox created successfully'));
 
     if (wait && sandbox.id) {
-      this.log('');
+      this.log(t('commands.ods.create.waiting', 'Waiting for sandbox to get started..'));
       sandbox = await this.waitForSandbox(sandbox.id, pollInterval, timeout);
     }
 

packages/b2c-cli/test/commands/ods/delete.test.ts

@@ -69,6 +69,15 @@ describe('ods delete', () => {
       expect(OdsDelete.flags.force.char).to.equal('f');
     });
 
+    it('should expose wait/polling flags', () => {
+      expect(OdsDelete.flags).to.have.property('wait');
+      expect(OdsDelete.flags.wait.char).to.equal('w');
+      expect(OdsDelete.flags).to.have.property('poll-interval');
+      expect(OdsDelete.flags['poll-interval'].dependsOn).to.deep.equal(['wait']);
+      expect(OdsDelete.flags).to.have.property('timeout');
+      expect(OdsDelete.flags.timeout.dependsOn).to.deep.equal(['wait']);
+    });
+
     it('should have correct description', () => {
       expect(OdsDelete.description).to.be.a('string');
       expect(OdsDelete.description.toLowerCase()).to.include('delete');
@@ -128,6 +137,46 @@ describe('ods delete', () => {
       expect(logs.length).to.be.greaterThan(0);
     });
 
+    it('should poll sandbox state when --wait is true', async () => {
+      const command = new OdsDelete([], {} as any);
+
+      Object.defineProperty(command, 'args', {
+        value: {sandboxId: 'sandbox-123'},
+        configurable: true,
+      });
+
+      (command as any).flags = {force: true, wait: true, 'poll-interval': 0, timeout: 1};
+      stubCommandConfigAndLogger(command);
+      stubJsonEnabled(command, true);
+
+      const getSpy = sinon.spy(async () => {
+        // First GET is for confirmation/details, subsequent GET is polling
+        if (getSpy.callCount === 0) {
+          return {
+            data: {data: {id: 'sandbox-123', realm: 'zzzv', instance: 'zzzv-001', state: 'started'}},
+            response: new Response(),
+          };
+        }
+
+        return {
+          data: {data: {state: 'deleted'}},
+          response: new Response(),
+        };
+      });
+
+      stubOdsClient(command, {
+        GET: getSpy,
+        DELETE: async () => ({
+          data: {data: {}},
+          response: new Response(null, {status: 202}),
+        }),
+      });
+
+      await command.run();
+
+      expect(getSpy.callCount, 'Expected GET to be called multiple times when --wait is true').to.be.greaterThan(1);
+    });
+
     it('should log messages in non-JSON mode', async () => {
       const command = new OdsDelete([], {} as any);
 

packages/b2c-cli/test/commands/ods/operations.test.ts

@@ -5,6 +5,7 @@
  */
 
 import {expect} from 'chai';
+import sinon from 'sinon';
 
 import OdsStart from '../../../src/commands/ods/start.js';
 
@@ -66,6 +67,15 @@ describe('ods operations', () => {
       expect(OdsStart.enableJsonFlag).to.be.true;
     });
 
+    it('should expose wait/polling flags', () => {
+      expect(OdsStart.flags).to.have.property('wait');
+      expect(OdsStart.flags.wait.char).to.equal('w');
+      expect(OdsStart.flags).to.have.property('poll-interval');
+      expect(OdsStart.flags['poll-interval'].dependsOn).to.deep.equal(['wait']);
+      expect(OdsStart.flags).to.have.property('timeout');
+      expect(OdsStart.flags.timeout.dependsOn).to.deep.equal(['wait']);
+    });
+
     it('should return operation data in JSON mode', async () => {
       const command = new OdsStart([], {} as any);
 
@@ -178,6 +188,40 @@ describe('ods operations', () => {
         expect(error.message).to.include('Bad request');
       }
     });
+
+    it('should poll sandbox state when --wait is true', async () => {
+      const command = new OdsStart([], {} as any);
+
+      Object.defineProperty(command, 'args', {
+        value: {sandboxId: 'sandbox-123'},
+        configurable: true,
+      });
+
+      Object.defineProperty(command, 'flags', {
+        value: {wait: true, 'poll-interval': 0, timeout: 1},
+        configurable: true,
+      });
+
+      stubCommandConfigAndLogger(command);
+      stubJsonEnabled(command, true);
+
+      const getSpy = sinon.spy(async () => ({
+        data: {data: {state: 'started'}},
+        response: new Response(),
+      }));
+
+      stubOdsClient(command, {
+        POST: async () => ({
+          data: {data: {operation: 'start', operationState: 'running'}},
+          response: new Response(),
+        }),
+        GET: getSpy,
+      });
+
+      await command.run();
+
+      expect(getSpy.called, 'Expected GET to be called when --wait is true').to.equal(true);
+    });
   });
 
   describe('ods stop', () => {
@@ -195,6 +239,15 @@ describe('ods operations', () => {
       expect(OdsStop.enableJsonFlag).to.be.true;
     });
 
+    it('should expose wait/polling flags', () => {
+      expect(OdsStop.flags).to.have.property('wait');
+      expect(OdsStop.flags.wait.char).to.equal('w');
+      expect(OdsStop.flags).to.have.property('poll-interval');
+      expect(OdsStop.flags['poll-interval'].dependsOn).to.deep.equal(['wait']);
+      expect(OdsStop.flags).to.have.property('timeout');
+      expect(OdsStop.flags.timeout.dependsOn).to.deep.equal(['wait']);
+    });
+
     it('should return operation data in JSON mode', async () => {
       const command = new OdsStop([], {} as any);
 
@@ -307,6 +360,40 @@ describe('ods operations', () => {
         expect(error.message).to.include('Bad request');
       }
     });
+
+    it('should poll sandbox state when --wait is true', async () => {
+      const command = new OdsStop([], {} as any);
+
+      Object.defineProperty(command, 'args', {
+        value: {sandboxId: 'sandbox-123'},
+        configurable: true,
+      });
+
+      Object.defineProperty(command, 'flags', {
+        value: {wait: true, 'poll-interval': 0, timeout: 1},
+        configurable: true,
+      });
+
+      stubCommandConfigAndLogger(command);
+      stubJsonEnabled(command, true);
+
+      const getSpy = sinon.spy(async () => ({
+        data: {data: {state: 'stopped'}},
+        response: new Response(),
+      }));
+
+      stubOdsClient(command, {
+        POST: async () => ({
+          data: {data: {operation: 'stop', operationState: 'running'}},
+          response: new Response(),
+        }),
+        GET: getSpy,
+      });
+
+      await command.run();
+
+      expect(getSpy.called, 'Expected GET to be called when --wait is true').to.equal(true);
+    });
   });
 
   describe('ods restart', () => {
@@ -324,6 +411,15 @@ describe('ods operations', () => {
       expect(OdsRestart.enableJsonFlag).to.be.true;
     });
 
+    it('should expose wait/polling flags', () => {
+      expect(OdsRestart.flags).to.have.property('wait');
+      expect(OdsRestart.flags.wait.char).to.equal('w');
+      expect(OdsRestart.flags).to.have.property('poll-interval');
+      expect(OdsRestart.flags['poll-interval'].dependsOn).to.deep.equal(['wait']);
+      expect(OdsRestart.flags).to.have.property('timeout');
+      expect(OdsRestart.flags.timeout.dependsOn).to.deep.equal(['wait']);
+    });
+
     it('should return operation data in JSON mode', async () => {
       const command = new OdsRestart([], {} as any);
 
@@ -436,5 +532,39 @@ describe('ods operations', () => {
         expect(error.message).to.include('Bad request');
       }
     });
+
+    it('should poll sandbox state when --wait is true', async () => {
+      const command = new OdsRestart([], {} as any);
+
+      Object.defineProperty(command, 'args', {
+        value: {sandboxId: 'sandbox-123'},
+        configurable: true,
+      });
+
+      Object.defineProperty(command, 'flags', {
+        value: {wait: true, 'poll-interval': 0, timeout: 1},
+        configurable: true,
+      });
+
+      stubCommandConfigAndLogger(command);
+      stubJsonEnabled(command, true);
+
+      const getSpy = sinon.spy(async () => ({
+        data: {data: {state: 'started'}},
+        response: new Response(),
+      }));
+
+      stubOdsClient(command, {
+        POST: async () => ({
+          data: {data: {operation: 'restart', operationState: 'running'}},
+          response: new Response(),
+        }),
+        GET: getSpy,
+      });
+
+      await command.run();
+
+      expect(getSpy.called, 'Expected GET to be called when --wait is true').to.equal(true);
+    });
   });
 });