feat: add new logic get test command

Author: EstebanRomero84

messages/logicgettest.md

@@ -0,0 +1,39 @@
+# summary
+
+Get the results of a test run.
+
+# description
+
+When you run 'sf logic run test' asynchronously, it returns a test run ID. Use that ID with this command to see the results.
+
+To see code coverage results, use the --code-coverage flag with --result-format. The output displays a high-level summary of the test run and the code coverage values for classes in your org. If you specify human-readable result format, use the --detailed-coverage flag to see detailed coverage results for each test method run.
+
+# examples
+
+- Get the results for a specific test run ID in the default human-readable format:
+
+  <%= config.bin %> <%= command.id %> --test-run-id <test run id>
+
+- Get the results for a specific test run ID, format them as JUnit, and save them to the "test-results/junit" directory:
+
+  <%= config.bin %> <%= command.id %> --test-run-id <test run id> --result-format junit
+
+# flags.test-run-id.summary
+
+ID of the test run.
+
+# flags.output-dir.summary
+
+Directory in which to store test result files.
+
+# flags.concise.summary
+
+Display only failed test results; works with human-readable output only.
+
+# apexLibErr
+
+Unknown error in Apex Library: %s
+
+# flags.detailed-coverage.summary
+
+Display detailed code coverage per test.

src/commands/apex/get/test.ts

@@ -5,18 +5,17 @@
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
 
-import { TestService } from '@salesforce/apex-node';
 import {
   Flags,
   loglevel,
   orgApiVersionFlagWithDeprecations,
   requiredOrgFlagWithDeprecations,
   SfCommand,
-  Ux,
 } from '@salesforce/sf-plugins-core';
 import { Messages } from '@salesforce/core';
-import { RunResult, TestReporter } from '../../../reporters/index.js';
+import { RunResult } from '../../../reporters/index.js';
 import { codeCoverageFlag, resultFormatFlag } from '../../../flags.js';
+import { TestGetBase } from '../../../shared/TestGetBase.js';
 
 Messages.importMessagesDirectoryFromMetaUrl(import.meta.url);
 const messages = Messages.loadMessages('@salesforce/plugin-apex', 'gettest');
@@ -60,20 +59,18 @@ export default class Test extends SfCommand<RunResult> {
   public async run(): Promise<RunResult> {
     const { flags } = await this.parse(Test);
 
-    const conn = flags['target-org'].getConnection(flags['api-version']);
-
-    const testService = new TestService(conn);
-    const result = await testService.reportAsyncResults(flags['test-run-id'], flags['code-coverage']);
-
-    const testReporter = new TestReporter(new Ux({ jsonEnabled: this.jsonEnabled() }), conn);
-
-    return testReporter.report(result, {
-      'output-dir': flags['output-dir'],
-      'result-format': flags['result-format'],
+    // Use shared business logic
+    return TestGetBase.execute({
+      connection: flags['target-org'].getConnection(flags['api-version']),
+      testRunId: flags['test-run-id'],
+      codeCoverage: flags['code-coverage'],
+      outputDir: flags['output-dir'],
+      resultFormat: flags['result-format'],
       json: flags.json,
-      'code-coverage': flags['code-coverage'],
-      'detailed-coverage': flags['detailed-coverage'],
+      detailedCoverage: flags['detailed-coverage'],
       concise: flags.concise,
+      jsonEnabled: this.jsonEnabled(),
+      isUnifiedLogic: false
     });
   }
 }

src/commands/logic/get/test.ts

@@ -0,0 +1,77 @@
+/*
+ * 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 {
+  Flags,
+  loglevel,
+  orgApiVersionFlagWithDeprecations,
+  requiredOrgFlagWithDeprecations,
+  SfCommand,
+} from '@salesforce/sf-plugins-core';
+import { Messages } from '@salesforce/core';
+import { RunResult } from '../../../reporters/index.js';
+import { codeCoverageFlag, resultFormatFlag } from '../../../flags.js';
+import { TestGetBase } from '../../../shared/TestGetBase.js';
+
+Messages.importMessagesDirectoryFromMetaUrl(import.meta.url);
+const messages = Messages.loadMessages('@salesforce/plugin-apex', 'logicgettest');
+
+export default class Test extends SfCommand<RunResult> {
+  public static readonly summary = messages.getMessage('summary');
+  public static readonly description = messages.getMessage('description');
+  public static readonly examples = messages.getMessages('examples');
+  public static readonly deprecateAliases = true;
+  public static readonly aliases = ['force:logic:test:report'];
+
+  public static readonly flags = {
+    'target-org': requiredOrgFlagWithDeprecations,
+    'api-version': orgApiVersionFlagWithDeprecations,
+    loglevel,
+    'test-run-id': Flags.salesforceId({
+      deprecateAliases: true,
+      aliases: ['testrunid'],
+      char: 'i',
+      summary: messages.getMessage('flags.test-run-id.summary'),
+      required: true,
+      startsWith: '707',
+      length: 'both',
+    }),
+    'code-coverage': codeCoverageFlag,
+    'detailed-coverage': Flags.boolean({
+      summary: messages.getMessage('flags.detailed-coverage.summary'),
+      dependsOn: ['code-coverage'],
+    }),
+    'output-dir': Flags.directory({
+      aliases: ['outputdir', 'output-directory'],
+      deprecateAliases: true,
+      char: 'd',
+      summary: messages.getMessage('flags.output-dir.summary'),
+    }),
+    'result-format': resultFormatFlag,
+    concise: Flags.boolean({
+      summary: messages.getMessage('flags.concise.summary'),
+    })
+  };
+
+  public async run(): Promise<RunResult> {
+    const { flags } = await this.parse(Test);
+
+    // Use shared business logic
+    return TestGetBase.execute({
+      connection: flags['target-org'].getConnection(),
+      testRunId: flags['test-run-id'],
+      codeCoverage: flags['code-coverage'],
+      outputDir: flags['output-dir'],
+      resultFormat: flags['result-format'],
+      json: flags.json,
+      detailedCoverage: false,
+      concise: flags.concise,
+      jsonEnabled: this.jsonEnabled(),
+      isUnifiedLogic: true
+    });
+  }
+}

src/reporters/jsonReporter.ts

@@ -85,7 +85,7 @@ type CliCoverageResult = {
 };
 
 export class JsonReporter {
-  public format(result: TestResult): RunResult {
+  public format(result: TestResult, includeCategory: boolean = false): RunResult {
     const returnObject: RunResult = {
       summary: {
         // result.summary contains more information than we want to return, so we'll specify each key we want to return instead of using ...
@@ -121,6 +121,7 @@ export class JsonReporter {
         },
         RunTime: test.runTime,
         FullName: test.fullName,
+        ...(includeCategory ? { Category: test.category } : {}),
       })),
       ...(result.codecoverage
         ? {

src/reporters/testReporter.ts

@@ -45,18 +45,20 @@ export class TestReporter {
       json?: boolean;
       'code-coverage'?: boolean;
       concise: boolean;
+      isUnifiedLogic?: boolean;
     }
   ): Promise<RunResult> {
     if (options['output-dir']) {
-      const jsonOutput = this.formatResultInJson(result);
+      const jsonOutput = this.formatResultInJson(result, options.isUnifiedLogic);
       const outputDirConfig = this.buildOutputDirConfig(
         result,
         jsonOutput,
         options['output-dir'],
         options['result-format'] as ResultFormat | undefined,
         Boolean(options['detailed-coverage']),
         options.concise,
-        options.synchronous
+        options.synchronous,
+        options.isUnifiedLogic
       );
 
       const testService = new TestService(this.connection);
@@ -70,7 +72,7 @@ export class TestReporter {
       }
       switch (options['result-format']) {
         case 'human':
-          this.logHuman(result, options['detailed-coverage'] as boolean, options['concise'], options['output-dir']);
+          this.logHuman(result, options['detailed-coverage'] as boolean, options['concise'], options['output-dir'], options.isUnifiedLogic);
           break;
         case 'tap':
           this.logTap(result);
@@ -83,7 +85,7 @@ export class TestReporter {
           if (!options.json) {
             this.ux.styledJSON({
               status: process.exitCode,
-              result: this.formatResultInJson(result),
+              result: this.formatResultInJson(result, options.isUnifiedLogic),
             });
           }
           break;
@@ -95,7 +97,7 @@ export class TestReporter {
       throw messages.createError('testResultProcessErr', [(e as Error).message]);
     }
 
-    return this.formatResultInJson(result);
+    return this.formatResultInJson(result, options.isUnifiedLogic);
   }
   /**
    * Builds output directory configuration with CLI format result files
@@ -116,7 +118,8 @@ export class TestReporter {
     resultFormat: ResultFormat | undefined,
     detailedCoverage: boolean,
     concise: boolean,
-    synchronous = false
+    synchronous = false,
+    isUnifiedLogic?: boolean
   ): OutputDirConfig {
     const outputDirConfig: OutputDirConfig = {
       dirPath: outputDir,
@@ -164,7 +167,7 @@ export class TestReporter {
         case ResultFormat.human:
           outputDirConfig.fileInfos?.push({
             filename: 'test-result.txt',
-            content: new HumanReporter().format(result, detailedCoverage, concise),
+            content: new HumanReporter().format(result, detailedCoverage, concise, isUnifiedLogic),
           });
           break;
         default:
@@ -174,22 +177,22 @@ export class TestReporter {
 
     return outputDirConfig;
   }
-  private formatResultInJson(result: TestResult): RunResult {
+  private formatResultInJson(result: TestResult, isUnifiedLogic?: boolean): RunResult {
     try {
       const reporter = new JsonReporter();
-      return reporter.format(result);
+      return reporter.format(result, isUnifiedLogic);
     } catch (e) {
       this.ux.styledJSON(result);
       throw messages.createError('testResultProcessErr', [(e as Error).message]);
     }
   }
 
-  private logHuman(result: TestResult, detailedCoverage: boolean, concise: boolean, outputDir?: string): void {
+  private logHuman(result: TestResult, detailedCoverage: boolean, concise: boolean, outputDir?: string, isUnifiedLogic?: boolean): void {
     if (outputDir) {
       this.ux.log(messages.getMessage('outputDirHint', [outputDir]));
     }
     const humanReporter = new HumanReporter();
-    const output = humanReporter.format(result, detailedCoverage, concise);
+    const output = humanReporter.format(result, detailedCoverage, concise, isUnifiedLogic);
     this.ux.log(output);
   }
 

src/shared/TestGetBase.ts

@@ -0,0 +1,63 @@
+/*
+ * 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 { TestService } from '@salesforce/apex-node';
+import { Connection } from '@salesforce/core';
+import { Ux } from '@salesforce/sf-plugins-core';
+import { RunResult, TestReporter } from '../reporters/index.js';
+
+export type TestGetBaseOptions = {
+  connection: Connection;
+  testRunId: string;
+  codeCoverage?: boolean;
+  outputDir?: string;
+  resultFormat?: string;
+  json?: boolean;
+  detailedCoverage?: boolean;
+  concise?: boolean;
+  isUnifiedLogic?: boolean;
+  testCategory?: string;
+  jsonEnabled: boolean;
+  additionalReportOptions?: Record<string, unknown>;
+};
+
+/**
+ * Common logic for getting test results.
+ */
+export class TestGetBase {
+  public static async execute(options: TestGetBaseOptions): Promise<RunResult> {
+    const {
+      connection,
+      testRunId,
+      codeCoverage,
+      outputDir,
+      resultFormat,
+      json,
+      detailedCoverage,
+      concise,
+      jsonEnabled,
+      isUnifiedLogic
+    } = options;
+
+    const testService = new TestService(connection);
+    const result = await testService.reportAsyncResults(testRunId, codeCoverage);
+
+    const testReporter = new TestReporter(new Ux({ jsonEnabled }), connection);
+
+    const reportOptions = {
+      'output-dir': outputDir,
+      'result-format': resultFormat,
+      json,
+      'code-coverage': codeCoverage,
+      'detailed-coverage': detailedCoverage,
+      concise: concise ?? false,
+      isUnifiedLogic
+    };
+
+    return testReporter.report(result, reportOptions);
+  }
+}