More renaming

Avoid usage of "Feature Flag" unless we are talking specifically about the response from github features api. Otherwise, use terms like "Toggleable features". Note both "toggleable" and "togglable" appear to be valid spellings of the word. I chose the first for no good reason.
2022-10-07 11:33:32 -07:00 · 2022-10-07 11:33:32 -07:00 · 1a17c59fb0
commit 1a17c59fb0
parent b27aed78f5
39 changed files with 237 additions and 200 deletions
--- a/src/analyze-action.ts
+++ b/src/analyze-action.ts
@ -19,7 +19,7 @@ import { runAutobuild } from "./autobuild";
 import { getCodeQL } from "./codeql";
 import { Config, getConfig } from "./config-utils";
 import { uploadDatabases } from "./database-upload";
-import { FeatureFlags, Features } from "./feature-flags";
+import { FeatureEnablement, Features } from "./feature-flags";
 import { Language } from "./languages";
 import { getActionsLogger, Logger } from "./logging";
 import { parseRepositoryNwo } from "./repository";
@ -126,7 +126,7 @@ function doesGoExtractionOutputExist(config: Config): boolean {
 }

 /**
- * When Go extraction reconciliation is enabled, either via the feature flag
+ * When Go extraction reconciliation is enabled, either via the feature
 * or an environment variable, we will attempt to autobuild Go to preserve
 * compatibility for users who have set up Go using a legacy scanning style
 * CodeQL workflow, i.e. one without an autobuild step or manual build
@ -140,7 +140,7 @@ function doesGoExtractionOutputExist(config: Config): boolean {
 */
 async function runAutobuildIfLegacyGoWorkflow(
  config: Config,
-  featureFlags: FeatureFlags,
+  featureFlags: FeatureEnablement,
  logger: Logger
 ) {
  if (!config.languages.includes(Language.go)) {
--- a/src/analyze.test.ts
+++ b/src/analyze.test.ts
@ -14,10 +14,13 @@ import {
 import { setCodeQL } from "./codeql";
 import { Config } from "./config-utils";
 import * as count from "./count-loc";
-import { createFeatureFlags } from "./feature-flags";
 import { Language } from "./languages";
 import { getRunnerLogger } from "./logging";
-import { setupTests, setupActionsVars } from "./testing-utils";
+import {
+  setupTests,
+  setupActionsVars,
+  createFeatureFlags,
+} from "./testing-utils";
 import * as util from "./util";

 setupTests(test);
--- a/src/analyze.ts
+++ b/src/analyze.ts
@ -16,7 +16,7 @@ import {
 } from "./codeql";
 import * as configUtils from "./config-utils";
 import { countLoc } from "./count-loc";
-import { FeatureFlags } from "./feature-flags";
+import { FeatureEnablement } from "./feature-flags";
 import { isScannedLanguage, Language } from "./languages";
 import { Logger } from "./logging";
 import * as sharedEnv from "./shared-environment";
@ -122,7 +122,7 @@ export async function createdDBForScannedLanguages(
  codeql: CodeQL,
  config: configUtils.Config,
  logger: Logger,
-  featureFlags: FeatureFlags
+  featureFlags: FeatureEnablement
 ) {
  // Insert the LGTM_INDEX_X env vars at this point so they are set when
  // we extract any scanned languages.
@ -173,7 +173,7 @@ async function finalizeDatabaseCreation(
  threadsFlag: string,
  memoryFlag: string,
  logger: Logger,
-  featureFlags: FeatureFlags
+  featureFlags: FeatureEnablement
 ): Promise<DatabaseCreationTimings> {
  const codeql = await getCodeQL(config.codeQLCmd);

@ -214,7 +214,7 @@ export async function runQueries(
  automationDetailsId: string | undefined,
  config: configUtils.Config,
  logger: Logger,
-  featureFlags: FeatureFlags
+  featureFlags: FeatureEnablement
 ): Promise<QueriesStatusReport> {
  const statusReport: QueriesStatusReport = {};

@ -500,7 +500,7 @@ export async function runFinalize(
  memoryFlag: string,
  config: configUtils.Config,
  logger: Logger,
-  featureFlags: FeatureFlags
+  featureFlags: FeatureEnablement
 ): Promise<DatabaseCreationTimings> {
  try {
    await del(outputDir, { force: true });
--- a/src/autobuild.ts
+++ b/src/autobuild.ts
@ -1,13 +1,13 @@
 import { getCodeQL } from "./codeql";
 import * as configUtils from "./config-utils";
-import { FeatureFlags } from "./feature-flags";
+import { FeatureEnablement } from "./feature-flags";
 import { Language, isTracedLanguage } from "./languages";
 import { Logger } from "./logging";
 import * as util from "./util";

 export async function determineAutobuildLanguages(
  config: configUtils.Config,
-  featureFlags: FeatureFlags,
+  featureFlags: FeatureEnablement,
  logger: Logger
 ): Promise<Language[] | undefined> {
  const isGoExtractionReconciliationEnabled =
--- a/src/codeql.test.ts
+++ b/src/codeql.test.ts
@ -13,10 +13,14 @@ import { GitHubApiDetails } from "./api-client";
 import * as codeql from "./codeql";
 import { AugmentationProperties, Config } from "./config-utils";
 import * as defaults from "./defaults.json";
-import { createFeatureFlags, Feature, FeatureFlags } from "./feature-flags";
+import { Feature, FeatureEnablement } from "./feature-flags";
 import { Language } from "./languages";
 import { getRunnerLogger } from "./logging";
-import { setupTests, setupActionsVars } from "./testing-utils";
+import {
+  setupTests,
+  setupActionsVars,
+  createFeatureFlags,
+} from "./testing-utils";
 import * as util from "./util";
 import { Mode, initializeEnvironment } from "./util";

@ -76,7 +80,7 @@ async function mockApiAndSetupCodeQL({
  version,
 }: {
  apiDetails?: GitHubApiDetails;
-  featureFlags?: FeatureFlags;
+  featureFlags?: FeatureEnablement;
  isPinned?: boolean;
  tmpDir: string;
  toolsInput?: { input?: string };
--- a/src/codeql.ts
+++ b/src/codeql.ts
@ -15,7 +15,7 @@ import * as api from "./api-client";
 import { Config } from "./config-utils";
 import * as defaults from "./defaults.json"; // Referenced from codeql-action-sync-tool!
 import { errorMatchers } from "./error-matcher";
-import { Feature, FeatureFlags } from "./feature-flags";
+import { Feature, FeatureEnablement } from "./feature-flags";
 import { isTracedLanguage, Language } from "./languages";
 import { Logger } from "./logging";
 import { toolrunnerErrorCatcher } from "./toolrunner-error-catcher";
@ -91,7 +91,7 @@ export interface CodeQL {
    sourceRoot: string,
    processName: string | undefined,
    processLevel: number | undefined,
-    featureFlags: FeatureFlags,
+    featureFlags: FeatureEnablement,
    logger: Logger
  ): Promise<void>;
  /**
@ -416,7 +416,7 @@ async function getCodeQLBundleDownloadURL(
 * @param apiDetails
 * @param tempDir
 * @param variant
- * @param featureFlags
+ * @param features
 * @param logger
 * @param checkVersion Whether to check that CodeQL CLI meets the minimum
 *        version requirement. Must be set to true outside tests.
@ -427,7 +427,7 @@ export async function setupCodeQL(
  apiDetails: api.GitHubApiDetails,
  tempDir: string,
  variant: util.GitHubVariant,
-  featureFlags: FeatureFlags,
+  features: FeatureEnablement,
  logger: Logger,
  checkVersion: boolean
 ): Promise<{ codeql: CodeQL; toolsVersion: string }> {
@ -438,12 +438,12 @@ export async function setupCodeQL(
      codeqlURL === "latest"
        ? '"tools: latest" was requested'
        : // If the user hasn't requested a particular CodeQL version, then bypass
-        // the toolcache when the appropriate feature flag is enabled. This
+        // the toolcache when the appropriate feature is enabled. This
        // allows us to quickly rollback a broken bundle that has made its way
        // into the toolcache.
        codeqlURL === undefined &&
-          (await featureFlags.getValue(Feature.BypassToolcacheEnabled))
-        ? "a specific version of CodeQL was not requested and the bypass toolcache feature flag is enabled"
+          (await features.getValue(Feature.BypassToolcacheEnabled))
+        ? "a specific version of CodeQL was not requested and the bypass toolcache feature is enabled"
        : undefined;
    const forceLatest = forceLatestReason !== undefined;
    if (forceLatest) {
@ -772,7 +772,7 @@ async function getCodeQLForCmd(
      sourceRoot: string,
      processName: string | undefined,
      processLevel: number | undefined,
-      featureFlags: FeatureFlags,
+      featureFlags: FeatureEnablement,
      logger: Logger
    ) {
      const extraArgs = config.languages.map(
@ -1274,7 +1274,7 @@ async function runTool(cmd: string, args: string[] = []) {
 async function generateCodescanningConfig(
  codeql: CodeQL,
  config: Config,
-  featureFlags: FeatureFlags
+  featureFlags: FeatureEnablement
 ): Promise<string | undefined> {
  if (!(await util.useCodeScanningConfigInCli(codeql, featureFlags))) {
    return;
--- a/src/config-utils.test.ts
+++ b/src/config-utils.test.ts
@ -9,10 +9,10 @@ import * as sinon from "sinon";
 import * as api from "./api-client";
 import { getCachedCodeQL, PackDownloadOutput, setCodeQL } from "./codeql";
 import * as configUtils from "./config-utils";
-import { createFeatureFlags, Feature } from "./feature-flags";
+import { Feature } from "./feature-flags";
 import { Language } from "./languages";
 import { getRunnerLogger, Logger } from "./logging";
-import { setupTests } from "./testing-utils";
+import { setupTests, createFeatureFlags } from "./testing-utils";
 import * as util from "./util";

 setupTests(test);
--- a/src/config-utils.ts
+++ b/src/config-utils.ts
@ -14,7 +14,7 @@ import {
  ResolveQueriesOutput,
 } from "./codeql";
 import * as externalQueries from "./external-queries";
-import { Feature, FeatureFlags } from "./feature-flags";
+import { Feature, FeatureEnablement } from "./feature-flags";
 import { Language, parseLanguage } from "./languages";
 import { Logger } from "./logging";
 import { RepositoryNwo } from "./repository";
@ -389,7 +389,7 @@ async function addBuiltinSuiteQueries(
  resultMap: Queries,
  packs: Packs,
  suiteName: string,
-  featureFlags: FeatureFlags,
+  featureFlags: FeatureEnablement,
  configFile?: string
 ): Promise<boolean> {
  let injectedMlQueries = false;
@ -543,7 +543,7 @@ async function parseQueryUses(
  tempDir: string,
  workspacePath: string,
  apiDetails: api.GitHubApiExternalRepoDetails,
-  featureFlags: FeatureFlags,
+  featureFlags: FeatureEnablement,
  logger: Logger,
  configFile?: string
 ): Promise<boolean> {
@ -948,7 +948,7 @@ async function addQueriesAndPacksFromWorkflow(
  tempDir: string,
  workspacePath: string,
  apiDetails: api.GitHubApiExternalRepoDetails,
-  featureFlags: FeatureFlags,
+  featureFlags: FeatureEnablement,
  logger: Logger
 ): Promise<boolean> {
  let injectedMlQueries = false;
@ -1005,7 +1005,7 @@ export async function getDefaultConfig(
  workspacePath: string,
  gitHubVersion: GitHubVersion,
  apiDetails: api.GitHubApiCombinedDetails,
-  featureFlags: FeatureFlags,
+  featureFlags: FeatureEnablement,
  logger: Logger
 ): Promise<Config> {
  const languages = await getLanguages(
@ -1114,7 +1114,7 @@ async function loadConfig(
  workspacePath: string,
  gitHubVersion: GitHubVersion,
  apiDetails: api.GitHubApiCombinedDetails,
-  featureFlags: FeatureFlags,
+  featureFlags: FeatureEnablement,
  logger: Logger
 ): Promise<Config> {
  let parsedYAML: UserConfig;
@ -1638,7 +1638,7 @@ export async function initConfig(
  workspacePath: string,
  gitHubVersion: GitHubVersion,
  apiDetails: api.GitHubApiCombinedDetails,
-  featureFlags: FeatureFlags,
+  featureFlags: FeatureEnablement,
  logger: Logger
 ): Promise<Config> {
  let config: Config;
--- a/src/feature-flags.test.ts
+++ b/src/feature-flags.test.ts
@ -4,7 +4,7 @@ import { GitHubApiDetails } from "./api-client";
 import {
  Feature,
  featureConfig,
-  FeatureFlags,
+  FeatureEnablement,
  Features,
 } from "./feature-flags";
 import { getRunnerLogger } from "./logging";
@ -261,6 +261,24 @@ for (const featureFlag of Object.keys(featureConfig)) {
  }
 }

+// If we ever run into a situation where we no longer have any feature flags that
+// specify a minimum version, then we will have a bunch of code no longer being
+// tested. This is unlikely, and this test will fail if that happens.
+// If we do end up in that situation, then we should consider adding a synthetic
+// feature flag with a minium version that is only used for tests.
+test("At least one feature has a minimum version specified", (t) => {
+  t.assert(
+    Object.values(featureConfig).some((f) => f.minimumVersion !== undefined),
+    "At least one feature flag should have a minimum version specified"
+  );
+
+  // An even less likely scenario is that we no longer have any feature flags.
+  t.assert(
+    Object.values(featureConfig).length > 0,
+    "There should be at least one feature flag"
+  );
+});
+
 function assertAllFeaturesUndefinedInApi(t, loggedMessages: LoggedMessage[]) {
  for (const featureFlag of Object.keys(featureConfig)) {
    t.assert(
@ -285,7 +303,7 @@ function setUpTests(
  tmpDir: string,
  logger = getRunnerLogger(true),
  gitHubVersion = { type: GitHubVariant.DOTCOM } as util.GitHubVersion
-): FeatureFlags {
+): FeatureEnablement {
  setupActionsVars(tmpDir, tmpDir);

  return new Features(gitHubVersion, testApiDetails, testRepositoryNwo, logger);
--- a/src/feature-flags.ts
+++ b/src/feature-flags.ts
@ -4,16 +4,16 @@ import { Logger } from "./logging";
 import { RepositoryNwo } from "./repository";
 import * as util from "./util";

-export interface FeatureFlags {
-  getValue(flag: Feature, codeql?: CodeQL): Promise<boolean>;
+export interface FeatureEnablement {
+  getValue(feaature: Feature, codeql?: CodeQL): Promise<boolean>;
 }

 export enum Feature {
  BypassToolcacheEnabled = "bypass_toolcache_enabled",
+  CliConfigFileEnabled = "cli_config_file_enabled",
+  GolangExtractionReconciliationEnabled = "golang_extraction_reconciliation_enabled",
  MlPoweredQueriesEnabled = "ml_powered_queries_enabled",
  TrapCachingEnabled = "trap_caching_enabled",
-  GolangExtractionReconciliationEnabled = "golang_extraction_reconciliation_enabled",
-  CliConfigFileEnabled = "cli_config_file_enabled",
 }

 export const featureConfig: Record<
@ -24,6 +24,14 @@ export const featureConfig: Record<
    envVar: "CODEQL_BYPASS_TOOLCACHE",
    minimumVersion: undefined,
  },
+  [Feature.CliConfigFileEnabled]: {
+    envVar: "CODEQL_PASS_CONFIG_TO_CLI",
+    minimumVersion: "2.10.1",
+  },
+  [Feature.GolangExtractionReconciliationEnabled]: {
+    envVar: "CODEQL_GOLANG_EXTRACTION_RECONCILIATION",
+    minimumVersion: undefined,
+  },
  [Feature.MlPoweredQueriesEnabled]: {
    envVar: "CODEQL_ML_POWERED_QUERIES",
    minimumVersion: "2.7.5",
@ -32,14 +40,6 @@ export const featureConfig: Record<
    envVar: "CODEQL_TRAP_CACHING",
    minimumVersion: undefined,
  },
-  [Feature.GolangExtractionReconciliationEnabled]: {
-    envVar: "CODEQL_GOLANG_EXTRACTION_RECONCILIATION",
-    minimumVersion: undefined,
-  },
-  [Feature.CliConfigFileEnabled]: {
-    envVar: "CODEQL_PASS_CONFIG_TO_CLI",
-    minimumVersion: "2.10.1",
-  },
 };

 /**
@ -48,14 +48,14 @@ export const featureConfig: Record<
 *
 * It maps feature flags to whether they are enabled or not.
 */
-type FeatureFlagsApiResponse = Partial<Record<Feature, boolean>>;
+type GitHubFeatureFlagsApiResponse = Partial<Record<Feature, boolean>>;

 /**
 * Determines the enablement status of a number of features.
 * If feature enablement is not able to be determined locally, a request to the
 * github API is made to determine the enablement status.
 */
-export class Features implements FeatureFlags {
+export class Features implements FeatureEnablement {
  private gitHubFeatureFlags: GitHubFeatureFlags;

  constructor(
@ -74,7 +74,7 @@ export class Features implements FeatureFlags {

  /**
   *
-   * @param flag The feature flag to check.
+   * @param feature The feature flag to check.
   * @param codeql An optional CodeQL object. If provided, and a `minimumVersion` is specified for the
   *        feature flag, the version of the CodeQL CLI will be checked against the minimum version.
   *        If the version is less than the minimum version, the feature flag will be considered
@ -84,20 +84,20 @@ export class Features implements FeatureFlags {
   *
   * @throws if a `minimumVersion` is specified for the feature flag, and `codeql` is not provided.
   */
-  async getValue(flag: Feature, codeql?: CodeQL): Promise<boolean> {
-    if (!codeql && featureConfig[flag].minimumVersion) {
+  async getValue(feature: Feature, codeql?: CodeQL): Promise<boolean> {
+    if (!codeql && featureConfig[feature].minimumVersion) {
      throw new Error(
-        `Internal error: A minimum version is specified for feature flag ${flag}, but no instance of CodeQL was provided.`
+        `Internal error: A minimum version is specified for feature ${feature}, but no instance of CodeQL was provided.`
      );
    }

    // Bypassing the toolcache is disabled in test mode.
-    if (flag === Feature.BypassToolcacheEnabled && util.isInTestMode()) {
+    if (feature === Feature.BypassToolcacheEnabled && util.isInTestMode()) {
      return false;
    }

    const envVar = (
-      process.env[featureConfig[flag].envVar] || ""
+      process.env[featureConfig[feature].envVar] || ""
    ).toLocaleLowerCase();

    // Do not use this feature if user explicitly disables it via an environment variable.
@ -106,7 +106,7 @@ export class Features implements FeatureFlags {
    }

    // Never use this feature if the CLI version explicitly can't support it.
-    const minimumVersion = featureConfig[flag].minimumVersion;
+    const minimumVersion = featureConfig[feature].minimumVersion;
    if (codeql && minimumVersion) {
      if (!(await util.codeQlVersionAbove(codeql, minimumVersion))) {
        return false;
@ -119,12 +119,12 @@ export class Features implements FeatureFlags {
    }

    // Ask the GitHub API if the feature is enabled.
-    return await this.gitHubFeatureFlags.getValue(flag);
+    return await this.gitHubFeatureFlags.getValue(feature);
  }
 }

-class GitHubFeatureFlags implements FeatureFlags {
-  private cachedApiResponse: FeatureFlagsApiResponse | undefined;
+class GitHubFeatureFlags implements FeatureEnablement {
+  private cachedApiResponse: GitHubFeatureFlagsApiResponse | undefined;

  constructor(
    private gitHubVersion: util.GitHubVersion,
@ -135,25 +135,25 @@ class GitHubFeatureFlags implements FeatureFlags {
    /**/
  }

-  async getValue(flag: Feature): Promise<boolean> {
+  async getValue(feature: Feature): Promise<boolean> {
    const response = await this.getApiResponse();
    if (response === undefined) {
      this.logger.debug(
-        `No feature flags API response for ${flag}, considering it disabled.`
+        `No feature flags API response for ${feature}, considering it disabled.`
      );
      return false;
    }
-    const flagValue = response[flag];
-    if (flagValue === undefined) {
+    const featureEnablement = response[feature];
+    if (featureEnablement === undefined) {
      this.logger.debug(
-        `Feature flag '${flag}' undefined in API response, considering it disabled.`
+        `Feature '${feature}' undefined in API response, considering it disabled.`
      );
      return false;
    }
-    return flagValue || false;
+    return !!featureEnablement;
  }

-  private async getApiResponse(): Promise<FeatureFlagsApiResponse> {
+  private async getApiResponse(): Promise<GitHubFeatureFlagsApiResponse> {
    const apiResponse =
      this.cachedApiResponse || (await this.loadApiResponse());
    this.cachedApiResponse = apiResponse;
@ -164,7 +164,7 @@ class GitHubFeatureFlags implements FeatureFlags {
    // Do nothing when not running against github.com
    if (this.gitHubVersion.type !== util.GitHubVariant.DOTCOM) {
      this.logger.debug(
-        "Not running against github.com. Disabling all feature flags."
+        "Not running against github.com. Disabling all toggleable features."
      );
      return {};
    }
@ -187,27 +187,14 @@ class GitHubFeatureFlags implements FeatureFlags {
            `please ensure the Action has the 'security-events: write' permission. Details: ${e}`
        );
      } else {
-        // Some feature flags, such as `ml_powered_queries_enabled` affect the produced alerts.
-        // Considering these feature flags disabled in the event of a transient error could
+        // Some feature, such as `ml_powered_queries_enabled` affect the produced alerts.
+        // Considering these feature disabled in the event of a transient error could
        // therefore lead to alert churn. As a result, we crash if we cannot determine the value of
-        // the feature flags.
+        // the feature.
        throw new Error(
-          `Encountered an error while trying to load feature flags: ${e}`
+          `Encountered an error while trying to determine feature enablement: ${e}`
        );
      }
    }
  }
 }
-
-/**
- * Create a feature flags instance with the specified set of enabled flags.
- *
- * This should be only used within tests.
- */
-export function createFeatureFlags(enabledFlags: Feature[]): FeatureFlags {
-  return {
-    getValue: async (flag) => {
-      return enabledFlags.includes(flag);
-    },
-  };
-}
--- a/src/init-action.ts
+++ b/src/init-action.ts
@ -15,7 +15,7 @@ import {
 import { getGitHubVersionActionsOnly } from "./api-client";
 import { CodeQL, CODEQL_VERSION_NEW_TRACING } from "./codeql";
 import * as configUtils from "./config-utils";
-import { Feature, FeatureFlags, Features } from "./feature-flags";
+import { Feature, FeatureEnablement, Features } from "./feature-flags";
 import {
  initCodeQL,
  initConfig,
@ -318,7 +318,7 @@ async function run() {
 }

 async function getTrapCachingEnabled(
-  featureFlags: FeatureFlags
+  featureFlags: FeatureEnablement
 ): Promise<boolean> {
  const trapCaching = getOptionalInput("trap-caching");
  if (trapCaching !== undefined) {
--- a/src/init.ts
+++ b/src/init.ts
@ -8,7 +8,7 @@ import * as analysisPaths from "./analysis-paths";
 import { GitHubApiCombinedDetails, GitHubApiDetails } from "./api-client";
 import { CodeQL, CODEQL_VERSION_NEW_TRACING, setupCodeQL } from "./codeql";
 import * as configUtils from "./config-utils";
-import { FeatureFlags } from "./feature-flags";
+import { FeatureEnablement } from "./feature-flags";
 import { Logger } from "./logging";
 import { RepositoryNwo } from "./repository";
 import { TracerConfig, getCombinedTracerConfig } from "./tracer-config";
@ -20,7 +20,7 @@ export async function initCodeQL(
  apiDetails: GitHubApiDetails,
  tempDir: string,
  variant: util.GitHubVariant,
-  featureFlags: FeatureFlags,
+  featureFlags: FeatureEnablement,
  logger: Logger
 ): Promise<{ codeql: CodeQL; toolsVersion: string }> {
  logger.startGroup("Setup CodeQL tools");
@ -55,7 +55,7 @@ export async function initConfig(
  workspacePath: string,
  gitHubVersion: util.GitHubVersion,
  apiDetails: GitHubApiCombinedDetails,
-  featureFlags: FeatureFlags,
+  featureFlags: FeatureEnablement,
  logger: Logger
 ): Promise<configUtils.Config> {
  logger.startGroup("Load language configuration");
@ -90,7 +90,7 @@ export async function runInit(
  sourceRoot: string,
  processName: string | undefined,
  processLevel: number | undefined,
-  featureFlags: FeatureFlags,
+  featureFlags: FeatureEnablement,
  logger: Logger
 ): Promise<TracerConfig | undefined> {
  fs.mkdirSync(config.dbLocation, { recursive: true });
--- a/src/runner.ts
+++ b/src/runner.ts
@ -8,11 +8,11 @@ import { runFinalize, runQueries } from "./analyze";
 import { determineAutobuildLanguages, runAutobuild } from "./autobuild";
 import { CodeQL, CODEQL_VERSION_NEW_TRACING, getCodeQL } from "./codeql";
 import { Config, getConfig } from "./config-utils";
-import { createFeatureFlags } from "./feature-flags";
 import { initCodeQL, initConfig, injectWindowsTracer, runInit } from "./init";
 import { Language, parseLanguage } from "./languages";
 import { getRunnerLogger } from "./logging";
 import { parseRepositoryNwo } from "./repository";
+import { createFeatureFlags } from "./testing-utils";
 import * as upload_lib from "./upload-lib";
 import {
  checkGitHubVersionInRange,
--- a/src/testing-utils.ts
+++ b/src/testing-utils.ts
@ -4,6 +4,7 @@ import * as sinon from "sinon";

 import * as apiClient from "./api-client";
 import * as CodeQL from "./codeql";
+import { Feature, FeatureEnablement } from "./feature-flags";
 import { Logger } from "./logging";
 import { HTTPError } from "./util";

@ -168,3 +169,18 @@ export function mockCodeQLVersion(version) {
    },
  } as CodeQL.CodeQL;
 }
+
+/**
+ * Create a feature enablement instance with the specified set of enabled features.
+ *
+ * This should be only used within tests.
+ */
+export function createFeatureFlags(
+  enabledFeatures: Feature[]
+): FeatureEnablement {
+  return {
+    getValue: async (feature) => {
+      return enabledFeatures.includes(feature);
+    },
+  };
+}
--- a/src/util.ts
+++ b/src/util.ts
@ -18,7 +18,7 @@ import {
  parsePacksSpecification,
  prettyPrintPack,
 } from "./config-utils";
-import { Feature, FeatureFlags } from "./feature-flags";
+import { Feature, FeatureEnablement } from "./feature-flags";
 import { Language } from "./languages";
 import { Logger } from "./logging";

@ -779,14 +779,14 @@ export function isInTestMode(): boolean {
 */
 export async function useCodeScanningConfigInCli(
  codeql: CodeQL,
-  featureFlags: FeatureFlags
+  featureFlags: FeatureEnablement
 ): Promise<boolean> {
  return await featureFlags.getValue(Feature.CliConfigFileEnabled, codeql);
 }

 export async function logCodeScanningConfigInCli(
  codeql: CodeQL,
-  featureFlags: FeatureFlags,
+  featureFlags: FeatureEnablement,
  logger: Logger
 ) {
  if (await useCodeScanningConfigInCli(codeql, featureFlags)) {
@ -832,7 +832,7 @@ export function listFolder(dir: string): string[] {
 }

 export async function isGoExtractionReconciliationEnabled(
-  featureFlags: FeatureFlags
+  featureFlags: FeatureEnablement
 ): Promise<boolean> {
  return await featureFlags.getValue(
    Feature.GolangExtractionReconciliationEnabled