Punti di interruzione Mocha utilizzando Visual Studio Code

È possibile aggiungere punti di interruzione a quelli dei test Mocha utilizzando Visual Studio Code?

Normalmente durante il debug del codice è necessario configurare launch.json, impostando l'attributo del programma sul file javascript da eseguire. Non sono sicuro di come farlo per Mocha però.

Lo sapevi che devi semplicemente entrare nella configurazione di avvio, posizionare il cursore dopo o tra le altre configurazioni e premere ctrl- spaceper ottenere una configurazione mocha valida e corrente generata automaticamente?

Che funziona perfettamente bene per me. Compreso l'arresto ai punti di interruzione. (Ne avevo anche uno precedente, ora obsoleto, che non esisteva più per vari motivi legati all'impostazione.)

A partire da VSCode 1.21.1 (marzo 2018) questo produce:

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

Nota a debug-brk margine : è deprecato (per chiunque abbia Node> = Versione 8 almeno).

Se non vuoi usare --debug-brk+ Allega o indicare un percorso assoluto alla tua installazione globale di mocha (che si interromperà se mantieni il tuo launch.json sotto il controllo della versione e hai più sviluppatori su macchine diverse), installa mocha come dipendenza dev e aggiungilo al tuo launch.json:

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

Pieno supporto per il debug nei test premendo semplicemente F5.

--no-timeoutssi assicura che i tuoi test non scadano perché ti sei fermato a un punto di interruzione e si --colorsassicura che Mocha produca i colori anche se non rileva che VS Code supporta i colori.

Un altro modo consiste nell'usare l' --debug-brkopzione della riga di comando di mocha e l'impostazione di Attachavvio predefinita del debugger di Visual Studio Code.

Spiegazione più approfondita suggerita (da André)

Per fare questo:

Esegui mocha dalla riga di comando usando questo comando:

mocha --debug-brk

Ora in VS Code fai clic sull'icona Debug, quindi seleziona Attachdall'opzione accanto al pulsante di avvio. Aggiungi punti di interruzione in VS Code e quindi fai clic su Avvia.

Ho fatto questo lavoro su VSCode su OS X 10.10. Basta sostituire il ./settings/launch.jsonfile con questo.

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

È anche disponibile come sintesi qui .

I valori chiave che devi modificare sono program, che dovrebbe essere impostato _mochasull'eseguibile e args, che dovrebbe essere un array dei tuoi file di prova.

Il modo in cui l'ho fatto funzionare su VS Code (1.8.2) su Mac OS X è:

{
    "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 deve essere installato nella directory dei moduli npm.

1. Vai al Debug > Add Configuration...menu
2. Seleziona l' Node.jsambiente
3. Seleziona l' Mocha Testsopzione dall'elenco a discesa visualizzato
4. Digita il percorso del tuo file di prova come ultimo elemento della argsproprietà
5. Aggiungere un breakpoint
6. Fare clic Debugsull'icona
7. Seleziona Mocha Testscome configurazione
8. Premere il Start debuggingpulsante
9. :-)

Ho trovato un modo per farlo che classifico come soluzione alternativa . Mi aspetto che il team di Visual Studio Code fornisca una soluzione più definitiva per questo, ma nel frattempo questo è quello che ho fatto:

1. Ho creato un ./settings/mocha.jsfile che esegue mocha passando in modo programmatico argomenti come un elenco di file da eseguire. Puoi vedere il file completo qui ;

2. Ho creato una configurazione di avvio che eseguirà ./settings/mocha.jscome programe passerà i file / modelli di file che dobbiamo testare come argomenti:

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

   Esempio completo di launch.json

Quindi questo è l'equivalente di fare mocha test/unit/*.js test/unit/**/*.jse ora possiamo usare i punti di interruzione nei nostri test mocha.

Se aggiungi la variabile $ {file} alla fine dell'elenco degli argomenti puoi avviare il debug direttamente dal file che hai aperto:

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

Ci scusiamo per l'aggiunta di un'altra risposta, ma nessuna delle precedenti ha funzionato abbastanza per me a partire da VS Code 1.8.1 e il debugger Node standard incluso in esso. Ecco il modo in cui l'ho risolto (con la guida dalle risposte precedenti qui e dai documenti ufficiali di debug di VS Code Node.js ) quindi c'è un clic / debug di pressione dei tasti:

• Assicurati che mocha sia installato come devDependencyin packages.json:"devDependencies": { "mocha": "^3.2", ... }
• Esegui npm installnella directory del tuo package.jsonper assicurarti che mocha sia ora installato innode_modules/
• Apri .vscode/launch.json(o in VS Code, premi F1, inizia a digitare "launch" e seleziona "Debug: Open launch.json")
• Fare clic sul pulsante blu "Aggiungi configurazione" in basso a destra (o semplicemente copiare e incollare uno degli altri); questo passaggio è facoltativo ... Voglio dire, puoi riutilizzare una configurazione esistente. Ma suggerisco di aggiungerne uno per mantenerlo meno confuso.
• Cambia quanto segue nel tuo launch.json, quindi scegli il nuovo nome di configurazione nella finestra di debug in VS Code e fai clic sulla freccia verde per avviare il debug dei tuoi test node + mocha!

Nella nuova configurazione 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
}, ...]

Ciò presuppone che il modello test/**/*.jsfunzioni per dove metti i tuoi test. Modificare come appropriato.

Sentiti libero di cambiare la porta fintanto che la cambi in entrambe le proprietà argse portin modo che corrisponda.

Le differenze chiave per me erano assicurarmi che mocha fosse dentro node_modules, usare programper puntare all'eseguibile e argsdover debug-brk=xpuntare alla porta specificata in port. Il resto di quanto sopra rende le cose più belle e più facili.

Sta a te e al tuo team decidere se inserire .vscode/launch.jsono meno il repository. È un file solo IDE, ma tutto il tuo team potrebbe usarlo in questo modo, nessun problema, poiché tutti i percorsi e le installazioni sono relativi ed espliciti.

Suggerimento: package.jsonpuò includere un scriptstag che avvia anche mocha con qualcosa di simile "test": "./node_modules/.bin/mocha", ma non viene utilizzato da VS Code, ma viene utilizzato quando npm testviene eseguito dalla riga di comando. Questo mi ha confuso per un po '. Notandolo qui nel caso anche gli altri si confondano.

EDIT: VS Code 1.9.0 ha aggiunto un'opzione "Aggiungi configurazione" nel menu a discesa della configurazione di debug e puoi scegliere "Node.js Mocha Tests" che aiuta a semplificare la maggior parte di quanto sopra. Devi ancora assicurarti che mocha sia nel tuo node_modulese potrebbe essere necessario aggiornare cwde last runtimeArgs(che è il modello per trovare i tuoi test) per puntare ai percorsi appropriati. Ma una volta impostate queste due proprietà, dovrebbe funzionare più o meno da lì.

in launch.json, aggiungi un'altra configurazione di seguito

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

se devi configurare la versione del nodo, aggiungi semplicemente un runtimeExecutablecampo come questo

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

Per chiunque utilizzi Windows. Se hai installato mocha a livello globale, l'impostazione del programma sul seguente percorso ha funzionato per me (scambia il tuo nome utente).

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

Funziona su una macchina Windows 7. Ho installato mocha a livello globale, ma questa configurazione punta all'installazione del progetto per evitare la necessità di un percorso del profilo utente (che btw, ho provato a utilizzare la variabile% USERPROFILE% senza successo). Ora sono in grado di impostare i punti di interruzione nei miei test di moka. Sìì!

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

Per coloro che utilizzano grunt o gulp, la configurazione è piuttosto semplice.

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');};

Nella versione VSCode 1.13.0 (macOS), lo hanno integrato nelle configurazioni -> Mocha Tests.

Quando si utilizza Babel o si generano file javascript ma si inseriscono punti di interruzione nella sorgente, è necessario assicurarsi di abilitare sourceMapse definire outFiles. Ecco un esempio di configurazione che ha funzionato per me.

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

Nota: dovrai modificare outFilesper includere tutto ciò a cui potresti voler aggiungere un punto di interruzione. Questo può essere più noioso quando in un monorepo e più progetti dipendenti.

1) Vai a

.vscode

poi

launch.json

file

2) Aggiungi la seguente configurazione in launch.json -

{
    "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) Impostare i punti di interruzione nel file di test e quindi premere F5

Quando si utilizza TypeScript, la seguente configurazione funziona per me 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"
    ]
}

La cosa importante da notare qui è che le mappe sorgente vengono generate e che la directory di output per js è impostata su 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"
    }

Si noti che sourceMapsè impostato su truee che outDirè impostato subuild

eseguire il debug

1. Incolla i punti di interruzione in index.tsqualsiasi altro file dattiloscritto importato
2. Apri un terminale ed esegui: mocha --debug-brk ./build/test/appTests.js
3. Da VSC, esegui la configurazione di avvio "Allega"

Ecco un esempio di configurazione di avvio (launch.json) di Microsoft, che funziona con Mocha e consente di utilizzare il debugger.

Inoltre, c'è una descrizione di come usare l'opzione --debug-brk.

Infine, ecco una versione alternativa di come eseguire il debug del codice con i test Mocha utilizzando il file tasks.json di VS Code e il task runner Gulp.

Se hai qualche dipendenza nel test, è anche facile allegarlo.

Ad esempio, sto utilizzando mongo-unit-helperanche unit test integrati con Database.

package.json lo script è: mocha --recursive --require ./test/mongo-unit-helper.js --exit"

Il mio launch.jsonaspetto è:

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

La soluzione è inserire --requireseparatamente argsin launch.json.

La soluzione più semplice

Aggiungi il seguente codice a launch.json all'interno della cartella .vscode:

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

Tuttavia, potresti voler aggiungere anche un argomento di timeout:

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