@salesforce/core 3.30.13 → 3.31.4

package/README.md

@@ -33,12 +33,11 @@ Here you can mock authorization for a Salesforce scratch org.
 
 ```typescript
 import { strictEqual } from 'assert';
-import { MockTestOrgData, testSetup } from '@salesforce/core/lib/testSetup';
+import { MockTestOrgData, TestContext } from '@salesforce/core/lib/testSetup';
 import { AuthInfo } from '@salesforce/core';
 
-const $$ = testSetup();
-
 describe('Mocking Auth data', () => {
+  const $$ = new TestContext();
   it('example', async () => {
     const testData = new MockTestOrgData();
     await $$.stubAuths(testData);
@@ -52,15 +51,14 @@ After having a valid AuthInfo object you can then create fake connections to a S
 
 ```typescript
 import { AuthInfo, Connection, SfError } from '@salesforce/core';
-import { MockTestOrgData, testSetup } from '@salesforce/core/lib/testSetup';
+import { MockTestOrgData, TestContext } from '@salesforce/core/lib/testSetup';
 import { AnyJson, ensureJsonMap, JsonMap } from '@salesforce/ts-types';
 import { ensureString } from '@salesforce/ts-types';
 import { deepStrictEqual } from 'assert';
 import { QueryResult } from 'jsforce';
 
-const $$ = testSetup();
-
 describe('Mocking a force server call', () => {
+  const $$ = new TestContext();
   it('example', async () => {
     const records: AnyJson = { records: ['123456', '234567'] };
     const testData = new MockTestOrgData();
@@ -88,12 +86,11 @@ You can mock the contents of various config files
 
 ```typescript
 import { strictEqual } from 'assert';
-import { MockTestOrgData, testSetup } from '@salesforce/core/lib/testSetup';
+import { MockTestOrgData, TestContext } from '@salesforce/core/lib/testSetup';
 import { StateAggregator, OrgConfigProperties } from '@salesforce/core';
 
-const $$ = testSetup();
-
 describe('Mocking Aliases', () => {
+  const $$ = new TestContext();
   it('example', async () => {
     const testData = new MockTestOrgData();
     await $$.stubAliases({ myAlias: testData.username });
@@ -128,12 +125,11 @@ Sinon `stub`s and `spy`s must be cleaned up after test invocations. To ease the
 ```typescript
 import { strictEqual } from 'assert';
 
-import { testSetup } from '@salesforce/core/lib/testSetup';
+import { TestContext } from '@salesforce/core/lib/testSetup';
 import * as os from 'os';
 
-const $$ = testSetup();
-
 describe('Using the built in Sinon sandbox.', () => {
+  const $$ = new TestContext();
   it('example', async () => {
     const unsupportedOS = 'LEO';
     $$.SANDBOX.stub(os, 'platform').returns(unsupportedOS);
@@ -198,11 +194,9 @@ It's also useful to check expected values and content from log lines. TestSetup
 
 ```typescript
 import { Logger, LogLine } from '@salesforce/core';
-import { testSetup } from '@salesforce/core/lib/testSetup';
+import { TestContext } from '@salesforce/core/lib/testSetup';
 import { strictEqual } from 'assert';
 
-const $$ = testSetup();
-
 const TEST_STRING = 'foo was here';
 
 class TestObject {
@@ -216,6 +210,7 @@ class TestObject {
 }
 
 describe('Testing log lines', () => {
+  const $$ = new TestContext();
   it('example', async () => {
     const obj = new TestObject($$.TEST_LOGGER);
     obj.method();

package/lib/stateAggregator/accessors/tokenAccessor.d.ts

@@ -39,7 +39,7 @@ export declare class TokenAccessor extends AsyncOptionalCreatable {
      * @param name
      * @param token
      */
-    set(name: string, token: SfToken): void;
+    set(name: string, token: Partial<SfToken>): void;
     /**
      * Update the token for the provided name.
      *

package/lib/testSetup.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
-import * as sinonType from 'sinon';
+import { SinonSandbox, SinonStatic, SinonStub } from 'sinon';
 import { AnyJson, JsonMap, Optional } from '@salesforce/ts-types';
 import { ConfigContents } from './config/configStore';
 import { Connection } from './org/connection';
@@ -15,13 +15,13 @@ import { AliasGroup } from './config/aliasesConfig';
  * on the TestContext.
  */
 export interface SandboxTypes {
-    DEFAULT: sinon.SinonSandbox;
-    CRYPTO: sinon.SinonSandbox;
-    CONFIG: sinon.SinonSandbox;
-    PROJECT: sinon.SinonSandbox;
-    CONNECTION: sinon.SinonSandbox;
-    FS: sinonType.SinonSandbox;
-    ORGS: sinonType.SinonSandbox;
+    DEFAULT: SinonSandbox;
+    CRYPTO: SinonSandbox;
+    CONFIG: SinonSandbox;
+    PROJECT: SinonSandbox;
+    CONNECTION: SinonSandbox;
+    FS: SinonSandbox;
+    ORGS: SinonSandbox;
 }
 /**
  * Different hooks into {@link ConfigFile} used for testing instead of doing file IO.
@@ -55,15 +55,15 @@ export interface ConfigStub {
     updateContents?: () => Promise<JsonMap>;
 }
 /**
- * Different configuration options when running before each
+ * Instantiate a @salesforce/core test context.
  */
-export interface TestContext {
+export declare class TestContext {
     /**
      * The default sandbox is cleared out before each test run.
      *
-     * **See** [sinon sandbox]{@link http://sinonjs.org/releases/v1.17.7/sandbox/}.
+     * **See** [sinon sandbox]{@link https://sinonjs.org/releases/v14/sandbox/}.
      */
-    SANDBOX: sinonType.SinonSandbox;
+    SANDBOX: SinonSandbox;
     /**
      * An object of different sandboxes. Used when
      * needing to restore parts of the system for customized testing.
@@ -77,10 +77,6 @@ export interface TestContext {
      * id A unique id for the test run.
      */
     id: string;
-    /**
-     * A function that returns unique strings.
-     */
-    uniqid: () => string;
     /**
      * An object used in tests that interact with config files.
      */
@@ -93,54 +89,56 @@ export interface TestContext {
         TokensConfig?: ConfigStub;
     };
     /**
-     * An record of stubs created during instantaion.
+     * A record of stubs created during instantiation.
      */
-    stubs: {
-        configRead?: sinonType.SinonStub;
-        configReadSync?: sinonType.SinonStub;
-        configWriteSync?: sinonType.SinonStub;
-        configWrite?: sinonType.SinonStub;
-        configExists?: sinonType.SinonStub;
-        configRemove?: sinonType.SinonStub;
-    };
+    stubs: Record<string, SinonStub>;
+    constructor(options?: {
+        sinon?: SinonStatic;
+        sandbox?: SinonSandbox;
+        setup?: boolean;
+    });
+    /**
+     * Generate unique string.
+     */
+    uniqid(): string;
     /**
      * A function used when resolving the local path. Calls localPathResolverSync by default.
      *
      * @param uid Unique id.
      */
-    localPathRetriever: (uid: string) => Promise<string>;
+    localPathRetriever(uid: string): Promise<string>;
     /**
      * A function used when resolving the local path.
      *
      * @param uid Unique id.
      */
-    localPathRetrieverSync: (uid: string) => string;
+    localPathRetrieverSync(uid: string): string;
     /**
      * A function used when resolving the global path. Calls globalPathResolverSync by default.
      *
      * @param uid Unique id.
      */
-    globalPathRetriever: (uid: string) => Promise<string>;
+    globalPathRetriever(uid: string): Promise<string>;
     /**
      * A function used when resolving the global path.
      *
      * @param uid Unique id.
      */
-    globalPathRetrieverSync: (uid: string) => string;
+    globalPathRetrieverSync(uid: string): string;
     /**
      * A function used for resolving paths. Calls localPathRetriever and globalPathRetriever.
      *
      * @param isGlobal `true` if the config is global.
      * @param uid user id.
      */
-    rootPathRetriever: (isGlobal: boolean, uid?: string) => Promise<string>;
+    rootPathRetriever(isGlobal: boolean, uid?: string): Promise<string>;
     /**
      * A function used for resolving paths. Calls localPathRetrieverSync and globalPathRetrieverSync.
      *
      * @param isGlobal `true` if the config is global.
      * @param uid user id.
      */
-    rootPathRetrieverSync: (isGlobal: boolean, uid?: string) => string;
+    rootPathRetrieverSync(isGlobal: boolean, uid?: string): string;
     /**
      * Used to mock http request to Salesforce.
      *
@@ -149,7 +147,7 @@ export interface TestContext {
      *
      * **See** {@link Connection.request}
      */
-    fakeConnectionRequest: (request: AnyJson, options?: AnyJson) => Promise<AnyJson>;
+    fakeConnectionRequest(request: AnyJson, options?: AnyJson): Promise<AnyJson>;
     /**
      * Gets a config stub contents by name.
      *
@@ -167,7 +165,7 @@ export interface TestContext {
     /**
      * Set stubs for working in the context of a SfProject
      */
-    inProject(inProject: boolean): void;
+    inProject(inProject?: boolean): void;
     /**
      * Stub salesforce org authorizations.
      */
@@ -175,7 +173,7 @@ export interface TestContext {
     /**
      * Stub salesforce sandbox authorizations.
      */
-    stubSandboxes(...orgs: MockTestSandboxData[]): Promise<void>;
+    stubSandboxes(...sandboxes: MockTestSandboxData[]): Promise<void>;
     /**
      * Stub the aliases in the global aliases config file.
      */
@@ -188,6 +186,14 @@ export interface TestContext {
      * Stub the tokens in the global token config file.
      */
     stubTokens(tokens: Record<string, string>): void;
+    restore(): void;
+    init(): void;
+    /**
+     * Add beforeEach and afterEach hooks to init the stubs and restore them.
+     * This is called automatically when the class is instantiated unless the setup option is set to false.
+     */
+    setup(): void;
+    private requireSinon;
 }
 /**
  * A function to generate a unique id and return it in the context of a template, if supplied.
@@ -215,16 +221,16 @@ export declare function uniqid(options?: {
  * const $$ = instantiateContext();
  *
  * beforeEach(() => {
- *   stubContext($$);
+ *   $$.init()
  * });
  *
  * afterEach(() => {
- *   restoreContext($$);
+ *   $$.restore();
  * });
  * ```
  * @param sinon
  */
-export declare const instantiateContext: (sinon?: any) => TestContext;
+export declare const instantiateContext: (sinon?: SinonStatic) => TestContext;
 /**
  * Stub a @salesforce/core test context. This will mock out logging to a file, config file reading and writing,
  * local and global path resolution, and http request using connection (soon)*.
@@ -240,16 +246,16 @@ export declare const instantiateContext: (sinon?: any) => TestContext;
  * const $$ = instantiateContext();
  *
  * beforeEach(() => {
- *   stubContext($$);
+ *   $$.init()
  * });
  *
  * afterEach(() => {
- *   restoreContext($$);
+ *   $$.restore();
  * });
  * ```
  * @param testContext
  */
-export declare const stubContext: (testContext: TestContext) => Record<string, sinonType.SinonStub>;
+export declare const stubContext: (testContext: TestContext) => Record<string, SinonStub>;
 /**
  * Restore a @salesforce/core test context. This is automatically stubbed in the global beforeEach created by
  * `const $$ = testSetup()` but is useful if you don't want to have a global stub of @salesforce/core and you
@@ -260,23 +266,40 @@ export declare const stubContext: (testContext: TestContext) => Record<string, s
  * const $$ = instantiateContext();
  *
  * beforeEach(() => {
- *   stubContext($$);
+ *   $$.init()
  * });
  *
  * afterEach(() => {
- *   restoreContext($$);
+ *   $$.restore();
  * });
  * ```
  * @param testContext
  */
 export declare const restoreContext: (testContext: TestContext) => void;
 /**
+ * @deprecated Use TestContext instead.
+ * Using testSetup will create globals stubs that could lead to erratic test behavior.
+ *
+ * This example shows you how to use TestContext:
+ * @example
+ * ```
+ * const $$ = new TestContext();
+ *
+ * beforeEach(() => {
+ *   $$.init();
+ * });
+ *
+ * afterEach(() => {
+ *   $$.restore();
+ * });
+ * ```
+ *
  * Use to mock out different pieces of sfdx-core to make testing easier. This will mock out
  * logging to a file, config file reading and writing, local and global path resolution, and
  * *http request using connection (soon)*.
  *
  * **Note:** The testSetup should be outside of the describe. If you need to stub per test, use
- * `instantiateContext`, `stubContext`, and `restoreContext`.
+ * `TestContext`.
  * ```
  * // In a mocha tests
  * import testSetup from '@salesforce/core/lib/testSetup';
@@ -292,13 +315,13 @@ export declare const restoreContext: (testContext: TestContext) => void;
  *    $$.stubAliases({ 'myTestAlias': 'user@company.com' });
  *
  *    // Will use the contents set above.
- *    const username = (await StateAggregator.getInstance()).aliases.resolveUseranme('myTestAlias');
+ *    const username = (await StateAggregator.getInstance()).aliases.resolveUsername('myTestAlias');
  *    expect(username).to.equal('user@company.com');
  *  });
  * });
  * ```
  */
-export declare const testSetup: (sinon?: any) => TestContext;
+export declare const testSetup: (sinon?: SinonStatic) => TestContext;
 /**
  * A pre-canned error for try/catch testing.
  *

package/lib/testSetup.js

@@ -11,7 +11,7 @@
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MockTestSandboxData = exports.MockTestOrgData = exports.StreamingMockCometClient = exports.StreamingMockCometSubscription = exports.StreamingMockSubscriptionCall = exports.shouldThrowSync = exports.shouldThrow = exports.unexpectedResult = exports.testSetup = exports.restoreContext = exports.stubContext = exports.instantiateContext = exports.uniqid = void 0;
+exports.MockTestSandboxData = exports.MockTestOrgData = exports.StreamingMockCometClient = exports.StreamingMockCometSubscription = exports.StreamingMockSubscriptionCall = exports.shouldThrowSync = exports.shouldThrow = exports.unexpectedResult = exports.testSetup = exports.restoreContext = exports.stubContext = exports.instantiateContext = exports.uniqid = exports.TestContext = void 0;
 const crypto_1 = require("crypto");
 const events_1 = require("events");
 const os_1 = require("os");
@@ -34,6 +34,234 @@ const org_1 = require("./org");
 const sandboxAccessor_1 = require("./stateAggregator/accessors/sandboxAccessor");
 const aliasesConfig_1 = require("./config/aliasesConfig");
 const global_1 = require("./global");
+/**
+ * Instantiate a @salesforce/core test context.
+ */
+class TestContext {
+    constructor(options = {}) {
+        /**
+         * id A unique id for the test run.
+         */
+        this.id = uniqid();
+        /**
+         * An object used in tests that interact with config files.
+         */
+        this.configStubs = {};
+        /**
+         * A record of stubs created during instantiation.
+         */
+        this.stubs = {};
+        const opts = { setup: true, ...options };
+        const sinon = this.requireSinon(opts.sinon);
+        // Import all the messages files in the sfdx-core messages dir.
+        messages_1.Messages.importMessagesDirectory((0, path_1.join)(__dirname));
+        // Create a global sinon sandbox and a test logger instance for use within tests.
+        this.SANDBOX = opts.sandbox ?? sinon.createSandbox();
+        this.SANDBOXES = {
+            DEFAULT: this.SANDBOX,
+            CONFIG: sinon.createSandbox(),
+            PROJECT: sinon.createSandbox(),
+            CRYPTO: sinon.createSandbox(),
+            CONNECTION: sinon.createSandbox(),
+            FS: sinon.createSandbox(),
+            ORGS: sinon.createSandbox(),
+        };
+        this.TEST_LOGGER = new logger_1.Logger({ name: 'SFDX_Core_Test_Logger' }).useMemoryLogging();
+        if (opts.setup) {
+            this.setup();
+        }
+    }
+    /**
+     * Generate unique string.
+     */
+    uniqid() {
+        return uniqid();
+    }
+    /**
+     * A function used when resolving the local path. Calls localPathResolverSync by default.
+     *
+     * @param uid Unique id.
+     */
+    async localPathRetriever(uid) {
+        return Promise.resolve(getTestLocalPath(uid));
+    }
+    /**
+     * A function used when resolving the local path.
+     *
+     * @param uid Unique id.
+     */
+    localPathRetrieverSync(uid) {
+        return getTestLocalPath(uid);
+    }
+    /**
+     * A function used when resolving the global path. Calls globalPathResolverSync by default.
+     *
+     * @param uid Unique id.
+     */
+    async globalPathRetriever(uid) {
+        return Promise.resolve(getTestGlobalPath(uid));
+    }
+    /**
+     * A function used when resolving the global path.
+     *
+     * @param uid Unique id.
+     */
+    globalPathRetrieverSync(uid) {
+        return getTestGlobalPath(uid);
+    }
+    /**
+     * A function used for resolving paths. Calls localPathRetriever and globalPathRetriever.
+     *
+     * @param isGlobal `true` if the config is global.
+     * @param uid user id.
+     */
+    async rootPathRetriever(isGlobal, uid) {
+        return retrieveRootPath(isGlobal, uid);
+    }
+    /**
+     * A function used for resolving paths. Calls localPathRetrieverSync and globalPathRetrieverSync.
+     *
+     * @param isGlobal `true` if the config is global.
+     * @param uid user id.
+     */
+    rootPathRetrieverSync(isGlobal, uid) {
+        return retrieveRootPathSync(isGlobal, uid);
+    }
+    /**
+     * Used to mock http request to Salesforce.
+     *
+     * @param request An HttpRequest.
+     * @param options Additional options.
+     *
+     * **See** {@link Connection.request}
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async fakeConnectionRequest(request, options) {
+        return defaultFakeConnectionRequest();
+    }
+    /**
+     * Gets a config stub contents by name.
+     *
+     * @param name The name of the config.
+     * @param group If the config supports groups.
+     */
+    getConfigStubContents(name, group) {
+        const stub = this.configStubs[name];
+        if (stub?.contents) {
+            if (group && stub.contents[group]) {
+                return (0, ts_types_1.ensureJsonMap)(stub.contents[group]);
+            }
+            else {
+                return stub.contents;
+            }
+        }
+        return {};
+    }
+    /**
+     * Sets a config stub contents by name
+     *
+     * @param name The name of the config stub.
+     * @param value The actual stub contents. The Mock data.
+     */
+    setConfigStubContents(name, value) {
+        if ((0, ts_types_1.ensureString)(name) && (0, ts_types_1.isJsonMap)(value)) {
+            this.configStubs[name] = value;
+        }
+    }
+    /**
+     * Set stubs for working in the context of a SfProject
+     */
+    inProject(inProject = true) {
+        this.SANDBOXES.PROJECT.restore();
+        if (inProject) {
+            this.SANDBOXES.PROJECT.stub(sfProject_1.SfProject, 'resolveProjectPath').callsFake(() => this.localPathRetriever(this.id));
+            this.SANDBOXES.PROJECT.stub(sfProject_1.SfProject, 'resolveProjectPathSync').callsFake(() => this.localPathRetrieverSync(this.id));
+        }
+        else {
+            this.SANDBOXES.PROJECT.stub(sfProject_1.SfProject, 'resolveProjectPath').rejects(new sfError_1.SfError('', 'InvalidProjectWorkspaceError'));
+            this.SANDBOXES.PROJECT.stub(sfProject_1.SfProject, 'resolveProjectPathSync').throws(new sfError_1.SfError('', 'InvalidProjectWorkspaceError'));
+        }
+    }
+    /**
+     * Stub salesforce org authorizations.
+     */
+    async stubAuths(...orgs) {
+        const entries = await Promise.all(orgs.map(async (org) => [org.username, await org.getConfig()]));
+        const orgMap = new Map(entries);
+        (0, ts_sinon_1.stubMethod)(this.SANDBOX, stateAggregator_1.OrgAccessor.prototype, 'getAllFiles').resolves([...orgMap.keys()].map((o) => `${o}.json`));
+        (0, ts_sinon_1.stubMethod)(this.SANDBOX, stateAggregator_1.OrgAccessor.prototype, 'hasFile').callsFake((username) => orgMap.has(username));
+        const retrieveContents = async function () {
+            const username = (0, path_1.basename)(this.path.replace('.json', ''));
+            return Promise.resolve(orgMap.get(username) ?? {});
+        };
+        this.configStubs.AuthInfoConfig = { retrieveContents };
+    }
+    /**
+     * Stub salesforce sandbox authorizations.
+     */
+    async stubSandboxes(...sandboxes) {
+        const entries = (await Promise.all(sandboxes.map(async (sandbox) => [sandbox.username, await sandbox.getConfig()])));
+        const sandboxMap = new Map(entries);
+        (0, ts_sinon_1.stubMethod)(this.SANDBOX, sandboxAccessor_1.SandboxAccessor.prototype, 'getAllFiles').resolves([...sandboxMap.keys()].map((o) => `${o}.sandbox.json`));
+        const retrieveContents = async function () {
+            const username = (0, path_1.basename)(this.path.replace('.sandbox.json', ''));
+            return Promise.resolve(sandboxMap.get(username) ?? {});
+        };
+        this.configStubs.SandboxOrgConfig = { retrieveContents };
+    }
+    /**
+     * Stub the aliases in the global aliases config file.
+     */
+    stubAliases(aliases, group = aliasesConfig_1.AliasGroup.ORGS) {
+        this.configStubs.AliasesConfig = { contents: { [group]: aliases } };
+    }
+    /**
+     * Stub contents in the config file.
+     */
+    async stubConfig(config) {
+        this.configStubs.Config = { contents: config };
+        // configAggregator may have already loaded an instance.  We're not sure why this happens.
+        // This seems to solve the problem by forcing a load of the new stubbed config.
+        await configAggregator_1.ConfigAggregator.create();
+    }
+    /**
+     * Stub the tokens in the global token config file.
+     */
+    stubTokens(tokens) {
+        this.configStubs.TokensConfig = { contents: tokens };
+    }
+    restore() {
+        (0, exports.restoreContext)(this);
+    }
+    init() {
+        this.stubs = (0, exports.stubContext)(this);
+    }
+    /**
+     * Add beforeEach and afterEach hooks to init the stubs and restore them.
+     * This is called automatically when the class is instantiated unless the setup option is set to false.
+     */
+    setup() {
+        beforeEach(() => {
+            this.init();
+        });
+        afterEach(() => {
+            this.restore();
+        });
+    }
+    requireSinon(sinon) {
+        if (sinon)
+            return sinon;
+        try {
+            sinon = require('sinon');
+        }
+        catch (e) {
+            throw new Error('The package sinon was not found. Add it to your package.json and pass it in to new TestContext({sinon})');
+        }
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return sinon;
+    }
+}
+exports.TestContext = TestContext;
 /**
  * A function to generate a unique id and return it in the context of a template, if supplied.
  *
@@ -84,121 +312,16 @@ function defaultFakeConnectionRequest() {
  * const $$ = instantiateContext();
  *
  * beforeEach(() => {
- *   stubContext($$);
+ *   $$.init()
  * });
  *
  * afterEach(() => {
- *   restoreContext($$);
+ *   $$.restore();
  * });
  * ```
  * @param sinon
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
-const instantiateContext = (sinon) => {
-    if (!sinon) {
-        try {
-            sinon = require('sinon');
-        }
-        catch (e) {
-            throw new Error('The package sinon was not found. Add it to your package.json and pass it in to testSetup(sinon.sandbox)');
-        }
-    }
-    // Import all the messages files in the sfdx-core messages dir.
-    // Messages.importMessagesDirectory(pathJoin(__dirname, '..', '..'));
-    messages_1.Messages.importMessagesDirectory((0, path_1.join)(__dirname));
-    // Create a global sinon sandbox and a test logger instance for use within tests.
-    const defaultSandbox = sinon.createSandbox();
-    const testContext = {
-        SANDBOX: defaultSandbox,
-        SANDBOXES: {
-            DEFAULT: defaultSandbox,
-            CONFIG: sinon.createSandbox(),
-            PROJECT: sinon.createSandbox(),
-            CRYPTO: sinon.createSandbox(),
-            CONNECTION: sinon.createSandbox(),
-            FS: sinon.createSandbox(),
-            ORGS: sinon.createSandbox(),
-        },
-        TEST_LOGGER: new logger_1.Logger({
-            name: 'SFDX_Core_Test_Logger',
-        }).useMemoryLogging(),
-        id: uniqid(),
-        uniqid,
-        configStubs: {},
-        stubs: {},
-        // eslint-disable-next-line @typescript-eslint/require-await
-        localPathRetriever: async (uid) => getTestLocalPath(uid),
-        localPathRetrieverSync: getTestLocalPath,
-        // eslint-disable-next-line @typescript-eslint/require-await
-        globalPathRetriever: async (uid) => getTestGlobalPath(uid),
-        globalPathRetrieverSync: getTestGlobalPath,
-        rootPathRetriever: retrieveRootPath,
-        rootPathRetrieverSync: retrieveRootPathSync,
-        fakeConnectionRequest: defaultFakeConnectionRequest,
-        getConfigStubContents(name, group) {
-            const stub = this.configStubs[name];
-            if (stub?.contents) {
-                if (group && stub.contents[group]) {
-                    return (0, ts_types_1.ensureJsonMap)(stub.contents[group]);
-                }
-                else {
-                    return stub.contents;
-                }
-            }
-            return {};
-        },
-        setConfigStubContents(name, value) {
-            if ((0, ts_types_1.ensureString)(name) && (0, ts_types_1.isJsonMap)(value)) {
-                this.configStubs[name] = value;
-            }
-        },
-        inProject(inProject = true) {
-            testContext.SANDBOXES.PROJECT.restore();
-            if (inProject) {
-                testContext.SANDBOXES.PROJECT.stub(sfProject_1.SfProject, 'resolveProjectPath').callsFake(() => testContext.localPathRetriever(testContext.id));
-                testContext.SANDBOXES.PROJECT.stub(sfProject_1.SfProject, 'resolveProjectPathSync').callsFake(() => testContext.localPathRetrieverSync(testContext.id));
-            }
-            else {
-                testContext.SANDBOXES.PROJECT.stub(sfProject_1.SfProject, 'resolveProjectPath').rejects(new sfError_1.SfError('', 'InvalidProjectWorkspaceError'));
-                testContext.SANDBOXES.PROJECT.stub(sfProject_1.SfProject, 'resolveProjectPathSync').throws(new sfError_1.SfError('', 'InvalidProjectWorkspaceError'));
-            }
-        },
-        async stubAuths(...orgs) {
-            const entries = await Promise.all(orgs.map(async (org) => [org.username, await org.getConfig()]));
-            const orgMap = new Map(entries);
-            (0, ts_sinon_1.stubMethod)(testContext.SANDBOX, stateAggregator_1.OrgAccessor.prototype, 'getAllFiles').resolves([...orgMap.keys()].map((o) => `${o}.json`));
-            (0, ts_sinon_1.stubMethod)(testContext.SANDBOX, stateAggregator_1.OrgAccessor.prototype, 'hasFile').callsFake((username) => orgMap.has(username));
-            const retrieveContents = async function () {
-                const username = (0, path_1.basename)(this.path.replace('.json', ''));
-                return Promise.resolve(orgMap.get(username) ?? {});
-            };
-            this.configStubs.AuthInfoConfig = { retrieveContents };
-        },
-        async stubSandboxes(...sandboxes) {
-            const entries = (await Promise.all(sandboxes.map(async (sanbox) => [sanbox.username, await sanbox.getConfig()])));
-            const sandboxMap = new Map(entries);
-            (0, ts_sinon_1.stubMethod)(testContext.SANDBOX, sandboxAccessor_1.SandboxAccessor.prototype, 'getAllFiles').resolves([...sandboxMap.keys()].map((o) => `${o}.sandbox.json`));
-            const retrieveContents = async function () {
-                const username = (0, path_1.basename)(this.path.replace('.sandbox.json', ''));
-                return Promise.resolve(sandboxMap.get(username) ?? {});
-            };
-            this.configStubs.SandboxOrgConfig = { retrieveContents };
-        },
-        stubAliases(aliases, group = aliasesConfig_1.AliasGroup.ORGS) {
-            this.configStubs.AliasesConfig = { contents: { [group]: aliases } };
-        },
-        async stubConfig(config) {
-            this.configStubs.Config = { contents: config };
-            // configAggregator may have already loaded an instance.  We're not sure why this happens.
-            // This seems to solve the problem by forcing a load of the new stubbed config.
-            await configAggregator_1.ConfigAggregator.create();
-        },
-        stubTokens(tokens) {
-            this.configStubs.TokensConfig = { contents: tokens };
-        },
-    };
-    return testContext;
-};
+const instantiateContext = (sinon) => new TestContext({ sinon, setup: false });
 exports.instantiateContext = instantiateContext;
 /**
  * Stub a @salesforce/core test context. This will mock out logging to a file, config file reading and writing,
@@ -215,11 +338,11 @@ exports.instantiateContext = instantiateContext;
  * const $$ = instantiateContext();
  *
  * beforeEach(() => {
- *   stubContext($$);
+ *   $$.init()
  * });
  *
  * afterEach(() => {
- *   restoreContext($$);
+ *   $$.restore();
  * });
  * ```
  * @param testContext
@@ -322,6 +445,7 @@ const stubContext = (testContext) => {
     });
     // Always start with the default and tests beforeEach or it methods can override it.
     testContext.fakeConnectionRequest = defaultFakeConnectionRequest;
+    testContext.stubs = stubs;
     return stubs;
 };
 exports.stubContext = stubContext;
@@ -335,11 +459,11 @@ exports.stubContext = stubContext;
  * const $$ = instantiateContext();
  *
  * beforeEach(() => {
- *   stubContext($$);
+ *   $$.init()
  * });
  *
  * afterEach(() => {
- *   restoreContext($$);
+ *   $$.restore();
  * });
  * ```
  * @param testContext
@@ -351,9 +475,12 @@ const restoreContext = (testContext) => {
     testContext.configStubs = {};
     // Give each test run a clean StateAggregator
     stateAggregator_1.StateAggregator.clearInstance();
+    // Allow each test to have their own config aggregator
+    // @ts-ignore clear for testing.
+    delete configAggregator_1.ConfigAggregator.instance;
 };
 exports.restoreContext = restoreContext;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any, no-underscore-dangle
+// eslint-disable-next-line no-underscore-dangle
 const _testSetup = (sinon) => {
     const testContext = (0, exports.instantiateContext)(sinon);
     beforeEach(() => {
@@ -368,12 +495,29 @@ const _testSetup = (sinon) => {
     return testContext;
 };
 /**
+ * @deprecated Use TestContext instead.
+ * Using testSetup will create globals stubs that could lead to erratic test behavior.
+ *
+ * This example shows you how to use TestContext:
+ * @example
+ * ```
+ * const $$ = new TestContext();
+ *
+ * beforeEach(() => {
+ *   $$.init();
+ * });
+ *
+ * afterEach(() => {
+ *   $$.restore();
+ * });
+ * ```
+ *
  * Use to mock out different pieces of sfdx-core to make testing easier. This will mock out
  * logging to a file, config file reading and writing, local and global path resolution, and
  * *http request using connection (soon)*.
  *
  * **Note:** The testSetup should be outside of the describe. If you need to stub per test, use
- * `instantiateContext`, `stubContext`, and `restoreContext`.
+ * `TestContext`.
  * ```
  * // In a mocha tests
  * import testSetup from '@salesforce/core/lib/testSetup';
@@ -389,7 +533,7 @@ const _testSetup = (sinon) => {
  *    $$.stubAliases({ 'myTestAlias': 'user@company.com' });
  *
  *    // Will use the contents set above.
- *    const username = (await StateAggregator.getInstance()).aliases.resolveUseranme('myTestAlias');
+ *    const username = (await StateAggregator.getInstance()).aliases.resolveUsername('myTestAlias');
  *    expect(username).to.equal('user@company.com');
  *  });
  * });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salesforce/core",
-  "version": "3.30.13",
+  "version": "3.31.04",
   "description": "Core libraries to interact with SFDX projects, orgs, and APIs.",
   "main": "lib/exported",
   "types": "lib/exported.d.ts",