Use postProcessSarifFiles and uploadProcessedFiles in uploadSarif

lib/analyze-action.js

@@ -96190,14 +96190,20 @@ async function uploadSarif(logger, features, checkoutPath, sarifPath, category)
     sarifGroups
   )) {
     const analysisConfig = getAnalysisConfig(analysisKind);
-    uploadResults[analysisKind] = await uploadSpecifiedFiles(
-      sarifFiles,
-      checkoutPath,
-      category,
-      features,
+    const processingResults = await postProcessSarifFiles(
       logger,
+      features,
+      checkoutPath,
+      sarifFiles,
+      category,
       analysisConfig
     );
+    uploadResults[analysisKind] = await uploadProcessedFiles(
+      logger,
+      checkoutPath,
+      analysisConfig,
+      processingResults
+    );
   }
   return uploadResults;
 }

lib/upload-lib.js

@@ -84856,7 +84856,6 @@ __export(upload_lib_exports, {
   uploadFiles: () => uploadFiles,
   uploadPayload: () => uploadPayload,
   uploadProcessedFiles: () => uploadProcessedFiles,
-  uploadSpecifiedFiles: () => uploadSpecifiedFiles,
   validateSarifFileSchema: () => validateSarifFileSchema,
   validateUniqueCategory: () => validateUniqueCategory,
   waitForProcessing: () => waitForProcessing
@@ -93011,7 +93010,6 @@ function filterAlertsByDiffRange(logger, sarif) {
   uploadFiles,
   uploadPayload,
   uploadProcessedFiles,
-  uploadSpecifiedFiles,
   validateSarifFileSchema,
   validateUniqueCategory,
   waitForProcessing

lib/upload-sarif-action.js

@@ -93402,22 +93402,6 @@ async function postProcessSarifFiles(logger, features, checkoutPath, sarifPaths,
   );
   return { sarif, analysisKey, environment };
 }
-async function uploadSpecifiedFiles(sarifPaths, checkoutPath, category, features, logger, uploadTarget) {
-  const processingResults = await postProcessSarifFiles(
-    logger,
-    features,
-    checkoutPath,
-    sarifPaths,
-    category,
-    uploadTarget
-  );
-  return uploadProcessedFiles(
-    logger,
-    checkoutPath,
-    uploadTarget,
-    processingResults
-  );
-}
 async function uploadProcessedFiles(logger, checkoutPath, uploadTarget, processingResults) {
   logger.startGroup(`Uploading ${uploadTarget.name} results`);
   const sarif = processingResults.sarif;
@@ -93646,14 +93630,20 @@ async function uploadSarif(logger, features, checkoutPath, sarifPath, category)
     sarifGroups
   )) {
     const analysisConfig = getAnalysisConfig(analysisKind);
-    uploadResults[analysisKind] = await uploadSpecifiedFiles(
-      sarifFiles,
-      checkoutPath,
-      category,
-      features,
+    const processingResults = await postProcessSarifFiles(
       logger,
+      features,
+      checkoutPath,
+      sarifFiles,
+      category,
       analysisConfig
     );
+    uploadResults[analysisKind] = await uploadProcessedFiles(
+      logger,
+      checkoutPath,
+      analysisConfig,
+      processingResults
+    );
   }
   return uploadResults;
 }

src/upload-lib.ts

@@ -789,7 +789,7 @@ export async function uploadFiles(
 /**
  * Uploads the given array of SARIF files.
  */
-export async function uploadSpecifiedFiles(
+async function uploadSpecifiedFiles(
   sarifPaths: string[],
   checkoutPath: string,
   category: string | undefined,

src/upload-sarif.test.ts

@@ -33,21 +33,29 @@ const uploadSarifMacro = test.macro({
 
       const toFullPath = (filename: string) => path.join(tempDir, filename);
 
-      const uploadSpecifiedFiles = sinon.stub(
+      const postProcessSarifFiles = sinon.stub(
         uploadLib,
-        "uploadSpecifiedFiles",
+        "postProcessSarifFiles",
+      );
+      const uploadProcessedFiles = sinon.stub(
+        uploadLib,
+        "uploadProcessedFiles",
       );
 
       for (const analysisKind of Object.values(AnalysisKind)) {
-        uploadSpecifiedFiles
+        const analysisConfig = getAnalysisConfig(analysisKind);
+        postProcessSarifFiles
           .withArgs(
-            sinon.match.any,
-            sinon.match.any,
-            sinon.match.any,
-            features,
             logger,
-            getAnalysisConfig(analysisKind),
+            sinon.match.any,
+            sinon.match.any,
+            sinon.match.any,
+            sinon.match.any,
+            analysisConfig,
           )
+          .resolves({ sarif: { runs: [] }, analysisKey: "", environment: "" });
+        uploadProcessedFiles
+          .withArgs(logger, sinon.match.any, analysisConfig, sinon.match.any)
           .resolves(expectedResult[analysisKind as AnalysisKind]?.uploadResult);
       }
 
@@ -63,35 +71,33 @@ const uploadSarifMacro = test.macro({
         if (analysisKindResult) {
           // We are expecting a result for this analysis kind, check that we have it.
           t.deepEqual(actual[analysisKind], analysisKindResult.uploadResult);
-          // Additionally, check that the mocked `uploadSpecifiedFiles` was called with only the file paths
+          // Additionally, check that the mocked `postProcessSarifFiles` was called with only the file paths
           // that we expected it to be called with.
           t.assert(
-            uploadSpecifiedFiles.calledWith(
+            postProcessSarifFiles.calledWith(
+              logger,
+              features,
+              sinon.match.any,
               analysisKindResult.expectedFiles?.map(toFullPath) ??
                 fullSarifPaths,
               sinon.match.any,
-              sinon.match.any,
-              features,
-              logger,
               getAnalysisConfig(analysisKind),
             ),
           );
         } else {
           // Otherwise, we are not expecting a result for this analysis kind. However, note that `undefined`
-          // is also returned by our mocked `uploadSpecifiedFiles` when there is no expected result for this
+          // is also returned by our mocked `uploadProcessedFiles` when there is no expected result for this
           // analysis kind.
           t.is(actual[analysisKind], undefined);
-          // Therefore, we also check that the mocked `uploadSpecifiedFiles` was not called for this analysis kind.
+          // Therefore, we also check that the mocked `uploadProcessedFiles` was not called for this analysis kind.
           t.assert(
-            !uploadSpecifiedFiles.calledWith(
-              sinon.match.any,
-              sinon.match.any,
-              sinon.match.any,
-              features,
+            !uploadProcessedFiles.calledWith(
               logger,
+              sinon.match.any,
               getAnalysisConfig(analysisKind),
+              sinon.match.any,
             ),
-            `uploadSpecifiedFiles was called for ${analysisKind}, but should not have been.`,
+            `uploadProcessedFiles was called for ${analysisKind}, but should not have been.`,
           );
         }
       }

src/upload-sarif.ts

@@ -37,14 +37,21 @@ export async function uploadSarif(
     sarifGroups,
   )) {
     const analysisConfig = analyses.getAnalysisConfig(analysisKind);
-    uploadResults[analysisKind] = await upload_lib.uploadSpecifiedFiles(
-      sarifFiles,
-      checkoutPath,
-      category,
-      features,
+    const processingResults = await upload_lib.postProcessSarifFiles(
       logger,
+      features,
+      checkoutPath,
+      sarifFiles,
+      category,
       analysisConfig,
     );
+
+    uploadResults[analysisKind] = await upload_lib.uploadProcessedFiles(
+      logger,
+      checkoutPath,
+      analysisConfig,
+      processingResults,
+    );
   }
 
   return uploadResults;