it-swarm.com.de

Mokka-Haltepunkte mithilfe von Visual Studio-Code

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

Normalerweise muss man beim Debuggen von Code die Datei launch.json konfigurieren und das Programmattribut auf die auszuführende Javascript-Datei setzen. Ich bin mir nicht sicher, wie ich das für Mocha machen soll.

87

Wussten Sie, dass Sie einfach in Ihre Startkonfiguration gehen, den Cursor hinter oder zwischen Ihre anderen Konfigurationen setzen und drücken ctrl-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 eine ältere, inzwischen veraltete Version, die aus verschiedenen einstellungsbedingten Gründen nicht mehr funktioniert hat.)

enter image description here

Ab VSCode 1.21.1 (März 2018) ergibt sich daraus:

{
  "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
    }
}

Als Randnotiz: debug-brkwird korrigiert (für jeden mit Node> = mindestens Version 8).

71
Frank Nocke

Wenn Sie --debug-brk + Nicht verwenden möchten, fügen Sie einen absoluten Pfad zu Ihrer globalen Mokka-Installation hinzu oder geben Sie ihn an (dies bremst, wenn Sie Ihren launch.json unter Versionskontrolle halten und mehrere Entwickler auf verschiedenen Computern haben) Mokka als Dev-Abhängigkeit und füge dies zu deiner 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 Unterstützung für das Debuggen in Ihren Tests, indem Sie einfach F5 drücken.

--no-timeouts Stellt sicher, dass Ihre Tests keine Zeitüberschreitung verursachen, da Sie an einem Haltepunkt angehalten haben, und --colors Stellt sicher, dass Mocha Farben ausgibt, obwohl nicht erkannt wird, dass VS Code Farben unterstützt.

67
felixfbecker

Eine andere Möglichkeit ist die Verwendung von --debug-brk Befehlszeilenoption von Mocha und die Standardstarteinstellung von Attach des Visual Studio Code-Debuggers.


Vorgeschlagene tiefere Erklärung (von André)

Um dies zu tun:

Führen Sie Mocha über die Befehlszeile mit folgendem Befehl aus:

mocha --debug-brk

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

42
Wolfgang Kluge

Ich habe diese Arbeit an VSCode unter OS X 10.10 gemacht. Ersetzen Sie einfach Ihr ./settings/launch.json Datei mit diesem.

{
    "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 Gist verfügbar hier .

Die Schlüsselwerte, die Sie ändern müssen, sind program, die auf _mocha executable und args, die ein Array Ihrer Testdateien sein sollten.

23
GPX

Die Art und Weise, wie ich es für VS Code (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 npm modules installiert sein.

10
mikebz
  1. Gehe zu Debug > Add Configuration... Speisekarte
  2. Wählen Node.js Umgebung
  3. Wählen Mocha Tests Option aus der angezeigten Dropdown-Liste
  4. Geben Sie den Pfad Ihrer Testdatei als letztes Element der Eigenschaft args ein
  5. breakpoint hinzufügen
  6. Klicken Sie auf das Symbol Debug
  7. Wählen Mocha Tests als Konfiguration
  8. Drücken Sie Start debugging Taste
  9. :-)
7
Yas

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

  1. Ich habe eine ./settings/mocha.js - Datei erstellt, in der mocha programmgesteuert Argumente als Liste der auszuführenden Dateien übergibt. Sie können die vollständige Datei sehen hier ;
  2. Ich habe eine Startkonfiguration erstellt, die den ./settings/mocha.js Als program ausführt und 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 launch.json-Beispiel

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

6
Dário

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

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

fügen Sie in der Datei launch.json unten eine 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 das Feld runtimeExecutable 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"
    },

Es tut mir leid, dass ich noch eine Antwort hinzugefügt habe, aber keine der vorherigen hat für mich mit VS Code 1.8.1 und dem darin enthaltenen Standard Node Debugger ganz funktioniert. So habe ich es gelöst ( Unter Anleitung der vorherigen Antworten hier und der offiziellen Anleitung VS Code Node.js Debugging docs) gibt es also ein Klick-/Tastendruck-Debugging:

  • Stellen Sie sicher, dass Mokka als devDependency in packages.json Installiert ist: "devDependencies": { "mocha": "^3.2", ... }
  • Führen Sie npm install Im Verzeichnis Ihres package.json Aus, um sicherzustellen, dass Mocha jetzt in node_modules/ Installiert ist.
  • Öffnen Sie .vscode/launch.json (Oder drücken Sie in 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 einen Ihrer anderen). Dieser Schritt ist optional. Ich meine, Sie können eine vorhandene Konfiguration wiederverwenden. Ich schlage jedoch vor, einen hinzuzufügen, um die Verwirrung zu verringern.
  • Ändern Sie Folgendes in Ihrem launch.json, Wählen Sie dann den neuen Konfigurationsnamen im Debug-Fenster in VS Code aus und klicken Sie auf den grünen Pfeil, um mit dem Debuggen Ihrer Node + Mocha-Tests zu beginnen!

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 test/**/*.js Dort funktioniert, wo Sie Ihre Tests durchführen. Bei Bedarf ändern.

Sie können den Port jederzeit ändern, solange Sie ihn in den entsprechenden Eigenschaften args und port ändern.

Der Hauptunterschied für mich bestand darin, sicherzustellen, dass Mokka in node_modules Enthalten war, indem ich program verwendete, um auf die ausführbare Datei zu verweisen, und argsdebug-brk=x, Um auf den angegebenen Port zu verweisen in port. Der Rest des oben Gesagten macht die Dinge einfach schöner und einfacher.

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

Tipp: Das package.json - Tag kann ein scripts -Tag enthalten, das auch Mokka mit so etwas wie "test": "./node_modules/.bin/mocha" Startet, aber nicht von VS Code verwendet wird - stattdessen wird es verwendet, wenn npm test Wird in der Befehlszeile ausgeführt. Dieser hat mich ein bisschen verwirrt. Beachten Sie dies hier für den Fall, dass andere ebenfalls verwirrt werden.

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

2
Jon Adams

Wenn Sie Babel verwenden oder Javascript-Dateien generieren und dennoch Haltepunkte in der Quelle platzieren, müssen Sie sourceMaps aktivieren und outFiles definieren. 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 outFiles ändern, um alle Elemente einzuschließen, denen Sie möglicherweise einen Haltepunkt hinzufügen möchten. Dies kann in einem Monorepo-Projekt und in mehreren abhängigen Projekten mühsamer sein.

1
ubershmekel

Dies funktioniert für mich auf einem Windows 7-Computer. Ich habe Mocha 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"
    }
1
rspring1975

Für diejenigen, die grunzen oder schlucken, 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');};
1

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

1
Obsidian

Für alle, die Windows verwenden. Wenn Sie Mocha global installiert haben, funktionierte es für mich, 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"
1
JayChase

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"
    ]
}

Hier ist zu beachten, dass Quellzuordnungen generiert werden und das Ausgabeverzeichnis für das js auf build festgelegt ist.

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 sourceMaps auf true gesetzt ist und dass outDir auf build gesetzt ist

zum Debuggen

  1. Halten Sie Haltepunkte in index.ts Jeder anderen importierten TypeScript-Datei
  2. Öffne ein Terminal und starte: mocha --debug-brk ./build/test/appTests.js
  3. Führen Sie in VSC die Startkonfiguration "Anhängen" aus
0
Bruno Grieder

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

Zum Beispiel verwende ich mongo-unit-helper, um auch Komponententests in die Datenbank zu integrieren.

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

Mein launch.json sieht 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 ist --require separat in args in launch.json.

0
airen

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

Außerdem gibt es eine Beschreibung Anleitung zur Verwendung der Option --debug-brk.

Schließlich ist hier ein alternative Version zum Debuggen von Code mit Mocha-Tests Verwenden der Datei tasks.json von VS Code und Gulp Task Runner.

0
javaeeeee

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) Setze Haltepunkte in der Testdatei und drücke dann F5

0
MERLIN THOMAS