web-dev-qa-db-fra.com

Points d'arrêt Mocha à l'aide de code Visual Studio

Est-il possible d'ajouter des points d'arrêt à des tests Mocha à l'aide de Visual Studio Code?

Normalement, lors du débogage du code, il est nécessaire de configurer le fichier launch.json, en définissant l'attribut du programme sur le fichier javascript à exécuter. Je ne sais pas comment faire cela pour Mocha cependant.

node.jsvisual-studio-codemochatdd
87
André Vermeulen

Saviez-vous que vous allez juste dans votre configuration de lancement, placez votre curseur après ou entre vos autres configurations et appuyez sur ctrl-space obtenir une configuration actuelle de mocha valide générée automatiquement?

Ce qui fonctionne parfaitement pour moi. Y compris les arrêts aux points d'arrêt. (J'avais aussi un précédent, maintenant obsolète, qui ne l'était plus pour diverses raisons liées au réglage.)

enter image description here

À partir du VSCode 1.21.1 (mars 2018), cela donne:

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

Sur une note de côté: debug-brkest déprécié (pour toute personne avec Node> = Version 8 au moins).

71
Frank Nocke

Si vous ne voulez pas utiliser --debug-brk + Attachez ou indiquez un chemin absolu à votre installation globale de mocha (ce qui ralentira si vous maintenez votre launch.json sous contrôle de version et si vous avez plusieurs développeurs sur différentes machines), installez mocha en tant que dépendance de dev et ajoutez-le à votre lancement. 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"
  }
}

Prise en charge complète du débogage dans vos tests en appuyant simplement sur F5.

--no-timeouts s'assure que vos tests n'expirent pas, car vous vous êtes arrêté à un point d'arrêt, et --colors s'assure que Mocha génère des couleurs même s'il ne détecte pas que VS Code prend en charge les couleurs.

67
felixfbecker

Une autre façon consiste à utiliser le --debug-brk option de ligne de commande de mocha et le paramètre par défaut Attach de lancement du débogueur de code Visual Studio.

Explication plus profonde suggérée (par André)

Pour faire ça:

Exécutez mocha à partir de la ligne de commande en utilisant cette commande:

mocha --debug-brk

Maintenant, dans VS Code, cliquez sur l’icône Debug, puis sélectionnez Attach dans l’option située en regard du bouton de démarrage. Ajoutez des points d'arrêt dans VS Code, puis cliquez sur Démarrer.

42
Wolfgang Kluge

J'ai fait ce travail sur VSCode sur OS X 10.10. Il suffit de remplacer votre ./settings/launch.json fichier avec cela.

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

Il est également disponible sous forme de Gist here .

Les valeurs de clé que vous devez modifier sont program, qui devrait être défini sur _mocha exécutable, et args, qui devrait être un tableau de vos fichiers de test.

23
GPX

Voici comment je fonctionne sur VS Code (1.8.2) sur 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 doit être installé dans le répertoire des modules npm.

10
mikebz
  1. Aller à Debug > Add Configuration... menu
  2. Sélectionnez Node.js environnement
  3. Sélectionnez Mocha Tests option dans la liste déroulante
  4. Tapez le chemin de votre fichier de test comme dernier élément de la propriété args
  5. Ajouter un breakpoint
  6. Cliquez sur l'icône Debug
  7. Sélectionnez Mocha Tests comme configuration
  8. Presse Start debugging bouton
  9. :-)
7
Yas

J'ai trouvé un moyen de le faire que je qualifie de solution de contournement . Je m'attends à ce que l'équipe de Visual Studio Code fournisse une solution plus définitive à cet égard, mais en attendant, voici ce que j'ai fait:

  1. J'ai créé un ./settings/mocha.js fichier qui exécute mocha en passant des arguments par programme en tant que liste de fichiers à exécuter. Vous pouvez voir le fichier complet ici ;

  2. J'ai créé une configuration de lancement qui exécutera le ./settings/mocha.js en tant que program et transmet les fichiers/modèles de fichiers que nous devons tester comme arguments:

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

    Exemple complet avec launch.json

Donc, cela équivaut à faire mocha test/unit/*.js test/unit/**/*.js et maintenant nous pouvons utiliser des points d'arrêt dans nos tests de moka.

6
Dário

Si vous ajoutez la variable $ {fichier} à la fin de la liste des arguments, vous pouvez lancer le débogage directement à partir du fichier que vous avez ouvert:

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

dans le fichier launch.json, ajoutez 1 configuration supplémentaire ci-dessous

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

si vous avez besoin de configurer la version du noeud, ajoutez simplement le champ runtimeExecutable comme ceci

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

Désolé d’ajouter encore une réponse, mais aucune des réponses précédentes n’a fonctionné pour moi à partir du code VS 1.8.1 et du standard Node inclus dans le débogueur. Voici comment je l’ai résolu ( avec les conseils des réponses précédentes ici et de l’officiel Débogage VS Code = .js ) afin qu’il y ait un débogage en un clic/pression:

  • Assurez-vous que mocha est installé en tant que devDependency dans packages.json: "devDependencies": { "mocha": "^3.2", ... }
  • Exécutez npm install Dans le répertoire de votre package.json Pour vous assurer que mocha est maintenant installé dans node_modules/
  • Ouvrez .vscode/launch.json (Ou dans VS Code, appuyez sur F1, commencez à taper "launch" et sélectionnez "Debug: Open launch.json")
  • Cliquez sur le bouton bleu "Ajouter une configuration" en bas à droite (ou copiez et collez l'un de vos autres); cette étape est facultative ... Je veux dire, vous pouvez réutiliser une configuration existante. Mais je suggère d'ajouter un pour le garder moins déroutant.
  • Modifiez les éléments suivants dans votre launch.json, Puis choisissez le nouveau nom de configuration dans la fenêtre de débogage dans VS Code et cliquez sur la flèche verte pour lancer le débogage de vos tests noeud + moka!

Dans la nouvelle configuration dans 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
}, ...]

Cela suppose que le modèle test/**/*.js Fonctionnera pour l'endroit où vous placez vos tests. Changer selon les besoins.

N'hésitez pas à modifier le port tant que vous le modifiez dans les propriétés args et port correspondantes.

La principale différence pour moi était de m'assurer que mocha était dans node_modules, En utilisant program pour désigner l'exécutable, et args nécessitant que debug-brk=x Pointant vers le port spécifié dans port. Le reste de ce qui précède rend les choses plus belles et plus faciles.

C’est à vous et à votre équipe de placer ou non .vscode/launch.json Dans le référentiel. C'est un fichier uniquement IDE, mais toute votre équipe pourrait l'utiliser comme ceci, pas de problème, car tous les chemins et installations sont relatifs et explicites.

Conseil: Le package.json Peut inclure une balise scripts qui lance également le moka avec quelque chose comme "test": "./node_modules/.bin/mocha", Mais il n’est pas utilisé par VS Code. Il est utilisé quand npm test Est exécuté sur la ligne de commande. Celui-ci m'a confondu un peu. Notez-le ici au cas où d'autres seraient confus.

EDIT: VS Code 1.9.0 a ajouté une option "Ajouter une configuration" dans la liste déroulante de configuration de débogage, et vous pouvez choisir "Node.js Mocha Tests" pour simplifier la plupart des opérations ci-dessus. Vous devez toujours vous assurer que le moka est dans votre node_modules Et que vous devrez peut-être mettre à jour le cwd et le dernier runtimeArgs (qui est le motif pour trouver vos tests) pour pointer vers le chemins appropriés. Mais une fois que vous définissez ces deux propriétés, cela devrait fonctionner à partir de là.

2
Jon Adams

Lorsque vous utilisez Babel ou que vous générez des fichiers javascript tout en plaçant des points d'arrêt dans la source, vous devez vous assurer d'activer sourceMaps et de définir outFiles. Voici un exemple de configuration qui a fonctionné pour moi.

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

Remarque - vous devrez modifier outFiles pour inclure tout ce à quoi vous souhaitez ajouter un point d'arrêt. Cela peut être plus fastidieux dans un monorepo et plusieurs projets dépendants.

1
ubershmekel

Cela fonctionne sur une machine Windows 7. J'ai mocha installé globalement, mais cette configuration pointe vers l'installation du projet pour éviter le besoin d'un chemin de profil utilisateur (qui, d'ailleurs, j'ai essayé d'utiliser la variable% USERPROFILE% sans succès). Je peux maintenant définir des points d'arrêt dans mes tests de moka. 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

Pour ceux qui utilisent grunt ou gulp, la configuration est assez simple.

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
Leandro Rodrigues

Dans VSCode version 1.13.0 (macOS), ils l'ont intégré dans les configurations -> Mocha Tests.

1
Obsidian

Pour toute personne utilisant Windows. Si vous avez installé mocha globalement, configurer le programme sur le chemin suivant a fonctionné pour moi (échangez avec votre nom d'utilisateur).

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

Lorsque vous utilisez TypeScript, la configuration suivante fonctionne pour moi dans le code Visual Studio 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"
    ]
}

Il est important de noter ici que les cartes source sont générées et que le répertoire de sortie du fichier js est défini sur 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"
    }

Veuillez noter que sourceMaps est défini sur true et que le outDir est défini sur build.

à déboguer

  1. Coller des points d'arrêt dans index.ts tout autre fichier TypeScript importé
  2. Ouvrez un terminal et lancez: mocha --debug-brk ./build/test/appTests.js
  3. Depuis VSC, lancez la configuration de lancement 'Attach'
0
Bruno Grieder

Si vous avez des dépendances dans le test, il est également facile de les joindre.

Par exemple, j'utilise mongo-unit-helper avoir également des tests unitaires intégrés à Database.

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

Ma launch.json ressemble à:

  "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 solution est de mettre --require séparément dans args dans launch.json.

0
airen

Voici un exemple de configuration de lancement (launch.json) de Microsoft, qui fonctionne avec Mocha et permet d'utiliser le débogueur.

De plus, il existe description comment utiliser l'option --debug-brk.

Enfin, voici une version alternative de la procédure de débogage du code avec les tests Mocha utilisant le fichier tasks.json de VS Code et du gestionnaire de tâches Gulp.

0
javaeeeee

1) Aller à

.vscode

puis

launch.json

fichier

2) Ajoutez la configuration suivante dans 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) Définissez les points d'arrêt dans le fichier test, puis appuyez sur F5

0
MERLIN THOMAS