export async function runUnitTestFromPath()

in apps/vs-code-designer/src/app/commands/workflows/unitTest/runUnitTest.ts [140:247]
90 lines of code
3 McCabe index (conditional complexity)

export async function runUnitTestFromPath(context: IActionContext, unitTestPath: string): Promise<UnitTestExecutionResult> {
  return await callWithTelemetryAndErrorHandling(runUnitTestEvent, async () => {
    const options: vscode.ProgressOptions = {
      location: vscode.ProgressLocation.Notification,
      title: localize('azureFunctions.runUnitTest', 'Running Unit Test...'),
    };

    await activateAzurite(context);

    return await vscode.window.withProgress(options, async (progress, token) => {
      token.onCancellationRequested(() => {
        // Handle cancellation logic
        context.telemetry.properties.canceledRun = 'true';
        ext.outputChannel.appendLine(localize('canceledRunUnitTest', 'Run unit test was canceled'));
      });

      const start = Date.now();
      try {
        const testsDirectory = getTestsDirectory(vscode.workspace.workspaceFolders[0].uri.fsPath);

        await new Promise((resolve) => setTimeout(resolve, 1000 + Math.random() * 1000));
        const duration = Date.now() - start;

        const testDirectory = getWorkspacePath(unitTestPath);
        const logicAppName = path.relative(testDirectory, unitTestPath).split(path.sep)[0];
        const workflowName = path.basename(path.dirname(unitTestPath));
        const unitTestName = getUnitTestName(path.basename(unitTestPath));
        const bundleVersionNumber = await getLatestBundleVersion(defaultExtensionBundlePathValue);
        const pathToExe = path.join(
          defaultExtensionBundlePathValue,
          bundleVersionNumber,
          'UnitTestExecutor',
          'Microsoft.Azure.Workflows.UnitTestExecutor.exe'
        );

        const { cmdOutput, cmdOutputIncludingStderr } = await new Promise<{ cmdOutput: string; cmdOutputIncludingStderr: string }>(
          (resolve, reject) => {
            let cmdOutput = '';
            let cmdOutputIncludingStderr = '';
            const childProc: cp.ChildProcess = cp.spawn(pathToExe, [
              '-PathToRootFolder',
              path.dirname(testDirectory),
              '-logicAppName',
              logicAppName,
              '-workflowName',
              workflowName,
              '-unitTestName',
              unitTestName,
            ]);

            childProc.stdout.on('data', (data: string | Buffer) => {
              data = data.toString();
              cmdOutput = cmdOutput.concat(data);
            });

            childProc.stderr.on('data', (data: string | Buffer) => {
              data = data.toString();
              cmdOutputIncludingStderr = cmdOutputIncludingStderr.concat(data);
            });

            childProc.on('error', reject);
            childProc.on('close', (code: number) => {
              if (code === 0) {
                resolve({
                  cmdOutput,
                  cmdOutputIncludingStderr,
                });
              } else {
                reject(new Error(`Process exited with code ${code}\n${cmdOutputIncludingStderr}`));
              }
            });
          }
        );
        progress.report({ increment: 100 });

        ext.outputChannel.appendLine(cmdOutput);
        ext.outputChannel.appendLine(cmdOutputIncludingStderr);
        context.telemetry.properties.unitTestCommandOut = cmdOutput;
        context.telemetry.properties.cmdOutputIncludingStderr = cmdOutput;
        context.telemetry.properties.sucessUnitTest = 'true';

        const projectName = path.relative(testsDirectory.fsPath, path.dirname(unitTestPath));
        const testResultsDirectory = path.join(testsDirectory.fsPath, testResultsDirectoryName, projectName, `${unitTestName}.unit-test`);
        const latestUnitTest = await getLatestUnitTest(testResultsDirectory);
        const testResult = {
          isSuccessful: latestUnitTest.data.Results.OverallStatus,
          duration,
        };
        vscode.window.showInformationMessage(localize('unitTestExecuted', 'Unit test results "{0}" was created.', latestUnitTest.label));

        ext.testRuns.set(unitTestPath, {
          unitTestPath,
          results: testResult,
        });

        return testResult;
      } catch (error) {
        vscode.window.showErrorMessage(`${localize('runFailure', 'Error Running Unit Test.')} ${error.message}`, localize('OK', 'OK'));
        context.telemetry.properties.errorMessage = error.message;
        context.telemetry.properties.sucessUnitTest = 'false';
        return {
          isSuccessful: false,
          duration: Date.now() - start,
        };
      }
    });
  });
}