mirror of
https://github.com/github/codeql-action.git
synced 2026-05-01 11:20:11 +00:00
Henry Mercer
716 lines
22 KiB
TypeScript
716 lines
22 KiB
TypeScript
import * as fs from "fs";
|
|
import path from "path";
|
|
|
|
import * as core from "@actions/core";
|
|
import * as github from "@actions/github";
|
|
import test, { ExecutionContext } from "ava";
|
|
import * as sinon from "sinon";
|
|
|
|
import * as actionsUtil from "./actions-util";
|
|
import { createStubCodeQL } from "./codeql";
|
|
import { Feature } from "./feature-flags";
|
|
import {
|
|
checkPacksForOverlayCompatibility,
|
|
cleanupDatabaseClusterDirectory,
|
|
getFileCoverageInformationEnabled,
|
|
logFileCoverageOnPrsDeprecationWarning,
|
|
} from "./init";
|
|
import { BuiltInLanguage } from "./languages";
|
|
import {
|
|
createFeatures,
|
|
LoggedMessage,
|
|
createTestConfig,
|
|
getRecordingLogger,
|
|
setupTests,
|
|
} from "./testing-utils";
|
|
import { ConfigurationError, withTmpDir } from "./util";
|
|
|
|
setupTests(test);
|
|
|
|
test("cleanupDatabaseClusterDirectory cleans up where possible", async (t) => {
|
|
await withTmpDir(async (tmpDir: string) => {
|
|
const dbLocation = path.resolve(tmpDir, "dbs");
|
|
fs.mkdirSync(dbLocation, { recursive: true });
|
|
|
|
const fileToCleanUp = path.resolve(dbLocation, "something-to-cleanup.txt");
|
|
fs.writeFileSync(fileToCleanUp, "");
|
|
|
|
const messages: LoggedMessage[] = [];
|
|
cleanupDatabaseClusterDirectory(
|
|
createTestConfig({ dbLocation }),
|
|
getRecordingLogger(messages),
|
|
);
|
|
|
|
t.is(messages.length, 2);
|
|
t.is(messages[0].type, "warning");
|
|
t.is(
|
|
messages[0].message,
|
|
`The database cluster directory ${dbLocation} must be empty. Attempting to clean it up.`,
|
|
);
|
|
t.is(messages[1].type, "info");
|
|
t.is(
|
|
messages[1].message,
|
|
`Cleaned up database cluster directory ${dbLocation}.`,
|
|
);
|
|
|
|
t.false(fs.existsSync(fileToCleanUp));
|
|
});
|
|
});
|
|
|
|
for (const { runnerEnv, ErrorConstructor, message } of [
|
|
{
|
|
runnerEnv: "self-hosted",
|
|
ErrorConstructor: ConfigurationError,
|
|
message: (dbLocation) =>
|
|
"The CodeQL Action requires an empty database cluster directory. By default, this is located " +
|
|
`at ${dbLocation}. You can customize it using the 'db-location' input to the init Action. An ` +
|
|
"attempt was made to clean up the directory, but this failed. This can happen if another " +
|
|
"process is using the directory or the directory is owned by a different user. Please clean " +
|
|
"up the directory manually and rerun the job.",
|
|
},
|
|
{
|
|
runnerEnv: "github-hosted",
|
|
ErrorConstructor: Error,
|
|
message: (dbLocation) =>
|
|
"The CodeQL Action requires an empty database cluster directory. By default, this is located " +
|
|
`at ${dbLocation}. You can customize it using the 'db-location' input to the init Action. An ` +
|
|
"attempt was made to clean up the directory, but this failed. This shouldn't typically " +
|
|
"happen on hosted runners. If you are using an advanced setup, please check your workflow, " +
|
|
"otherwise we recommend rerunning the job.",
|
|
},
|
|
]) {
|
|
test.serial(
|
|
`cleanupDatabaseClusterDirectory throws a ${ErrorConstructor.name} when cleanup fails on ${runnerEnv} runner`,
|
|
async (t) => {
|
|
await withTmpDir(async (tmpDir: string) => {
|
|
process.env["RUNNER_ENVIRONMENT"] = runnerEnv;
|
|
|
|
const dbLocation = path.resolve(tmpDir, "dbs");
|
|
fs.mkdirSync(dbLocation, { recursive: true });
|
|
|
|
const fileToCleanUp = path.resolve(
|
|
dbLocation,
|
|
"something-to-cleanup.txt",
|
|
);
|
|
fs.writeFileSync(fileToCleanUp, "");
|
|
|
|
const rmSyncError = `Failed to clean up file ${fileToCleanUp}`;
|
|
|
|
const messages: LoggedMessage[] = [];
|
|
t.throws(
|
|
() =>
|
|
cleanupDatabaseClusterDirectory(
|
|
createTestConfig({ dbLocation }),
|
|
getRecordingLogger(messages),
|
|
{},
|
|
() => {
|
|
throw new Error(rmSyncError);
|
|
},
|
|
),
|
|
{
|
|
instanceOf: ErrorConstructor,
|
|
message: `${message(dbLocation)} Details: ${rmSyncError}`,
|
|
},
|
|
);
|
|
|
|
t.is(messages.length, 1);
|
|
t.is(messages[0].type, "warning");
|
|
t.is(
|
|
messages[0].message,
|
|
`The database cluster directory ${dbLocation} must be empty. Attempting to clean it up.`,
|
|
);
|
|
});
|
|
},
|
|
);
|
|
}
|
|
|
|
test("cleanupDatabaseClusterDirectory can disable warning with options", async (t) => {
|
|
await withTmpDir(async (tmpDir: string) => {
|
|
const dbLocation = path.resolve(tmpDir, "dbs");
|
|
fs.mkdirSync(dbLocation, { recursive: true });
|
|
|
|
const fileToCleanUp = path.resolve(dbLocation, "something-to-cleanup.txt");
|
|
fs.writeFileSync(fileToCleanUp, "");
|
|
|
|
const messages: LoggedMessage[] = [];
|
|
cleanupDatabaseClusterDirectory(
|
|
createTestConfig({ dbLocation }),
|
|
getRecordingLogger(messages),
|
|
{ disableExistingDirectoryWarning: true },
|
|
);
|
|
|
|
// Should only have the info message, not the warning
|
|
t.is(messages.length, 1);
|
|
t.is(messages[0].type, "info");
|
|
t.is(
|
|
messages[0].message,
|
|
`Cleaned up database cluster directory ${dbLocation}.`,
|
|
);
|
|
|
|
t.false(fs.existsSync(fileToCleanUp));
|
|
});
|
|
});
|
|
|
|
type PackInfo = {
|
|
language: BuiltInLanguage;
|
|
packinfoContents: string | undefined;
|
|
sourceOnlyPack?: boolean;
|
|
qlpackFileName?: string;
|
|
};
|
|
|
|
const testCheckPacksForOverlayCompatibility = test.macro({
|
|
exec: async (
|
|
t: ExecutionContext,
|
|
_title: string,
|
|
{
|
|
cliOverlayVersion,
|
|
languages,
|
|
packs,
|
|
expectedResult,
|
|
}: {
|
|
cliOverlayVersion: number | undefined;
|
|
languages: BuiltInLanguage[];
|
|
packs: Record<string, PackInfo>;
|
|
expectedResult: boolean;
|
|
},
|
|
) => {
|
|
await withTmpDir(async (tmpDir) => {
|
|
const packDirsByLanguage = new Map<BuiltInLanguage, string[]>();
|
|
|
|
for (const [packName, packInfo] of Object.entries(packs)) {
|
|
const packPath = path.join(tmpDir, packName);
|
|
fs.mkdirSync(packPath, { recursive: true });
|
|
if (packInfo.packinfoContents) {
|
|
fs.writeFileSync(
|
|
path.join(packPath, ".packinfo"),
|
|
packInfo.packinfoContents,
|
|
);
|
|
}
|
|
const qlpackFileName = packInfo.qlpackFileName || "qlpack.yml";
|
|
fs.writeFileSync(
|
|
path.join(packPath, qlpackFileName),
|
|
packInfo.sourceOnlyPack
|
|
? `name: ${packName}\nversion: 1.0.0\n`
|
|
: `name: ${packName}\nversion: 1.0.0\nbuildMetadata:\n sha: 123abc\n`,
|
|
);
|
|
|
|
if (!packDirsByLanguage.has(packInfo.language)) {
|
|
packDirsByLanguage.set(packInfo.language, []);
|
|
}
|
|
packDirsByLanguage.get(packInfo.language)!.push(packPath);
|
|
}
|
|
|
|
const codeql = createStubCodeQL({
|
|
getVersion: async () => ({
|
|
version: "2.22.2",
|
|
overlayVersion: cliOverlayVersion,
|
|
}),
|
|
resolveQueriesStartingPacks: async (suitePaths: string[]) => {
|
|
for (const language of packDirsByLanguage.keys()) {
|
|
const suiteForLanguage = path.join(
|
|
language,
|
|
"temp",
|
|
"config-queries.qls",
|
|
);
|
|
if (suitePaths[0].endsWith(suiteForLanguage)) {
|
|
return packDirsByLanguage.get(language) || [];
|
|
}
|
|
}
|
|
return [];
|
|
},
|
|
});
|
|
|
|
const messages: LoggedMessage[] = [];
|
|
const result = await checkPacksForOverlayCompatibility(
|
|
codeql,
|
|
createTestConfig({ dbLocation: tmpDir, languages }),
|
|
getRecordingLogger(messages),
|
|
);
|
|
t.is(result, expectedResult);
|
|
t.deepEqual(
|
|
messages.length,
|
|
expectedResult ? 0 : 1,
|
|
"Expected log messages",
|
|
);
|
|
});
|
|
},
|
|
title: (_, title) => `checkPacksForOverlayCompatibility: ${title}`,
|
|
});
|
|
|
|
test(
|
|
testCheckPacksForOverlayCompatibility,
|
|
"returns false when CLI does not support overlay",
|
|
{
|
|
cliOverlayVersion: undefined,
|
|
languages: [BuiltInLanguage.java],
|
|
packs: {
|
|
"codeql/java-queries": {
|
|
language: BuiltInLanguage.java,
|
|
packinfoContents: '{"overlayVersion":2}',
|
|
},
|
|
},
|
|
expectedResult: false,
|
|
},
|
|
);
|
|
|
|
test(
|
|
testCheckPacksForOverlayCompatibility,
|
|
"returns true when there are no query packs",
|
|
{
|
|
cliOverlayVersion: 2,
|
|
languages: [BuiltInLanguage.java],
|
|
packs: {},
|
|
expectedResult: true,
|
|
},
|
|
);
|
|
|
|
test(
|
|
testCheckPacksForOverlayCompatibility,
|
|
"returns true when query pack has not been compiled",
|
|
{
|
|
cliOverlayVersion: 2,
|
|
languages: [BuiltInLanguage.java],
|
|
packs: {
|
|
"codeql/java-queries": {
|
|
language: BuiltInLanguage.java,
|
|
packinfoContents: undefined,
|
|
sourceOnlyPack: true,
|
|
},
|
|
},
|
|
expectedResult: true,
|
|
},
|
|
);
|
|
|
|
test(
|
|
testCheckPacksForOverlayCompatibility,
|
|
"returns true when query pack has expected overlay version",
|
|
{
|
|
cliOverlayVersion: 2,
|
|
languages: [BuiltInLanguage.java],
|
|
packs: {
|
|
"codeql/java-queries": {
|
|
language: BuiltInLanguage.java,
|
|
packinfoContents: '{"overlayVersion":2}',
|
|
},
|
|
},
|
|
expectedResult: true,
|
|
},
|
|
);
|
|
|
|
test(
|
|
testCheckPacksForOverlayCompatibility,
|
|
"returns true when query packs for all languages to analyze are compatible",
|
|
{
|
|
cliOverlayVersion: 2,
|
|
languages: [BuiltInLanguage.cpp, BuiltInLanguage.java],
|
|
packs: {
|
|
"codeql/cpp-queries": {
|
|
language: BuiltInLanguage.cpp,
|
|
packinfoContents: '{"overlayVersion":2}',
|
|
},
|
|
"codeql/java-queries": {
|
|
language: BuiltInLanguage.java,
|
|
packinfoContents: '{"overlayVersion":2}',
|
|
},
|
|
},
|
|
expectedResult: true,
|
|
},
|
|
);
|
|
|
|
test(
|
|
testCheckPacksForOverlayCompatibility,
|
|
"returns true when query pack for a language not analyzed is incompatible",
|
|
{
|
|
cliOverlayVersion: 2,
|
|
languages: [BuiltInLanguage.java],
|
|
packs: {
|
|
"codeql/cpp-queries": {
|
|
language: BuiltInLanguage.cpp,
|
|
packinfoContents: undefined,
|
|
},
|
|
"codeql/java-queries": {
|
|
language: BuiltInLanguage.java,
|
|
packinfoContents: '{"overlayVersion":2}',
|
|
},
|
|
},
|
|
expectedResult: true,
|
|
},
|
|
);
|
|
|
|
test(
|
|
testCheckPacksForOverlayCompatibility,
|
|
"returns false when query pack for a language to analyze is incompatible",
|
|
{
|
|
cliOverlayVersion: 2,
|
|
languages: [BuiltInLanguage.cpp, BuiltInLanguage.java],
|
|
packs: {
|
|
"codeql/cpp-queries": {
|
|
language: BuiltInLanguage.cpp,
|
|
packinfoContents: '{"overlayVersion":1}',
|
|
},
|
|
"codeql/java-queries": {
|
|
language: BuiltInLanguage.java,
|
|
packinfoContents: '{"overlayVersion":2}',
|
|
},
|
|
},
|
|
expectedResult: false,
|
|
},
|
|
);
|
|
|
|
test(
|
|
testCheckPacksForOverlayCompatibility,
|
|
"returns false when query pack is missing .packinfo",
|
|
{
|
|
cliOverlayVersion: 2,
|
|
languages: [BuiltInLanguage.java],
|
|
packs: {
|
|
"codeql/java-queries": {
|
|
language: BuiltInLanguage.java,
|
|
packinfoContents: '{"overlayVersion":2}',
|
|
},
|
|
"custom/queries": {
|
|
language: BuiltInLanguage.java,
|
|
packinfoContents: undefined,
|
|
},
|
|
},
|
|
expectedResult: false,
|
|
},
|
|
);
|
|
|
|
test(
|
|
testCheckPacksForOverlayCompatibility,
|
|
"returns false when query pack has different overlay version",
|
|
{
|
|
cliOverlayVersion: 2,
|
|
languages: [BuiltInLanguage.java],
|
|
packs: {
|
|
"codeql/java-queries": {
|
|
language: BuiltInLanguage.java,
|
|
packinfoContents: '{"overlayVersion":2}',
|
|
},
|
|
"custom/queries": {
|
|
language: BuiltInLanguage.java,
|
|
packinfoContents: '{"overlayVersion":1}',
|
|
},
|
|
},
|
|
expectedResult: false,
|
|
},
|
|
);
|
|
|
|
test(
|
|
testCheckPacksForOverlayCompatibility,
|
|
"returns false when query pack is missing overlayVersion in .packinfo",
|
|
{
|
|
cliOverlayVersion: 2,
|
|
languages: [BuiltInLanguage.java],
|
|
packs: {
|
|
"codeql/java-queries": {
|
|
language: BuiltInLanguage.java,
|
|
packinfoContents: '{"overlayVersion":2}',
|
|
},
|
|
"custom/queries": {
|
|
language: BuiltInLanguage.java,
|
|
packinfoContents: "{}",
|
|
},
|
|
},
|
|
expectedResult: false,
|
|
},
|
|
);
|
|
|
|
test(
|
|
testCheckPacksForOverlayCompatibility,
|
|
"returns false when .packinfo is not valid JSON",
|
|
{
|
|
cliOverlayVersion: 2,
|
|
languages: [BuiltInLanguage.java],
|
|
packs: {
|
|
"codeql/java-queries": {
|
|
language: BuiltInLanguage.java,
|
|
packinfoContents: '{"overlayVersion":2}',
|
|
},
|
|
"custom/queries": {
|
|
language: BuiltInLanguage.java,
|
|
packinfoContents: "this_is_not_valid_json",
|
|
},
|
|
},
|
|
expectedResult: false,
|
|
},
|
|
);
|
|
|
|
test(
|
|
testCheckPacksForOverlayCompatibility,
|
|
"returns true when query pack uses codeql-pack.yml filename",
|
|
{
|
|
cliOverlayVersion: 2,
|
|
languages: [BuiltInLanguage.java],
|
|
packs: {
|
|
"codeql/java-queries": {
|
|
language: BuiltInLanguage.java,
|
|
packinfoContents: '{"overlayVersion":2}',
|
|
qlpackFileName: "codeql-pack.yml",
|
|
},
|
|
},
|
|
expectedResult: true,
|
|
},
|
|
);
|
|
|
|
test("file coverage information enabled when debugMode is true", async (t) => {
|
|
const result = await getFileCoverageInformationEnabled(
|
|
true, // debugMode
|
|
createStubCodeQL({}),
|
|
createFeatures([Feature.SkipFileCoverageOnPrs]),
|
|
{},
|
|
);
|
|
t.true(result.enabled);
|
|
t.false(result.enabledByRepositoryProperty);
|
|
t.false(result.showDeprecationWarning);
|
|
});
|
|
|
|
test.serial(
|
|
"file coverage information enabled when not analyzing a pull request",
|
|
async (t) => {
|
|
sinon.stub(actionsUtil, "isAnalyzingPullRequest").returns(false);
|
|
|
|
const result = await getFileCoverageInformationEnabled(
|
|
false, // debugMode
|
|
createStubCodeQL({}),
|
|
createFeatures([Feature.SkipFileCoverageOnPrs]),
|
|
{},
|
|
);
|
|
t.true(result.enabled);
|
|
t.false(result.enabledByRepositoryProperty);
|
|
t.false(result.showDeprecationWarning);
|
|
},
|
|
);
|
|
|
|
test.serial(
|
|
"file coverage information enabled when feature flag is not enabled, with deprecation warning",
|
|
async (t) => {
|
|
sinon.stub(actionsUtil, "isAnalyzingPullRequest").returns(true);
|
|
|
|
const result = await getFileCoverageInformationEnabled(
|
|
false, // debugMode
|
|
createStubCodeQL({}),
|
|
createFeatures([]),
|
|
{},
|
|
);
|
|
t.true(result.enabled);
|
|
t.false(result.enabledByRepositoryProperty);
|
|
t.true(result.showDeprecationWarning);
|
|
},
|
|
);
|
|
|
|
test.serial(
|
|
"file coverage information enabled when repository property is set",
|
|
async (t) => {
|
|
sinon.stub(actionsUtil, "isAnalyzingPullRequest").returns(true);
|
|
|
|
const result = await getFileCoverageInformationEnabled(
|
|
false, // debugMode
|
|
createStubCodeQL({}),
|
|
createFeatures([Feature.SkipFileCoverageOnPrs]),
|
|
{
|
|
"github-codeql-file-coverage-on-prs": true,
|
|
},
|
|
);
|
|
t.true(result.enabled);
|
|
t.true(result.enabledByRepositoryProperty);
|
|
t.false(result.showDeprecationWarning);
|
|
},
|
|
);
|
|
|
|
test.serial(
|
|
"file coverage information enabled when env var opt-out is set",
|
|
async (t) => {
|
|
sinon.stub(actionsUtil, "isAnalyzingPullRequest").returns(true);
|
|
process.env["CODEQL_ACTION_FILE_COVERAGE_ON_PRS"] = "true";
|
|
|
|
const result = await getFileCoverageInformationEnabled(
|
|
false, // debugMode
|
|
createStubCodeQL({}),
|
|
createFeatures([Feature.SkipFileCoverageOnPrs]),
|
|
{},
|
|
);
|
|
t.true(result.enabled);
|
|
t.false(result.enabledByRepositoryProperty);
|
|
t.false(result.showDeprecationWarning);
|
|
},
|
|
);
|
|
|
|
test.serial(
|
|
"file coverage information disabled when all conditions for skipping are met",
|
|
async (t) => {
|
|
sinon.stub(actionsUtil, "isAnalyzingPullRequest").returns(true);
|
|
|
|
const result = await getFileCoverageInformationEnabled(
|
|
false, // debugMode
|
|
createStubCodeQL({}),
|
|
createFeatures([Feature.SkipFileCoverageOnPrs]),
|
|
{},
|
|
);
|
|
t.false(result.enabled);
|
|
t.false(result.enabledByRepositoryProperty);
|
|
t.false(result.showDeprecationWarning);
|
|
},
|
|
);
|
|
|
|
test.serial(
|
|
"file coverage deprecation warning for org-owned repo with default setup recommends repo property",
|
|
(t) => {
|
|
const exportVariableStub = sinon.stub(core, "exportVariable");
|
|
sinon.stub(actionsUtil, "isDefaultSetup").returns(true);
|
|
github.context.payload = {
|
|
repository: {
|
|
name: "test-repo",
|
|
owner: { login: "test-org", type: "Organization" },
|
|
},
|
|
};
|
|
const messages: LoggedMessage[] = [];
|
|
logFileCoverageOnPrsDeprecationWarning(getRecordingLogger(messages));
|
|
t.is(messages.length, 1);
|
|
t.is(messages[0].type, "warning");
|
|
t.is(
|
|
messages[0].message,
|
|
"Starting April 2026, the CodeQL Action will skip computing file coverage information on pull requests " +
|
|
"to improve analysis performance. File coverage information will still be computed on non-PR analyses.\n\n" +
|
|
"To opt out of this change, create a custom repository property " +
|
|
'with the name `github-codeql-file-coverage-on-prs` and the type "True/false", then set this property to ' +
|
|
"`true` in the repository's settings.",
|
|
);
|
|
t.true(exportVariableStub.calledOnce);
|
|
},
|
|
);
|
|
|
|
test.serial(
|
|
"file coverage deprecation warning for org-owned repo with advanced setup recommends env var and repo property",
|
|
(t) => {
|
|
const exportVariableStub = sinon.stub(core, "exportVariable");
|
|
sinon.stub(actionsUtil, "isDefaultSetup").returns(false);
|
|
github.context.payload = {
|
|
repository: {
|
|
name: "test-repo",
|
|
owner: { login: "test-org", type: "Organization" },
|
|
},
|
|
};
|
|
const messages: LoggedMessage[] = [];
|
|
logFileCoverageOnPrsDeprecationWarning(getRecordingLogger(messages));
|
|
t.is(messages.length, 1);
|
|
t.is(messages[0].type, "warning");
|
|
t.is(
|
|
messages[0].message,
|
|
"Starting April 2026, the CodeQL Action will skip computing file coverage information on pull requests " +
|
|
"to improve analysis performance. File coverage information will still be computed on non-PR analyses.\n\n" +
|
|
"To opt out of this change, set the `CODEQL_ACTION_FILE_COVERAGE_ON_PRS` environment variable to `true`. " +
|
|
"Alternatively, create a custom repository property " +
|
|
'with the name `github-codeql-file-coverage-on-prs` and the type "True/false", then set this property to ' +
|
|
"`true` in the repository's settings.",
|
|
);
|
|
t.true(exportVariableStub.calledOnce);
|
|
},
|
|
);
|
|
|
|
test.serial(
|
|
"file coverage deprecation warning for user-owned repo with default setup recommends advanced setup",
|
|
(t) => {
|
|
const exportVariableStub = sinon.stub(core, "exportVariable");
|
|
sinon.stub(actionsUtil, "isDefaultSetup").returns(true);
|
|
github.context.payload = {
|
|
repository: {
|
|
name: "test-repo",
|
|
owner: { login: "test-user", type: "User" },
|
|
},
|
|
};
|
|
const messages: LoggedMessage[] = [];
|
|
logFileCoverageOnPrsDeprecationWarning(getRecordingLogger(messages));
|
|
t.is(messages.length, 1);
|
|
t.is(messages[0].type, "warning");
|
|
t.is(
|
|
messages[0].message,
|
|
"Starting April 2026, the CodeQL Action will skip computing file coverage information on pull requests " +
|
|
"to improve analysis performance. File coverage information will still be computed on non-PR analyses.\n\n" +
|
|
"To opt out of this change, switch to an advanced setup workflow and " +
|
|
"set the `CODEQL_ACTION_FILE_COVERAGE_ON_PRS` environment variable to `true`.",
|
|
);
|
|
t.true(exportVariableStub.calledOnce);
|
|
},
|
|
);
|
|
|
|
test.serial(
|
|
"file coverage deprecation warning for user-owned repo with advanced setup recommends env var",
|
|
(t) => {
|
|
const exportVariableStub = sinon.stub(core, "exportVariable");
|
|
sinon.stub(actionsUtil, "isDefaultSetup").returns(false);
|
|
github.context.payload = {
|
|
repository: {
|
|
name: "test-repo",
|
|
owner: { login: "test-user", type: "User" },
|
|
},
|
|
};
|
|
const messages: LoggedMessage[] = [];
|
|
logFileCoverageOnPrsDeprecationWarning(getRecordingLogger(messages));
|
|
t.is(messages.length, 1);
|
|
t.is(messages[0].type, "warning");
|
|
t.is(
|
|
messages[0].message,
|
|
"Starting April 2026, the CodeQL Action will skip computing file coverage information on pull requests " +
|
|
"to improve analysis performance. File coverage information will still be computed on non-PR analyses.\n\n" +
|
|
"To opt out of this change, set the `CODEQL_ACTION_FILE_COVERAGE_ON_PRS` environment variable to `true`.",
|
|
);
|
|
t.true(exportVariableStub.calledOnce);
|
|
},
|
|
);
|
|
|
|
test.serial(
|
|
"file coverage deprecation warning for unknown owner type with default setup recommends advanced setup",
|
|
(t) => {
|
|
const exportVariableStub = sinon.stub(core, "exportVariable");
|
|
sinon.stub(actionsUtil, "isDefaultSetup").returns(true);
|
|
github.context.payload = { repository: undefined };
|
|
const messages: LoggedMessage[] = [];
|
|
logFileCoverageOnPrsDeprecationWarning(getRecordingLogger(messages));
|
|
t.is(messages.length, 1);
|
|
t.is(messages[0].type, "warning");
|
|
t.is(
|
|
messages[0].message,
|
|
"Starting April 2026, the CodeQL Action will skip computing file coverage information on pull requests " +
|
|
"to improve analysis performance. File coverage information will still be computed on non-PR analyses.\n\n" +
|
|
"To opt out of this change, switch to an advanced setup workflow and " +
|
|
"set the `CODEQL_ACTION_FILE_COVERAGE_ON_PRS` environment variable to `true`.",
|
|
);
|
|
t.true(exportVariableStub.calledOnce);
|
|
},
|
|
);
|
|
|
|
test.serial(
|
|
"file coverage deprecation warning for unknown owner type with advanced setup recommends env var",
|
|
(t) => {
|
|
const exportVariableStub = sinon.stub(core, "exportVariable");
|
|
sinon.stub(actionsUtil, "isDefaultSetup").returns(false);
|
|
github.context.payload = { repository: undefined };
|
|
const messages: LoggedMessage[] = [];
|
|
logFileCoverageOnPrsDeprecationWarning(getRecordingLogger(messages));
|
|
t.is(messages.length, 1);
|
|
t.is(messages[0].type, "warning");
|
|
t.is(
|
|
messages[0].message,
|
|
"Starting April 2026, the CodeQL Action will skip computing file coverage information on pull requests " +
|
|
"to improve analysis performance. File coverage information will still be computed on non-PR analyses.\n\n" +
|
|
"To opt out of this change, set the `CODEQL_ACTION_FILE_COVERAGE_ON_PRS` environment variable to `true`.",
|
|
);
|
|
t.true(exportVariableStub.calledOnce);
|
|
},
|
|
);
|
|
|
|
test.serial(
|
|
"logFileCoverageOnPrsDeprecationWarning does not log if already logged",
|
|
(t) => {
|
|
process.env["CODEQL_ACTION_DID_LOG_FILE_COVERAGE_ON_PRS_DEPRECATION"] =
|
|
"true";
|
|
const exportVariableStub = sinon.stub(core, "exportVariable");
|
|
const messages: LoggedMessage[] = [];
|
|
logFileCoverageOnPrsDeprecationWarning(getRecordingLogger(messages));
|
|
t.is(messages.length, 0);
|
|
t.true(exportVariableStub.notCalled);
|
|
},
|
|
);
|