Merge branch 'main' into robertbrignull/telemetry_ui

Author: robertbrignull

.github/actions/create-pr/action.yml

@@ -0,0 +1,82 @@
+name: Create a PR if one doesn't exists
+description: >
+  Creates a commit with the current changes to the repo, and opens a PR for that commit. If
+  any PR with the same title exists, then this action is marked as succeeded.
+inputs:
+  commit-message:
+    description: >
+      The message for the commit to be created.
+    required: true
+
+  title:
+    description: >
+      The title of the PR. If empty, the title and body will be determined from the commit message.
+    default: ''
+    required: false
+
+  body:
+    description: >
+      The body (description) of the PR. The `title` input must be specified in order for this input to be used.
+    default: ''
+    required: false
+
+  head-branch:
+    description: >
+      The name of the branch to hold the new commit. If an existing open PR with the same head
+      branch exists, the new branch will be force-pushed to that PR instead of creating a new PR.
+    required: true
+
+  base-branch:
+    description: >
+      The base branch to target with the new PR.
+    required: true
+
+  token:
+    description: |
+      The GitHub token to use. It must have enough privileges to
+      make API calls to create and close pull requests.
+    required: true
+
+runs:
+  using: composite
+  steps:
+    - name: Update git config
+      shell: bash
+      run: |
+        git config --global user.email "github-actions@github.com"
+        git config --global user.name "github-actions[bot]"
+    - name: Commit, Push and Open PR
+      shell: bash
+      env:
+        COMMIT_MESSAGE: ${{ inputs.commit-message }}
+        HEAD_BRANCH: ${{ inputs.head-branch }}
+        BASE_BRANCH: ${{ inputs.base-branch }}
+        GH_TOKEN: ${{ inputs.token }}
+        TITLE: ${{ inputs.title }}
+        BODY: ${{ inputs.body }}
+      run: |
+        set -exu
+        if ! [[ $(git diff --stat) != '' ]]; then
+          exit 0 # exit early
+        fi
+        # stage changes in the working tree
+        git add .
+        git commit -m "$COMMIT_MESSAGE"
+        git checkout -b "$HEAD_BRANCH"
+        # CAUTION: gits history changes with the following
+        git push --force origin "$HEAD_BRANCH"
+        PR_JSON=$(gh pr list --state open --json number --head "$HEAD_BRANCH")
+        if [[ $? -ne 0 ]]; then
+          echo "Failed to fetch existing PRs."
+          exit 1
+        fi
+        PR_NUMBERS=$(echo $PR_JSON | jq '. | length')
+        if [[ $PR_NUMBERS -ne 0 ]]; then 
+          echo "Found existing open PR: $PR_NUMBERS"
+          exit 0
+        fi
+        gh pr create --head "$HEAD_BRANCH" --base "$BASE_BRANCH" --title "$TITLE" --body "$BODY" --assignee ${{ github.actor }}
+        if [[ $? -ne 0 ]]; then
+          echo "Failed to create new PR."
+          exit 1
+        fi

.github/workflows/bump-cli.yml

@@ -0,0 +1,39 @@
+name: Bump CLI version
+on:
+  workflow_dispatch:
+  pull_request:
+    branches: [main]
+    paths:
+      - .github/actions/create-pr/action.yml
+      - .github/workflows/bump-cli.yml
+  schedule:
+  - cron: 0 0 */14 * * # run every 14 days
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 1
+      - name: Bump CLI
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          scripts/replace-cli-version.sh
+      - name: Commit, Push and Open a PR
+        uses: ./.github/actions/create-pr
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          base-branch: main
+          head-branch: github-action/bump-cli
+          commit-message: Bump CLI version from ${{ env.PREVIOUS_VERSION }} to ${{ env.LATEST_VERSION }} for integration tests
+          title: Bump CLI Version to ${{ env.LATEST_VERSION }} for integration tests
+          body: >
+            Bumps CLI version from ${{ env.PREVIOUS_VERSION }} to ${{ env.LATEST_VERSION }}

.github/workflows/main.yml

@@ -183,14 +183,25 @@ jobs:
         run: |
           npm run integration
 
+  set-matrix:
+    name: Set Matrix for cli-test
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Set the variables
+        id: set-variables
+        run: echo "cli-versions=$(cat ./supported_cli_versions.json | jq -rc)" >> $GITHUB_OUTPUT
+    outputs:
+      cli-versions: ${{ steps.set-variables.outputs.cli-versions }}
   cli-test:
     name: CLI Test
     runs-on: ${{ matrix.os }}
-    needs: [find-nightly]
+    needs: [find-nightly, set-matrix]
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest]
-        version: ['v2.7.6', 'v2.8.5', 'v2.9.4', 'v2.10.5', 'v2.11.6', 'nightly']
+        version: ${{ fromJson(needs.set-matrix.outputs.cli-versions) }}
       fail-fast: false
     env:
       CLI_VERSION: ${{ matrix.version }}

CONTRIBUTING.md

@@ -95,10 +95,13 @@ More information about Storybook can be found inside the **Overview** page once
 
 We have several types of tests:
 
-* Unit tests: these live in the `tests/pure-tests/` directory
+* Unit tests: these live in the `tests/unit-tests/` directory
 * View tests: these live in `src/view/variant-analysis/__tests__/`
-* VSCode integration tests: these live in `test/vscode-tests/no-workspace` and `test/vscode-tests/minimal-workspace`
+* VSCode integration tests:
+  * `test/vscode-tests/no-workspace` tests: These are intended to cover functionality that is meant to work before you even have a workspace open. 
+  * `test/vscode-tests/minimal-workspace` tests: These are intended to cover functionality that need a workspace but don't require the full extension to be activated.
 * CLI integration tests: these live in `test/vscode-tests/cli-integration`
+  * These tests are intendended to be cover functionality that is related to the integration between the CodeQL CLI and the extension.
 
 The CLI integration tests require an instance of the CodeQL CLI to run so they will require some extra setup steps. When adding new tests to our test suite, please be mindful of whether they need to be in the cli-integration folder. If the tests don't depend on the CLI, they are better suited to being a VSCode integration test.
 

extensions/ql-vscode/.vscodeignore

@@ -14,3 +14,4 @@ gulpfile.js/**
 tsconfig.json
 .prettierrc
 vsc-extension-quickstart.md
+node_modules/**

extensions/ql-vscode/gulpfile.ts/appInsights.ts

@@ -13,7 +13,7 @@ export function injectAppInsightsKey() {
   }
 
   // replace the key
-  return src(["out/telemetry.js"])
+  return src(["out/extension.js"])
     .pipe(replace(/REPLACE-APP-INSIGHTS-KEY/, process.env.APP_INSIGHTS_KEY))
     .pipe(dest("out/"));
 }

extensions/ql-vscode/gulpfile.ts/deploy.ts

@@ -22,21 +22,27 @@ const packageFiles = [
   "language-configuration.json",
   "snippets.json",
   "media",
-  "node_modules",
   "out",
   "workspace-databases-schema.json",
 ];
 
+async function copyDirectory(
+  sourcePath: string,
+  destPath: string,
+): Promise<void> {
+  console.log(`copying ${sourcePath} to ${destPath}`);
+  await copy(sourcePath, destPath);
+}
+
 async function copyPackage(
   sourcePath: string,
   destPath: string,
 ): Promise<void> {
-  for (const file of packageFiles) {
-    console.log(
-      `copying ${resolve(sourcePath, file)} to ${resolve(destPath, file)}`,
-    );
-    await copy(resolve(sourcePath, file), resolve(destPath, file));
-  }
+  await Promise.all(
+    packageFiles.map((file) =>
+      copyDirectory(resolve(sourcePath, file), resolve(destPath, file)),
+    ),
+  );
 }
 
 export async function deployPackage(
@@ -88,6 +94,12 @@ export async function deployPackage(
     );
     await copyPackage(sourcePath, distPath);
 
+    // This is necessary for vsce to know the dependencies
+    await copyDirectory(
+      resolve(sourcePath, "node_modules"),
+      resolve(distPath, "node_modules"),
+    );
+
     return {
       distPath,
       name: packageJson.name,

extensions/ql-vscode/gulpfile.ts/index.ts

@@ -1,29 +1,39 @@
-import { series, parallel } from "gulp";
-import { compileTypeScript, watchTypeScript, cleanOutput } from "./typescript";
+import { parallel, series } from "gulp";
+import {
+  compileEsbuild,
+  watchEsbuild,
+  checkTypeScript,
+  watchCheckTypeScript,
+  cleanOutput,
+  copyWasmFiles,
+} from "./typescript";
 import { compileTextMateGrammar } from "./textmate";
-import { copyTestData, watchTestData } from "./tests";
 import { compileView, watchView } from "./webpack";
 import { packageExtension } from "./package";
 import { injectAppInsightsKey } from "./appInsights";
 
 export const buildWithoutPackage = series(
   cleanOutput,
   parallel(
-    compileTypeScript,
+    compileEsbuild,
+    copyWasmFiles,
+    checkTypeScript,
     compileTextMateGrammar,
     compileView,
-    copyTestData,
   ),
 );
 
+export const watch = parallel(watchEsbuild, watchCheckTypeScript, watchView);
+
 export {
   cleanOutput,
   compileTextMateGrammar,
-  watchTypeScript,
+  watchEsbuild,
+  watchCheckTypeScript,
   watchView,
-  compileTypeScript,
-  copyTestData,
-  watchTestData,
+  compileEsbuild,
+  copyWasmFiles,
+  checkTypeScript,
   injectAppInsightsKey,
   compileView,
 };

extensions/ql-vscode/gulpfile.ts/package.ts

@@ -3,7 +3,9 @@ import { deployPackage } from "./deploy";
 import { spawn } from "child-process-promise";
 
 export async function packageExtension(): Promise<void> {
-  const deployedPackage = await deployPackage(resolve("package.json"));
+  const deployedPackage = await deployPackage(
+    resolve(__dirname, "../package.json"),
+  );
   console.log(
     `Packaging extension '${deployedPackage.name}@${deployedPackage.version}'...`,
   );
@@ -16,7 +18,7 @@ export async function packageExtension(): Promise<void> {
       `${deployedPackage.name}-${deployedPackage.version}.vsix`,
     ),
   ];
-  const proc = spawn("./node_modules/.bin/vsce", args, {
+  const proc = spawn(resolve(__dirname, "../node_modules/.bin/vsce"), args, {
     cwd: deployedPackage.distPath,
   });
   proc.childProcess.stdout!.on("data", (data) => {