fix: add output-dir to cache, use it if found W-17919149 (#104)

* fix: add output-dir to cache, use it if found

* test: fix UT stub

* chore: fix cached ID

* chore: add result format to cache

Author: WillieRuemmele

src/agentTestCache.ts

@@ -8,9 +8,13 @@
 import { Global, SfError, TTLConfig } from '@salesforce/core';
 import { Duration } from '@salesforce/kit';
 
+type ResultFormat = 'json' | 'human' | 'junit' | 'tap';
+
 type CacheContents = {
   runId: string;
   name: string;
+  outputDir?: string;
+  resultFormat?: ResultFormat;
 };
 
 export class AgentTestCache extends TTLConfig<TTLConfig.Options, CacheContents> {
@@ -28,10 +32,15 @@ export class AgentTestCache extends TTLConfig<TTLConfig.Options, CacheContents>
     };
   }
 
-  public async createCacheEntry(runId: string, name: string): Promise<void> {
+  public async createCacheEntry(
+    runId: string,
+    name: string,
+    outputDir?: string,
+    resultFormat?: ResultFormat
+  ): Promise<void> {
     if (!runId) throw new SfError('runId is required to create a cache entry');
 
-    this.set(runId, { runId, name });
+    this.set(runId, { runId, name, outputDir, resultFormat });
     await this.write();
   }
 
@@ -49,7 +58,10 @@ export class AgentTestCache extends TTLConfig<TTLConfig.Options, CacheContents>
     return this.get(key);
   }
 
-  public useIdOrMostRecent(runId: string | undefined, useMostRecent: boolean): { runId: string; name?: string } {
+  public useIdOrMostRecent(
+    runId: string | undefined,
+    useMostRecent: boolean
+  ): { runId: string; name?: string; outputDir?: string; resultFormat?: ResultFormat } {
     if (runId && useMostRecent) {
       throw new SfError('Cannot specify both a runId and use most recent flag');
     }
@@ -59,7 +71,7 @@ export class AgentTestCache extends TTLConfig<TTLConfig.Options, CacheContents>
     }
 
     if (runId) {
-      return { runId };
+      return this.has(runId) ? this.get(runId) : { runId };
     }
 
     return this.resolveFromCache();

src/commands/agent/test/resume.ts

@@ -50,7 +50,10 @@ export default class AgentTestResume extends SfCommand<AgentTestRunResult> {
     const { flags } = await this.parse(AgentTestResume);
 
     const agentTestCache = await AgentTestCache.create();
-    const { name, runId } = agentTestCache.useIdOrMostRecent(flags['job-id'], flags['use-most-recent']);
+    const { name, runId, outputDir, resultFormat } = agentTestCache.useIdOrMostRecent(
+      flags['job-id'],
+      flags['use-most-recent']
+    );
 
     const mso = new TestStages({
       title: `Agent Test Run: ${name ?? runId}`,
@@ -66,10 +69,10 @@ export default class AgentTestResume extends SfCommand<AgentTestRunResult> {
 
     await handleTestResults({
       id: runId,
-      format: flags['result-format'],
+      format: resultFormat ?? flags['result-format'],
       results: response,
       jsonEnabled: this.jsonEnabled(),
-      outputDir: flags['output-dir'],
+      outputDir: outputDir ?? flags['output-dir'],
     });
 
     return { ...response!, runId, status: 'COMPLETED' };

src/commands/agent/test/run.ts

@@ -96,7 +96,7 @@ export default class AgentTestRun extends SfCommand<AgentTestRunResult> {
     this.mso.update({ id: response.runId });
 
     const agentTestCache = await AgentTestCache.create();
-    await agentTestCache.createCacheEntry(response.runId, apiName);
+    await agentTestCache.createCacheEntry(response.runId, apiName, flags['output-dir'], flags['result-format']);
 
     if (flags.wait?.minutes) {
       const { completed, response: detailsResponse } = await this.mso.poll(agentTester, response.runId, flags.wait);

test/agentTestCache.test.ts

@@ -85,6 +85,17 @@ describe('AgentTestCache', () => {
       expect(result).to.deep.equal({ runId: '123' });
     });
 
+    it('should return the provided runId', () => {
+      sinon.stub(cache, 'has').returns(true);
+      sinon.stub(cache, 'get').returns({ runId: '123', name: 'testName', outputDir: 'myCachedOutput' });
+      const result = cache.useIdOrMostRecent('123', false);
+      expect(result).to.deep.equal({
+        name: 'testName',
+        outputDir: 'myCachedOutput',
+        runId: '123',
+      });
+    });
+
     it('should return the most recent cache entry', async () => {
       sinon.stub(cache, 'resolveFromCache').returns({ runId: '123', name: 'testName' });
       const result = cache.useIdOrMostRecent(undefined, true);