Improve command test patterns with Sinon and integration tests

- Add sinon, @types/sinon, @oclif/test as SDK dev dependencies
- Create stubParse helper for cleaner parse method mocking
- Refactor 5 command test files to use Sinon instead of manual mocking
- Add test fixture (test/fixtures/test-cli/) for integration testing
- Add base-command.integration.test.ts with runCommand() tests
- Update testing skill docs with new patterns

The stubParse helper eliminates the brittle MockableXxxCommand type
casting pattern. Integration tests exercise full command lifecycle
through the oclif test utilities.

Author: clavery

.claude/skills/testing/SKILL.md

@@ -12,6 +12,7 @@ This skill covers project-specific testing patterns for the B2C CLI project.
 - **Test Runner**: Mocha
 - **Assertions**: Chai (property-based)
 - **HTTP Mocking**: MSW (Mock Service Worker)
+- **Stubbing/Mocking**: Sinon
 - **Code Coverage**: c8
 - **TypeScript**: tsx (native execution without compilation)
 
@@ -120,14 +121,12 @@ const config = resolveConfig({}, {
 });
 ```
 
-In CLI command tests, mock the `credentials-file` flag:
+In CLI command tests, use the `stubParse` helper with the `credentials-file` flag:
 
 ```typescript
-cmd.parse = (async () => ({
-  args: {},
-  flags: {'credentials-file': '/dev/null'},  // Isolates from real ~/.mobify
-  metadata: {},
-})) as typeof cmd.parse;
+import { stubParse } from '../helpers/stub-parse.js';
+
+stubParse(command, {'credentials-file': '/dev/null'});  // Isolates from real ~/.mobify
 ```
 
 ## Polling Tests (Avoid Fake Timers)
@@ -312,33 +311,34 @@ const customAuth = new MockAuthStrategy('custom-token');
 
 Command tests should focus on **command-specific logic**, not trivial flag verification.
 
-### Good Command Tests
+### Using the stubParse Helper
 
-Test behavior that is specific to the command class:
+Use the `stubParse` helper from `test/helpers/stub-parse.js` to stub oclif's parse method. This handles the type casting needed for oclif's protected `parse` method:
 
 ```typescript
-describe('requireMrtCredentials', () => {
+import sinon from 'sinon';
+import { stubParse } from '../helpers/stub-parse.js';
+import { isolateConfig, restoreConfig } from '../helpers/config-isolation.js';
+
+describe('cli/mrt-command', () => {
+  afterEach(() => {
+    sinon.restore();
+    restoreConfig();
+  });
+
   it('throws error when no credentials', async () => {
-    cmd.parse = (async () => ({
-      args: {},
-      flags: {'credentials-file': '/dev/null'},
-      metadata: {},
-    })) as typeof cmd.parse;
-
-    await cmd.init();
-    let errorCalled = false;
-    cmd.error = () => {
-      errorCalled = true;
-      throw new Error('Expected error');
-    };
+    stubParse(command, {'credentials-file': '/dev/null'});
+    await command.init();
+
+    const errorStub = sinon.stub(command, 'error').throws(new Error('Expected error'));
 
     try {
       command.testRequireMrtCredentials();
     } catch {
       // Expected
     }
 
-    expect(errorCalled).to.be.true;
+    expect(errorStub.called).to.be.true;
   });
 });
 ```
@@ -350,12 +350,10 @@ Do not write tests that just verify flag values equal mocked values:
 ```typescript
 // BAD - tests nothing (just verifies JavaScript assignment works)
 it('handles server flag', async () => {
-  cmd.parse = (async () => ({
-    flags: {server: 'test.demandware.net'},
-  })) as typeof cmd.parse;
+  stubParse(command, {server: 'test.demandware.net'});
 
-  await cmd.init();
-  expect(cmd.flags.server).to.equal('test.demandware.net');  // Trivial!
+  await command.init();
+  expect(command.flags.server).to.equal('test.demandware.net');  // Trivial!
 });
 ```
 
@@ -372,6 +370,10 @@ it('handles server flag', async () => {
 
 ## Testing CLI Commands with oclif
 
+### Integration Tests with runCommand
+
+Use `@oclif/test`'s `runCommand()` for integration-style tests:
+
 ```typescript
 import { runCommand } from '@oclif/test';
 import { expect } from 'chai';
@@ -384,6 +386,18 @@ describe('ods list', () => {
 });
 ```
 
+### SDK Base Command Integration Tests
+
+The SDK includes a test fixture at `test/fixtures/test-cli/` for integration testing base command behavior. See `test/cli/base-command.integration.test.ts` for examples.
+
+### When to Use Each Approach
+
+| Approach | Use For |
+|----------|---------|
+| Unit tests with `stubParse` | Testing protected method logic in isolation |
+| Integration tests with fixture | Testing full command lifecycle, flag parsing |
+| `runCommand()` in b2c-cli | Testing actual CLI commands |
+
 ## E2E Tests
 
 E2E tests run against real infrastructure and are skipped without credentials:

packages/b2c-tooling-sdk/package.json

@@ -210,12 +210,14 @@
     "@eslint/compat": "^1",
     "@oclif/core": "^4",
     "@oclif/prettier-config": "^0.2.1",
+    "@oclif/test": "^4.1.14",
     "@salesforce/dev-config": "^4.3.2",
     "@tony.ganchev/eslint-plugin-header": "^3.1.11",
     "@types/archiver": "^7.0.0",
     "@types/chai": "^4.3.20",
     "@types/mocha": "^10.0.10",
     "@types/node": "^18.19.130",
+    "@types/sinon": "^21.0.0",
     "@types/xml2js": "^0.4.14",
     "c8": "^10.1.3",
     "chai": "^4.5.0",
@@ -227,6 +229,7 @@
     "openapi-typescript": "^7.10.1",
     "prettier": "^3.6.2",
     "shx": "^0.3.3",
+    "sinon": "^21.0.1",
     "tsx": "^4.20.6",
     "typescript": "^5",
     "typescript-eslint": "^8"

packages/b2c-tooling-sdk/test/cli/base-command.integration.test.ts

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2025, Salesforce, Inc.
+ * 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 {expect} from 'chai';
+import {runCommand} from '@oclif/test';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const fixtureRoot = path.join(__dirname, '../fixtures/test-cli');
+
+describe('BaseCommand integration', () => {
+  it('runs test-base command without errors', async () => {
+    const {error} = await runCommand(['test-base'], {root: fixtureRoot});
+    expect(error).to.be.undefined;
+  });
+
+  it('handles --extra-query flag', async () => {
+    const {error, result} = await runCommand<{extraParams?: Record<string, unknown>}>(
+      ['test-base', '--extra-query', '{"debug":"true"}', '--json'],
+      {root: fixtureRoot},
+    );
+
+    expect(error).to.be.undefined;
+    expect(result?.extraParams?.query).to.deep.equal({debug: 'true'});
+  });
+
+  it('handles --extra-body flag', async () => {
+    const {error, result} = await runCommand<{extraParams?: Record<string, unknown>}>(
+      ['test-base', '--extra-body', '{"_internal":true}', '--json'],
+      {root: fixtureRoot},
+    );
+
+    expect(error).to.be.undefined;
+    expect(result?.extraParams?.body).to.deep.equal({_internal: true});
+  });
+
+  it('handles both --extra-query and --extra-body flags', async () => {
+    const {error, result} = await runCommand<{extraParams?: Record<string, unknown>}>(
+      ['test-base', '--extra-query', '{"debug":"true"}', '--extra-body', '{"_internal":true}', '--json'],
+      {root: fixtureRoot},
+    );
+
+    expect(error).to.be.undefined;
+    expect(result?.extraParams?.query).to.deep.equal({debug: 'true'});
+    expect(result?.extraParams?.body).to.deep.equal({_internal: true});
+  });
+
+  it('returns undefined extraParams when no extra flags provided', async () => {
+    const {error, result} = await runCommand<{extraParams?: Record<string, unknown>}>(['test-base', '--json'], {
+      root: fixtureRoot,
+    });
+
+    expect(error).to.be.undefined;
+    expect(result?.extraParams).to.be.undefined;
+  });
+});