ist jetzt verfügbar! Lesen Sie über die neuen Funktionen und Fehlerbehebungen vom November.

Erweiterungen testen

Visual Studio Code unterstützt das Ausführen und Debuggen von Tests für Ihre Erweiterung. Diese Tests werden in einer speziellen Instanz von VS Code namens Extension Development Host ausgeführt und haben vollen Zugriff auf die VS Code API. Wir bezeichnen diese Tests als Integrationstests, da sie über Unit-Tests hinausgehen, die ohne eine VS Code-Instanz ausgeführt werden können. Diese Dokumentation konzentriert sich auf VS Code Integrationstests.

Übersicht

Wenn Sie den Yeoman Generator zum Erstellen einer Erweiterung verwenden, sind Integrationstests bereits für Sie erstellt.

In der generierten Erweiterung können Sie npm run test oder yarn test verwenden, um die Integrationstests auszuführen, die

  • lädt die neueste Version von VS Code herunter und entpackt sie.
  • führt die von Skript des Erweiterungstest-Testers angegebenen Mocha-Tests aus.

Schnelle Einrichtung: Das Test-CLI

Das VS Code-Team veröffentlicht ein Befehlszeilen-Tool zum Ausführen von Erweiterungstests. Ein Beispiel finden Sie im Erweiterungs-Sample-Repository.

Das Test-CLI bietet eine schnelle Einrichtung und ermöglicht es Ihnen auch, VS Code-UI-Tests mit dem Extension Test Runner einfach auszuführen und zu debuggen. Das CLI verwendet intern ausschließlich Mocha.

Um loszulegen, sollten Sie zuerst das Modul @vscode/test-cli sowie das Modul @vscode/test-electron installieren, das das Ausführen von Tests in VS Code Desktop ermöglicht.

npm install --save-dev @vscode/test-cli @vscode/test-electron

Nach der Installation der Module haben Sie den Befehl vscode-test, den Sie im Abschnitt scripts Ihrer package.json hinzufügen können.

{
  "name": "my-cool-extension",
  "scripts": {
+   "test": "vscode-test"

vscode-test sucht nach einer .vscode-test.js/mjs/cjs-Datei relativ zum aktuellen Arbeitsverzeichnis. Diese Datei bietet die Konfiguration für den Test-Runner, und die vollständige Definition finden Sie hier.

Gängige Optionen sind

  • (erforderlich) files - Ein Muster, eine Liste von Mustern oder absolute Pfade, die die auszuführenden Tests enthalten.
  • version - Die Version von VS Code, die für die Ausführung von Tests verwendet werden soll (Standard ist stable).
  • workspaceFolder - Der Pfad zu einem Arbeitsbereich, der während der Tests geöffnet werden soll.
  • extensionDevelopmentPath - Der Pfad zu Ihrem Erweiterungsordner (Standard ist das Verzeichnis der Konfigurationsdatei).
  • mocha - Ein Objekt, das zusätzliche Optionen enthält, die an Mocha übergeben werden.

Die Konfiguration könnte so einfach sein wie

// .vscode-test.js
const { defineConfig } = require('@vscode/test-cli');

module.exports = defineConfig({ files: 'out/test/**/*.test.js' });

...oder fortgeschrittener

// .vscode-test.js
const { defineConfig } = require('@vscode/test-cli');

module.exports = defineConfig([
  {
    label: 'unitTests',
    files: 'out/test/**/*.test.js',
    version: 'insiders',
    workspaceFolder: './sampleWorkspace',
    mocha: {
      ui: 'tdd',
      timeout: 20000
    }
  }
  // you can specify additional test configurations, too
]);

Wenn Sie mehrere Konfigurationen definieren, indem Sie ein Array übergeben, werden diese sequenziell ausgeführt, wenn Sie vscode-test ausführen. Sie können nach dem label filtern und sie einzeln mit dem Flag --label ausführen, z. B. vscode-test --label unitTests. Führen Sie vscode-test --help für die vollständige Liste der Befehlszeilenoptionen aus.

Test-Skripte

Sobald das CLI eingerichtet ist, können Sie Ihre Tests schreiben und ausführen. Test-Skripte haben Zugriff auf die VS Code API und werden unter Mocha ausgeführt. Hier ist ein Beispiel (src/test/suite/extension.test.ts)

import * as assert from 'assert';

// You can import and use all API from the 'vscode' module
// as well as import your extension to test it
import * as vscode from 'vscode';
// import * as myExtension from '../extension';

suite('Extension Test Suite', () => {
  suiteTeardown(() => {
    vscode.window.showInformationMessage('All tests done!');
  });

  test('Sample test', () => {
    assert.strictEqual(-1, [1, 2, 3].indexOf(5));
    assert.strictEqual(-1, [1, 2, 3].indexOf(0));
  });
});

Sie können diesen Test mit dem Befehl npm test ausführen oder indem Sie den Befehl Test: Alle Tests ausführen in VS Code verwenden, nachdem Sie den Extension Test Runner installiert haben. Sie können den Test auch mit dem Befehl Test: Alle Tests debuggen debuggen.

Erweiterte Einrichtung: Ihr eigener Runner

Die Konfiguration für diese Anleitung finden Sie im helloworld-test-sample. Der Rest dieses Dokuments erklärt diese Dateien im Kontext des Samples.

VS Code stellt zwei CLI-Parameter für die Ausführung von Erweiterungstests bereit: --extensionDevelopmentPath und --extensionTestsPath.

Zum Beispiel

# - Launches VS Code Extension Host
# - Loads the extension at <EXTENSION-ROOT-PATH>
# - Executes the test runner script at <TEST-RUNNER-SCRIPT-PATH>
code \
--extensionDevelopmentPath=<EXTENSION-ROOT-PATH> \
--extensionTestsPath=<TEST-RUNNER-SCRIPT-PATH>

Das Test-Skript (src/test/runTest.ts) verwendet die @vscode/test-electron API, um den Prozess des Herunterladens, Entpackens und Startens von VS Code mit Erweiterungstestparametern zu vereinfachen.

import * as path from 'path';

import { runTests } from '@vscode/test-electron';

async function main() {
  try {
    // The folder containing the Extension Manifest package.json
    // Passed to `--extensionDevelopmentPath`
    const extensionDevelopmentPath = path.resolve(__dirname, '../../');

    // The path to the extension test runner script
    // Passed to --extensionTestsPath
    const extensionTestsPath = path.resolve(__dirname, './suite/index');

    // Download VS Code, unzip it and run the integration test
    await runTests({ extensionDevelopmentPath, extensionTestsPath });
  } catch (err) {
    console.error(err);
    console.error('Failed to run tests');
    process.exit(1);
  }
}

main();

Die @vscode/test-electron API ermöglicht auch

  • das Starten von VS Code mit einem bestimmten Arbeitsbereich.
  • das Herunterladen einer anderen VS Code-Version als der neuesten stabilen Version.
  • das Starten von VS Code mit zusätzlichen CLI-Parametern.

Weitere Beispiele für die API-Nutzung finden Sie unter microsoft/vscode-test.

Das Test-Runner-Skript

Beim Ausführen des Erweiterungs-Integrationstests zeigt --extensionTestsPath auf das Test-Runner-Skript (src/test/suite/index.ts), das die Testsuite programmatisch ausführt. Unten sehen Sie das Test-Runner-Skript von helloworld-test-sample, das Mocha verwendet, um die Testsuite auszuführen. Sie können dies als Ausgangspunkt verwenden und Ihr Setup mit der Mocha-API anpassen. Sie können Mocha auch durch ein beliebiges anderes Testframework ersetzen, das programmatisch ausgeführt werden kann.

import * as path from 'path';
import * as Mocha from 'mocha';
import { glob } from 'glob';

export function run(): Promise<void> {
  // Create the mocha test
  const mocha = new Mocha({
    ui: 'tdd',
    color: true
  });

  const testsRoot = path.resolve(__dirname, '..');

  return new Promise((c, e) => {
    glob('**/**.test.js', { cwd: testsRoot })
      .then(files => {
        // Add files to the test suite
        files.forEach(f => mocha.addFile(path.resolve(testsRoot, f)));

        try {
          // Run the mocha test
          mocha.run(failures => {
            if (failures > 0) {
              e(new Error(`${failures} tests failed.`));
            } else {
              c();
            }
          });
        } catch (err) {
          e(err);
        }
      })
      .catch(err => {
        return e(err);
      });
  });
}

Sowohl das Test-Runner-Skript als auch die *.test.js-Dateien haben Zugriff auf die VS Code API.

Hier ist ein Beispieltest (src/test/suite/extension.test.ts)

import * as assert from 'assert';
import { after } from 'mocha';

// You can import and use all API from the 'vscode' module
// as well as import your extension to test it
import * as vscode from 'vscode';
// import * as myExtension from '../extension';

suite('Extension Test Suite', () => {
  after(() => {
    vscode.window.showInformationMessage('All tests done!');
  });

  test('Sample test', () => {
    assert.strictEqual(-1, [1, 2, 3].indexOf(5));
    assert.strictEqual(-1, [1, 2, 3].indexOf(0));
  });
});

Tests debuggen

Das Debuggen von Tests ist ähnlich wie das Debuggen der Erweiterung.

Hier ist ein Beispiel für eine launch.json Debugger-Konfiguration

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Extension Tests",
      "type": "extensionHost",
      "request": "launch",
      "runtimeExecutable": "${execPath}",
      "args": [
        "--extensionDevelopmentPath=${workspaceFolder}",
        "--extensionTestsPath=${workspaceFolder}/out/test/suite/index"
      ],
      "outFiles": ["${workspaceFolder}/out/test/**/*.js"]
    }
  ]
}

Tipps

Verwenden der Insiders-Version für die Entwicklung von Erweiterungen

Aufgrund von Einschränkungen von VS Code wird ein Fehler ausgelöst, wenn Sie die stabile Version von VS Code verwenden und versuchen, den Integrationstest auf der CLI auszuführen.

Running extension tests from the command line is currently only supported if no other instance of Code is running.

Im Allgemeinen kann die Version, mit der die Tests ausgeführt werden, nicht bereits ausgeführt werden, wenn Sie Erweiterungstests von der CLI ausführen. Als Workaround können Sie die Tests in VS Code Stable ausführen und VS Code Insiders für die Entwicklung verwenden. Solange Sie die Tests nicht von der CLI in VS Code Insiders, sondern in VS Code Stable ausführen, funktioniert dieses Setup einwandfrei.

Eine Alternative ist die Ausführung der Erweiterungstests über die Debug-Startkonfiguration innerhalb von VS Code selbst. Dies hat den zusätzlichen Vorteil, dass Sie die Tests sogar debuggen können.

Andere Erweiterungen beim Debuggen deaktivieren

Wenn Sie einen Erweiterungstest in VS Code debuggen, verwendet VS Code die global installierte Instanz von VS Code und lädt alle installierten Erweiterungen. Sie können die Konfiguration --disable-extensions zu launch.json oder der Option launchArgs der @vscode/test-electron runTests API hinzufügen.

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Extension Tests",
      "type": "extensionHost",
      "request": "launch",
      "runtimeExecutable": "${execPath}",
      "args": [
        "--disable-extensions",
        "--extensionDevelopmentPath=${workspaceFolder}",
        "--extensionTestsPath=${workspaceFolder}/out/test/suite/index"
      ],
      "outFiles": ["${workspaceFolder}/out/test/**/*.js"]
    }
  ]
}

await runTests({
  extensionDevelopmentPath,
  extensionTestsPath,
  /**
   * A list of launch arguments passed to VS Code executable, in addition to `--extensionDevelopmentPath`
   * and `--extensionTestsPath` which are provided by `extensionDevelopmentPath` and `extensionTestsPath`
   * options.
   *
   * If the first argument is a path to a file/folder/workspace, the launched VS Code instance
   * will open it.
   *
   * See `code --help` for possible arguments.
   */
  launchArgs: ['--disable-extensions']
});

Benutzerdefinierte Einrichtung mit @vscode/test-electron

Manchmal möchten Sie benutzerdefinierte Setups ausführen, z. B. das Ausführen von code --install-extension, um eine andere Erweiterung vor dem Start Ihres Tests zu installieren. @vscode/test-electron verfügt über eine granularere API, um diesen Fall zu berücksichtigen.

import * as cp from 'child_process';
import * as path from 'path';
import {
  downloadAndUnzipVSCode,
  resolveCliArgsFromVSCodeExecutablePath,
  runTests
} from '@vscode/test-electron';

async function main() {
  try {
    const extensionDevelopmentPath = path.resolve(__dirname, '../../../');
    const extensionTestsPath = path.resolve(__dirname, './suite/index');
    const vscodeExecutablePath = await downloadAndUnzipVSCode('1.40.1');
    const [cliPath, ...args] = resolveCliArgsFromVSCodeExecutablePath(vscodeExecutablePath);

    // Use cp.spawn / cp.exec for custom setup
    cp.spawnSync(
      cliPath,
      [...args, '--install-extension', '<EXTENSION-ID-OR-PATH-TO-VSIX>'],
      {
        encoding: 'utf-8',
        stdio: 'inherit'
      }
    );

    // Run the extension test
    await runTests({
      // Use the specified `code` executable
      vscodeExecutablePath,
      extensionDevelopmentPath,
      extensionTestsPath
    });
  } catch (err) {
    console.error('Failed to run tests');
    process.exit(1);
  }
}

main();

Nächste Schritte

  • Continuous Integration - Führen Sie Ihre Erweiterungstests in einem Continuous Integration-Dienst wie Azure DevOps aus.
12/10/2025
© . This site is unofficial and not affiliated with Microsoft.