feat: implement progress api

packages/apex-node/src/i18n/i18n.ts

@@ -36,6 +36,9 @@ export const messages = {
   streamingTransportUp: 'Listening for streaming state changes...',
   streamingTransportDown: 'Faye client generated a transport:down event.',
   streamingProcessingTestRun: 'Processing test run %s',
+  retrievingTestRunSummary: 'Retrieving test run summary record',
+  queryingForAggregateCodeCoverage:
+    'Querying for aggregate code coverage results',
   failRate: 'Fail Rate',
   testsRan: 'Tests Ran',
   orgId: 'Org Id',

packages/apex-node/src/index.ts

@@ -14,6 +14,7 @@ export {
 export { LogService, ApexLogGetOptions, LogRecord, LogResult } from './logs';
 export { JUnitReporter, TapReporter, HumanReporter } from './reporters';
 export {
+  ApexTestProgressValue,
   ApexTestResultData,
   ApexTestResultOutcome,
   AsyncTestArrayConfiguration,

packages/apex-node/src/streaming/streamingClient.ts

@@ -59,10 +59,20 @@ export class StreamingClient {
     });
 
     this.client.on('transport:up', () => {
+      this.progress?.report({
+        type: 'StreamingClientProgress',
+        value: 'streamingTransportUp',
+        message: nls.localize('streamingTransportUp')
+      });
       console.log(nls.localize('streamingTransportUp'));
     });
 
     this.client.on('transport:down', () => {
+      this.progress?.report({
+        type: 'StreamingClientProgress',
+        value: 'streamingTransportDown',
+        message: nls.localize('streamingTransportDown')
+      });
       console.log(nls.localize('streamingTransportDown'));
     });
 
@@ -167,6 +177,12 @@ export class StreamingClient {
       return result;
     }
 
+    this.progress?.report({
+      type: 'StreamingClientProgress',
+      value: 'streamingProcessingTestRun',
+      message: nls.localize('streamingProcessingTestRun', testRunId),
+      testRunId
+    });
     console.log(nls.localize('streamingProcessingTestRun', testRunId));
     return null;
   }
@@ -183,6 +199,11 @@ export class StreamingClient {
       throw new Error(nls.localize('noTestQueueResults', testRunId));
     }
 
+    this.progress?.report({
+      type: 'TestQueueProgress',
+      value: result
+    });
+
     for (let i = 0; i < result.records.length; i++) {
       const item = result.records[i];
       if (

packages/apex-node/src/tests/index.ts

@@ -7,6 +7,7 @@
 
 export { TestService } from './testService';
 export {
+  ApexTestProgressValue,
   AsyncTestConfiguration,
   AsyncTestArrayConfiguration,
   SyncTestConfiguration,

packages/apex-node/src/tests/testService.ts

@@ -405,7 +405,8 @@ export class TestService {
       asyncRunResult.queueItem,
       asyncRunResult.runId,
       getCurrentTime(),
-      codeCoverage
+      codeCoverage,
+      progress
     );
   }
 
@@ -439,7 +440,8 @@ export class TestService {
     testQueueResult: ApexTestQueueItem,
     testRunId: string,
     commandStartTime: number,
-    codeCoverage = false
+    codeCoverage = false,
+    progress?: Progress<ApexTestProgressValue>
   ): Promise<TestResult> {
     if (!this.isValidTestRunID(testRunId)) {
       throw new Error(nls.localize('invalidTestRunIdErr', testRunId));
@@ -450,6 +452,13 @@ export class TestService {
     testRunSummaryQuery +=
       'MethodsEnqueued, StartTime, EndTime, TestTime, UserId ';
     testRunSummaryQuery += `FROM ApexTestRunResult WHERE AsyncApexJobId = '${testRunId}'`;
+
+    progress?.report({
+      type: 'FormatTestResultProgress',
+      value: 'retrievingTestRunSummary',
+      message: nls.localize('retrievingTestRunSummary')
+    });
+
     const testRunSummaryResults = (await this.connection.tooling.query(
       testRunSummaryQuery
     )) as ApexTestRunResult;
@@ -526,6 +535,11 @@ export class TestService {
         }
       });
 
+      progress?.report({
+        type: 'FormatTestResultProgress',
+        value: 'queryingForAggregateCodeCoverage',
+        message: nls.localize('queryingForAggregateCodeCoverage')
+      });
       const {
         codeCoverageResults,
         totalLines,

packages/apex-node/src/tests/types.ts

@@ -462,4 +462,24 @@ export type NamespaceQueryResult = {
   records: NamespaceRecord[];
 };
 
-export type ApexTestProgressValue = ApexTestRunResultRecord;
+export type ApexTestProgressValue =
+  | {
+      type: 'StreamingClientProgress';
+      value: 'streamingTransportUp' | 'streamingTransportDown';
+      message: string;
+    }
+  | {
+      type: 'StreamingClientProgress';
+      value: 'streamingProcessingTestRun';
+      testRunId: string;
+      message: string;
+    }
+  | {
+      type: 'TestQueueProgress';
+      value: ApexTestQueueItem;
+    }
+  | {
+      type: 'FormatTestResultProgress';
+      value: 'retrievingTestRunSummary' | 'queryingForAggregateCodeCoverage';
+      message: string;
+    };

packages/apex-node/test/streaming/streamingClient.test.ts

@@ -7,14 +7,19 @@
 
 import { AuthInfo, Connection } from '@salesforce/core';
 import { MockTestOrgData, testSetup } from '@salesforce/core/lib/testSetup';
-import { createSandbox, SinonSandbox } from 'sinon';
+import { assert, createSandbox, SinonSandbox } from 'sinon';
 import { StreamingClient } from '../../src/streaming';
 import { expect } from 'chai';
 import { Client as FayeClient, Subscription } from 'faye';
 import { fail } from 'assert';
+import { Progress } from '../../src';
 import { TestResultMessage } from '../../src/streaming/types';
-import { ApexTestQueueItemStatus } from '../../src/tests/types';
+import {
+  ApexTestQueueItemStatus,
+  ApexTestProgressValue
+} from '../../src/tests/types';
 import { nls } from '../../src/i18n';
+import { EventEmitter } from 'events';
 
 const $$ = testSetup();
 let mockConnection: Connection;
@@ -233,4 +238,113 @@ describe('Streaming API Client', () => {
     expect(mockToolingQuery.calledOnce).to.equal(true);
     expect(results).to.equal(null);
   });
+
+  it('should report streamingTransportUp progress', () => {
+    const reportStub = sandboxStub.stub();
+    const progressReporter: Progress<ApexTestProgressValue> = {
+      report: reportStub
+    };
+    const mockFayeClient = new EventEmitter();
+    const stubOn = sandboxStub.stub(FayeClient.prototype, 'on');
+    stubOn.callsFake(mockFayeClient.on.bind(mockFayeClient));
+
+    new StreamingClient(mockConnection, progressReporter);
+    mockFayeClient.emit('transport:up');
+
+    assert.calledOnce(reportStub);
+    assert.calledWith(reportStub, {
+      type: 'StreamingClientProgress',
+      value: 'streamingTransportUp',
+      message: nls.localize('streamingTransportUp')
+    });
+  });
+
+  it('should report streamingTransportDown progress', () => {
+    const reportStub = sandboxStub.stub();
+    const progressReporter: Progress<ApexTestProgressValue> = {
+      report: reportStub
+    };
+    const mockFayeClient = new EventEmitter();
+    const stubOn = sandboxStub.stub(FayeClient.prototype, 'on');
+    stubOn.callsFake(mockFayeClient.on.bind(mockFayeClient));
+
+    new StreamingClient(mockConnection, progressReporter);
+    mockFayeClient.emit('transport:down');
+
+    assert.calledOnce(reportStub);
+    assert.calledWith(reportStub, {
+      type: 'StreamingClientProgress',
+      value: 'streamingTransportDown',
+      message: nls.localize('streamingTransportDown')
+    });
+  });
+
+  it('should report streamingProcessingTestRun progress', async () => {
+    const mockToolingQuery = sandboxStub.stub(mockConnection.tooling, 'query');
+    mockToolingQuery.resolves({
+      done: true,
+      totalSize: 0,
+      records: [
+        {
+          Id: '707xx0000AGQ3jbQQD',
+          Status: ApexTestQueueItemStatus.Processing,
+          ApexClassId: '01pxx00000O6tXZQAx',
+          TestRunResultId: '05mxx000000TgYuQAw'
+        }
+      ]
+    });
+    const reportStub = sandboxStub.stub();
+    const progressReporter: Progress<ApexTestProgressValue> = {
+      report: reportStub
+    };
+
+    const streamClient = new StreamingClient(mockConnection, progressReporter);
+    await streamClient.handler(testResultMsg);
+
+    assert.calledWith(reportStub, {
+      type: 'StreamingClientProgress',
+      value: 'streamingProcessingTestRun',
+      message: nls.localize('streamingProcessingTestRun', '707xx0000AGQ3jbQQD'),
+      testRunId: '707xx0000AGQ3jbQQD'
+    });
+  });
+
+  it('should report test queue progress', async () => {
+    const mockToolingQuery = sandboxStub.stub(mockConnection.tooling, 'query');
+    mockToolingQuery.resolves({
+      done: true,
+      totalSize: 0,
+      records: [
+        {
+          Id: '707xx0000AGQ3jbQQD',
+          Status: ApexTestQueueItemStatus.Processing,
+          ApexClassId: '01pxx00000O6tXZQAx',
+          TestRunResultId: '05mxx000000TgYuQAw'
+        }
+      ]
+    });
+    const reportStub = sandboxStub.stub();
+    const progressReporter: Progress<ApexTestProgressValue> = {
+      report: reportStub
+    };
+
+    const streamClient = new StreamingClient(mockConnection, progressReporter);
+    await streamClient.handler(testResultMsg);
+
+    assert.calledWith(reportStub, {
+      type: 'TestQueueProgress',
+      value: {
+        done: true,
+        totalSize: 0,
+        records: [
+          {
+            Id: '707xx0000AGQ3jbQQD',
+            Status: ApexTestQueueItemStatus.Processing,
+            ApexClassId: '01pxx00000O6tXZQAx',
+            TestRunResultId: '05mxx000000TgYuQAw'
+          }
+        ]
+      }
+    });
+  });
 });