Mokka-Haltepunkte mit Visual Studio-Code

Ist es möglich, Mocha-Tests mit Visual Studio Code Haltepunkte hinzuzufügen?

Normalerweise muss beim Debuggen von Code die Datei launch.json konfiguriert werden, wobei das Programmattribut auf die auszuführende Javascript-Datei festgelegt wird. Ich bin mir jedoch nicht sicher, wie ich das für Mokka machen soll.

Wussten Sie, dass Sie einfach in Ihre Startkonfiguration gehen, den Cursor nach oder zwischen Ihre anderen Konfigurationen setzen und ctrl- drücken space, um eine aktuelle, gültige Mokka-Konfiguration automatisch zu generieren?

Welches funktioniert perfekt für mich. Einschließlich Anhalten an Haltepunkten. (Ich hatte auch einen früheren, jetzt veralteten, der aus verschiedenen einstellungsbezogenen Gründen nicht mehr funktionierte.)

Ab VSCode 1.21.1 (März 2018) ergibt dies:

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Mocha (Test single file)",
      "type": "node",
      "request": "launch",
      "runtimeArgs": [
        "${workspaceRoot}/node_modules/.bin/mocha",
        "--inspect-brk",
        "${relativeFile}",
      ],
      "console": "integratedTerminal",
      "internalConsoleOptions": "neverOpen",
      "port": 9229
    }
}

debug-brk Nebenbei bemerkt: ist korrigiert (für jeden mit Node> = Version 8 mindestens).

Wenn Sie nicht --debug-brk+ Anhängen verwenden oder einen absoluten Pfad zu Ihrer globalen Mokka-Installation angeben möchten (der bremst, wenn Sie Ihre launch.json unter Versionskontrolle halten und mehrere Entwickler auf verschiedenen Computern haben), installieren Sie Mokka als Entwicklungsabhängigkeit und Fügen Sie dies zu Ihrem launch.json hinzu:

{
  "name": "mocha",
  "type": "node",
  "request": "launch",
  "program": "${workspaceRoot}/node_modules/mocha/bin/_mocha",
  "stopOnEntry": false,
  "args": ["--no-timeouts", "--colors"], //you can specify paths to specific tests here
  "cwd": "${workspaceRoot}",
  "runtimeExecutable": null,
  "env": {
    "NODE_ENV": "testing"
  }
}

Volle Debugging-Unterstützung in Ihren Tests durch Drücken von F5.

--no-timeoutsstellt sicher, dass Ihre Tests keine Zeitüberschreitung aufweisen, weil Sie an einem Haltepunkt angehalten haben, und --colorsstellt sicher , dass Mocha Farben ausgibt, obwohl nicht erkannt wird, dass VS Code Farben unterstützt.

Eine andere Möglichkeit besteht darin, die --debug-brkBefehlszeilenoption von mocha und die Standardeinstellung für den AttachStart des Visual Studio Code-Debuggers zu verwenden.

Vorgeschlagene tiefere Erklärung (von André)

Um dies zu tun:

Führen Sie Mokka über die Befehlszeile mit diesem Befehl aus:

mocha --debug-brk

Klicken Sie nun in VS Code auf das Debug-Symbol und wählen Sie dann Attachaus der Option neben der Startschaltfläche. Fügen Sie Haltepunkte in VS Code hinzu und klicken Sie dann auf Start.

Ich habe diese Arbeit auf VSCode unter OS X 10.10 gemacht. Ersetzen Sie einfach Ihre ./settings/launch.jsonDatei durch diese.

{
    "version": "0.1.0",
    "configurations": [
        {
            "name": "Run app.js",
            "type": "node",
            "program": "app.js", // Assuming this is your main app file.
            "stopOnEntry": false,
            "args": [],
            "cwd": ".",
            "runtimeExecutable": null,
            "env": { "NODE_ENV": "production"}
        },
        {
            "name": "Run mocha",
            "type": "node",
            "program": "/Users/myname/myfolder/node_modules/mocha/bin/_mocha",
            "stopOnEntry": false,
            "args": ["test/unit.js"],
            "cwd": ".",
            "runtimeExecutable": null,
            "env": { "NODE_ENV": "production"}
        }
    ]
}

Es ist auch als Kern verfügbar hier .

Die Schlüsselwerte, die Sie ändern müssen, sind die program, die auf die _mochaausführbare Datei festgelegt werden sollten, und argsdie ein Array Ihrer Testdateien sein sollten.

Die Art und Weise, wie ich es unter VS OS (1.8.2) unter Mac OS X zum Laufen gebracht habe, ist:

{
    "name": "Mocha",
    "type": "node",
    "request": "launch",
    "program": "${workspaceRoot}/node_modules/mocha/bin/_mocha",
    "stopOnEntry": false,
    "args": ["--recursive"], //you can specify paths to specific tests here
    "cwd": "${workspaceRoot}",
    "runtimeExecutable": null,
    "env": {
        "NODE_ENV": "testing"
    }
}

Mocha muss im Verzeichnis der npm-Module installiert sein.

1. Gehe zu Debug > Add Configuration... Menü gehen
2. Wählen Node.jsUmgebung
3. Wählen Mocha Tests Option aus der angezeigten Dropdown-Liste
4. Geben Sie den Pfad Ihrer Testdatei als letztes Element der ein args Eigenschaft ein
5. Füge hinzu ein breakpoint
6. Klicke auf Debug Symbol
7. Wählen Mocha Tests Sie als Konfigurations
8. Drücken Sie Start debugging Sie Taste
9. :-)

Ich habe einen Weg gefunden, dies zu tun, den ich als Problemumgehung klassifiziere . Ich erwarte, dass das Visual Studio Code-Team eine endgültigere Lösung dafür bereitstellt, aber in der Zwischenzeit habe ich Folgendes getan:

1. Ich habe eine ./settings/mocha.jsDatei erstellt, in der Mokka programmgesteuert ausgeführt wird, wobei Argumente als Liste der auszuführenden Dateien übergeben werden. Sie können die vollständige Datei hier sehen ;

2. Ich habe eine Startkonfiguration erstellt, die ./settings/mocha.jsals ausgeführt wird programund die zu testenden Dateien / Dateimuster als Argumente übergibt:

   {
       "name": "Unit tests",
       "type": "node",
       "program": ".settings/mocha.js",
       "stopOnEntry": true,
       "args": ["test/unit/*.js", "test/unit/**/*.js"],
       "cwd": ".",
       "runtimeExecutable": null,
       "env": { }
   }

   Vollständiges Beispiel für launch.json

Das entspricht also dem Tun mocha test/unit/*.js test/unit/**/*.jsund jetzt können wir Haltepunkte in unseren Mokka-Tests verwenden.

Wenn Sie am Ende der Argumentliste die Variable $ {file} hinzufügen, können Sie das Debuggen direkt aus der geöffneten Datei starten:

        {
            "type": "node",
            "request": "launch",
            "name": "Mocha Tests",
            "program": "${workspaceFolder}/node_modules/mocha/bin/_mocha",
            "args": [
                "-u",
                "tdd",
                "--timeout",
                "999999",
                "--colors",
                "${file}"
            ],
            "internalConsoleOptions": "openOnSessionStart"
        }

Es tut mir leid, dass ich noch eine weitere Antwort hinzugefügt habe, aber keine der vorherigen hat ab VS Code 1.8.1 und dem darin enthaltenen Standard-Node-Debugger für mich funktioniert. Hier ist die Art und Weise, wie ich es gelöst habe (unter Anleitung der vorherigen Antworten hier und der offiziellen VS Code Node.js Debugging- Dokumente), sodass es ein Debugging mit einem Klick / Tastendruck gibt:

• Stellen Sie sicher, dass Mokka als devDependencyin installiert ist packages.json:"devDependencies": { "mocha": "^3.2", ... }
• Führen Sie es npm installin Ihrem Verzeichnis aus package.json, um sicherzustellen, dass Mokka jetzt in installiert istnode_modules/
• Öffnen Sie .vscode/launch.json(oder drücken Sie im VS-Code F1, geben Sie "launch" ein und wählen Sie "Debug: Open launch.json").
• Klicken Sie unten rechts auf die blaue Schaltfläche "Konfiguration hinzufügen" (oder kopieren Sie einfach eine Ihrer anderen und fügen Sie sie ein). Dieser Schritt ist optional ... Ich meine, Sie können eine vorhandene Konfiguration wiederverwenden. Aber ich schlage vor, eine hinzuzufügen, um es weniger verwirrend zu halten.
• Ändern Sie Folgendes in Ihrem launch.json, wählen Sie dann den neuen Konfigurationsnamen im Debug-Fenster in VS Code und klicken Sie auf den grünen Pfeil, um das Debuggen Ihrer Knoten- + Mokka-Tests zu starten!

In der neuen Konfiguration in launch.json:

"configurations": [{
    "name": "whatever name you want to show in the VS Code debug list",
    "type": "node",
    "cwd": "${workspaceRoot}",
    "program": "${workspaceRoot}/node_modules/mocha/bin/mocha",
    "args": ["--debug-brk=5858", "--no-timeouts", "--colors", "test/**/*.js"],
    "address": "localhost",
    "port": 5858,
    // the other default properties that are created for you are fine as-is
}, ...]

Dies setzt voraus, dass das Muster dort test/**/*.jsfunktioniert, wo Sie Ihre Tests durchführen. Gegebenenfalls ändern.

Sie können den Port jederzeit ändern, solange Sie ihn in den entsprechenden argsund portEigenschaften ändern .

Die wichtigsten Unterschiede für mich dafür , dass Mokka war node_modules, mit programder ausführbaren Datei zu Punkt, und argsbenötigen debug-brk=xzeigte auf den Port angegeben in port. Der Rest der oben genannten macht die Dinge nur schöner und einfacher.

Es liegt an Ihnen und Ihrem Team, ob Sie .vscode/launch.jsondas Repository einrichten oder nicht. Es ist eine reine IDE-Datei, aber Ihr gesamtes Team könnte sie problemlos verwenden, da alle Pfade und Installationen relativ und explizit sind.

Tipp: Das package.jsonkann ein scriptsTag enthalten, das auch Mokka mit so etwas wie startet "test": "./node_modules/.bin/mocha", aber nicht von VS Code verwendet wird. Stattdessen wird es verwendet, wenn npm testes über die Befehlszeile ausgeführt wird. Dieser verwirrte mich ein bisschen. Beachten Sie es hier, falls andere auch verwirrt werden.

BEARBEITEN: VS Code 1.9.0 hat in der Dropdown-Liste Debug-Konfiguration die Option "Konfiguration hinzufügen" hinzugefügt, und Sie können "Node.js Mocha Tests" auswählen, um die meisten der oben genannten Punkte zu vereinfachen. Sie müssen immer noch sicherstellen, dass sich Mokka in Ihrem befindet, node_modulesund möglicherweise das cwdund das letzte runtimeArgs(das Muster zum Auffinden Ihrer Tests) aktualisieren , um auf die entsprechenden Pfade zu verweisen. Aber sobald Sie diese beiden Eigenschaften festgelegt haben, sollte es von dort aus ziemlich gut funktionieren.

Fügen Sie in der Datei launch.json 1 weitere Konfiguration hinzu

{
      "type": "node",
      "request": "launch",
      "name": "Mocha Tests",
      "program": "${workspaceRoot}/node_modules/mocha/bin/_mocha",
      "args": [
        "--timeout",
        "10000",
        "${workspaceRoot}/services/*.spec.js",
        "${workspaceRoot}/*.spec.js"
      ],
      "internalConsoleOptions": "openOnSessionStart"
    },

Wenn Sie die Knotenversion konfigurieren müssen, fügen Sie einfach ein runtimeExecutableFeld wie dieses hinzu

{
      "type": "node",
      "request": "launch",
      "name": "Mocha Tests",
      "program": "${workspaceRoot}/node_modules/mocha/bin/_mocha",
      "args": [
        "--timeout",
        "10000",
        "${workspaceRoot}/services/*.spec.js",
        "${workspaceRoot}/*.spec.js"
      ],
      "internalConsoleOptions": "openOnSessionStart",
      "runtimeExecutable": "${env:HOME}/.nvm/versions/node/v8.2.1/bin/node"
    },

Für alle, die Windows verwenden. Wenn Sie Mokka global installiert haben, hat es für mich funktioniert, das Programm auf den folgenden Pfad zu setzen (tauschen Sie Ihren Benutzernamen aus).

"program": "C:\\Users\\myname\\AppData\\Roaming\\npm\\node_modules\\mocha\\bin\\_mocha"

Dies funktioniert für mich auf einem Windows 7-Computer. Ich habe Mokka global installiert, aber diese Konfiguration verweist auf die Projektinstallation, um die Notwendigkeit eines Benutzerprofilpfads zu vermeiden (übrigens habe ich versucht, die Variable% USERPROFILE% ohne Erfolg zu verwenden). Ich kann jetzt in meinen Mokka-Tests Haltepunkte setzen. Yay!

{
        "name": "Mocha Tests",
        "type": "node",
        "request": "launch",
        "stopOnEntry": false,
        "program": "${workspaceRoot}/node_modules/mocha/bin/_mocha",
        "cwd": "${workspaceRoot}",
        "args": ["./test/**/*.js"],
        "runtimeExecutable": null,
        "envFile": "${workspaceRoot}/.env"
    }

Für diejenigen, die Grunzen oder Schlucken verwenden, ist die Konfiguration ziemlich einfach.

Launch.json

{
"version": "0.2.0",
"configurations": [

    {
        "name": "Run mocha by grunt",
        "type": "node",
        "program": "${workspaceRoot}/node_modules/grunt/bin/grunt",
        "stopOnEntry": false,
        "args": ["mochaTest"],
        "cwd": "${workspaceRoot}",
        "runtimeExecutable": null
    }
]}

Gruntfile.js

module.exports = function (grunt) {

grunt.initConfig({
    mochaTest: {
        test: {
            options: {
                reporter: 'spec'
            },
            src: ['test/**/*test.js']
        }
    }
});

grunt.loadNpmTasks('grunt-mocha-test');

grunt.registerTask('default', 'mochaTest');};

In VSCode Version 1.13.0 (macOS) ist es unter Konfigurationen -> integriert Mocha Tests.

Wenn Sie Babel verwenden oder Javascript-Dateien generieren und dennoch Haltepunkte in der Quelle platzieren, müssen Sie sicherstellen, dass diese aktiviert sourceMapsund definiert sind outFiles. Hier ist eine Beispielkonfiguration, die für mich funktioniert hat.

    {
        "name": "Mocha Test",
        "type": "node",
        "request": "launch",
        "program": "${workspaceRoot}/packages/api/node_modules/mocha/bin/_mocha",
        "cwd": "${workspaceRoot}/packages/api",
        "args": ["--colors", "--no-timeouts", "out/test"],
        "outFiles": ["${workspaceRoot}/packages/api/out/*"],
        "sourceMaps": true,
    },

Hinweis - Sie müssen Änderungen vornehmen outFiles, um alles einzuschließen, zu dem Sie möglicherweise einen Haltepunkt hinzufügen möchten. Dies kann in einem Monorepo und mehreren abhängigen Projekten langwieriger sein.

1) Gehe zu

.vscode

dann

launch.json

Datei

2) Fügen Sie die folgende Konfiguration in launch.json hinzu -

{
    "version": "0.2.0",
    "configurations": [
        {
            "type": "node",
            "request": "launch",
            "name": "Mocha Test",
            "cwd": "${workspaceRoot}",
            "runtimeExecutable": "${workspaceRoot}/*folder_path_containing_test*/node_modules/.bin/mocha",
            "windows": {
                "runtimeExecutable": "${workspaceRoot}/*folder_path_containing_test*/node_modules/.bin/mocha.cmd"
            },
            "runtimeArgs": [
                "--colors",
                "--recursive",
                "${workspaceRoot}/*folder_path_till_test*/tests"
            ],
            "internalConsoleOptions": "openOnSessionStart"
        },
        {
            "type": "node",
            "request": "launch",
            "name": "Launch Program",
            "program": "${workspaceRoot}/*folder_path_to_test*/app.js"
        }
    ]
}

3) Setzen Sie Haltepunkte in der Testdatei und drücken Sie dann F5

Bei Verwendung von TypeScript funktioniert die folgende Konfiguration für mich in Visual Studio Code 0.8.0 (tsc 1.5.3).

tsconfig.json

{
    "compilerOptions": {
        "module": "commonjs",
        "target": "es5",
        "noImplicitAny": false,
        "removeComments": true,
        "preserveConstEnums": true,
        "sourceMap": true,
        "outDir": "build",
        "declaration": false
    },
    "files": [
        "./src/index.ts",
        "./src/test/appTests.ts"
    ]
}

Hierbei ist zu beachten, dass Quellkarten generiert werden und das Ausgabeverzeichnis für js auf gesetzt ist build

launch.json

    {
        "name": "Attach",
        "type": "node",
        // TCP/IP address. Default is "localhost".
        "address": "localhost",
        // Port to attach to.
        "port": 5858,
        "sourceMaps": true,
        "outDir": "build"
    }

Bitte beachten Sie, dass dies sourceMapsauf trueund auf outDireingestellt istbuild

zu debuggen

1. Halte Haltepunkte in index.tsjede andere importierte Typoskriptdatei
2. Öffnen Sie ein Terminal und führen Sie Folgendes aus: mocha --debug-brk ./build/test/appTests.js
3. Führen Sie in VSC die Startkonfiguration "Anhängen" aus

Hier ist ein Beispiel für die Startkonfiguration (launch.json) von Microsoft, die mit Mocha zusammenarbeitet und die Verwendung des Debuggers ermöglicht.

Außerdem gibt es eine Beschreibung , wie die debug-brk Option zu verwenden.

Schließlich finden Sie hier eine alternative Version zum Debuggen von Code mit Mocha-Tests unter Verwendung der Datei task.json von VS Code und Gulp Task Runner.

Wenn Sie im Test eine gewisse Abhängigkeit haben, können Sie diese auch einfach anhängen.

Zum Beispiel verwende ich mongo-unit-helperauch Unit-Tests, die in die Datenbank integriert sind.

package.json Skript ist: mocha --recursive --require ./test/mongo-unit-helper.js --exit"

Mein launch.jsonsieht aus wie:

  "configurations": [
  {
  "type": "node",
  "request": "launch",
  "name": "Mocha Tests",
  "program": "${workspaceFolder}/node_modules/mocha/bin/_mocha",
  "args": [
    "-u",
    "tdd",
    "--timeout",
    "999999",
    "--colors",
    "--recursive",
    "--require",
    "${workspaceFolder}/test/mongo-unit-helper.js",
    "${workspaceFolder}/test/**/*.js",
  ],
  "internalConsoleOptions": "openOnSessionStart"
 }
]

Die Lösung besteht darin, --requireseparat argseinzutragen launch.json.

Einfachste Lösung

Fügen Sie der Datei launch.json im Ordner .vscode den folgenden Code hinzu:

{
            "name": "Unit tests",
            "type": "node",
            "request": "launch",
            "program": "${workspaceRoot}/node_modules/mocha/bin/_mocha",
            "args": [
            ],
        }

Möglicherweise möchten Sie jedoch auch ein Timeout-Argument hinzufügen:

 {
            "name": "Unit tests",
            "type": "node",
            "request": "launch",
            "program": "${workspaceRoot}/node_modules/mocha/bin/_mocha",
            "args": [
                "--timeout",
                "999999"
            ],
        }