Use getGroupedSarifFilePaths for upload-sarif Action

src/upload-sarif.test.ts

@@ -4,87 +4,16 @@ import * as path from "path";
 import test, { ExecutionContext } from "ava";
 import * as sinon from "sinon";
 
-import {
-  AnalysisConfig,
-  AnalysisKind,
-  CodeScanning,
-  getAnalysisConfig,
-} from "./analyses";
+import { AnalysisKind, getAnalysisConfig } from "./analyses";
 import { getRunnerLogger } from "./logging";
 import { createFeatures, setupTests } from "./testing-utils";
 import { UploadResult } from "./upload-lib";
 import * as uploadLib from "./upload-lib";
-import { findAndUpload, uploadSarif } from "./upload-sarif";
+import { uploadSarif } from "./upload-sarif";
 import * as util from "./util";
 
 setupTests(test);
 
-const findAndUploadMacro = test.macro({
-  exec: async (
-    t: ExecutionContext<unknown>,
-    sarifFiles: string[],
-    analysis: AnalysisConfig,
-    sarifPath: (tempDir: string) => string = (tempDir) => tempDir,
-    expectedResult: UploadResult | undefined,
-  ) => {
-    await util.withTmpDir(async (tempDir) => {
-      sinon.stub(uploadLib, "uploadSpecifiedFiles").resolves(expectedResult);
-      const logger = getRunnerLogger(true);
-      const features = createFeatures([]);
-
-      for (const sarifFile of sarifFiles) {
-        fs.writeFileSync(path.join(tempDir, sarifFile), "");
-      }
-
-      const stats = fs.statSync(sarifPath(tempDir));
-      const actual = await findAndUpload(
-        logger,
-        features,
-        sarifPath(tempDir),
-        stats,
-        "",
-        analysis,
-      );
-
-      t.deepEqual(actual, expectedResult);
-    });
-  },
-  title: (providedTitle = "") => `findAndUpload - ${providedTitle}`,
-});
-
-test(
-  "no matching files",
-  findAndUploadMacro,
-  ["test.json"],
-  CodeScanning,
-  undefined,
-  undefined,
-);
-
-test(
-  "matching files for Code Scanning with directory path",
-  findAndUploadMacro,
-  ["test.sarif"],
-  CodeScanning,
-  undefined,
-  {
-    statusReport: {},
-    sarifID: "some-id",
-  },
-);
-
-test(
-  "matching files for Code Scanning with file path",
-  findAndUploadMacro,
-  ["test.sarif"],
-  CodeScanning,
-  (tempDir) => path.join(tempDir, "test.sarif"),
-  {
-    statusReport: {},
-    sarifID: "some-id",
-  },
-);
-
 interface UploadSarifExpectedResult {
   uploadResult?: UploadResult;
   expectedFiles?: string[];

src/upload-sarif.ts

@@ -1,64 +1,8 @@
-import * as fs from "fs";
-
 import * as analyses from "./analyses";
 import { FeatureEnablement } from "./feature-flags";
 import { Logger } from "./logging";
 import * as upload_lib from "./upload-lib";
-import { ConfigurationError } from "./util";
-
-/**
- * Searches for SARIF files for the given `analysis` in the given `sarifPath`.
- * If any are found, then they are uploaded to the appropriate endpoint for the given `analysis`.
- *
- * @param logger The logger to use.
- * @param features Information about FFs.
- * @param sarifPath The path to a SARIF file or directory containing SARIF files.
- * @param pathStats Information about `sarifPath`.
- * @param checkoutPath The checkout path.
- * @param analysis The configuration of the analysis we should upload SARIF files for.
- * @param category The SARIF category to use for the upload.
- * @returns The result of uploading the SARIF file(s) or `undefined` if there are none.
- */
-export async function findAndUpload(
-  logger: Logger,
-  features: FeatureEnablement,
-  sarifPath: string,
-  pathStats: fs.Stats,
-  checkoutPath: string,
-  analysis: analyses.AnalysisConfig,
-  category?: string,
-): Promise<upload_lib.UploadResult | undefined> {
-  let sarifFiles: string[] | undefined;
-
-  if (pathStats.isDirectory()) {
-    sarifFiles = upload_lib.findSarifFilesInDir(
-      sarifPath,
-      analysis.sarifPredicate,
-    );
-  } else if (
-    pathStats.isFile() &&
-    (analysis.sarifPredicate(sarifPath) ||
-      (analysis.kind === analyses.AnalysisKind.CodeScanning &&
-        !analyses.CodeQuality.sarifPredicate(sarifPath)))
-  ) {
-    sarifFiles = [sarifPath];
-  } else {
-    return undefined;
-  }
-
-  if (sarifFiles.length !== 0) {
-    return await upload_lib.uploadSpecifiedFiles(
-      sarifFiles,
-      checkoutPath,
-      category,
-      features,
-      logger,
-      analysis,
-    );
-  }
-
-  return undefined;
-}
+import { entriesTyped } from "./util";
 
 // Maps analysis kinds to SARIF IDs.
 export type UploadSarifResults = Partial<
@@ -83,38 +27,22 @@ export async function uploadSarif(
   sarifPath: string,
   category?: string,
 ): Promise<UploadSarifResults> {
-  const pathStats = fs.lstatSync(sarifPath, { throwIfNoEntry: false });
-
-  if (pathStats === undefined) {
-    throw new ConfigurationError(`Path does not exist: ${sarifPath}.`);
-  }
+  const sarifGroups = await upload_lib.getGroupedSarifFilePaths(
+    logger,
+    sarifPath,
+  );
 
   const uploadResults: UploadSarifResults = {};
-  const uploadResult = await findAndUpload(
-    logger,
-    features,
-    sarifPath,
-    pathStats,
-    checkoutPath,
-    analyses.CodeScanning,
-    category,
-  );
-  if (uploadResult !== undefined) {
-    uploadResults[analyses.AnalysisKind.CodeScanning] = uploadResult;
-  }
-
-  // If there are `.quality.sarif` files in `sarifPath`, then upload those to the code quality service.
-  const qualityUploadResult = await findAndUpload(
-    logger,
-    features,
-    sarifPath,
-    pathStats,
-    checkoutPath,
-    analyses.CodeQuality,
-    analyses.CodeQuality.fixCategory(logger, category),
-  );
-  if (qualityUploadResult !== undefined) {
-    uploadResults[analyses.AnalysisKind.CodeQuality] = qualityUploadResult;
+  for (const [analysisKind, sarifFiles] of entriesTyped(sarifGroups)) {
+    const analysisConfig = analyses.getAnalysisConfig(analysisKind);
+    uploadResults[analysisKind] = await upload_lib.uploadSpecifiedFiles(
+      sarifFiles,
+      checkoutPath,
+      analysisConfig.fixCategory(logger, category),
+      features,
+      logger,
+      analysisConfig,
+    );
   }
 
   return uploadResults;