@W-21319424 Increasing the unit test coverage for cli package (#197)

* @W-21319424 Increasing the unit test coverage for cli package

* adding tests

* remove incorrect --show-usage flag from realm list command documentation

* adding tests

Author: charithaT07

packages/b2c-cli/test/commands/_test/index.test.ts

@@ -3,14 +3,71 @@
  * SPDX-License-Identifier: Apache-2
  * For full license text, see the license.txt file in the repo root or http://www.apache.org/licenses/LICENSE-2.0
  */
-import {runCommand} from '@oclif/test';
+
 import {expect} from 'chai';
+import sinon from 'sinon';
+import Test from '../../../src/commands/_test/index.js';
+import {createIsolatedConfigHooks, createTestCommand} from '../../helpers/test-setup.js';
+
+describe('commands/_test', () => {
+  const hooks = createIsolatedConfigHooks();
+
+  beforeEach(async () => {
+    await hooks.beforeEach();
+  });
+
+  afterEach(() => {
+    hooks.afterEach();
+  });
+
+  async function createCommand(): Promise<any> {
+    return createTestCommand(Test, hooks.getConfig(), {}, {});
+  }
+
+  it('exercises logging functionality', async () => {
+    const command = await createCommand();
+
+    const logStub = sinon.stub(command, 'log');
+    const traceStub = sinon.stub(command.logger, 'trace');
+    const infoStub = sinon.stub(command.logger, 'info');
+
+    await command.run();
+
+    expect(logStub.calledWith('Using this.log() - goes through pino')).to.be.true;
+    expect(traceStub.calledWith('Trace level message')).to.be.true;
+    expect(infoStub.called).to.be.true;
+  });
+
+  it('logs with context objects', async () => {
+    const command = await createCommand();
+
+    sinon.stub(command, 'log');
+    const infoStub = sinon.stub(command.logger, 'info');
+
+    await command.run();
+
+    // Verify info was called with context objects
+    const callWithContext = infoStub
+      .getCalls()
+      .find((call) => call.args[0] && typeof call.args[0] === 'object' && 'operation' in call.args[0]);
+    expect(callWithContext).to.exist;
+    expect(callWithContext?.args[0]).to.deep.include({operation: 'test', duration: 123});
+  });
+
+  it('logs with redacted sensitive fields', async () => {
+    const command = await createCommand();
+
+    sinon.stub(command, 'log');
+    const infoStub = sinon.stub(command.logger, 'info');
+
+    await command.run();
 
-describe('_test', () => {
-  // Skip in automated tests - this is a debug command that intentionally produces log output
-  // Run manually with: ./cli _test
-  it.skip('runs the smoke test command without errors', async () => {
-    const {error} = await runCommand('_test');
-    expect(error).to.be.undefined;
+    // Verify info was called with object containing sensitive fields
+    const callWithSensitive = infoStub
+      .getCalls()
+      .find((call) => call.args[0] && typeof call.args[0] === 'object' && 'password' in call.args[0]);
+    expect(callWithSensitive).to.exist;
+    expect(callWithSensitive?.args[0]).to.have.property('password');
+    expect(callWithSensitive?.args[0]).to.have.property('client_secret');
   });
 });

packages/b2c-cli/test/commands/am/clients/get.test.ts

@@ -110,6 +110,88 @@ describe('am clients get', () => {
       expect(result.redirectUrls).to.deep.equal(['https://example.com/callback']);
     });
 
+    it('should display client details in non-JSON mode', async () => {
+      const command = new ClientGet([], {} as any);
+      (command as any).args = {'api-client-id': 'client-123'};
+      (command as any).flags = {};
+      stubCommandConfigAndLogger(command);
+      stubJsonEnabled(command, false);
+      stubImplicitOAuthStrategy(command);
+
+      const fullClient = {
+        ...mockClient,
+        organizations: ['org-1', {id: 'org-2'}],
+        roles: ['ADMIN', {roleEnumName: 'USER', id: 'user-role'}],
+        roleTenantFilterMap: {ADMIN: 'f_ecom_zzxy_prd'},
+        roleTenantFilter: '',
+        defaultScopes: ['openid'],
+        versionControl: ['v1'],
+        disabledTimestamp: null,
+        lastAuthenticatedDate: '2025-01-15',
+        passwordModificationTimestamp: 1_706_200_000_000,
+      };
+
+      server.use(
+        http.get(`${BASE_URL}/apiclients/client-123`, () => {
+          return HttpResponse.json(fullClient);
+        }),
+      );
+
+      const result = await command.run();
+      expect(result.id).to.equal('client-123');
+    });
+
+    it('should display client with minimal fields in non-JSON mode', async () => {
+      const command = new ClientGet([], {} as any);
+      (command as any).args = {'api-client-id': 'client-456'};
+      (command as any).flags = {};
+      stubCommandConfigAndLogger(command);
+      stubJsonEnabled(command, false);
+      stubImplicitOAuthStrategy(command);
+
+      const minimalClient = {
+        id: 'client-456',
+        name: 'Minimal Client',
+        active: false,
+        redirectUrls: [],
+        scopes: [],
+        defaultScopes: [],
+        organizations: [],
+        roles: [],
+        roleTenantFilterMap: {},
+        roleTenantFilter: 'ADMIN:zzxy_prd',
+      };
+
+      server.use(
+        http.get(`${BASE_URL}/apiclients/client-456`, () => {
+          return HttpResponse.json(minimalClient);
+        }),
+      );
+
+      const result = await command.run();
+      expect(result.id).to.equal('client-456');
+    });
+
+    it('should handle valid expand flag', async () => {
+      const command = new ClientGet([], {} as any);
+      (command as any).args = {'api-client-id': 'client-123'};
+      (command as any).flags = {expand: 'organizations,roles'};
+      stubCommandConfigAndLogger(command);
+      stubJsonEnabled(command, true);
+      stubImplicitOAuthStrategy(command);
+
+      server.use(
+        http.get(`${BASE_URL}/apiclients/client-123`, ({request}) => {
+          const url = new URL(request.url);
+          expect(url.searchParams.get('expand')).to.include('organizations');
+          return HttpResponse.json(mockClient);
+        }),
+      );
+
+      const result = await command.run();
+      expect(result.id).to.equal('client-123');
+    });
+
     it('should error when API client not found', async () => {
       const command = new ClientGet([], {} as any);
       (command as any).args = {'api-client-id': 'nonexistent'};

packages/b2c-cli/test/commands/am/clients/update.test.ts

@@ -10,7 +10,12 @@ import {http, HttpResponse} from 'msw';
 import {setupServer} from 'msw/node';
 import {isolateConfig, restoreConfig} from '@salesforce/b2c-tooling-sdk/test-utils';
 import ClientUpdate from '../../../../src/commands/am/clients/update.js';
-import {stubCommandConfigAndLogger, stubJsonEnabled, stubImplicitOAuthStrategy} from '../../../helpers/test-setup.js';
+import {
+  stubCommandConfigAndLogger,
+  stubJsonEnabled,
+  stubImplicitOAuthStrategy,
+  makeCommandThrowOnError,
+} from '../../../helpers/test-setup.js';
 
 const TEST_HOST = 'account.test.demandware.com';
 const BASE_URL = `https://${TEST_HOST}/dw/rest/v1`;
@@ -52,6 +57,68 @@ describe('am clients update', () => {
     });
   });
 
+  describe('validation', () => {
+    it('should error when no flags provided', async () => {
+      const command = new ClientUpdate([], {} as any);
+      (command as any).args = {'api-client-id': 'client-123'};
+      (command as any).flags = {};
+      stubCommandConfigAndLogger(command);
+      makeCommandThrowOnError(command);
+
+      try {
+        await command.run();
+        expect.fail('Should have thrown');
+      } catch (error: unknown) {
+        expect((error as Error).message).to.match(/No changes specified/);
+      }
+    });
+
+    it('should error when name exceeds 200 chars', async () => {
+      const command = new ClientUpdate([], {} as any);
+      (command as any).args = {'api-client-id': 'client-123'};
+      (command as any).flags = {name: 'a'.repeat(201)};
+      stubCommandConfigAndLogger(command);
+      makeCommandThrowOnError(command);
+
+      try {
+        await command.run();
+        expect.fail('Should have thrown');
+      } catch (error: unknown) {
+        expect((error as Error).message).to.match(/at most 200 characters/);
+      }
+    });
+
+    it('should error when description exceeds 256 chars', async () => {
+      const command = new ClientUpdate([], {} as any);
+      (command as any).args = {'api-client-id': 'client-123'};
+      (command as any).flags = {description: 'a'.repeat(257)};
+      stubCommandConfigAndLogger(command);
+      makeCommandThrowOnError(command);
+
+      try {
+        await command.run();
+        expect.fail('Should have thrown');
+      } catch (error: unknown) {
+        expect((error as Error).message).to.match(/at most 256 characters/);
+      }
+    });
+
+    it('should error on invalid role-tenant-filter', async () => {
+      const command = new ClientUpdate([], {} as any);
+      (command as any).args = {'api-client-id': 'client-123'};
+      (command as any).flags = {'role-tenant-filter': 'INVALID FORMAT!!'};
+      stubCommandConfigAndLogger(command);
+      makeCommandThrowOnError(command);
+
+      try {
+        await command.run();
+        expect.fail('Should have thrown');
+      } catch (error: unknown) {
+        expect((error as Error).message).to.match(/Role tenant filter must match pattern/);
+      }
+    });
+  });
+
   describe('output formatting', () => {
     it('should return updated client in JSON mode', async () => {
       const command = new ClientUpdate([], {} as any);
@@ -83,5 +150,66 @@ describe('am clients update', () => {
       expect(result.id).to.equal('client-123');
       expect(result.name).to.equal('Updated Name');
     });
+
+    it('should handle all update flags', async () => {
+      const command = new ClientUpdate([], {} as any);
+      (command as any).args = {'api-client-id': 'client-123'};
+      (command as any).flags = {
+        name: 'New Name',
+        description: 'New desc',
+        organizations: 'org-1,org-2',
+        roles: 'role-1,role-2',
+        'role-tenant-filter': 'SALESFORCE_COMMERCE_API:abcd_prd',
+        active: true,
+        'redirect-urls': 'https://a.com,https://b.com',
+        scopes: 'openid,mail',
+        'default-scopes': 'openid',
+        'version-control': 'v1',
+        'token-endpoint-auth-method': 'client_secret_post',
+        'jwt-public-key': '  some-key  ',
+      };
+      stubCommandConfigAndLogger(command);
+      stubJsonEnabled(command, true);
+      stubImplicitOAuthStrategy(command);
+
+      server.use(
+        http.put(`${BASE_URL}/apiclients/client-123`, async ({request}) => {
+          const body = (await request.json()) as Record<string, unknown>;
+          expect(body.name).to.equal('New Name');
+          expect(body.active).to.equal(true);
+          expect(body.organizations).to.deep.equal(['org-1', 'org-2']);
+          expect(body.roles).to.deep.equal(['role-1', 'role-2']);
+          expect(body.scopes).to.deep.equal(['openid', 'mail']);
+          expect(body.defaultScopes).to.deep.equal(['openid']);
+          expect(body.redirectUrls).to.deep.equal(['https://a.com', 'https://b.com']);
+          expect(body.tokenEndpointAuthMethod).to.equal('client_secret_post');
+          expect(body.jwtPublicKey).to.equal('some-key');
+          return HttpResponse.json({id: 'client-123', ...body});
+        }),
+      );
+
+      const result = await command.run();
+      expect(result.id).to.equal('client-123');
+    });
+
+    it('should handle empty jwt-public-key as null', async () => {
+      const command = new ClientUpdate([], {} as any);
+      (command as any).args = {'api-client-id': 'client-123'};
+      (command as any).flags = {'jwt-public-key': ''};
+      stubCommandConfigAndLogger(command);
+      stubJsonEnabled(command, true);
+      stubImplicitOAuthStrategy(command);
+
+      server.use(
+        http.put(`${BASE_URL}/apiclients/client-123`, async ({request}) => {
+          const body = (await request.json()) as Record<string, unknown>;
+          expect(body.jwtPublicKey).to.equal(null);
+          return HttpResponse.json({id: 'client-123'});
+        }),
+      );
+
+      const result = await command.run();
+      expect(result.id).to.equal('client-123');
+    });
   });
 });