From 0158d059462e1a5c5c64c4d1355366c32dcabfba Mon Sep 17 00:00:00 2001 From: Henry Mercer Date: Tue, 3 Mar 2026 17:17:07 +0100 Subject: [PATCH 01/14] Make "feature not enabled" reason more specific --- lib/init-action.js | 19 ++++++++++--------- src/config-utils.test.ts | 32 ++++++++++++++++---------------- src/config-utils.ts | 24 ++++++++++++------------ src/overlay/diagnostics.ts | 8 ++++++-- 4 files changed, 44 insertions(+), 39 deletions(-) diff --git a/lib/init-action.js b/lib/init-action.js index 9b81fc7b8e..7b99390822 100644 --- a/lib/init-action.js +++ b/lib/init-action.js @@ -106388,9 +106388,9 @@ var OVERLAY_ANALYSIS_CODE_SCANNING_FEATURES = { rust: "overlay_analysis_code_scanning_rust" /* OverlayAnalysisCodeScanningRust */, swift: "overlay_analysis_code_scanning_swift" /* OverlayAnalysisCodeScanningSwift */ }; -async function isOverlayAnalysisFeatureEnabled(features, codeql, languages, codeScanningConfig) { +async function getOverlayFeatureDisabledReason(features, codeql, languages, codeScanningConfig) { if (!await features.getValue("overlay_analysis" /* OverlayAnalysis */, codeql)) { - return false; + return "overall-feature-not-enabled" /* OverallFeatureNotEnabled */; } let enableForCodeScanningOnly = false; for (const language of languages) { @@ -106403,12 +106403,15 @@ async function isOverlayAnalysisFeatureEnabled(features, codeql, languages, code enableForCodeScanningOnly = true; continue; } - return false; + return "language-not-enabled" /* LanguageNotEnabled */; } if (enableForCodeScanningOnly) { - return codeScanningConfig["disable-default-queries"] !== true && codeScanningConfig.packs === void 0 && codeScanningConfig.queries === void 0 && codeScanningConfig["query-filters"] === void 0; + const isCodeScanningOnly = codeScanningConfig["disable-default-queries"] !== true && codeScanningConfig.packs === void 0 && codeScanningConfig.queries === void 0 && codeScanningConfig["query-filters"] === void 0; + if (!isCodeScanningOnly) { + return "non-default-queries" /* NonDefaultQueries */; + } } - return true; + return void 0; } function runnerHasSufficientDiskSpace(diskUsage, logger, useV2ResourceChecks) { const minimumDiskSpaceBytes = useV2ResourceChecks ? OVERLAY_MINIMUM_AVAILABLE_DISK_SPACE_V2_BYTES : OVERLAY_MINIMUM_AVAILABLE_DISK_SPACE_BYTES; @@ -106469,12 +106472,12 @@ async function getOverlayDatabaseMode(codeql, features, languages, sourceRoot, b ); overlayDatabaseMode = "none" /* None */; disabledReason = "disabled-by-repository-property" /* DisabledByRepositoryProperty */; - } else if (await isOverlayAnalysisFeatureEnabled( + } else if ((disabledReason = await getOverlayFeatureDisabledReason( features, codeql, languages, codeScanningConfig - )) { + )) === void 0) { const performResourceChecks = !await features.getValue( "overlay_analysis_skip_resource_checks" /* OverlayAnalysisSkipResourceChecks */, codeql @@ -106520,8 +106523,6 @@ async function getOverlayDatabaseMode(codeql, features, languages, sourceRoot, b `Setting overlay database mode to ${overlayDatabaseMode} with caching because we are analyzing the default branch.` ); } - } else { - disabledReason = "feature-not-enabled" /* FeatureNotEnabled */; } const disabledResult = (reason) => ({ overlayDatabaseMode: "none" /* None */, diff --git a/src/config-utils.test.ts b/src/config-utils.test.ts index 6f780b29bf..a0b58cad13 100644 --- a/src/config-utils.test.ts +++ b/src/config-utils.test.ts @@ -1151,7 +1151,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.FeatureNotEnabled, + disabledReason: OverlayDisabledReason.OverallFeatureNotEnabled, }, ); @@ -1460,7 +1460,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.FeatureNotEnabled, + disabledReason: OverlayDisabledReason.NonDefaultQueries, }, ); @@ -1481,7 +1481,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.FeatureNotEnabled, + disabledReason: OverlayDisabledReason.NonDefaultQueries, }, ); @@ -1502,7 +1502,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.FeatureNotEnabled, + disabledReason: OverlayDisabledReason.NonDefaultQueries, }, ); @@ -1523,7 +1523,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.FeatureNotEnabled, + disabledReason: OverlayDisabledReason.NonDefaultQueries, }, ); @@ -1538,7 +1538,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.FeatureNotEnabled, + disabledReason: OverlayDisabledReason.OverallFeatureNotEnabled, }, ); @@ -1553,7 +1553,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.FeatureNotEnabled, + disabledReason: OverlayDisabledReason.OverallFeatureNotEnabled, }, ); @@ -1568,7 +1568,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.FeatureNotEnabled, + disabledReason: OverlayDisabledReason.LanguageNotEnabled, }, ); @@ -1757,7 +1757,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.FeatureNotEnabled, + disabledReason: OverlayDisabledReason.NonDefaultQueries, }, ); @@ -1778,7 +1778,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.FeatureNotEnabled, + disabledReason: OverlayDisabledReason.NonDefaultQueries, }, ); @@ -1799,7 +1799,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.FeatureNotEnabled, + disabledReason: OverlayDisabledReason.NonDefaultQueries, }, ); @@ -1820,7 +1820,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.FeatureNotEnabled, + disabledReason: OverlayDisabledReason.NonDefaultQueries, }, ); @@ -1835,7 +1835,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.FeatureNotEnabled, + disabledReason: OverlayDisabledReason.OverallFeatureNotEnabled, }, ); @@ -1850,7 +1850,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.FeatureNotEnabled, + disabledReason: OverlayDisabledReason.OverallFeatureNotEnabled, }, ); @@ -1865,7 +1865,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.FeatureNotEnabled, + disabledReason: OverlayDisabledReason.LanguageNotEnabled, }, ); @@ -2057,7 +2057,7 @@ for (const language in KnownLanguage) { { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.FeatureNotEnabled, + disabledReason: OverlayDisabledReason.LanguageNotEnabled, }, ); } diff --git a/src/config-utils.ts b/src/config-utils.ts index 14274a7238..459a494854 100644 --- a/src/config-utils.ts +++ b/src/config-utils.ts @@ -653,14 +653,14 @@ const OVERLAY_ANALYSIS_CODE_SCANNING_FEATURES: Record = { swift: Feature.OverlayAnalysisCodeScanningSwift, }; -async function isOverlayAnalysisFeatureEnabled( +async function getOverlayFeatureDisabledReason( features: FeatureEnablement, codeql: CodeQL, languages: Language[], codeScanningConfig: UserConfig, -): Promise { +): Promise { if (!(await features.getValue(Feature.OverlayAnalysis, codeql))) { - return false; + return OverlayDisabledReason.OverallFeatureNotEnabled; } let enableForCodeScanningOnly = false; for (const language of languages) { @@ -677,20 +677,22 @@ async function isOverlayAnalysisFeatureEnabled( enableForCodeScanningOnly = true; continue; } - return false; + return OverlayDisabledReason.LanguageNotEnabled; } if (enableForCodeScanningOnly) { // A code-scanning configuration runs only the (default) code-scanning suite // if the default queries are not disabled, and no packs, queries, or // query-filters are specified. - return ( + const isCodeScanningOnly = codeScanningConfig["disable-default-queries"] !== true && codeScanningConfig.packs === undefined && codeScanningConfig.queries === undefined && - codeScanningConfig["query-filters"] === undefined - ); + codeScanningConfig["query-filters"] === undefined; + if (!isCodeScanningOnly) { + return OverlayDisabledReason.NonDefaultQueries; + } } - return true; + return undefined; } /** Checks if the runner has enough disk space for overlay analysis. */ @@ -837,12 +839,12 @@ export async function getOverlayDatabaseMode( overlayDatabaseMode = OverlayDatabaseMode.None; disabledReason = OverlayDisabledReason.DisabledByRepositoryProperty; } else if ( - await isOverlayAnalysisFeatureEnabled( + (disabledReason = await getOverlayFeatureDisabledReason( features, codeql, languages, codeScanningConfig, - ) + )) === undefined ) { const performResourceChecks = !(await features.getValue( Feature.OverlayAnalysisSkipResourceChecks, @@ -903,8 +905,6 @@ export async function getOverlayDatabaseMode( "with caching because we are analyzing the default branch.", ); } - } else { - disabledReason = OverlayDisabledReason.FeatureNotEnabled; } const disabledResult = (reason: OverlayDisabledReason | undefined) => ({ diff --git a/src/overlay/diagnostics.ts b/src/overlay/diagnostics.ts index abf3c24a76..ec2fdabb0b 100644 --- a/src/overlay/diagnostics.ts +++ b/src/overlay/diagnostics.ts @@ -12,8 +12,12 @@ import { RepositoryPropertyName } from "../feature-flags/properties"; export enum OverlayDisabledReason { /** Overlay analysis was disabled by a repository property. */ DisabledByRepositoryProperty = "disabled-by-repository-property", - /** Overlay analysis feature was not enabled. */ - FeatureNotEnabled = "feature-not-enabled", + /** The top-level overlay analysis feature flag is not enabled. */ + OverallFeatureNotEnabled = "overall-feature-not-enabled", + /** Overlay analysis is not enabled for one or more of the configured languages. */ + LanguageNotEnabled = "language-not-enabled", + /** Overlay analysis is restricted to code-scanning-only configs but the config uses custom queries or packs. */ + NonDefaultQueries = "non-default-queries", /** The build mode is incompatible with overlay analysis. */ IncompatibleBuildMode = "incompatible-build-mode", /** The CodeQL CLI version is too old to support overlay analysis. */ From 9f77ff18bb6f0ace92e068bb5d4a32dc73e9a02e Mon Sep 17 00:00:00 2001 From: Henry Mercer Date: Tue, 3 Mar 2026 17:21:59 +0100 Subject: [PATCH 02/14] Make "insufficient resources" reason more specific --- lib/init-action.js | 15 ++++++++------- src/config-utils.test.ts | 16 ++++++++-------- src/config-utils.ts | 17 +++++++++-------- src/overlay/diagnostics.ts | 6 ++++-- 4 files changed, 29 insertions(+), 25 deletions(-) diff --git a/lib/init-action.js b/lib/init-action.js index 7b99390822..40276cc1b2 100644 --- a/lib/init-action.js +++ b/lib/init-action.js @@ -106447,14 +106447,14 @@ async function runnerHasSufficientMemory(codeql, ramInput, logger) { ); return true; } -async function runnerSupportsOverlayAnalysis(codeql, diskUsage, ramInput, logger, useV2ResourceChecks) { +async function getResourceDisabledReason(codeql, diskUsage, ramInput, logger, useV2ResourceChecks) { if (!runnerHasSufficientDiskSpace(diskUsage, logger, useV2ResourceChecks)) { - return false; + return "insufficient-disk-space" /* InsufficientDiskSpace */; } if (!await runnerHasSufficientMemory(codeql, ramInput, logger)) { - return false; + return "insufficient-memory" /* InsufficientMemory */; } - return true; + return void 0; } async function getOverlayDatabaseMode(codeql, features, languages, sourceRoot, buildMode, ramInput, codeScanningConfig, repositoryProperties, gitVersion, logger) { let overlayDatabaseMode = "none" /* None */; @@ -106489,15 +106489,16 @@ async function getOverlayDatabaseMode(codeql, features, languages, sourceRoot, b "overlay_analysis_status_check" /* OverlayAnalysisStatusCheck */ ); const diskUsage = performResourceChecks || checkOverlayStatus ? await checkDiskUsage(logger) : void 0; - if (performResourceChecks && !await runnerSupportsOverlayAnalysis( + let resourceDisabledReason; + if (performResourceChecks && (resourceDisabledReason = await getResourceDisabledReason( codeql, diskUsage, ramInput, logger, useV2ResourceChecks - )) { + )) !== void 0) { overlayDatabaseMode = "none" /* None */; - disabledReason = "insufficient-resources" /* InsufficientResources */; + disabledReason = resourceDisabledReason; } else if (checkOverlayStatus && diskUsage === void 0) { logger.warning( `Unable to determine disk usage, therefore setting overlay database mode to ${"none" /* None */}.` diff --git a/src/config-utils.test.ts b/src/config-utils.test.ts index a0b58cad13..ac7303086b 100644 --- a/src/config-utils.test.ts +++ b/src/config-utils.test.ts @@ -1234,7 +1234,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.InsufficientResources, + disabledReason: OverlayDisabledReason.InsufficientDiskSpace, }, ); @@ -1253,7 +1253,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.InsufficientResources, + disabledReason: OverlayDisabledReason.InsufficientDiskSpace, }, ); @@ -1298,7 +1298,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.InsufficientResources, + disabledReason: OverlayDisabledReason.InsufficientDiskSpace, }, ); @@ -1342,7 +1342,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.InsufficientResources, + disabledReason: OverlayDisabledReason.InsufficientDiskSpace, }, ); @@ -1361,7 +1361,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.InsufficientResources, + disabledReason: OverlayDisabledReason.InsufficientMemory, }, ); @@ -1638,7 +1638,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.InsufficientResources, + disabledReason: OverlayDisabledReason.InsufficientDiskSpace, }, ); @@ -1679,7 +1679,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.InsufficientResources, + disabledReason: OverlayDisabledReason.InsufficientDiskSpace, }, ); @@ -1698,7 +1698,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.InsufficientResources, + disabledReason: OverlayDisabledReason.InsufficientMemory, }, ); diff --git a/src/config-utils.ts b/src/config-utils.ts index 459a494854..9f3aaa9e81 100644 --- a/src/config-utils.ts +++ b/src/config-utils.ts @@ -759,20 +759,20 @@ async function runnerHasSufficientMemory( * Checks if the runner supports overlay analysis based on available disk space * and the maximum memory CodeQL will be allowed to use. */ -async function runnerSupportsOverlayAnalysis( +async function getResourceDisabledReason( codeql: CodeQL, diskUsage: DiskUsage | undefined, ramInput: string | undefined, logger: Logger, useV2ResourceChecks: boolean, -): Promise { +): Promise { if (!runnerHasSufficientDiskSpace(diskUsage, logger, useV2ResourceChecks)) { - return false; + return OverlayDisabledReason.InsufficientDiskSpace; } if (!(await runnerHasSufficientMemory(codeql, ramInput, logger))) { - return false; + return OverlayDisabledReason.InsufficientMemory; } - return true; + return undefined; } /** @@ -860,18 +860,19 @@ export async function getOverlayDatabaseMode( performResourceChecks || checkOverlayStatus ? await checkDiskUsage(logger) : undefined; + let resourceDisabledReason: OverlayDisabledReason | undefined; if ( performResourceChecks && - !(await runnerSupportsOverlayAnalysis( + (resourceDisabledReason = await getResourceDisabledReason( codeql, diskUsage, ramInput, logger, useV2ResourceChecks, - )) + )) !== undefined ) { overlayDatabaseMode = OverlayDatabaseMode.None; - disabledReason = OverlayDisabledReason.InsufficientResources; + disabledReason = resourceDisabledReason; } else if (checkOverlayStatus && diskUsage === undefined) { logger.warning( `Unable to determine disk usage, therefore setting overlay database mode to ${OverlayDatabaseMode.None}.`, diff --git a/src/overlay/diagnostics.ts b/src/overlay/diagnostics.ts index ec2fdabb0b..3c20f1049b 100644 --- a/src/overlay/diagnostics.ts +++ b/src/overlay/diagnostics.ts @@ -24,8 +24,10 @@ export enum OverlayDisabledReason { IncompatibleCodeQl = "incompatible-codeql", /** The Git version could not be determined or is too old. */ IncompatibleGit = "incompatible-git", - /** The runner does not have enough disk space or memory. */ - InsufficientResources = "insufficient-resources", + /** The runner does not have enough disk space to perform overlay analysis. */ + InsufficientDiskSpace = "insufficient-disk-space", + /** The runner does not have enough memory to perform overlay analysis. */ + InsufficientMemory = "insufficient-memory", /** The source root is not inside a git repository. */ NoGitRoot = "no-git-root", /** Overlay analysis was skipped because it previously failed with similar hardware resources. */ From eddf33655d217c7c77cae50233f1388cd13b0973 Mon Sep 17 00:00:00 2001 From: Henry Mercer Date: Tue, 3 Mar 2026 17:22:36 +0100 Subject: [PATCH 03/14] Sort `OverlayDisabledReason` enum --- src/overlay/diagnostics.ts | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/overlay/diagnostics.ts b/src/overlay/diagnostics.ts index 3c20f1049b..56f2bf8db3 100644 --- a/src/overlay/diagnostics.ts +++ b/src/overlay/diagnostics.ts @@ -12,12 +12,6 @@ import { RepositoryPropertyName } from "../feature-flags/properties"; export enum OverlayDisabledReason { /** Overlay analysis was disabled by a repository property. */ DisabledByRepositoryProperty = "disabled-by-repository-property", - /** The top-level overlay analysis feature flag is not enabled. */ - OverallFeatureNotEnabled = "overall-feature-not-enabled", - /** Overlay analysis is not enabled for one or more of the configured languages. */ - LanguageNotEnabled = "language-not-enabled", - /** Overlay analysis is restricted to code-scanning-only configs but the config uses custom queries or packs. */ - NonDefaultQueries = "non-default-queries", /** The build mode is incompatible with overlay analysis. */ IncompatibleBuildMode = "incompatible-build-mode", /** The CodeQL CLI version is too old to support overlay analysis. */ @@ -28,8 +22,14 @@ export enum OverlayDisabledReason { InsufficientDiskSpace = "insufficient-disk-space", /** The runner does not have enough memory to perform overlay analysis. */ InsufficientMemory = "insufficient-memory", + /** Overlay analysis is not enabled for one or more of the configured languages. */ + LanguageNotEnabled = "language-not-enabled", /** The source root is not inside a git repository. */ NoGitRoot = "no-git-root", + /** Overlay analysis is restricted to code-scanning-only configs but the config uses custom queries or packs. */ + NonDefaultQueries = "non-default-queries", + /** The top-level overlay analysis feature flag is not enabled. */ + OverallFeatureNotEnabled = "overall-feature-not-enabled", /** Overlay analysis was skipped because it previously failed with similar hardware resources. */ SkippedDueToCachedStatus = "skipped-due-to-cached-status", /** Disk usage could not be determined during the overlay status check. */ From f654d61146ed01541285d09285501f51ac5b6c15 Mon Sep 17 00:00:00 2001 From: Henry Mercer Date: Tue, 3 Mar 2026 17:24:47 +0100 Subject: [PATCH 04/14] Add JSDoc --- src/config-utils.ts | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/src/config-utils.ts b/src/config-utils.ts index 9f3aaa9e81..e9d9db6f74 100644 --- a/src/config-utils.ts +++ b/src/config-utils.ts @@ -653,6 +653,11 @@ const OVERLAY_ANALYSIS_CODE_SCANNING_FEATURES: Record = { swift: Feature.OverlayAnalysisCodeScanningSwift, }; +/** + * Checks whether the overlay analysis feature is enabled for the given + * languages and configuration, returning the specific reason it is disabled, + * or `undefined` if it is enabled. + */ async function getOverlayFeatureDisabledReason( features: FeatureEnablement, codeql: CodeQL, @@ -756,8 +761,9 @@ async function runnerHasSufficientMemory( } /** - * Checks if the runner supports overlay analysis based on available disk space - * and the maximum memory CodeQL will be allowed to use. + * Checks if the runner has sufficient disk space and memory for overlay + * analysis, returning the specific reason if not, or `undefined` if resources + * are sufficient. */ async function getResourceDisabledReason( codeql: CodeQL, From 776fd85f8c0027b7fc8bbfca14cf3dcb0672da49 Mon Sep 17 00:00:00 2001 From: Henry Mercer Date: Tue, 3 Mar 2026 18:48:23 +0100 Subject: [PATCH 05/14] Address review comments --- lib/init-action.js | 10 ++++++++-- src/config-utils.test.ts | 4 ++-- src/config-utils.ts | 19 ++++++++++--------- src/overlay/diagnostics.ts | 5 ++++- 4 files changed, 24 insertions(+), 14 deletions(-) diff --git a/lib/init-action.js b/lib/init-action.js index 40276cc1b2..c9ad04ec2a 100644 --- a/lib/init-action.js +++ b/lib/init-action.js @@ -106415,8 +106415,8 @@ async function getOverlayFeatureDisabledReason(features, codeql, languages, code } function runnerHasSufficientDiskSpace(diskUsage, logger, useV2ResourceChecks) { const minimumDiskSpaceBytes = useV2ResourceChecks ? OVERLAY_MINIMUM_AVAILABLE_DISK_SPACE_V2_BYTES : OVERLAY_MINIMUM_AVAILABLE_DISK_SPACE_BYTES; - if (diskUsage === void 0 || diskUsage.numAvailableBytes < minimumDiskSpaceBytes) { - const diskSpaceMb = diskUsage === void 0 ? 0 : Math.round(diskUsage.numAvailableBytes / 1e6); + if (diskUsage.numAvailableBytes < minimumDiskSpaceBytes) { + const diskSpaceMb = Math.round(diskUsage.numAvailableBytes / 1e6); const minimumDiskSpaceMb = Math.round(minimumDiskSpaceBytes / 1e6); logger.info( `Setting overlay database mode to ${"none" /* None */} due to insufficient disk space (${diskSpaceMb} MB, needed ${minimumDiskSpaceMb} MB).` @@ -106448,6 +106448,12 @@ async function runnerHasSufficientMemory(codeql, ramInput, logger) { return true; } async function getResourceDisabledReason(codeql, diskUsage, ramInput, logger, useV2ResourceChecks) { + if (diskUsage === void 0) { + logger.info( + `Unable to determine available disk space for overlay analysis. Setting overlay database mode to ${"none" /* None */}.` + ); + return "unable-to-determine-disk-usage" /* UnableToDetermineDiskUsage */; + } if (!runnerHasSufficientDiskSpace(diskUsage, logger, useV2ResourceChecks)) { return "insufficient-disk-space" /* InsufficientDiskSpace */; } diff --git a/src/config-utils.test.ts b/src/config-utils.test.ts index ac7303086b..d5df03129a 100644 --- a/src/config-utils.test.ts +++ b/src/config-utils.test.ts @@ -1253,7 +1253,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.InsufficientDiskSpace, + disabledReason: OverlayDisabledReason.UnableToDetermineDiskUsage, }, ); @@ -1679,7 +1679,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, - disabledReason: OverlayDisabledReason.InsufficientDiskSpace, + disabledReason: OverlayDisabledReason.UnableToDetermineDiskUsage, }, ); diff --git a/src/config-utils.ts b/src/config-utils.ts index e9d9db6f74..214361c951 100644 --- a/src/config-utils.ts +++ b/src/config-utils.ts @@ -702,21 +702,15 @@ async function getOverlayFeatureDisabledReason( /** Checks if the runner has enough disk space for overlay analysis. */ function runnerHasSufficientDiskSpace( - diskUsage: DiskUsage | undefined, + diskUsage: DiskUsage, logger: Logger, useV2ResourceChecks: boolean, ): boolean { const minimumDiskSpaceBytes = useV2ResourceChecks ? OVERLAY_MINIMUM_AVAILABLE_DISK_SPACE_V2_BYTES : OVERLAY_MINIMUM_AVAILABLE_DISK_SPACE_BYTES; - if ( - diskUsage === undefined || - diskUsage.numAvailableBytes < minimumDiskSpaceBytes - ) { - const diskSpaceMb = - diskUsage === undefined - ? 0 - : Math.round(diskUsage.numAvailableBytes / 1_000_000); + if (diskUsage.numAvailableBytes < minimumDiskSpaceBytes) { + const diskSpaceMb = Math.round(diskUsage.numAvailableBytes / 1_000_000); const minimumDiskSpaceMb = Math.round(minimumDiskSpaceBytes / 1_000_000); logger.info( `Setting overlay database mode to ${OverlayDatabaseMode.None} ` + @@ -772,6 +766,13 @@ async function getResourceDisabledReason( logger: Logger, useV2ResourceChecks: boolean, ): Promise { + if (diskUsage === undefined) { + logger.info( + `Unable to determine available disk space for overlay analysis. ` + + `Setting overlay database mode to ${OverlayDatabaseMode.None}.`, + ); + return OverlayDisabledReason.UnableToDetermineDiskUsage; + } if (!runnerHasSufficientDiskSpace(diskUsage, logger, useV2ResourceChecks)) { return OverlayDisabledReason.InsufficientDiskSpace; } diff --git a/src/overlay/diagnostics.ts b/src/overlay/diagnostics.ts index 56f2bf8db3..f3b0c0e29d 100644 --- a/src/overlay/diagnostics.ts +++ b/src/overlay/diagnostics.ts @@ -26,7 +26,10 @@ export enum OverlayDisabledReason { LanguageNotEnabled = "language-not-enabled", /** The source root is not inside a git repository. */ NoGitRoot = "no-git-root", - /** Overlay analysis is restricted to code-scanning-only configs but the config uses custom queries or packs. */ + /** + * Overlay analysis is restricted to code-scanning-only configs but the config uses custom + * queries or packs, disables default queries, or specifies query filters. + */ NonDefaultQueries = "non-default-queries", /** The top-level overlay analysis feature flag is not enabled. */ OverallFeatureNotEnabled = "overall-feature-not-enabled", From b371ccd8eaf4fcfcfaca930844c96de5b6469cb2 Mon Sep 17 00:00:00 2001 From: Henry Mercer Date: Wed, 4 Mar 2026 13:53:12 +0100 Subject: [PATCH 06/14] Refactor `getOverlayDatabaseMode` and add new disablement reason --- lib/init-action.js | 177 +++++++++++++++---------- src/config-utils.test.ts | 1 + src/config-utils.ts | 263 +++++++++++++++++++++++-------------- src/overlay/diagnostics.ts | 2 + 4 files changed, 272 insertions(+), 171 deletions(-) diff --git a/lib/init-action.js b/lib/init-action.js index c9ad04ec2a..a86eaf6767 100644 --- a/lib/init-action.js +++ b/lib/init-action.js @@ -106388,9 +106388,12 @@ var OVERLAY_ANALYSIS_CODE_SCANNING_FEATURES = { rust: "overlay_analysis_code_scanning_rust" /* OverlayAnalysisCodeScanningRust */, swift: "overlay_analysis_code_scanning_swift" /* OverlayAnalysisCodeScanningSwift */ }; -async function getOverlayFeatureDisabledReason(features, codeql, languages, codeScanningConfig) { +async function checkOverlayAnalysisFeatureEnabled(features, codeql, languages, codeScanningConfig) { if (!await features.getValue("overlay_analysis" /* OverlayAnalysis */, codeql)) { - return "overall-feature-not-enabled" /* OverallFeatureNotEnabled */; + return { + enabled: false, + reason: "overall-feature-not-enabled" /* OverallFeatureNotEnabled */ + }; } let enableForCodeScanningOnly = false; for (const language of languages) { @@ -106403,15 +106406,18 @@ async function getOverlayFeatureDisabledReason(features, codeql, languages, code enableForCodeScanningOnly = true; continue; } - return "language-not-enabled" /* LanguageNotEnabled */; + return { enabled: false, reason: "language-not-enabled" /* LanguageNotEnabled */ }; } if (enableForCodeScanningOnly) { const isCodeScanningOnly = codeScanningConfig["disable-default-queries"] !== true && codeScanningConfig.packs === void 0 && codeScanningConfig.queries === void 0 && codeScanningConfig["query-filters"] === void 0; if (!isCodeScanningOnly) { - return "non-default-queries" /* NonDefaultQueries */; + return { + enabled: false, + reason: "non-default-queries" /* NonDefaultQueries */ + }; } } - return void 0; + return { enabled: true }; } function runnerHasSufficientDiskSpace(diskUsage, logger, useV2ResourceChecks) { const minimumDiskSpaceBytes = useV2ResourceChecks ? OVERLAY_MINIMUM_AVAILABLE_DISK_SPACE_V2_BYTES : OVERLAY_MINIMUM_AVAILABLE_DISK_SPACE_BYTES; @@ -106447,97 +106453,128 @@ async function runnerHasSufficientMemory(codeql, ramInput, logger) { ); return true; } -async function getResourceDisabledReason(codeql, diskUsage, ramInput, logger, useV2ResourceChecks) { - if (diskUsage === void 0) { - logger.info( - `Unable to determine available disk space for overlay analysis. Setting overlay database mode to ${"none" /* None */}.` - ); - return "unable-to-determine-disk-usage" /* UnableToDetermineDiskUsage */; - } +async function checkRunnerResources(codeql, diskUsage, ramInput, logger, useV2ResourceChecks) { if (!runnerHasSufficientDiskSpace(diskUsage, logger, useV2ResourceChecks)) { - return "insufficient-disk-space" /* InsufficientDiskSpace */; + return { + sufficient: false, + reason: "insufficient-disk-space" /* InsufficientDiskSpace */ + }; } if (!await runnerHasSufficientMemory(codeql, ramInput, logger)) { - return "insufficient-memory" /* InsufficientMemory */; + return { + sufficient: false, + reason: "insufficient-memory" /* InsufficientMemory */ + }; } - return void 0; + return { sufficient: true }; } async function getOverlayDatabaseMode(codeql, features, languages, sourceRoot, buildMode, ramInput, codeScanningConfig, repositoryProperties, gitVersion, logger) { - let overlayDatabaseMode = "none" /* None */; - let useOverlayDatabaseCaching = false; - let disabledReason; + const disabledResult = (reason) => ({ + overlayDatabaseMode: "none" /* None */, + useOverlayDatabaseCaching: false, + disabledReason: reason + }); const modeEnv = process.env.CODEQL_OVERLAY_DATABASE_MODE; if (modeEnv === "overlay" /* Overlay */ || modeEnv === "overlay-base" /* OverlayBase */ || modeEnv === "none" /* None */) { - overlayDatabaseMode = modeEnv; logger.info( - `Setting overlay database mode to ${overlayDatabaseMode} from the CODEQL_OVERLAY_DATABASE_MODE environment variable.` + `Setting overlay database mode to ${modeEnv} from the CODEQL_OVERLAY_DATABASE_MODE environment variable.` + ); + return validateOverlayDatabaseMode( + modeEnv, + false, + codeql, + languages, + sourceRoot, + buildMode, + gitVersion, + logger ); - } else if (repositoryProperties["github-codeql-disable-overlay" /* DISABLE_OVERLAY */] === true) { + } + if (repositoryProperties["github-codeql-disable-overlay" /* DISABLE_OVERLAY */] === true) { logger.info( `Setting overlay database mode to ${"none" /* None */} because the ${"github-codeql-disable-overlay" /* DISABLE_OVERLAY */} repository property is set to true.` ); - overlayDatabaseMode = "none" /* None */; - disabledReason = "disabled-by-repository-property" /* DisabledByRepositoryProperty */; - } else if ((disabledReason = await getOverlayFeatureDisabledReason( + return disabledResult("disabled-by-repository-property" /* DisabledByRepositoryProperty */); + } + const featureResult = await checkOverlayAnalysisFeatureEnabled( features, codeql, languages, codeScanningConfig - )) === void 0) { - const performResourceChecks = !await features.getValue( - "overlay_analysis_skip_resource_checks" /* OverlayAnalysisSkipResourceChecks */, - codeql + ); + if (!featureResult.enabled) { + return disabledResult(featureResult.reason); + } + const performResourceChecks = !await features.getValue( + "overlay_analysis_skip_resource_checks" /* OverlayAnalysisSkipResourceChecks */, + codeql + ); + const useV2ResourceChecks = await features.getValue( + "overlay_analysis_resource_checks_v2" /* OverlayAnalysisResourceChecksV2 */ + ); + const checkOverlayStatus = await features.getValue( + "overlay_analysis_status_check" /* OverlayAnalysisStatusCheck */ + ); + const diskUsage = performResourceChecks || checkOverlayStatus ? await checkDiskUsage(logger) : void 0; + if ((performResourceChecks || checkOverlayStatus) && diskUsage === void 0) { + logger.warning( + `Unable to determine disk usage, therefore setting overlay database mode to ${"none" /* None */}.` + ); + return disabledResult("unable-to-determine-disk-usage" /* UnableToDetermineDiskUsage */); + } + const resourceResult = performResourceChecks && diskUsage ? await checkRunnerResources( + codeql, + diskUsage, + ramInput, + logger, + useV2ResourceChecks + ) : { sufficient: true }; + if (!resourceResult.sufficient) { + return disabledResult(resourceResult.reason); + } + if (checkOverlayStatus && diskUsage && await shouldSkipOverlayAnalysis(codeql, languages, diskUsage, logger)) { + logger.info( + `Setting overlay database mode to ${"none" /* None */} because overlay analysis previously failed with this combination of languages, disk space, and CodeQL version.` ); - const useV2ResourceChecks = await features.getValue( - "overlay_analysis_resource_checks_v2" /* OverlayAnalysisResourceChecksV2 */ + return disabledResult("skipped-due-to-cached-status" /* SkippedDueToCachedStatus */); + } + let overlayDatabaseMode; + if (isAnalyzingPullRequest()) { + overlayDatabaseMode = "overlay" /* Overlay */; + logger.info( + `Setting overlay database mode to ${overlayDatabaseMode} with caching because we are analyzing a pull request.` ); - const checkOverlayStatus = await features.getValue( - "overlay_analysis_status_check" /* OverlayAnalysisStatusCheck */ + } else if (await isAnalyzingDefaultBranch()) { + overlayDatabaseMode = "overlay-base" /* OverlayBase */; + logger.info( + `Setting overlay database mode to ${overlayDatabaseMode} with caching because we are analyzing the default branch.` ); - const diskUsage = performResourceChecks || checkOverlayStatus ? await checkDiskUsage(logger) : void 0; - let resourceDisabledReason; - if (performResourceChecks && (resourceDisabledReason = await getResourceDisabledReason( - codeql, - diskUsage, - ramInput, - logger, - useV2ResourceChecks - )) !== void 0) { - overlayDatabaseMode = "none" /* None */; - disabledReason = resourceDisabledReason; - } else if (checkOverlayStatus && diskUsage === void 0) { - logger.warning( - `Unable to determine disk usage, therefore setting overlay database mode to ${"none" /* None */}.` - ); - overlayDatabaseMode = "none" /* None */; - disabledReason = "unable-to-determine-disk-usage" /* UnableToDetermineDiskUsage */; - } else if (checkOverlayStatus && diskUsage && await shouldSkipOverlayAnalysis(codeql, languages, diskUsage, logger)) { - logger.info( - `Setting overlay database mode to ${"none" /* None */} because overlay analysis previously failed with this combination of languages, disk space, and CodeQL version.` - ); - overlayDatabaseMode = "none" /* None */; - disabledReason = "skipped-due-to-cached-status" /* SkippedDueToCachedStatus */; - } else if (isAnalyzingPullRequest()) { - overlayDatabaseMode = "overlay" /* Overlay */; - useOverlayDatabaseCaching = true; - logger.info( - `Setting overlay database mode to ${overlayDatabaseMode} with caching because we are analyzing a pull request.` - ); - } else if (await isAnalyzingDefaultBranch()) { - overlayDatabaseMode = "overlay-base" /* OverlayBase */; - useOverlayDatabaseCaching = true; - logger.info( - `Setting overlay database mode to ${overlayDatabaseMode} with caching because we are analyzing the default branch.` - ); - } + } else { + return disabledResult("not-pull-request-or-default-branch" /* NotPullRequestOrDefaultBranch */); } + return validateOverlayDatabaseMode( + overlayDatabaseMode, + true, + codeql, + languages, + sourceRoot, + buildMode, + gitVersion, + logger + ); +} +async function validateOverlayDatabaseMode(overlayDatabaseMode, useOverlayDatabaseCaching, codeql, languages, sourceRoot, buildMode, gitVersion, logger) { const disabledResult = (reason) => ({ overlayDatabaseMode: "none" /* None */, useOverlayDatabaseCaching: false, disabledReason: reason }); if (overlayDatabaseMode === "none" /* None */) { - return disabledResult(disabledReason); + return { + overlayDatabaseMode: "none" /* None */, + useOverlayDatabaseCaching: false, + disabledReason: void 0 + }; } if (buildMode !== "none" /* None */ && (await Promise.all( languages.map( @@ -106580,7 +106617,7 @@ async function getOverlayDatabaseMode(codeql, features, languages, sourceRoot, b return { overlayDatabaseMode, useOverlayDatabaseCaching, - disabledReason + disabledReason: void 0 }; } function dbLocationOrDefault(dbLocation, tempDir) { diff --git a/src/config-utils.test.ts b/src/config-utils.test.ts index d5df03129a..0708c3d089 100644 --- a/src/config-utils.test.ts +++ b/src/config-utils.test.ts @@ -1165,6 +1165,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, + disabledReason: OverlayDisabledReason.NotPullRequestOrDefaultBranch, }, ); diff --git a/src/config-utils.ts b/src/config-utils.ts index 214361c951..af1548eaba 100644 --- a/src/config-utils.ts +++ b/src/config-utils.ts @@ -655,17 +655,21 @@ const OVERLAY_ANALYSIS_CODE_SCANNING_FEATURES: Record = { /** * Checks whether the overlay analysis feature is enabled for the given - * languages and configuration, returning the specific reason it is disabled, - * or `undefined` if it is enabled. + * languages and configuration. */ -async function getOverlayFeatureDisabledReason( +async function checkOverlayAnalysisFeatureEnabled( features: FeatureEnablement, codeql: CodeQL, languages: Language[], codeScanningConfig: UserConfig, -): Promise { +): Promise< + { enabled: true } | { enabled: false; reason: OverlayDisabledReason } +> { if (!(await features.getValue(Feature.OverlayAnalysis, codeql))) { - return OverlayDisabledReason.OverallFeatureNotEnabled; + return { + enabled: false, + reason: OverlayDisabledReason.OverallFeatureNotEnabled, + }; } let enableForCodeScanningOnly = false; for (const language of languages) { @@ -682,7 +686,7 @@ async function getOverlayFeatureDisabledReason( enableForCodeScanningOnly = true; continue; } - return OverlayDisabledReason.LanguageNotEnabled; + return { enabled: false, reason: OverlayDisabledReason.LanguageNotEnabled }; } if (enableForCodeScanningOnly) { // A code-scanning configuration runs only the (default) code-scanning suite @@ -694,10 +698,13 @@ async function getOverlayFeatureDisabledReason( codeScanningConfig.queries === undefined && codeScanningConfig["query-filters"] === undefined; if (!isCodeScanningOnly) { - return OverlayDisabledReason.NonDefaultQueries; + return { + enabled: false, + reason: OverlayDisabledReason.NonDefaultQueries, + }; } } - return undefined; + return { enabled: true }; } /** Checks if the runner has enough disk space for overlay analysis. */ @@ -756,30 +763,30 @@ async function runnerHasSufficientMemory( /** * Checks if the runner has sufficient disk space and memory for overlay - * analysis, returning the specific reason if not, or `undefined` if resources - * are sufficient. + * analysis. */ -async function getResourceDisabledReason( +async function checkRunnerResources( codeql: CodeQL, - diskUsage: DiskUsage | undefined, + diskUsage: DiskUsage, ramInput: string | undefined, logger: Logger, useV2ResourceChecks: boolean, -): Promise { - if (diskUsage === undefined) { - logger.info( - `Unable to determine available disk space for overlay analysis. ` + - `Setting overlay database mode to ${OverlayDatabaseMode.None}.`, - ); - return OverlayDisabledReason.UnableToDetermineDiskUsage; - } +): Promise< + { sufficient: true } | { sufficient: false; reason: OverlayDisabledReason } +> { if (!runnerHasSufficientDiskSpace(diskUsage, logger, useV2ResourceChecks)) { - return OverlayDisabledReason.InsufficientDiskSpace; + return { + sufficient: false, + reason: OverlayDisabledReason.InsufficientDiskSpace, + }; } if (!(await runnerHasSufficientMemory(codeql, ramInput, logger))) { - return OverlayDisabledReason.InsufficientMemory; + return { + sufficient: false, + reason: OverlayDisabledReason.InsufficientMemory, + }; } - return undefined; + return { sufficient: true }; } /** @@ -819,9 +826,11 @@ export async function getOverlayDatabaseMode( useOverlayDatabaseCaching: boolean; disabledReason: OverlayDisabledReason | undefined; }> { - let overlayDatabaseMode = OverlayDatabaseMode.None; - let useOverlayDatabaseCaching = false; - let disabledReason: OverlayDisabledReason | undefined; + const disabledResult = (reason: OverlayDisabledReason | undefined) => ({ + overlayDatabaseMode: OverlayDatabaseMode.None, + useOverlayDatabaseCaching: false, + disabledReason: reason, + }); const modeEnv = process.env.CODEQL_OVERLAY_DATABASE_MODE; // Any unrecognized CODEQL_OVERLAY_DATABASE_MODE value will be ignored and @@ -831,98 +840,150 @@ export async function getOverlayDatabaseMode( modeEnv === OverlayDatabaseMode.OverlayBase || modeEnv === OverlayDatabaseMode.None ) { - overlayDatabaseMode = modeEnv; logger.info( - `Setting overlay database mode to ${overlayDatabaseMode} ` + + `Setting overlay database mode to ${modeEnv} ` + "from the CODEQL_OVERLAY_DATABASE_MODE environment variable.", ); - } else if ( - repositoryProperties[RepositoryPropertyName.DISABLE_OVERLAY] === true - ) { + return validateOverlayDatabaseMode( + modeEnv, + false, + codeql, + languages, + sourceRoot, + buildMode, + gitVersion, + logger, + ); + } + + if (repositoryProperties[RepositoryPropertyName.DISABLE_OVERLAY] === true) { logger.info( `Setting overlay database mode to ${OverlayDatabaseMode.None} ` + `because the ${RepositoryPropertyName.DISABLE_OVERLAY} repository property is set to true.`, ); - overlayDatabaseMode = OverlayDatabaseMode.None; - disabledReason = OverlayDisabledReason.DisabledByRepositoryProperty; - } else if ( - (disabledReason = await getOverlayFeatureDisabledReason( - features, - codeql, - languages, - codeScanningConfig, - )) === undefined + return disabledResult(OverlayDisabledReason.DisabledByRepositoryProperty); + } + + const featureResult = await checkOverlayAnalysisFeatureEnabled( + features, + codeql, + languages, + codeScanningConfig, + ); + if (!featureResult.enabled) { + return disabledResult(featureResult.reason); + } + + const performResourceChecks = !(await features.getValue( + Feature.OverlayAnalysisSkipResourceChecks, + codeql, + )); + const useV2ResourceChecks = await features.getValue( + Feature.OverlayAnalysisResourceChecksV2, + ); + const checkOverlayStatus = await features.getValue( + Feature.OverlayAnalysisStatusCheck, + ); + const diskUsage = + performResourceChecks || checkOverlayStatus + ? await checkDiskUsage(logger) + : undefined; + if ( + (performResourceChecks || checkOverlayStatus) && + diskUsage === undefined ) { - const performResourceChecks = !(await features.getValue( - Feature.OverlayAnalysisSkipResourceChecks, - codeql, - )); - const useV2ResourceChecks = await features.getValue( - Feature.OverlayAnalysisResourceChecksV2, + logger.warning( + `Unable to determine disk usage, therefore setting overlay database mode to ${OverlayDatabaseMode.None}.`, + ); + return disabledResult(OverlayDisabledReason.UnableToDetermineDiskUsage); + } + const resourceResult = + performResourceChecks && diskUsage + ? await checkRunnerResources( + codeql, + diskUsage, + ramInput, + logger, + useV2ResourceChecks, + ) + : { sufficient: true as const }; + if (!resourceResult.sufficient) { + return disabledResult(resourceResult.reason); + } + if ( + checkOverlayStatus && + diskUsage && + (await shouldSkipOverlayAnalysis(codeql, languages, diskUsage, logger)) + ) { + logger.info( + `Setting overlay database mode to ${OverlayDatabaseMode.None} ` + + "because overlay analysis previously failed with this combination of languages, " + + "disk space, and CodeQL version.", ); - const checkOverlayStatus = await features.getValue( - Feature.OverlayAnalysisStatusCheck, + return disabledResult(OverlayDisabledReason.SkippedDueToCachedStatus); + } + + let overlayDatabaseMode: OverlayDatabaseMode; + if (isAnalyzingPullRequest()) { + overlayDatabaseMode = OverlayDatabaseMode.Overlay; + logger.info( + `Setting overlay database mode to ${overlayDatabaseMode} ` + + "with caching because we are analyzing a pull request.", ); - const diskUsage = - performResourceChecks || checkOverlayStatus - ? await checkDiskUsage(logger) - : undefined; - let resourceDisabledReason: OverlayDisabledReason | undefined; - if ( - performResourceChecks && - (resourceDisabledReason = await getResourceDisabledReason( - codeql, - diskUsage, - ramInput, - logger, - useV2ResourceChecks, - )) !== undefined - ) { - overlayDatabaseMode = OverlayDatabaseMode.None; - disabledReason = resourceDisabledReason; - } else if (checkOverlayStatus && diskUsage === undefined) { - logger.warning( - `Unable to determine disk usage, therefore setting overlay database mode to ${OverlayDatabaseMode.None}.`, - ); - overlayDatabaseMode = OverlayDatabaseMode.None; - disabledReason = OverlayDisabledReason.UnableToDetermineDiskUsage; - } else if ( - checkOverlayStatus && - diskUsage && - (await shouldSkipOverlayAnalysis(codeql, languages, diskUsage, logger)) - ) { - logger.info( - `Setting overlay database mode to ${OverlayDatabaseMode.None} ` + - "because overlay analysis previously failed with this combination of languages, " + - "disk space, and CodeQL version.", - ); - overlayDatabaseMode = OverlayDatabaseMode.None; - disabledReason = OverlayDisabledReason.SkippedDueToCachedStatus; - } else if (isAnalyzingPullRequest()) { - overlayDatabaseMode = OverlayDatabaseMode.Overlay; - useOverlayDatabaseCaching = true; - logger.info( - `Setting overlay database mode to ${overlayDatabaseMode} ` + - "with caching because we are analyzing a pull request.", - ); - } else if (await isAnalyzingDefaultBranch()) { - overlayDatabaseMode = OverlayDatabaseMode.OverlayBase; - useOverlayDatabaseCaching = true; - logger.info( - `Setting overlay database mode to ${overlayDatabaseMode} ` + - "with caching because we are analyzing the default branch.", - ); - } + } else if (await isAnalyzingDefaultBranch()) { + overlayDatabaseMode = OverlayDatabaseMode.OverlayBase; + logger.info( + `Setting overlay database mode to ${overlayDatabaseMode} ` + + "with caching because we are analyzing the default branch.", + ); + } else { + return disabledResult(OverlayDisabledReason.NotPullRequestOrDefaultBranch); } - const disabledResult = (reason: OverlayDisabledReason | undefined) => ({ + return validateOverlayDatabaseMode( + overlayDatabaseMode, + true, + codeql, + languages, + sourceRoot, + buildMode, + gitVersion, + logger, + ); +} + +/** + * Validates that the given overlay database mode is compatible with the current + * configuration (build mode, CodeQL version, git repository, git version). Returns + * the mode unchanged if all checks pass, or falls back to `None` with the + * appropriate disabled reason. + */ +async function validateOverlayDatabaseMode( + overlayDatabaseMode: OverlayDatabaseMode, + useOverlayDatabaseCaching: boolean, + codeql: CodeQL, + languages: Language[], + sourceRoot: string, + buildMode: BuildMode | undefined, + gitVersion: GitVersionInfo | undefined, + logger: Logger, +): Promise<{ + overlayDatabaseMode: OverlayDatabaseMode; + useOverlayDatabaseCaching: boolean; + disabledReason: OverlayDisabledReason | undefined; +}> { + const disabledResult = (reason: OverlayDisabledReason) => ({ overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, disabledReason: reason, }); if (overlayDatabaseMode === OverlayDatabaseMode.None) { - return disabledResult(disabledReason); + return { + overlayDatabaseMode: OverlayDatabaseMode.None, + useOverlayDatabaseCaching: false, + disabledReason: undefined, + }; } if ( @@ -983,7 +1044,7 @@ export async function getOverlayDatabaseMode( return { overlayDatabaseMode, useOverlayDatabaseCaching, - disabledReason, + disabledReason: undefined, }; } diff --git a/src/overlay/diagnostics.ts b/src/overlay/diagnostics.ts index f3b0c0e29d..30121d1bbe 100644 --- a/src/overlay/diagnostics.ts +++ b/src/overlay/diagnostics.ts @@ -31,6 +31,8 @@ export enum OverlayDisabledReason { * queries or packs, disables default queries, or specifies query filters. */ NonDefaultQueries = "non-default-queries", + /** We are not analyzing a pull request or the default branch. */ + NotPullRequestOrDefaultBranch = "not-pull-request-or-default-branch", /** The top-level overlay analysis feature flag is not enabled. */ OverallFeatureNotEnabled = "overall-feature-not-enabled", /** Overlay analysis was skipped because it previously failed with similar hardware resources. */ From d1c255c293cad54704d0f466c029477da4a0e569 Mon Sep 17 00:00:00 2001 From: Henry Mercer Date: Wed, 4 Mar 2026 13:55:29 +0100 Subject: [PATCH 07/14] Update `NonDefaultQueries` documentation --- src/overlay/diagnostics.ts | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/overlay/diagnostics.ts b/src/overlay/diagnostics.ts index 30121d1bbe..1d3f21cda5 100644 --- a/src/overlay/diagnostics.ts +++ b/src/overlay/diagnostics.ts @@ -27,8 +27,10 @@ export enum OverlayDisabledReason { /** The source root is not inside a git repository. */ NoGitRoot = "no-git-root", /** - * Overlay analysis is restricted to code-scanning-only configs but the config uses custom - * queries or packs, disables default queries, or specifies query filters. + * For one or more of the configured languages, overlay analysis is only + * enabled when using the default query suite, but the config customises the + * queries by disabling default queries, specifying custom queries or packs, + * or adding query filters. */ NonDefaultQueries = "non-default-queries", /** We are not analyzing a pull request or the default branch. */ From be20394012ed4c85da698fe7a0dca6c441514b7c Mon Sep 17 00:00:00 2001 From: Henry Mercer Date: Wed, 4 Mar 2026 13:56:56 +0100 Subject: [PATCH 08/14] Rename to `usesDefaultQueriesOnly` --- lib/init-action.js | 4 ++-- src/config-utils.ts | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/lib/init-action.js b/lib/init-action.js index a86eaf6767..3b186e6ccc 100644 --- a/lib/init-action.js +++ b/lib/init-action.js @@ -106409,8 +106409,8 @@ async function checkOverlayAnalysisFeatureEnabled(features, codeql, languages, c return { enabled: false, reason: "language-not-enabled" /* LanguageNotEnabled */ }; } if (enableForCodeScanningOnly) { - const isCodeScanningOnly = codeScanningConfig["disable-default-queries"] !== true && codeScanningConfig.packs === void 0 && codeScanningConfig.queries === void 0 && codeScanningConfig["query-filters"] === void 0; - if (!isCodeScanningOnly) { + const usesDefaultQueriesOnly = codeScanningConfig["disable-default-queries"] !== true && codeScanningConfig.packs === void 0 && codeScanningConfig.queries === void 0 && codeScanningConfig["query-filters"] === void 0; + if (!usesDefaultQueriesOnly) { return { enabled: false, reason: "non-default-queries" /* NonDefaultQueries */ diff --git a/src/config-utils.ts b/src/config-utils.ts index af1548eaba..094f55a8ab 100644 --- a/src/config-utils.ts +++ b/src/config-utils.ts @@ -692,12 +692,12 @@ async function checkOverlayAnalysisFeatureEnabled( // A code-scanning configuration runs only the (default) code-scanning suite // if the default queries are not disabled, and no packs, queries, or // query-filters are specified. - const isCodeScanningOnly = + const usesDefaultQueriesOnly = codeScanningConfig["disable-default-queries"] !== true && codeScanningConfig.packs === undefined && codeScanningConfig.queries === undefined && codeScanningConfig["query-filters"] === undefined; - if (!isCodeScanningOnly) { + if (!usesDefaultQueriesOnly) { return { enabled: false, reason: OverlayDisabledReason.NonDefaultQueries, From 6a77217a467c0bd455197762fd06bf7ddc825ba0 Mon Sep 17 00:00:00 2001 From: Henry Mercer Date: Wed, 4 Mar 2026 17:26:10 +0100 Subject: [PATCH 09/14] Add disabled by env var disablement reason --- lib/init-action.js | 12 +++++------- src/config-utils.test.ts | 1 + src/config-utils.ts | 15 ++++++--------- src/overlay/diagnostics.ts | 2 ++ 4 files changed, 14 insertions(+), 16 deletions(-) diff --git a/lib/init-action.js b/lib/init-action.js index 3b186e6ccc..0fa09f504b 100644 --- a/lib/init-action.js +++ b/lib/init-action.js @@ -106479,6 +106479,11 @@ async function getOverlayDatabaseMode(codeql, features, languages, sourceRoot, b logger.info( `Setting overlay database mode to ${modeEnv} from the CODEQL_OVERLAY_DATABASE_MODE environment variable.` ); + if (modeEnv === "none" /* None */) { + return disabledResult( + "disabled-by-environment-variable" /* DisabledByEnvironmentVariable */ + ); + } return validateOverlayDatabaseMode( modeEnv, false, @@ -106569,13 +106574,6 @@ async function validateOverlayDatabaseMode(overlayDatabaseMode, useOverlayDataba useOverlayDatabaseCaching: false, disabledReason: reason }); - if (overlayDatabaseMode === "none" /* None */) { - return { - overlayDatabaseMode: "none" /* None */, - useOverlayDatabaseCaching: false, - disabledReason: void 0 - }; - } if (buildMode !== "none" /* None */ && (await Promise.all( languages.map( async (l) => l !== "go" /* go */ && // Workaround to allow overlay analysis for Go with any build diff --git a/src/config-utils.test.ts b/src/config-utils.test.ts index 0708c3d089..e6ba047250 100644 --- a/src/config-utils.test.ts +++ b/src/config-utils.test.ts @@ -1139,6 +1139,7 @@ test( { overlayDatabaseMode: OverlayDatabaseMode.None, useOverlayDatabaseCaching: false, + disabledReason: OverlayDisabledReason.DisabledByEnvironmentVariable, }, ); diff --git a/src/config-utils.ts b/src/config-utils.ts index 094f55a8ab..30b415380d 100644 --- a/src/config-utils.ts +++ b/src/config-utils.ts @@ -844,6 +844,11 @@ export async function getOverlayDatabaseMode( `Setting overlay database mode to ${modeEnv} ` + "from the CODEQL_OVERLAY_DATABASE_MODE environment variable.", ); + if (modeEnv === OverlayDatabaseMode.None) { + return disabledResult( + OverlayDisabledReason.DisabledByEnvironmentVariable, + ); + } return validateOverlayDatabaseMode( modeEnv, false, @@ -959,7 +964,7 @@ export async function getOverlayDatabaseMode( * appropriate disabled reason. */ async function validateOverlayDatabaseMode( - overlayDatabaseMode: OverlayDatabaseMode, + overlayDatabaseMode: Exclude, useOverlayDatabaseCaching: boolean, codeql: CodeQL, languages: Language[], @@ -978,14 +983,6 @@ async function validateOverlayDatabaseMode( disabledReason: reason, }); - if (overlayDatabaseMode === OverlayDatabaseMode.None) { - return { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, - disabledReason: undefined, - }; - } - if ( buildMode !== BuildMode.None && ( diff --git a/src/overlay/diagnostics.ts b/src/overlay/diagnostics.ts index 1d3f21cda5..6bc11a73ff 100644 --- a/src/overlay/diagnostics.ts +++ b/src/overlay/diagnostics.ts @@ -10,6 +10,8 @@ import { RepositoryPropertyName } from "../feature-flags/properties"; /** Reason why overlay analysis was disabled. */ export enum OverlayDisabledReason { + /** Overlay analysis was disabled by the CODEQL_OVERLAY_DATABASE_MODE environment variable being set to "none". */ + DisabledByEnvironmentVariable = "disabled-by-environment-variable", /** Overlay analysis was disabled by a repository property. */ DisabledByRepositoryProperty = "disabled-by-repository-property", /** The build mode is incompatible with overlay analysis. */ From 5fa8dad095d7b12a67bc8df2fe8c5e36cb8c52ce Mon Sep 17 00:00:00 2001 From: Henry Mercer Date: Wed, 4 Mar 2026 17:36:42 +0100 Subject: [PATCH 10/14] Use `Result`s for enablement return types --- lib/init-action.js | 103 ++++++++++++----------------- src/config-utils.test.ts | 93 ++++----------------------- src/config-utils.ts | 135 ++++++++++++++++----------------------- 3 files changed, 109 insertions(+), 222 deletions(-) diff --git a/lib/init-action.js b/lib/init-action.js index 0fa09f504b..7ab924d660 100644 --- a/lib/init-action.js +++ b/lib/init-action.js @@ -106390,10 +106390,7 @@ var OVERLAY_ANALYSIS_CODE_SCANNING_FEATURES = { }; async function checkOverlayAnalysisFeatureEnabled(features, codeql, languages, codeScanningConfig) { if (!await features.getValue("overlay_analysis" /* OverlayAnalysis */, codeql)) { - return { - enabled: false, - reason: "overall-feature-not-enabled" /* OverallFeatureNotEnabled */ - }; + return new Failure("overall-feature-not-enabled" /* OverallFeatureNotEnabled */); } let enableForCodeScanningOnly = false; for (const language of languages) { @@ -106406,18 +106403,15 @@ async function checkOverlayAnalysisFeatureEnabled(features, codeql, languages, c enableForCodeScanningOnly = true; continue; } - return { enabled: false, reason: "language-not-enabled" /* LanguageNotEnabled */ }; + return new Failure("language-not-enabled" /* LanguageNotEnabled */); } if (enableForCodeScanningOnly) { const usesDefaultQueriesOnly = codeScanningConfig["disable-default-queries"] !== true && codeScanningConfig.packs === void 0 && codeScanningConfig.queries === void 0 && codeScanningConfig["query-filters"] === void 0; if (!usesDefaultQueriesOnly) { - return { - enabled: false, - reason: "non-default-queries" /* NonDefaultQueries */ - }; + return new Failure("non-default-queries" /* NonDefaultQueries */); } } - return { enabled: true }; + return new Success(void 0); } function runnerHasSufficientDiskSpace(diskUsage, logger, useV2ResourceChecks) { const minimumDiskSpaceBytes = useV2ResourceChecks ? OVERLAY_MINIMUM_AVAILABLE_DISK_SPACE_V2_BYTES : OVERLAY_MINIMUM_AVAILABLE_DISK_SPACE_BYTES; @@ -106455,34 +106449,21 @@ async function runnerHasSufficientMemory(codeql, ramInput, logger) { } async function checkRunnerResources(codeql, diskUsage, ramInput, logger, useV2ResourceChecks) { if (!runnerHasSufficientDiskSpace(diskUsage, logger, useV2ResourceChecks)) { - return { - sufficient: false, - reason: "insufficient-disk-space" /* InsufficientDiskSpace */ - }; + return new Failure("insufficient-disk-space" /* InsufficientDiskSpace */); } if (!await runnerHasSufficientMemory(codeql, ramInput, logger)) { - return { - sufficient: false, - reason: "insufficient-memory" /* InsufficientMemory */ - }; + return new Failure("insufficient-memory" /* InsufficientMemory */); } - return { sufficient: true }; + return new Success(void 0); } async function getOverlayDatabaseMode(codeql, features, languages, sourceRoot, buildMode, ramInput, codeScanningConfig, repositoryProperties, gitVersion, logger) { - const disabledResult = (reason) => ({ - overlayDatabaseMode: "none" /* None */, - useOverlayDatabaseCaching: false, - disabledReason: reason - }); const modeEnv = process.env.CODEQL_OVERLAY_DATABASE_MODE; if (modeEnv === "overlay" /* Overlay */ || modeEnv === "overlay-base" /* OverlayBase */ || modeEnv === "none" /* None */) { logger.info( `Setting overlay database mode to ${modeEnv} from the CODEQL_OVERLAY_DATABASE_MODE environment variable.` ); if (modeEnv === "none" /* None */) { - return disabledResult( - "disabled-by-environment-variable" /* DisabledByEnvironmentVariable */ - ); + return new Failure("disabled-by-environment-variable" /* DisabledByEnvironmentVariable */); } return validateOverlayDatabaseMode( modeEnv, @@ -106499,7 +106480,7 @@ async function getOverlayDatabaseMode(codeql, features, languages, sourceRoot, b logger.info( `Setting overlay database mode to ${"none" /* None */} because the ${"github-codeql-disable-overlay" /* DISABLE_OVERLAY */} repository property is set to true.` ); - return disabledResult("disabled-by-repository-property" /* DisabledByRepositoryProperty */); + return new Failure("disabled-by-repository-property" /* DisabledByRepositoryProperty */); } const featureResult = await checkOverlayAnalysisFeatureEnabled( features, @@ -106507,8 +106488,8 @@ async function getOverlayDatabaseMode(codeql, features, languages, sourceRoot, b languages, codeScanningConfig ); - if (!featureResult.enabled) { - return disabledResult(featureResult.reason); + if (featureResult.isFailure()) { + return featureResult; } const performResourceChecks = !await features.getValue( "overlay_analysis_skip_resource_checks" /* OverlayAnalysisSkipResourceChecks */, @@ -106525,7 +106506,7 @@ async function getOverlayDatabaseMode(codeql, features, languages, sourceRoot, b logger.warning( `Unable to determine disk usage, therefore setting overlay database mode to ${"none" /* None */}.` ); - return disabledResult("unable-to-determine-disk-usage" /* UnableToDetermineDiskUsage */); + return new Failure("unable-to-determine-disk-usage" /* UnableToDetermineDiskUsage */); } const resourceResult = performResourceChecks && diskUsage ? await checkRunnerResources( codeql, @@ -106533,15 +106514,15 @@ async function getOverlayDatabaseMode(codeql, features, languages, sourceRoot, b ramInput, logger, useV2ResourceChecks - ) : { sufficient: true }; - if (!resourceResult.sufficient) { - return disabledResult(resourceResult.reason); + ) : new Success(void 0); + if (resourceResult.isFailure()) { + return resourceResult; } if (checkOverlayStatus && diskUsage && await shouldSkipOverlayAnalysis(codeql, languages, diskUsage, logger)) { logger.info( `Setting overlay database mode to ${"none" /* None */} because overlay analysis previously failed with this combination of languages, disk space, and CodeQL version.` ); - return disabledResult("skipped-due-to-cached-status" /* SkippedDueToCachedStatus */); + return new Failure("skipped-due-to-cached-status" /* SkippedDueToCachedStatus */); } let overlayDatabaseMode; if (isAnalyzingPullRequest()) { @@ -106555,7 +106536,7 @@ async function getOverlayDatabaseMode(codeql, features, languages, sourceRoot, b `Setting overlay database mode to ${overlayDatabaseMode} with caching because we are analyzing the default branch.` ); } else { - return disabledResult("not-pull-request-or-default-branch" /* NotPullRequestOrDefaultBranch */); + return new Failure("not-pull-request-or-default-branch" /* NotPullRequestOrDefaultBranch */); } return validateOverlayDatabaseMode( overlayDatabaseMode, @@ -106569,11 +106550,6 @@ async function getOverlayDatabaseMode(codeql, features, languages, sourceRoot, b ); } async function validateOverlayDatabaseMode(overlayDatabaseMode, useOverlayDatabaseCaching, codeql, languages, sourceRoot, buildMode, gitVersion, logger) { - const disabledResult = (reason) => ({ - overlayDatabaseMode: "none" /* None */, - useOverlayDatabaseCaching: false, - disabledReason: reason - }); if (buildMode !== "none" /* None */ && (await Promise.all( languages.map( async (l) => l !== "go" /* go */ && // Workaround to allow overlay analysis for Go with any build @@ -106586,37 +106562,36 @@ async function validateOverlayDatabaseMode(overlayDatabaseMode, useOverlayDataba logger.warning( `Cannot build an ${overlayDatabaseMode} database because build-mode is set to "${buildMode}" instead of "none". Falling back to creating a normal full database instead.` ); - return disabledResult("incompatible-build-mode" /* IncompatibleBuildMode */); + return new Failure("incompatible-build-mode" /* IncompatibleBuildMode */); } if (!await codeQlVersionAtLeast(codeql, CODEQL_OVERLAY_MINIMUM_VERSION)) { logger.warning( `Cannot build an ${overlayDatabaseMode} database because the CodeQL CLI is older than ${CODEQL_OVERLAY_MINIMUM_VERSION}. Falling back to creating a normal full database instead.` ); - return disabledResult("incompatible-codeql" /* IncompatibleCodeQl */); + return new Failure("incompatible-codeql" /* IncompatibleCodeQl */); } if (await getGitRoot(sourceRoot) === void 0) { logger.warning( `Cannot build an ${overlayDatabaseMode} database because the source root "${sourceRoot}" is not inside a git repository. Falling back to creating a normal full database instead.` ); - return disabledResult("no-git-root" /* NoGitRoot */); + return new Failure("no-git-root" /* NoGitRoot */); } if (gitVersion === void 0) { logger.warning( `Cannot build an ${overlayDatabaseMode} database because the Git version could not be determined. Falling back to creating a normal full database instead.` ); - return disabledResult("incompatible-git" /* IncompatibleGit */); + return new Failure("incompatible-git" /* IncompatibleGit */); } if (!gitVersion.isAtLeast(GIT_MINIMUM_VERSION_FOR_OVERLAY)) { logger.warning( `Cannot build an ${overlayDatabaseMode} database because the installed Git version is older than ${GIT_MINIMUM_VERSION_FOR_OVERLAY}. Falling back to creating a normal full database instead.` ); - return disabledResult("incompatible-git" /* IncompatibleGit */); + return new Failure("incompatible-git" /* IncompatibleGit */); } - return { + return new Success({ overlayDatabaseMode, - useOverlayDatabaseCaching, - disabledReason: void 0 - }; + useOverlayDatabaseCaching + }); } function dbLocationOrDefault(dbLocation, tempDir) { return dbLocation || path9.resolve(tempDir, "codeql_databases"); @@ -106704,11 +106679,7 @@ async function initConfig(features, inputs) { } else { logger.debug(`Skipping check for generated files.`); } - const { - overlayDatabaseMode, - useOverlayDatabaseCaching, - disabledReason: overlayDisabledReason - } = await getOverlayDatabaseMode( + const overlayDatabaseModeResult = await getOverlayDatabaseMode( inputs.codeql, inputs.features, config.languages, @@ -106720,19 +106691,27 @@ async function initConfig(features, inputs) { gitVersion, logger ); - logger.info( - `Using overlay database mode: ${overlayDatabaseMode} ${useOverlayDatabaseCaching ? "with" : "without"} caching.` - ); - config.overlayDatabaseMode = overlayDatabaseMode; - config.useOverlayDatabaseCaching = useOverlayDatabaseCaching; - if (overlayDisabledReason !== void 0) { + if (overlayDatabaseModeResult.isSuccess()) { + const { overlayDatabaseMode, useOverlayDatabaseCaching } = overlayDatabaseModeResult.value; + logger.info( + `Using overlay database mode: ${overlayDatabaseMode} ${useOverlayDatabaseCaching ? "with" : "without"} caching.` + ); + config.overlayDatabaseMode = overlayDatabaseMode; + config.useOverlayDatabaseCaching = useOverlayDatabaseCaching; + } else { + const overlayDisabledReason = overlayDatabaseModeResult.value; + logger.info( + `Using overlay database mode: ${"none" /* None */} without caching.` + ); + config.overlayDatabaseMode = "none" /* None */; + config.useOverlayDatabaseCaching = false; await addOverlayDisablementDiagnostics( config, inputs.codeql, overlayDisabledReason ); } - if (overlayDatabaseMode === "overlay" /* Overlay */ || await shouldPerformDiffInformedAnalysis( + if (config.overlayDatabaseMode === "overlay" /* Overlay */ || await shouldPerformDiffInformedAnalysis( inputs.codeql, inputs.features, logger diff --git a/src/config-utils.test.ts b/src/config-utils.test.ts index e6ba047250..f00e1a40e9 100644 --- a/src/config-utils.test.ts +++ b/src/config-utils.test.ts @@ -40,6 +40,8 @@ import { withTmpDir, BuildMode, DiskUsage, + Success, + Failure, } from "./util"; import * as util from "./util"; @@ -1017,11 +1019,14 @@ const getOverlayDatabaseModeMacro = test.macro({ t: ExecutionContext, _title: string, setupOverrides: Partial, - expected: { - overlayDatabaseMode: OverlayDatabaseMode; - useOverlayDatabaseCaching: boolean; - disabledReason?: OverlayDisabledReason; - }, + expected: + | { + overlayDatabaseMode: OverlayDatabaseMode; + useOverlayDatabaseCaching: boolean; + } + | { + disabledReason: OverlayDisabledReason; + }, ) => { return await withTmpDir(async (tempDir) => { const messages: LoggedMessage[] = []; @@ -1092,11 +1097,11 @@ const getOverlayDatabaseModeMacro = test.macro({ logger, ); - if (!("disabledReason" in expected)) { - expected.disabledReason = undefined; + if ("disabledReason" in expected) { + t.deepEqual(result, new Failure(expected.disabledReason)); + } else { + t.deepEqual(result, new Success(expected)); } - - t.deepEqual(result, expected); } finally { // Restore the original environment process.env = originalEnv; @@ -1137,8 +1142,6 @@ test( overlayDatabaseEnvVar: "none", }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.DisabledByEnvironmentVariable, }, ); @@ -1150,8 +1153,6 @@ test( overlayDatabaseEnvVar: "invalid-mode", }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.OverallFeatureNotEnabled, }, ); @@ -1164,8 +1165,6 @@ test( features: [Feature.OverlayAnalysis, Feature.OverlayAnalysisJavascript], }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.NotPullRequestOrDefaultBranch, }, ); @@ -1234,8 +1233,6 @@ test( }, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.InsufficientDiskSpace, }, ); @@ -1253,8 +1250,6 @@ test( diskUsage: undefined, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.UnableToDetermineDiskUsage, }, ); @@ -1298,8 +1293,6 @@ test( }, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.InsufficientDiskSpace, }, ); @@ -1342,8 +1335,6 @@ test( }, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.InsufficientDiskSpace, }, ); @@ -1361,8 +1352,6 @@ test( memoryFlagValue: 3072, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.InsufficientMemory, }, ); @@ -1419,8 +1408,6 @@ test( shouldSkipOverlayAnalysisDueToCachedStatus: true, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.SkippedDueToCachedStatus, }, ); @@ -1439,8 +1426,6 @@ test( shouldSkipOverlayAnalysisDueToCachedStatus: true, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.SkippedDueToCachedStatus, }, ); @@ -1460,8 +1445,6 @@ test( isDefaultBranch: true, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.NonDefaultQueries, }, ); @@ -1481,8 +1464,6 @@ test( isDefaultBranch: true, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.NonDefaultQueries, }, ); @@ -1502,8 +1483,6 @@ test( isDefaultBranch: true, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.NonDefaultQueries, }, ); @@ -1523,8 +1502,6 @@ test( isDefaultBranch: true, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.NonDefaultQueries, }, ); @@ -1538,8 +1515,6 @@ test( isDefaultBranch: true, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.OverallFeatureNotEnabled, }, ); @@ -1553,8 +1528,6 @@ test( isDefaultBranch: true, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.OverallFeatureNotEnabled, }, ); @@ -1568,8 +1541,6 @@ test( isDefaultBranch: true, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.LanguageNotEnabled, }, ); @@ -1638,8 +1609,6 @@ test( }, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.InsufficientDiskSpace, }, ); @@ -1679,8 +1648,6 @@ test( diskUsage: undefined, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.UnableToDetermineDiskUsage, }, ); @@ -1698,8 +1665,6 @@ test( memoryFlagValue: 3072, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.InsufficientMemory, }, ); @@ -1757,8 +1722,6 @@ test( isPullRequest: true, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.NonDefaultQueries, }, ); @@ -1778,8 +1741,6 @@ test( isPullRequest: true, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.NonDefaultQueries, }, ); @@ -1799,8 +1760,6 @@ test( isPullRequest: true, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.NonDefaultQueries, }, ); @@ -1820,8 +1779,6 @@ test( isPullRequest: true, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.NonDefaultQueries, }, ); @@ -1835,8 +1792,6 @@ test( isPullRequest: true, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.OverallFeatureNotEnabled, }, ); @@ -1850,8 +1805,6 @@ test( isPullRequest: true, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.OverallFeatureNotEnabled, }, ); @@ -1865,8 +1818,6 @@ test( isPullRequest: true, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.LanguageNotEnabled, }, ); @@ -1919,8 +1870,6 @@ test( languages: [KnownLanguage.java], }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.IncompatibleBuildMode, }, ); @@ -1934,8 +1883,6 @@ test( languages: [KnownLanguage.java], }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.IncompatibleBuildMode, }, ); @@ -1948,8 +1895,6 @@ test( codeqlVersion: "2.14.0", }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.IncompatibleCodeQl, }, ); @@ -1962,8 +1907,6 @@ test( gitRoot: undefined, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.NoGitRoot, }, ); @@ -1976,8 +1919,6 @@ test( gitVersion: new GitVersionInfo("2.30.0", "2.30.0"), // Version below required 2.38.0 }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.IncompatibleGit, }, ); @@ -1990,8 +1931,6 @@ test( gitVersion: undefined, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.IncompatibleGit, }, ); @@ -2008,8 +1947,6 @@ test( }, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.DisabledByRepositoryProperty, }, ); @@ -2057,8 +1994,6 @@ for (const language in KnownLanguage) { isPullRequest: true, }, { - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, disabledReason: OverlayDisabledReason.LanguageNotEnabled, }, ); diff --git a/src/config-utils.ts b/src/config-utils.ts index 30b415380d..2fe9ce5460 100644 --- a/src/config-utils.ts +++ b/src/config-utils.ts @@ -69,6 +69,9 @@ import { isInTestMode, joinAtMost, DiskUsage, + Result, + Success, + Failure, } from "./util"; /** @@ -662,14 +665,9 @@ async function checkOverlayAnalysisFeatureEnabled( codeql: CodeQL, languages: Language[], codeScanningConfig: UserConfig, -): Promise< - { enabled: true } | { enabled: false; reason: OverlayDisabledReason } -> { +): Promise> { if (!(await features.getValue(Feature.OverlayAnalysis, codeql))) { - return { - enabled: false, - reason: OverlayDisabledReason.OverallFeatureNotEnabled, - }; + return new Failure(OverlayDisabledReason.OverallFeatureNotEnabled); } let enableForCodeScanningOnly = false; for (const language of languages) { @@ -686,7 +684,7 @@ async function checkOverlayAnalysisFeatureEnabled( enableForCodeScanningOnly = true; continue; } - return { enabled: false, reason: OverlayDisabledReason.LanguageNotEnabled }; + return new Failure(OverlayDisabledReason.LanguageNotEnabled); } if (enableForCodeScanningOnly) { // A code-scanning configuration runs only the (default) code-scanning suite @@ -698,13 +696,10 @@ async function checkOverlayAnalysisFeatureEnabled( codeScanningConfig.queries === undefined && codeScanningConfig["query-filters"] === undefined; if (!usesDefaultQueriesOnly) { - return { - enabled: false, - reason: OverlayDisabledReason.NonDefaultQueries, - }; + return new Failure(OverlayDisabledReason.NonDefaultQueries); } } - return { enabled: true }; + return new Success(undefined); } /** Checks if the runner has enough disk space for overlay analysis. */ @@ -771,22 +766,19 @@ async function checkRunnerResources( ramInput: string | undefined, logger: Logger, useV2ResourceChecks: boolean, -): Promise< - { sufficient: true } | { sufficient: false; reason: OverlayDisabledReason } -> { +): Promise> { if (!runnerHasSufficientDiskSpace(diskUsage, logger, useV2ResourceChecks)) { - return { - sufficient: false, - reason: OverlayDisabledReason.InsufficientDiskSpace, - }; + return new Failure(OverlayDisabledReason.InsufficientDiskSpace); } if (!(await runnerHasSufficientMemory(codeql, ramInput, logger))) { - return { - sufficient: false, - reason: OverlayDisabledReason.InsufficientMemory, - }; + return new Failure(OverlayDisabledReason.InsufficientMemory); } - return { sufficient: true }; + return new Success(undefined); +} + +interface OverlayParameters { + overlayDatabaseMode: Exclude; + useOverlayDatabaseCaching: boolean; } /** @@ -821,17 +813,7 @@ export async function getOverlayDatabaseMode( repositoryProperties: RepositoryProperties, gitVersion: GitVersionInfo | undefined, logger: Logger, -): Promise<{ - overlayDatabaseMode: OverlayDatabaseMode; - useOverlayDatabaseCaching: boolean; - disabledReason: OverlayDisabledReason | undefined; -}> { - const disabledResult = (reason: OverlayDisabledReason | undefined) => ({ - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, - disabledReason: reason, - }); - +): Promise> { const modeEnv = process.env.CODEQL_OVERLAY_DATABASE_MODE; // Any unrecognized CODEQL_OVERLAY_DATABASE_MODE value will be ignored and // treated as if the environment variable was not set. @@ -845,9 +827,7 @@ export async function getOverlayDatabaseMode( "from the CODEQL_OVERLAY_DATABASE_MODE environment variable.", ); if (modeEnv === OverlayDatabaseMode.None) { - return disabledResult( - OverlayDisabledReason.DisabledByEnvironmentVariable, - ); + return new Failure(OverlayDisabledReason.DisabledByEnvironmentVariable); } return validateOverlayDatabaseMode( modeEnv, @@ -866,7 +846,7 @@ export async function getOverlayDatabaseMode( `Setting overlay database mode to ${OverlayDatabaseMode.None} ` + `because the ${RepositoryPropertyName.DISABLE_OVERLAY} repository property is set to true.`, ); - return disabledResult(OverlayDisabledReason.DisabledByRepositoryProperty); + return new Failure(OverlayDisabledReason.DisabledByRepositoryProperty); } const featureResult = await checkOverlayAnalysisFeatureEnabled( @@ -875,8 +855,8 @@ export async function getOverlayDatabaseMode( languages, codeScanningConfig, ); - if (!featureResult.enabled) { - return disabledResult(featureResult.reason); + if (featureResult.isFailure()) { + return featureResult; } const performResourceChecks = !(await features.getValue( @@ -900,7 +880,7 @@ export async function getOverlayDatabaseMode( logger.warning( `Unable to determine disk usage, therefore setting overlay database mode to ${OverlayDatabaseMode.None}.`, ); - return disabledResult(OverlayDisabledReason.UnableToDetermineDiskUsage); + return new Failure(OverlayDisabledReason.UnableToDetermineDiskUsage); } const resourceResult = performResourceChecks && diskUsage @@ -911,9 +891,9 @@ export async function getOverlayDatabaseMode( logger, useV2ResourceChecks, ) - : { sufficient: true as const }; - if (!resourceResult.sufficient) { - return disabledResult(resourceResult.reason); + : new Success(undefined); + if (resourceResult.isFailure()) { + return resourceResult; } if ( checkOverlayStatus && @@ -925,7 +905,7 @@ export async function getOverlayDatabaseMode( "because overlay analysis previously failed with this combination of languages, " + "disk space, and CodeQL version.", ); - return disabledResult(OverlayDisabledReason.SkippedDueToCachedStatus); + return new Failure(OverlayDisabledReason.SkippedDueToCachedStatus); } let overlayDatabaseMode: OverlayDatabaseMode; @@ -942,7 +922,7 @@ export async function getOverlayDatabaseMode( "with caching because we are analyzing the default branch.", ); } else { - return disabledResult(OverlayDisabledReason.NotPullRequestOrDefaultBranch); + return new Failure(OverlayDisabledReason.NotPullRequestOrDefaultBranch); } return validateOverlayDatabaseMode( @@ -972,17 +952,7 @@ async function validateOverlayDatabaseMode( buildMode: BuildMode | undefined, gitVersion: GitVersionInfo | undefined, logger: Logger, -): Promise<{ - overlayDatabaseMode: OverlayDatabaseMode; - useOverlayDatabaseCaching: boolean; - disabledReason: OverlayDisabledReason | undefined; -}> { - const disabledResult = (reason: OverlayDisabledReason) => ({ - overlayDatabaseMode: OverlayDatabaseMode.None, - useOverlayDatabaseCaching: false, - disabledReason: reason, - }); - +): Promise> { if ( buildMode !== BuildMode.None && ( @@ -1003,7 +973,7 @@ async function validateOverlayDatabaseMode( `build-mode is set to "${buildMode}" instead of "none". ` + "Falling back to creating a normal full database instead.", ); - return disabledResult(OverlayDisabledReason.IncompatibleBuildMode); + return new Failure(OverlayDisabledReason.IncompatibleBuildMode); } if (!(await codeQlVersionAtLeast(codeql, CODEQL_OVERLAY_MINIMUM_VERSION))) { logger.warning( @@ -1011,7 +981,7 @@ async function validateOverlayDatabaseMode( `the CodeQL CLI is older than ${CODEQL_OVERLAY_MINIMUM_VERSION}. ` + "Falling back to creating a normal full database instead.", ); - return disabledResult(OverlayDisabledReason.IncompatibleCodeQl); + return new Failure(OverlayDisabledReason.IncompatibleCodeQl); } if ((await getGitRoot(sourceRoot)) === undefined) { logger.warning( @@ -1019,7 +989,7 @@ async function validateOverlayDatabaseMode( `the source root "${sourceRoot}" is not inside a git repository. ` + "Falling back to creating a normal full database instead.", ); - return disabledResult(OverlayDisabledReason.NoGitRoot); + return new Failure(OverlayDisabledReason.NoGitRoot); } if (gitVersion === undefined) { logger.warning( @@ -1027,7 +997,7 @@ async function validateOverlayDatabaseMode( "the Git version could not be determined. " + "Falling back to creating a normal full database instead.", ); - return disabledResult(OverlayDisabledReason.IncompatibleGit); + return new Failure(OverlayDisabledReason.IncompatibleGit); } if (!gitVersion.isAtLeast(GIT_MINIMUM_VERSION_FOR_OVERLAY)) { logger.warning( @@ -1035,14 +1005,13 @@ async function validateOverlayDatabaseMode( `the installed Git version is older than ${GIT_MINIMUM_VERSION_FOR_OVERLAY}. ` + "Falling back to creating a normal full database instead.", ); - return disabledResult(OverlayDisabledReason.IncompatibleGit); + return new Failure(OverlayDisabledReason.IncompatibleGit); } - return { + return new Success({ overlayDatabaseMode, useOverlayDatabaseCaching, - disabledReason: undefined, - }; + }); } function dbLocationOrDefault( @@ -1188,11 +1157,7 @@ export async function initConfig( // and queries, which in turn depends on the user config and the augmentation // properties. So we need to calculate the overlay database mode after the // rest of the config has been populated. - const { - overlayDatabaseMode, - useOverlayDatabaseCaching, - disabledReason: overlayDisabledReason, - } = await getOverlayDatabaseMode( + const overlayDatabaseModeResult = await getOverlayDatabaseMode( inputs.codeql, inputs.features, config.languages, @@ -1204,14 +1169,22 @@ export async function initConfig( gitVersion, logger, ); - logger.info( - `Using overlay database mode: ${overlayDatabaseMode} ` + - `${useOverlayDatabaseCaching ? "with" : "without"} caching.`, - ); - config.overlayDatabaseMode = overlayDatabaseMode; - config.useOverlayDatabaseCaching = useOverlayDatabaseCaching; - - if (overlayDisabledReason !== undefined) { + if (overlayDatabaseModeResult.isSuccess()) { + const { overlayDatabaseMode, useOverlayDatabaseCaching } = + overlayDatabaseModeResult.value; + logger.info( + `Using overlay database mode: ${overlayDatabaseMode} ` + + `${useOverlayDatabaseCaching ? "with" : "without"} caching.`, + ); + config.overlayDatabaseMode = overlayDatabaseMode; + config.useOverlayDatabaseCaching = useOverlayDatabaseCaching; + } else { + const overlayDisabledReason = overlayDatabaseModeResult.value; + logger.info( + `Using overlay database mode: ${OverlayDatabaseMode.None} without caching.`, + ); + config.overlayDatabaseMode = OverlayDatabaseMode.None; + config.useOverlayDatabaseCaching = false; await addOverlayDisablementDiagnostics( config, inputs.codeql, @@ -1220,7 +1193,7 @@ export async function initConfig( } if ( - overlayDatabaseMode === OverlayDatabaseMode.Overlay || + config.overlayDatabaseMode === OverlayDatabaseMode.Overlay || (await shouldPerformDiffInformedAnalysis( inputs.codeql, inputs.features, From 4cd47adfe1f1d75037409c421f2a2125ad674e05 Mon Sep 17 00:00:00 2001 From: Henry Mercer Date: Wed, 4 Mar 2026 17:38:24 +0100 Subject: [PATCH 11/14] Address review comments --- lib/init-action.js | 9 +++++---- src/config-utils.ts | 15 +++++---------- 2 files changed, 10 insertions(+), 14 deletions(-) diff --git a/lib/init-action.js b/lib/init-action.js index 7ab924d660..eb3e7e81f6 100644 --- a/lib/init-action.js +++ b/lib/init-action.js @@ -106501,14 +106501,15 @@ async function getOverlayDatabaseMode(codeql, features, languages, sourceRoot, b const checkOverlayStatus = await features.getValue( "overlay_analysis_status_check" /* OverlayAnalysisStatusCheck */ ); - const diskUsage = performResourceChecks || checkOverlayStatus ? await checkDiskUsage(logger) : void 0; - if ((performResourceChecks || checkOverlayStatus) && diskUsage === void 0) { + const needDiskUsage = performResourceChecks || checkOverlayStatus; + const diskUsage = needDiskUsage ? await checkDiskUsage(logger) : void 0; + if (needDiskUsage && diskUsage === void 0) { logger.warning( `Unable to determine disk usage, therefore setting overlay database mode to ${"none" /* None */}.` ); return new Failure("unable-to-determine-disk-usage" /* UnableToDetermineDiskUsage */); } - const resourceResult = performResourceChecks && diskUsage ? await checkRunnerResources( + const resourceResult = performResourceChecks && diskUsage !== void 0 ? await checkRunnerResources( codeql, diskUsage, ramInput, @@ -106518,7 +106519,7 @@ async function getOverlayDatabaseMode(codeql, features, languages, sourceRoot, b if (resourceResult.isFailure()) { return resourceResult; } - if (checkOverlayStatus && diskUsage && await shouldSkipOverlayAnalysis(codeql, languages, diskUsage, logger)) { + if (checkOverlayStatus && diskUsage !== void 0 && await shouldSkipOverlayAnalysis(codeql, languages, diskUsage, logger)) { logger.info( `Setting overlay database mode to ${"none" /* None */} because overlay analysis previously failed with this combination of languages, disk space, and CodeQL version.` ); diff --git a/src/config-utils.ts b/src/config-utils.ts index 2fe9ce5460..ac3df08f45 100644 --- a/src/config-utils.ts +++ b/src/config-utils.ts @@ -869,21 +869,16 @@ export async function getOverlayDatabaseMode( const checkOverlayStatus = await features.getValue( Feature.OverlayAnalysisStatusCheck, ); - const diskUsage = - performResourceChecks || checkOverlayStatus - ? await checkDiskUsage(logger) - : undefined; - if ( - (performResourceChecks || checkOverlayStatus) && - diskUsage === undefined - ) { + const needDiskUsage = performResourceChecks || checkOverlayStatus; + const diskUsage = needDiskUsage ? await checkDiskUsage(logger) : undefined; + if (needDiskUsage && diskUsage === undefined) { logger.warning( `Unable to determine disk usage, therefore setting overlay database mode to ${OverlayDatabaseMode.None}.`, ); return new Failure(OverlayDisabledReason.UnableToDetermineDiskUsage); } const resourceResult = - performResourceChecks && diskUsage + performResourceChecks && diskUsage !== undefined ? await checkRunnerResources( codeql, diskUsage, @@ -897,7 +892,7 @@ export async function getOverlayDatabaseMode( } if ( checkOverlayStatus && - diskUsage && + diskUsage !== undefined && (await shouldSkipOverlayAnalysis(codeql, languages, diskUsage, logger)) ) { logger.info( From 7449e3294d5deeaabe2ebc8c7e114321e881de07 Mon Sep 17 00:00:00 2001 From: Henry Mercer Date: Wed, 4 Mar 2026 17:38:56 +0100 Subject: [PATCH 12/14] Rename to `EnabledOverlayConfig` --- src/config-utils.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/config-utils.ts b/src/config-utils.ts index ac3df08f45..1cce557b27 100644 --- a/src/config-utils.ts +++ b/src/config-utils.ts @@ -776,7 +776,7 @@ async function checkRunnerResources( return new Success(undefined); } -interface OverlayParameters { +interface EnabledOverlayConfig { overlayDatabaseMode: Exclude; useOverlayDatabaseCaching: boolean; } @@ -813,7 +813,7 @@ export async function getOverlayDatabaseMode( repositoryProperties: RepositoryProperties, gitVersion: GitVersionInfo | undefined, logger: Logger, -): Promise> { +): Promise> { const modeEnv = process.env.CODEQL_OVERLAY_DATABASE_MODE; // Any unrecognized CODEQL_OVERLAY_DATABASE_MODE value will be ignored and // treated as if the environment variable was not set. @@ -947,7 +947,7 @@ async function validateOverlayDatabaseMode( buildMode: BuildMode | undefined, gitVersion: GitVersionInfo | undefined, logger: Logger, -): Promise> { +): Promise> { if ( buildMode !== BuildMode.None && ( From 60a0e2bf96ea033de2c24ca4b1c8da7c5357aaa1 Mon Sep 17 00:00:00 2001 From: Henry Mercer Date: Wed, 4 Mar 2026 17:49:23 +0100 Subject: [PATCH 13/14] Update method naming and JSDoc --- lib/init-action.js | 4 +- src/config-utils.test.ts | 116 +++++++++++++++++++-------------------- src/config-utils.ts | 9 +-- 3 files changed, 65 insertions(+), 64 deletions(-) diff --git a/lib/init-action.js b/lib/init-action.js index eb3e7e81f6..077d0b3838 100644 --- a/lib/init-action.js +++ b/lib/init-action.js @@ -106456,7 +106456,7 @@ async function checkRunnerResources(codeql, diskUsage, ramInput, logger, useV2Re } return new Success(void 0); } -async function getOverlayDatabaseMode(codeql, features, languages, sourceRoot, buildMode, ramInput, codeScanningConfig, repositoryProperties, gitVersion, logger) { +async function checkOverlayEnablement(codeql, features, languages, sourceRoot, buildMode, ramInput, codeScanningConfig, repositoryProperties, gitVersion, logger) { const modeEnv = process.env.CODEQL_OVERLAY_DATABASE_MODE; if (modeEnv === "overlay" /* Overlay */ || modeEnv === "overlay-base" /* OverlayBase */ || modeEnv === "none" /* None */) { logger.info( @@ -106680,7 +106680,7 @@ async function initConfig(features, inputs) { } else { logger.debug(`Skipping check for generated files.`); } - const overlayDatabaseModeResult = await getOverlayDatabaseMode( + const overlayDatabaseModeResult = await checkOverlayEnablement( inputs.codeql, inputs.features, config.languages, diff --git a/src/config-utils.test.ts b/src/config-utils.test.ts index f00e1a40e9..a96f41e842 100644 --- a/src/config-utils.test.ts +++ b/src/config-utils.test.ts @@ -1014,7 +1014,7 @@ const defaultOverlayDatabaseModeTestSetup: OverlayDatabaseModeTestSetup = { repositoryProperties: {}, }; -const getOverlayDatabaseModeMacro = test.macro({ +const checkOverlayEnablementMacro = test.macro({ exec: async ( t: ExecutionContext, _title: string, @@ -1084,7 +1084,7 @@ const getOverlayDatabaseModeMacro = test.macro({ .stub(gitUtils, "isAnalyzingDefaultBranch") .resolves(setup.isDefaultBranch); - const result = await configUtils.getOverlayDatabaseMode( + const result = await configUtils.checkOverlayEnablement( codeql, features, setup.languages, @@ -1108,11 +1108,11 @@ const getOverlayDatabaseModeMacro = test.macro({ } }); }, - title: (_, title) => `getOverlayDatabaseMode: ${title}`, + title: (_, title) => `checkOverlayEnablement: ${title}`, }); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Environment variable override - Overlay", { overlayDatabaseEnvVar: "overlay", @@ -1124,7 +1124,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Environment variable override - OverlayBase", { overlayDatabaseEnvVar: "overlay-base", @@ -1136,7 +1136,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Environment variable override - None", { overlayDatabaseEnvVar: "none", @@ -1147,7 +1147,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Ignore invalid environment variable", { overlayDatabaseEnvVar: "invalid-mode", @@ -1158,7 +1158,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Ignore feature flag when analyzing non-default branch", { languages: [KnownLanguage.javascript], @@ -1170,7 +1170,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Overlay-base database on default branch when feature enabled", { languages: [KnownLanguage.javascript], @@ -1184,7 +1184,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Overlay-base database on default branch when feature enabled with custom analysis", { languages: [KnownLanguage.javascript], @@ -1201,7 +1201,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Overlay-base database on default branch when code-scanning feature enabled", { languages: [KnownLanguage.javascript], @@ -1218,7 +1218,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay-base database on default branch if runner disk space is too low", { languages: [KnownLanguage.javascript], @@ -1238,7 +1238,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay-base database on default branch if we can't determine runner disk space", { languages: [KnownLanguage.javascript], @@ -1255,7 +1255,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Overlay-base database on default branch if runner disk space is too low and skip resource checks flag is enabled", { languages: [KnownLanguage.javascript], @@ -1277,7 +1277,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay-base database on default branch if runner disk space is below v2 limit and v2 resource checks enabled", { languages: [KnownLanguage.javascript], @@ -1298,7 +1298,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Overlay-base database on default branch if runner disk space is between v2 and v1 limits and v2 resource checks enabled", { languages: [KnownLanguage.javascript], @@ -1320,7 +1320,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay-base database on default branch if runner disk space is between v2 and v1 limits and v2 resource checks not enabled", { languages: [KnownLanguage.javascript], @@ -1340,7 +1340,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay-base database on default branch if memory flag is too low", { languages: [KnownLanguage.javascript], @@ -1357,7 +1357,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Overlay-base database on default branch if memory flag is too low but CodeQL >= 2.24.3", { languages: [KnownLanguage.javascript], @@ -1376,7 +1376,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Overlay-base database on default branch if memory flag is too low and skip resource checks flag is enabled", { languages: [KnownLanguage.javascript], @@ -1395,7 +1395,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay-base database on default branch when cached status indicates previous failure", { languages: [KnownLanguage.javascript], @@ -1413,7 +1413,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay analysis on PR when cached status indicates previous failure", { languages: [KnownLanguage.javascript], @@ -1431,7 +1431,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay-base database on default branch when code-scanning feature enabled with disable-default-queries", { languages: [KnownLanguage.javascript], @@ -1450,7 +1450,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay-base database on default branch when code-scanning feature enabled with packs", { languages: [KnownLanguage.javascript], @@ -1469,7 +1469,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay-base database on default branch when code-scanning feature enabled with queries", { languages: [KnownLanguage.javascript], @@ -1488,7 +1488,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay-base database on default branch when code-scanning feature enabled with query-filters", { languages: [KnownLanguage.javascript], @@ -1507,7 +1507,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay-base database on default branch when only language-specific feature enabled", { languages: [KnownLanguage.javascript], @@ -1520,7 +1520,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay-base database on default branch when only code-scanning feature enabled", { languages: [KnownLanguage.javascript], @@ -1533,7 +1533,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay-base database on default branch when language-specific feature disabled", { languages: [KnownLanguage.javascript], @@ -1546,7 +1546,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Overlay analysis on PR when feature enabled", { languages: [KnownLanguage.javascript], @@ -1560,7 +1560,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Overlay analysis on PR when feature enabled with custom analysis", { languages: [KnownLanguage.javascript], @@ -1577,7 +1577,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Overlay analysis on PR when code-scanning feature enabled", { languages: [KnownLanguage.javascript], @@ -1594,7 +1594,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay analysis on PR if runner disk space is too low", { languages: [KnownLanguage.javascript], @@ -1614,7 +1614,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Overlay analysis on PR if runner disk space is too low and skip resource checks flag is enabled", { languages: [KnownLanguage.javascript], @@ -1636,7 +1636,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay analysis on PR if we can't determine runner disk space", { languages: [KnownLanguage.javascript], @@ -1653,7 +1653,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay analysis on PR if memory flag is too low", { languages: [KnownLanguage.javascript], @@ -1670,7 +1670,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Overlay analysis on PR if memory flag is too low but CodeQL >= 2.24.3", { languages: [KnownLanguage.javascript], @@ -1689,7 +1689,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Overlay analysis on PR if memory flag is too low and skip resource checks flag is enabled", { languages: [KnownLanguage.javascript], @@ -1708,7 +1708,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay analysis on PR when code-scanning feature enabled with disable-default-queries", { languages: [KnownLanguage.javascript], @@ -1727,7 +1727,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay analysis on PR when code-scanning feature enabled with packs", { languages: [KnownLanguage.javascript], @@ -1746,7 +1746,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay analysis on PR when code-scanning feature enabled with queries", { languages: [KnownLanguage.javascript], @@ -1765,7 +1765,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay analysis on PR when code-scanning feature enabled with query-filters", { languages: [KnownLanguage.javascript], @@ -1784,7 +1784,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay analysis on PR when only language-specific feature enabled", { languages: [KnownLanguage.javascript], @@ -1797,7 +1797,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay analysis on PR when only code-scanning feature enabled", { languages: [KnownLanguage.javascript], @@ -1810,7 +1810,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay analysis on PR when language-specific feature disabled", { languages: [KnownLanguage.javascript], @@ -1823,7 +1823,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Overlay PR analysis by env", { overlayDatabaseEnvVar: "overlay", @@ -1835,7 +1835,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Overlay PR analysis by env on a runner with low disk space", { overlayDatabaseEnvVar: "overlay", @@ -1848,7 +1848,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Overlay PR analysis by feature flag", { languages: [KnownLanguage.javascript], @@ -1862,7 +1862,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Fallback due to autobuild with traced language", { overlayDatabaseEnvVar: "overlay", @@ -1875,7 +1875,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Fallback due to no build mode with traced language", { overlayDatabaseEnvVar: "overlay", @@ -1888,7 +1888,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Fallback due to old CodeQL version", { overlayDatabaseEnvVar: "overlay", @@ -1900,7 +1900,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Fallback due to missing git root", { overlayDatabaseEnvVar: "overlay", @@ -1912,7 +1912,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Fallback due to old git version", { overlayDatabaseEnvVar: "overlay", @@ -1924,7 +1924,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Fallback when git version cannot be determined", { overlayDatabaseEnvVar: "overlay", @@ -1936,7 +1936,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "No overlay when disabled via repository property", { languages: [KnownLanguage.javascript], @@ -1952,7 +1952,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Overlay not disabled when repository property is false", { languages: [KnownLanguage.javascript], @@ -1969,7 +1969,7 @@ test( ); test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, "Environment variable override takes precedence over repository property", { overlayDatabaseEnvVar: "overlay", @@ -1986,7 +1986,7 @@ test( // Exercise language-specific overlay analysis features code paths for (const language in KnownLanguage) { test( - getOverlayDatabaseModeMacro, + checkOverlayEnablementMacro, `Check default overlay analysis feature for ${language}`, { languages: [language], diff --git a/src/config-utils.ts b/src/config-utils.ts index 1cce557b27..b805869388 100644 --- a/src/config-utils.ts +++ b/src/config-utils.ts @@ -799,10 +799,11 @@ interface EnabledOverlayConfig { * For `Overlay` and `OverlayBase`, the function performs further checks and * reverts to `None` if any check should fail. * - * @returns An object containing the overlay database mode and whether the - * action should perform overlay-base database caching. + * @returns A `Success` containing the overlay database mode and whether the + * action should perform overlay-base database caching, or a `Failure` + * containing the reason why overlay analysis is disabled. */ -export async function getOverlayDatabaseMode( +export async function checkOverlayEnablement( codeql: CodeQL, features: FeatureEnablement, languages: Language[], @@ -1152,7 +1153,7 @@ export async function initConfig( // and queries, which in turn depends on the user config and the augmentation // properties. So we need to calculate the overlay database mode after the // rest of the config has been populated. - const overlayDatabaseModeResult = await getOverlayDatabaseMode( + const overlayDatabaseModeResult = await checkOverlayEnablement( inputs.codeql, inputs.features, config.languages, From 6d1c37ed8fb8237990223f659b2f48210559c35a Mon Sep 17 00:00:00 2001 From: Henry Mercer Date: Wed, 4 Mar 2026 17:58:13 +0100 Subject: [PATCH 14/14] Fix some tests that should be serial --- src/config-utils.test.ts | 311 ++++++++++++++++++++------------------- 1 file changed, 163 insertions(+), 148 deletions(-) diff --git a/src/config-utils.test.ts b/src/config-utils.test.ts index bb63fcf6ee..06994c0ede 100644 --- a/src/config-utils.test.ts +++ b/src/config-utils.test.ts @@ -139,7 +139,7 @@ function mockListLanguages(languages: string[]) { sinon.stub(api, "getApiClient").value(() => client); } -test("load empty config", async (t) => { +test.serial("load empty config", async (t) => { return await withTmpDir(async (tempDir) => { const logger = getRunnerLogger(true); const languages = "javascript,python"; @@ -180,7 +180,7 @@ test("load empty config", async (t) => { }); }); -test("load code quality config", async (t) => { +test.serial("load code quality config", async (t) => { return await withTmpDir(async (tempDir) => { const logger = getRunnerLogger(true); const languages = "actions"; @@ -230,65 +230,68 @@ test("load code quality config", async (t) => { }); }); -test("initActionState doesn't throw if there are queries configured in the repository properties", async (t) => { - return await withTmpDir(async (tempDir) => { - const logger = getRunnerLogger(true); - const languages = "javascript"; - - const codeql = createStubCodeQL({ - async betterResolveLanguages() { - return { - extractors: { - javascript: [{ extractor_root: "" }], - }, - }; - }, - }); +test.serial( + "initActionState doesn't throw if there are queries configured in the repository properties", + async (t) => { + return await withTmpDir(async (tempDir) => { + const logger = getRunnerLogger(true); + const languages = "javascript"; - // This should be ignored and no error should be thrown. - const repositoryProperties = { - "github-codeql-extra-queries": "+foo", - }; + const codeql = createStubCodeQL({ + async betterResolveLanguages() { + return { + extractors: { + javascript: [{ extractor_root: "" }], + }, + }; + }, + }); - // Expected configuration for a CQ-only analysis. - const computedConfig: UserConfig = { - "disable-default-queries": true, - queries: [{ uses: "code-quality" }], - "query-filters": [], - }; + // This should be ignored and no error should be thrown. + const repositoryProperties = { + "github-codeql-extra-queries": "+foo", + }; - const expectedConfig = createTestConfig({ - analysisKinds: [AnalysisKind.CodeQuality], - languages: [KnownLanguage.javascript], - codeQLCmd: codeql.getPath(), - computedConfig, - dbLocation: path.resolve(tempDir, "codeql_databases"), - debugArtifactName: "", - debugDatabaseName: "", - tempDir, - repositoryProperties, - }); + // Expected configuration for a CQ-only analysis. + const computedConfig: UserConfig = { + "disable-default-queries": true, + queries: [{ uses: "code-quality" }], + "query-filters": [], + }; - await t.notThrowsAsync(async () => { - const config = await configUtils.initConfig( - createFeatures([]), - createTestInitConfigInputs({ - analysisKinds: [AnalysisKind.CodeQuality], - languagesInput: languages, - repository: { owner: "github", repo: "example" }, - tempDir, - codeql, - repositoryProperties, - logger, - }), - ); + const expectedConfig = createTestConfig({ + analysisKinds: [AnalysisKind.CodeQuality], + languages: [KnownLanguage.javascript], + codeQLCmd: codeql.getPath(), + computedConfig, + dbLocation: path.resolve(tempDir, "codeql_databases"), + debugArtifactName: "", + debugDatabaseName: "", + tempDir, + repositoryProperties, + }); + + await t.notThrowsAsync(async () => { + const config = await configUtils.initConfig( + createFeatures([]), + createTestInitConfigInputs({ + analysisKinds: [AnalysisKind.CodeQuality], + languagesInput: languages, + repository: { owner: "github", repo: "example" }, + tempDir, + codeql, + repositoryProperties, + logger, + }), + ); - t.deepEqual(config, expectedConfig); + t.deepEqual(config, expectedConfig); + }); }); - }); -}); + }, +); -test("loading a saved config produces the same config", async (t) => { +test.serial("loading a saved config produces the same config", async (t) => { return await withTmpDir(async (tempDir) => { const logger = getRunnerLogger(true); @@ -335,7 +338,7 @@ test("loading a saved config produces the same config", async (t) => { }); }); -test("loading config with version mismatch throws", async (t) => { +test.serial("loading config with version mismatch throws", async (t) => { return await withTmpDir(async (tempDir) => { const logger = getRunnerLogger(true); @@ -387,7 +390,7 @@ test("loading config with version mismatch throws", async (t) => { }); }); -test("load input outside of workspace", async (t) => { +test.serial("load input outside of workspace", async (t) => { return await withTmpDir(async (tempDir) => { try { await configUtils.initConfig( @@ -412,7 +415,7 @@ test("load input outside of workspace", async (t) => { }); }); -test("load non-local input with invalid repo syntax", async (t) => { +test.serial("load non-local input with invalid repo syntax", async (t) => { return await withTmpDir(async (tempDir) => { // no filename given, just a repo const configFile = "octo-org/codeql-config@main"; @@ -440,7 +443,7 @@ test("load non-local input with invalid repo syntax", async (t) => { }); }); -test("load non-existent input", async (t) => { +test.serial("load non-existent input", async (t) => { return await withTmpDir(async (tempDir) => { const languagesInput = "javascript"; const configFile = "input"; @@ -470,7 +473,7 @@ test("load non-existent input", async (t) => { }); }); -test("load non-empty input", async (t) => { +test.serial("load non-empty input", async (t) => { return await withTmpDir(async (tempDir) => { const codeql = createStubCodeQL({ async betterResolveLanguages() { @@ -541,18 +544,20 @@ test("load non-empty input", async (t) => { }); }); -test("Using config input and file together, config input should be used.", async (t) => { - return await withTmpDir(async (tempDir) => { - process.env["RUNNER_TEMP"] = tempDir; - process.env["GITHUB_WORKSPACE"] = tempDir; +test.serial( + "Using config input and file together, config input should be used.", + async (t) => { + return await withTmpDir(async (tempDir) => { + process.env["RUNNER_TEMP"] = tempDir; + process.env["GITHUB_WORKSPACE"] = tempDir; - const inputFileContents = ` + const inputFileContents = ` name: my config queries: - uses: ./foo_file`; - const configFilePath = createConfigFile(inputFileContents, tempDir); + const configFilePath = createConfigFile(inputFileContents, tempDir); - const configInput = ` + const configInput = ` name: my config queries: - uses: ./foo @@ -563,39 +568,40 @@ test("Using config input and file together, config input should be used.", async - c/d@1.2.3 `; - fs.mkdirSync(path.join(tempDir, "foo")); + fs.mkdirSync(path.join(tempDir, "foo")); - const codeql = createStubCodeQL({ - async betterResolveLanguages() { - return { - extractors: { - javascript: [{ extractor_root: "" }], - python: [{ extractor_root: "" }], - }, - }; - }, - }); + const codeql = createStubCodeQL({ + async betterResolveLanguages() { + return { + extractors: { + javascript: [{ extractor_root: "" }], + python: [{ extractor_root: "" }], + }, + }; + }, + }); - // Only JS, python packs will be ignored - const languagesInput = "javascript"; + // Only JS, python packs will be ignored + const languagesInput = "javascript"; - const config = await configUtils.initConfig( - createFeatures([]), - createTestInitConfigInputs({ - languagesInput, - configFile: configFilePath, - configInput, - tempDir, - codeql, - workspacePath: tempDir, - }), - ); + const config = await configUtils.initConfig( + createFeatures([]), + createTestInitConfigInputs({ + languagesInput, + configFile: configFilePath, + configInput, + tempDir, + codeql, + workspacePath: tempDir, + }), + ); - t.deepEqual(config.originalUserInput, yaml.load(configInput)); - }); -}); + t.deepEqual(config.originalUserInput, yaml.load(configInput)); + }); + }, +); -test("API client used when reading remote config", async (t) => { +test.serial("API client used when reading remote config", async (t) => { return await withTmpDir(async (tempDir) => { const codeql = createStubCodeQL({ async betterResolveLanguages() { @@ -644,34 +650,37 @@ test("API client used when reading remote config", async (t) => { }); }); -test("Remote config handles the case where a directory is provided", async (t) => { - return await withTmpDir(async (tempDir) => { - const dummyResponse = []; // directories are returned as arrays - mockGetContents(dummyResponse); +test.serial( + "Remote config handles the case where a directory is provided", + async (t) => { + return await withTmpDir(async (tempDir) => { + const dummyResponse = []; // directories are returned as arrays + mockGetContents(dummyResponse); - const repoReference = "octo-org/codeql-config/config.yaml@main"; - try { - await configUtils.initConfig( - createFeatures([]), - createTestInitConfigInputs({ - configFile: repoReference, - tempDir, - workspacePath: tempDir, - }), - ); - throw new Error("initConfig did not throw error"); - } catch (err) { - t.deepEqual( - err, - new ConfigurationError( - errorMessages.getConfigFileDirectoryGivenMessage(repoReference), - ), - ); - } - }); -}); + const repoReference = "octo-org/codeql-config/config.yaml@main"; + try { + await configUtils.initConfig( + createFeatures([]), + createTestInitConfigInputs({ + configFile: repoReference, + tempDir, + workspacePath: tempDir, + }), + ); + throw new Error("initConfig did not throw error"); + } catch (err) { + t.deepEqual( + err, + new ConfigurationError( + errorMessages.getConfigFileDirectoryGivenMessage(repoReference), + ), + ); + } + }); + }, +); -test("Invalid format of remote config handled correctly", async (t) => { +test.serial("Invalid format of remote config handled correctly", async (t) => { return await withTmpDir(async (tempDir) => { const dummyResponse = { // note no "content" property here @@ -700,7 +709,7 @@ test("Invalid format of remote config handled correctly", async (t) => { }); }); -test("No detected languages", async (t) => { +test.serial("No detected languages", async (t) => { return await withTmpDir(async (tempDir) => { mockListLanguages([]); const codeql = createStubCodeQL({ @@ -728,7 +737,7 @@ test("No detected languages", async (t) => { }); }); -test("Unknown languages", async (t) => { +test.serial("Unknown languages", async (t) => { return await withTmpDir(async (tempDir) => { const languagesInput = "rubbish,english"; @@ -755,7 +764,7 @@ test("Unknown languages", async (t) => { const mockLogger = getRunnerLogger(true); -test("no generateRegistries when registries is undefined", async (t) => { +test.serial("no generateRegistries when registries is undefined", async (t) => { return await withTmpDir(async (tmpDir) => { const registriesInput = undefined; const logger = getRunnerLogger(true); @@ -767,24 +776,27 @@ test("no generateRegistries when registries is undefined", async (t) => { }); }); -test("generateRegistries prefers original CODEQL_REGISTRIES_AUTH", async (t) => { - return await withTmpDir(async (tmpDir) => { - process.env.CODEQL_REGISTRIES_AUTH = "original"; - const registriesInput = yaml.dump([ - { - url: "http://ghcr.io", - packages: ["codeql/*", "codeql-testing/*"], - token: "not-a-token", - }, - ]); - const logger = getRunnerLogger(true); - const { registriesAuthTokens, qlconfigFile } = - await configUtils.generateRegistries(registriesInput, tmpDir, logger); +test.serial( + "generateRegistries prefers original CODEQL_REGISTRIES_AUTH", + async (t) => { + return await withTmpDir(async (tmpDir) => { + process.env.CODEQL_REGISTRIES_AUTH = "original"; + const registriesInput = yaml.dump([ + { + url: "http://ghcr.io", + packages: ["codeql/*", "codeql-testing/*"], + token: "not-a-token", + }, + ]); + const logger = getRunnerLogger(true); + const { registriesAuthTokens, qlconfigFile } = + await configUtils.generateRegistries(registriesInput, tmpDir, logger); - t.is(registriesAuthTokens, "original"); - t.is(qlconfigFile, path.join(tmpDir, "qlconfig.yml")); - }); -}); + t.is(registriesAuthTokens, "original"); + t.is(qlconfigFile, path.join(tmpDir, "qlconfig.yml")); + }); + }, +); // getLanguages @@ -862,7 +874,7 @@ const mockRepositoryNwo = parseRepositoryNwo("owner/repo"); expectedLanguages: ["javascript"], }, ].forEach((args) => { - test(`getLanguages: ${args.name}`, async (t) => { + test.serial(`getLanguages: ${args.name}`, async (t) => { const mockRequest = mockLanguagesInRepo(args.languagesInRepository); const stubExtractorEntry = { extractor_root: "", @@ -1999,13 +2011,16 @@ for (const language in KnownLanguage) { ); } -test("hasActionsWorkflows doesn't throw if workflows folder doesn't exist", async (t) => { - return withTmpDir(async (tmpDir) => { - t.notThrows(() => configUtils.hasActionsWorkflows(tmpDir)); - }); -}); +test.serial( + "hasActionsWorkflows doesn't throw if workflows folder doesn't exist", + async (t) => { + return withTmpDir(async (tmpDir) => { + t.notThrows(() => configUtils.hasActionsWorkflows(tmpDir)); + }); + }, +); -test("getPrimaryAnalysisConfig - single analysis kind", (t) => { +test.serial("getPrimaryAnalysisConfig - single analysis kind", (t) => { // If only one analysis kind is configured, we expect to get the matching configuration. for (const analysisKind of supportedAnalysisKinds) { const singleKind = createTestConfig({ analysisKinds: [analysisKind] }); @@ -2013,7 +2028,7 @@ test("getPrimaryAnalysisConfig - single analysis kind", (t) => { } }); -test("getPrimaryAnalysisConfig - Code Scanning + Code Quality", (t) => { +test.serial("getPrimaryAnalysisConfig - Code Scanning + Code Quality", (t) => { // For CS+CQ, we expect to get the Code Scanning configuration. const codeScanningAndCodeQuality = createTestConfig({ analysisKinds: [AnalysisKind.CodeScanning, AnalysisKind.CodeQuality],