fix: handle multiple sandbox processes in a resumable state

Author: shetzel

messages/sandboxbase.md

@@ -15,3 +15,7 @@ If the org is ready, checking the status also authorizes the org for use with Sa
 # warning.ClientTimeoutWaitingForSandboxCreate
 
 The wait time for the sandbox creation has been exhausted. Please see the results below for more information.
+
+# warning.MultipleMatchingSandboxProcesses
+
+There were multiple sandbox processes found for "%s" in a resumable state. Ignoring sandbox process ID(s) "%s" in status(es) "%s" and using the most recent process ID "%s". To resume a different sandbox process please use that unique sandbox process ID with the command. E.g, "sf org resume sandbox --job-id %s -o %s"

src/commands/org/resume/sandbox.ts

@@ -93,7 +93,7 @@ export default class ResumeSandbox extends SandboxCommandBase<SandboxProcessObje
       if (latestEntry) {
         const [, sandboxRequestData] = latestEntry;
         if (sandboxRequestData) {
-          return { SandboxName: sandboxRequestData.sandboxProcessObject?.SandboxName };
+          return { SandboxProcessObjId: sandboxRequestData.sandboxProcessObject?.Id };
         }
       }
     }
@@ -130,7 +130,7 @@ export default class ResumeSandbox extends SandboxCommandBase<SandboxProcessObje
       (await this.verifyIfAuthExists({
         prodOrg: this.prodOrg,
         sandboxName: this.sandboxRequestData.sandboxProcessObject.SandboxName,
-        jobId: this.flags['job-id'],
+        jobId: this.flags['job-id'] ?? this.sandboxRequestData.sandboxProcessObject.Id,
         lifecycle,
       }))
     ) {
@@ -228,7 +228,7 @@ const getSandboxProcessObject = async (
   sandboxName?: string,
   jobId?: string
 ): Promise<SandboxProcessObject> => {
-  const where = sandboxName ? `SandboxName='${sandboxName}'` : `Id='${jobId}'`;
+  const where = jobId ? `Id='${jobId}'` : `SandboxName='${sandboxName}'`;
   const queryStr = `SELECT Id, Status, SandboxName, SandboxInfoId, LicenseType, CreatedDate, CopyProgress, SandboxOrganization, SourceId, Description, EndDate FROM SandboxProcess WHERE ${where} AND Status != 'D'`;
   try {
     return await prodOrg.getConnection().singleRecordQuery(queryStr, {

src/shared/sandboxCommandBase.ts

@@ -150,6 +150,27 @@ export abstract class SandboxCommandBase<T> extends SfCommand<T> {
       this.updateProgress(results, options.isAsync);
       this.reportResults(results);
     });
+
+    lifecycle.on(SandboxEvents.EVENT_MULTIPLE_SBX_PROCESSES, async (results: SandboxProcessObject[]) => {
+      const resumingProcess = results.shift() as SandboxProcessObject;
+      const sbxProcessIds: string[] = [];
+      const sbxProcessStatuses: string[] = [];
+      results.map((sbxProc) => {
+        sbxProcessIds.push(sbxProc.Id);
+        sbxProcessStatuses.push(sbxProc.Status);
+      });
+      this.warn(
+        messages.getMessage('warning.MultipleMatchingSandboxProcesses', [
+          results[0].SandboxName,
+          sbxProcessIds.toString(),
+          sbxProcessStatuses.toString(),
+          resumingProcess.Id,
+          sbxProcessIds[0],
+          this.prodOrg?.getUsername(),
+        ])
+      );
+      return Promise.resolve();
+    });
   }
 
   protected reportResults(results: ResultEvent): void {

test/unit/org/resumeSandbox.test.ts

@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2020, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+import {
+  Lifecycle,
+  Messages,
+  Org,
+  SandboxEvents,
+  SandboxProcessObject,
+  AuthFields,
+  SandboxRequestCacheEntry,
+  SfError,
+} from '@salesforce/core';
+import { stubMethod } from '@salesforce/ts-sinon';
+import * as sinon from 'sinon';
+import { expect, config } from 'chai';
+import { OrgAccessor } from '@salesforce/core/lib/stateAggregator';
+import { stubSfCommandUx, stubSpinner, stubUx } from '@salesforce/sf-plugins-core';
+import ResumeSandbox from '../../../src/commands/org/resume/sandbox';
+
+config.truncateThreshold = 0;
+
+const prodOrgUsername = '[email protected]';
+const sandboxName = 'TestSbx';
+const fakeOrg: AuthFields = {
+  orgId: '00Dsomefakeorg1',
+  instanceUrl: 'https://some.fake.org',
+  username: prodOrgUsername,
+};
+
+const sandboxProcessObj: SandboxProcessObject = {
+  Id: '0GR4p000000U8EMXXX',
+  Status: 'Completed',
+  SandboxName: sandboxName,
+  SandboxInfoId: '0GQ4p000000U6sKXXX',
+  LicenseType: 'DEVELOPER',
+  CreatedDate: '2021-12-07T16:20:21.000+0000',
+  CopyProgress: 100,
+  SandboxOrganization: '00D2f0000008XXX',
+  SourceId: '123',
+  Description: 'sandbox description',
+  ApexClassId: '123',
+  EndDate: '2021-12-07T16:38:47.000+0000',
+};
+
+const sandboxRequestData: SandboxRequestCacheEntry = {
+  prodOrgUsername,
+  sandboxRequest: {},
+  sandboxProcessObject: {
+    SandboxName: sandboxName,
+  },
+  setDefault: false,
+};
+
+describe('[org resume sandbox]', () => {
+  Messages.importMessagesDirectory(__dirname);
+  const messages = Messages.loadMessages('@salesforce/plugin-org', 'sandboxbase');
+
+  const sandbox = sinon.createSandbox();
+
+  beforeEach(() => {
+    stubMethod(sandbox, OrgAccessor.prototype, 'read').resolves(fakeOrg);
+    stubMethod(sandbox, OrgAccessor.prototype, 'write').resolves(fakeOrg);
+    sfCommandUxStubs = stubSfCommandUx(sandbox);
+    stubUx(sandbox);
+    stubSpinner(sandbox);
+  });
+
+  let sfCommandUxStubs: ReturnType<typeof stubSfCommandUx>;
+
+  it('will warn when multiple sandboxes are in a resumable state', async () => {
+    stubMethod(sandbox, ResumeSandbox.prototype, 'getSandboxRequestConfig').resolves();
+    stubMethod(sandbox, ResumeSandbox.prototype, 'buildSandboxRequestCacheEntry').returns(sandboxRequestData);
+    stubMethod(sandbox, ResumeSandbox.prototype, 'createResumeSandboxRequest').returns({
+      SandboxName: sandboxName,
+    });
+    stubMethod(sandbox, Org, 'create').resolves(Org.prototype);
+    stubMethod(sandbox, Org.prototype, 'getUsername').returns(prodOrgUsername);
+    const sbxCreateNotComplete = new SfError('sbx create not complete', 'sandboxCreateNotComplete');
+    const inProgSandboxProcessObj = Object.assign({}, sandboxProcessObj, {
+      Status: 'In Progress',
+      Id: '0GR4p000000U8EMZZZ',
+      CopyProgress: 25,
+      CreatedDate: '2022-12-07T16:20:21.000+0000',
+    });
+    stubMethod(sandbox, Org.prototype, 'resumeSandbox').callsFake(async () => {
+      await Lifecycle.getInstance().emit(SandboxEvents.EVENT_MULTIPLE_SBX_PROCESSES, [
+        inProgSandboxProcessObj,
+        sandboxProcessObj,
+      ]);
+      throw sbxCreateNotComplete;
+    });
+
+    try {
+      await ResumeSandbox.run(['-o', prodOrgUsername, '--name', sandboxName]);
+      expect(false, 'ResumeSandbox should have thrown sandboxCreateNotComplete');
+    } catch (err: unknown) {
+      const warningMsg = messages.getMessage('warning.MultipleMatchingSandboxProcesses', [
+        sandboxName,
+        sandboxProcessObj.Id,
+        sandboxProcessObj.Status,
+        inProgSandboxProcessObj.Id,
+        sandboxProcessObj.Id,
+        prodOrgUsername,
+      ]);
+      expect(sfCommandUxStubs.warn.calledWith(warningMsg)).to.be.true;
+      const error = err as SfError;
+      expect(error.name).to.equal('sandboxCreateNotComplete');
+    }
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+});