import * as fs from "fs";

import * as path from "path";

import * as github from "@actions/github";

import test, { ExecutionContext } from "ava";

import * as yaml from "js-yaml";

import * as sinon from "sinon";

import { ActionState } from "./action-common";

import * as actionsUtil from "./actions-util";

import { AnalysisKind, supportedAnalysisKinds } from "./analyses";

import * as api from "./api-client";

import { CachingKind } from "./caching-utils";

import { createStubCodeQL } from "./codeql";

import { UserConfig } from "./config/db-config";

import * as file from "./config/file";

import * as configUtils from "./config-utils";

import * as errorMessages from "./error-messages";

import { Feature } from "./feature-flags";

import { RepositoryProperties } from "./feature-flags/properties";

import * as gitUtils from "./git-utils";

import { GitVersionInfo } from "./git-utils";

import { BuiltInLanguage, Language } from "./languages";

import { getRunnerLogger } from "./logging";

import { CODEQL_OVERLAY_MINIMUM_VERSION } from "./overlay";

import * as overlayDiagnostics from "./overlay/diagnostics";

import { OverlayDisabledReason } from "./overlay/diagnostics";

import { OverlayDatabaseMode } from "./overlay/overlay-database-mode";

import * as overlayStatus from "./overlay/status";

import { parseRepositoryNwo } from "./repository";

import {

setupTests,

setupActionsVars,

mockLanguagesInRepo as mockLanguagesInRepo,

createFeatures,

getRecordingLogger,

LoggedMessage,

mockCodeQLVersion,

createTestConfig,

makeMacro,

initAllState,

callee,

SAMPLE_DOTCOM_API_DETAILS,

AssertableTarget,

} from "./testing-utils";

import {

GitHubVariant,

GitHubVersion,

ConfigurationError,

withTmpDir,

BuildMode,

DiskUsage,

Success,

Failure,

} from "./util";

import * as util from "./util";

const githubVersion = { type: GitHubVariant.DOTCOM } as GitHubVersion;

function createTestInitConfigInputs(

function createConfigFile(inputFileContents: string, tmpDir: string): string {

type GetContentsResponse = { content?: string } | object[];

function mockGetContents(

function mockListLanguages(languages: string[]) {

test.serial("load empty config", async (t) => {

return await withTmpDir(async (tempDir) => {

const logger = getRunnerLogger(true);

const languages = "javascript,python";

setupActionsVars(tempDir, tempDir);

const codeql = createStubCodeQL({

async resolveLanguages() {

},

});

const state = initAllState({ logger });

const config = await configUtils.initConfig(

state,

createTestInitConfigInputs({

languagesInput: languages,

repository: { owner: "github", repo: "example" },

sourceRoot: tempDir,

tempDir,

codeql,

logger,

}),

);

const expectedConfig = await configUtils.initActionState(

createTestInitConfigInputs({

languagesInput: languages,

tempDir,

codeql,

logger,

}),

{},

undefined,

);

t.deepEqual(config, expectedConfig);

});

test.serial("load code quality config", async (t) => {

return await withTmpDir(async (tempDir) => {

const logger = getRunnerLogger(true);

const languages = "actions";

setupActionsVars(tempDir, tempDir);

const codeql = createStubCodeQL({

async resolveLanguages() {

},

});

const state = initAllState({ logger });

const config = await configUtils.initConfig(

state,

createTestInitConfigInputs({

analysisKinds: [AnalysisKind.CodeQuality],

languagesInput: languages,

repository: { owner: "github", repo: "example" },

sourceRoot: tempDir,

tempDir,

codeql,

logger,

}),

);

// And the config we expect it to result in

const expectedConfig = createTestConfig({

analysisKinds: [AnalysisKind.CodeQuality],

languages: [BuiltInLanguage.actions],

// This gets set because we only have `AnalysisKind.CodeQuality`

computedConfig: {

"disable-default-queries": true,

queries: [{ uses: "code-quality" }],

"query-filters": [],

},

tempDir,

codeQLCmd: codeql.getPath(),

gitHubVersion: githubVersion,

dbLocation: path.resolve(tempDir, "codeql_databases"),

debugMode: false,

debugArtifactName: "",

debugDatabaseName: "",

});

t.deepEqual(config, expectedConfig);

});

"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";

setupActionsVars(tempDir, tempDir);

const codeql = createStubCodeQL({

async resolveLanguages() {

},

});

// This should be ignored and no error should be thrown.

const repositoryProperties = {

"github-codeql-extra-queries": "+foo",

};

// Expected configuration for a CQ-only analysis.

const computedConfig: UserConfig = {

"disable-default-queries": true,

queries: [{ uses: "code-quality" }],

"query-filters": [],

};

const expectedConfig = createTestConfig({

analysisKinds: [AnalysisKind.CodeQuality],

languages: [BuiltInLanguage.javascript],

codeQLCmd: codeql.getPath(),

computedConfig,

dbLocation: path.resolve(tempDir, "codeql_databases"),

debugArtifactName: "",

debugDatabaseName: "",

tempDir,

repositoryProperties,

});

const state = initAllState({ logger });

await t.notThrowsAsync(async () => {

const config = await configUtils.initConfig(

state,

createTestInitConfigInputs({

analysisKinds: [AnalysisKind.CodeQuality],

languagesInput: languages,

repository: { owner: "github", repo: "example" },

sourceRoot: tempDir,

tempDir,

codeql,

repositoryProperties,

logger,

}),

);

t.deepEqual(config, expectedConfig);

});

});

},

test.serial("loading a saved config produces the same config", async (t) => {

return await withTmpDir(async (tempDir) => {

const logger = getRunnerLogger(true);

const codeql = createStubCodeQL({

async resolveLanguages() {

},

});

// Sanity check the saved config file does not already exist

t.false(fs.existsSync(configUtils.getPathToParsedConfigFile(tempDir)));

// Sanity check that getConfig returns undefined before we have called initConfig

t.deepEqual(await configUtils.getConfig(tempDir, logger), undefined);

const state = initAllState({ logger });

const config1 = await configUtils.initConfig(

state,

createTestInitConfigInputs({

languagesInput: "javascript,python",

tempDir,

codeql,

workspacePath: tempDir,

logger,

}),

);

await configUtils.saveConfig(config1, logger);

// The saved config file should now exist

t.true(fs.existsSync(configUtils.getPathToParsedConfigFile(tempDir)));

// And that same newly-initialised config should now be returned by getConfig

const config2 = await configUtils.getConfig(tempDir, logger);

t.not(config2, undefined);

if (config2 !== undefined) {

// removes properties assigned to undefined.

const expectedConfig = JSON.parse(JSON.stringify(config1));

t.deepEqual(expectedConfig, config2);

}

});

test.serial("loading config with version mismatch throws", async (t) => {

return await withTmpDir(async (tempDir) => {

const logger = getRunnerLogger(true);

const codeql = createStubCodeQL({

async resolveLanguages() {

},

});

// Sanity check the saved config file does not already exist

t.false(fs.existsSync(configUtils.getPathToParsedConfigFile(tempDir)));

// Sanity check that getConfig returns undefined before we have called initConfig

t.deepEqual(await configUtils.getConfig(tempDir, logger), undefined);

// Stub `getActionVersion` to return some nonsense.

const getActionVersionStub = sinon

.stub(actionsUtil, "getActionVersion")

.returns("does-not-exist");

const state = initAllState({ logger });

const config = await configUtils.initConfig(

state,

createTestInitConfigInputs({

languagesInput: "javascript,python",

tempDir,

codeql,

workspacePath: tempDir,

logger,

}),

);

// initConfig does not save the config, so we do it here.

await configUtils.saveConfig(config, logger);

// Restore `getActionVersion`.

getActionVersionStub.restore();

// The saved config file should now exist

t.true(fs.existsSync(configUtils.getPathToParsedConfigFile(tempDir)));

// Trying to read the configuration should now throw an error.

await t.throwsAsync(configUtils.getConfig(tempDir, logger), {

instanceOf: ConfigurationError,

});

});

test.serial("load input outside of workspace", async (t) => {

return await withTmpDir(async (tempDir) => {

try {

const state = initAllState();

await configUtils.initConfig(

state,

createTestInitConfigInputs({

configFile: "../input",

tempDir,

workspacePath: tempDir,

}),

);

throw new Error("initConfig did not throw error");

} catch (err) {

t.deepEqual(

err,

new ConfigurationError(

errorMessages.getConfigFileOutsideWorkspaceErrorMessage(

path.join(tempDir, "../input"),

),

),

);

}

});

test.serial("load non-existent input", async (t) => {

return await withTmpDir(async (tempDir) => {

const languagesInput = "javascript";

const configFile = "input";

t.false(fs.existsSync(path.join(tempDir, configFile)));

try {

const state = initAllState();

await configUtils.initConfig(

state,

createTestInitConfigInputs({

languagesInput,

configFile,

tempDir,

workspacePath: tempDir,

}),

);

throw new Error("initConfig did not throw error");

} catch (err) {

t.deepEqual(

err,

new ConfigurationError(

errorMessages.getConfigFileDoesNotExistErrorMessage(

path.join(tempDir, "input"),

),

),

);

}

});

const simpleConfigFileContents = `

const simpleConfigInput: UserConfig = {

name: "my config",

queries: [{ uses: "./foo_file" }],

const otherConfigFileContents = `

test.serial("load non-empty input", async (t) => {

return await withTmpDir(async (tempDir) => {

setupActionsVars(tempDir, tempDir);

const codeql = createStubCodeQL({

async resolveLanguages() {

},

});

fs.mkdirSync(path.join(tempDir, "foo"));

const userConfig: UserConfig = {

name: "my config",

"disable-default-queries": true,

queries: [{ uses: "./foo" }],

"paths-ignore": ["a", "b"],

paths: ["c/d"],

};

// And the config we expect it to parse to

const expectedConfig = createTestConfig({

languages: [BuiltInLanguage.javascript],

repositoryRoot: undefined,

buildMode: BuildMode.None,

originalUserInput: userConfig,

computedConfig: userConfig,

tempDir,

codeQLCmd: codeql.getPath(),

gitHubVersion: githubVersion,

dbLocation: path.resolve(tempDir, "codeql_databases"),

debugMode: false,

debugArtifactName: "my-artifact",

debugDatabaseName: "my-db",

});

const languagesInput = "javascript";

const configFilePath = createConfigFile(otherConfigFileContents, tempDir);

const state = initAllState();

const actualConfig = await configUtils.initConfig(

state,

createTestInitConfigInputs({

languagesInput,

sourceRoot: tempDir,

buildModeInput: "none",

configFile: configFilePath,

debugArtifactName: "my-artifact",

debugDatabaseName: "my-db",

tempDir,

codeql,

workspacePath: tempDir,

}),

);

// Should exactly equal the object we constructed earlier

t.deepEqual(actualConfig, expectedConfig);

});

"Using config input and file together, config input should be used.",

async (t) => {

return await withTmpDir(async (tempDir) => {

setupActionsVars(tempDir, tempDir);

const configFilePath = createConfigFile(

simpleConfigFileContents,

tempDir,

);

const configInput: UserConfig = {

name: "my config",

queries: [{ uses: "./foo" }],

packs: {

javascript: ["a/b@1.2.3"],

python: ["c/d@1.2.3"],

},

};

fs.mkdirSync(path.join(tempDir, "foo"));

const codeql = createStubCodeQL({

async resolveLanguages() {

},

});

// Only JS, python packs will be ignored

const languagesInput = "javascript";

const state = initAllState({ env: util.getEnv() });

const config = await configUtils.initConfig(

state,

createTestInitConfigInputs({

languagesInput,

configFile: configFilePath,

configInput,

tempDir,

codeql,

workspacePath: tempDir,

}),

);

// Compare with a separate object rather than `configInput` itself, so that the test catches

// changes made to the input in place.

t.deepEqual(config.originalUserInput, {

name: "my config",

queries: [{ uses: "./foo" }],

packs: {

javascript: ["a/b@1.2.3"],

python: ["c/d@1.2.3"],

},

});

});

},

test.serial("API client used when reading remote config", async (t) => {

return await withTmpDir(async (tempDir) => {

const codeql = createStubCodeQL({

async resolveLanguages() {

},

});

const inputFileContents = `

const dummyResponse = {

content: Buffer.from(inputFileContents).toString("base64"),

};

const spyGetContents = mockGetContents(dummyResponse);

// Create checkout directory for remote queries repository

fs.mkdirSync(path.join(tempDir, "foo/bar/dev"), { recursive: true });

const configFile = "octo-org/codeql-config/config.yaml@main";

const languagesInput = "javascript";

const state = initAllState();

await configUtils.initConfig(

state,

createTestInitConfigInputs({

languagesInput,

configFile,

tempDir,

codeql,

workspacePath: tempDir,

}),

);

t.assert(spyGetContents.called);

});

"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";

const state = initAllState();

try {

await configUtils.initConfig(

state,

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.serial("Invalid format of remote config handled correctly", async (t) => {

return await withTmpDir(async (tempDir) => {

const dummyResponse = {

// note no "content" property here

};

mockGetContents(dummyResponse);

const repoReference = "octo-org/codeql-config/config.yaml@main";

const state = initAllState();

try {

await configUtils.initConfig(

state,

createTestInitConfigInputs({

configFile: repoReference,

tempDir,

workspacePath: tempDir,

}),

);

throw new Error("initConfig did not throw error");

} catch (err) {

t.deepEqual(

err,

new ConfigurationError(

errorMessages.getConfigFileFormatInvalidMessage(repoReference),

),

);

}

});

test.serial("No detected languages", async (t) => {

return await withTmpDir(async (tempDir) => {

mockListLanguages([]);

const codeql = createStubCodeQL({

async resolveLanguages() {

return { extractors: {} };

},

});

const state = initAllState();

try {

await configUtils.initConfig(

state,

createTestInitConfigInputs({

tempDir,

codeql,

workspacePath: tempDir,

}),

);

throw new Error("initConfig did not throw error");

} catch (err) {

t.deepEqual(

err,

new ConfigurationError(errorMessages.getNoLanguagesError()),

);

}

});

test.serial("Unknown languages", async (t) => {

return await withTmpDir(async (tempDir) => {

const languagesInput = "rubbish,english";

const state = initAllState();

try {

await configUtils.initConfig(

state,

createTestInitConfigInputs({

languagesInput,

tempDir,

workspacePath: tempDir,

}),

);

throw new Error("initConfig did not throw error");

} catch (err) {

t.deepEqual(

err,

new ConfigurationError(

errorMessages.getUnknownLanguagesError(["rubbish", "english"]),

),

);

}

});

const mockLogger = getRunnerLogger(true);

test.serial("no generateRegistries when registries is undefined", async (t) => {

return await withTmpDir(async (tmpDir) => {

const registriesInput = undefined;

const logger = getRunnerLogger(true);

const { registriesAuthTokens, qlconfigFile } =

await configUtils.generateRegistries(registriesInput, tmpDir, logger);

t.is(registriesAuthTokens, undefined);

t.is(qlconfigFile, undefined);

});

"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"));

});

},

const mockRepositoryNwo = parseRepositoryNwo("owner/repo");

{

name: "languages from input",

languagesInput: "jAvAscript, \n jaVa",

languagesInRepository: ["SwiFt", "other"],

expectedLanguages: ["javascript", "java"],

expectedApiCall: false,

},

{

name: "languages from github api",

languagesInput: "",

languagesInRepository: [" jAvAscript\n \t", " jaVa", "SwiFt", "other"],

expectedLanguages: ["javascript", "java"],

expectedApiCall: true,

},

{

name: "aliases from input",

languagesInput: " typEscript\n \t, C#, c , KoTlin",

languagesInRepository: ["SwiFt", "other"],

expectedLanguages: ["javascript", "csharp", "cpp", "java"],

expectedApiCall: false,

},

{

name: "duplicate languages from input",

languagesInput: "jAvAscript, \n jaVa, kotlin, typescript",

languagesInRepository: ["SwiFt", "other"],

expectedLanguages: ["javascript", "java"],

expectedApiCall: false,

},

{

name: "aliases from github api",

languagesInput: "",

languagesInRepository: [" typEscript\n \t", " C#", "c", "other"],

expectedLanguages: ["javascript", "csharp", "cpp"],

expectedApiCall: true,

},

{

name: "unsupported languages from github api",

languagesInput: "",

languagesInRepository: ["html"],

expectedApiCall: true,

expectedError: errorMessages.getNoLanguagesError(),

},

{

name: "no languages",

languagesInput: "",

languagesInRepository: [],

expectedApiCall: true,

expectedError: errorMessages.getNoLanguagesError(),

},

{

name: "unrecognized languages from input",

languagesInput: "a, b, c, javascript",

languagesInRepository: [],

expectedApiCall: false,

expectedError: errorMessages.getUnknownLanguagesError(["a", "b"]),

},

{

name: "extractors that aren't languages aren't included (specified)",

languagesInput: "html",

languagesInRepository: [],

expectedApiCall: false,

expectedError: errorMessages.getUnknownLanguagesError(["html"]),

},

{

name: "extractors that aren't languages aren't included (autodetected)",

languagesInput: "",

languagesInRepository: ["html", "javascript"],

expectedApiCall: true,

expectedLanguages: ["javascript"],

},

].forEach((args) => {

test.serial(`getLanguages: ${args.name}`, async (t) => {

const mockRequest = mockLanguagesInRepo(args.languagesInRepository);

const stubExtractorEntry = {

extractor_root: "",

};

const codeQL = createStubCodeQL({

resolveLanguages: (options) =>

}),

});

if (args.expectedLanguages) {

// happy path

const actualLanguages = await configUtils.getLanguages(

codeQL,

args.languagesInput,

mockRepositoryNwo,

".",

mockLogger,

);

t.deepEqual(actualLanguages.sort(), args.expectedLanguages.sort());

} else {

// there is an error

await t.throwsAsync(

async () =>

await configUtils.getLanguages(

codeQL,

args.languagesInput,

mockRepositoryNwo,

".",

mockLogger,

),

{ message: args.expectedError },

);