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

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 faut configurer le launch.json, en définissant l'attribut de programme sur le fichier javascript à exécuter. Je ne sais pas trop comment faire cela pour Mocha.

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

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

À partir de 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 latérale: debug-brk est obsolète (pour toute personne avec Node> = Version 8 au moins).

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

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

--no-timeoutss'assure que vos tests n'expirent pas parce que vous vous êtes arrêté à un point d'arrêt, et --colorss'assure que Mocha produit des couleurs même s'il ne détecte pas que VS Code prend en charge les couleurs.

Une autre méthode consiste à utiliser l' --debug-brkoption de ligne de commande de mocha et le Attachparamètre de lancement par défaut du débogueur Visual Studio Code.

Explication plus approfondie suggérée (d'André)

Pour faire ça:

Exécutez mocha à partir de la ligne de commande à l'aide de cette commande:

mocha --debug-brk

Maintenant, dans VS Code, cliquez sur l'icône de débogage, puis sélectionnez Attachl'option à côté du bouton de démarrage. Ajoutez des points d'arrêt dans VS Code, puis cliquez sur Démarrer.

J'ai fait ce travail sur VSCode sur OS X 10.10. Remplacez simplement votre ./settings/launch.jsonfichier par ceci.

{
    "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 résumé ici .

Les valeurs clés que vous devez modifier sont program, qui doivent être définies sur l' _mochaexécutable et args, qui doivent être un tableau de vos fichiers de test.

La façon dont je l'ai fait fonctionner sur VS Code (1.8.2) sur Mac OS X est:

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

1. Aller au Debug > Add Configuration...menu
2. Sélectionnez l' Node.jsenvironnement
3. Sélectionnez une Mocha Testsoption dans la liste déroulante qui apparaît
4. Tapez le chemin de votre fichier de test comme dernier élément de la argspropriété
5. Ajouter un breakpoint
6. Cliquer sur Debug icône
7. Sélectionner Mocha Tests comme configuration
8. presse Start debugging bouton
9. :-)

J'ai trouvé un moyen de le faire que je classe comme une solution de contournement . J'attends de l'équipe Visual Studio Code qu'elle fournisse une solution plus définitive pour cela, mais en attendant, voici ce que j'ai fait:

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

2. J'ai créé une configuration de lancement qui exécutera le en ./settings/mocha.jstant que programet transmettra les fichiers / modèles de fichier que nous devons tester en tant qu'arguments:

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

   Exemple de launch.json complet

C'est donc l'équivalent de faire mocha test/unit/*.js test/unit/**/*.jset maintenant nous pouvons utiliser des points d'arrêt dans nos tests moka.

Si vous ajoutez la variable $ {file} à la fin de la liste des arguments, vous pouvez démarrer 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"
        }

Désolé d'avoir ajouté une autre réponse, mais aucune des précédentes n'a vraiment fonctionné pour moi à partir de VS Code 1.8.1 et du débogueur de nœud standard inclus. Voici la façon dont je l'ai résolu (avec les conseils des réponses précédentes ici et des documents de débogage officiels de VS Code Node.js ), il y a donc un débogage en un clic / pression sur une touche:

• Assurez-vous que mocha est installé en tant que devDependencyin packages.json:"devDependencies": { "mocha": "^3.2", ... }
• Exécutez npm installdans le répertoire de votre package.jsonpour vous assurer que mocha est maintenant installé dansnode_modules/
• Ouvrez .vscode/launch.json(ou dans VS Code, appuyez sur F1, commencez à taper «lancer» et sélectionnez «Déboguer: Ouvrir launch.json»)
• Cliquez sur le bouton bleu "Ajouter une configuration" en bas à droite (ou copiez et collez simplement l'un de vos autres); cette étape est facultative ... je veux dire, vous pouvez réutiliser une configuration existante. Mais je suggère d'en ajouter un pour éviter toute confusion.
• Modifiez les éléments suivants dans votre launch.json , puis choisissez le nouveau nom de configuration dans la fenêtre de débogage de VS Code et cliquez sur la flèche verte pour commencer le débogage de votre nœud + tests mocha!

Dans la nouvelle configuration de 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 le modèle test/**/*.js fonctionnera là où vous placez vos tests. Modifiez le cas échéant.

N'hésitez pas à changer de port tant que vous le changez dans les deux argsport propriétés et pour correspondre.

La principale différence pour moi était de s'assurer que mocha était présent node_modules, d'utiliser programpour pointer vers l'exécutable et d' argsavoir besoindebug-brk=x pointer vers le port spécifié dans port. Le reste de ce qui précède rend les choses plus jolies et plus faciles.

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

Astuce: Le package.jsonpeut inclure une scriptsbalise qui lance également mocha avec quelque chose comme "test": "./node_modules/.bin/mocha", mais il n'est pas utilisé par VS Code - à la place, il est utilisé lorsquenpm test est exécuté sur la ligne de commande. Celui-ci m'a un peu dérouté. Notez-le ici au cas où les autres seraient également 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 "Tests Mocha Node.js" qui aident à simplifier la plupart de ce qui précède. Vous devez toujours vous assurer que mocha est dans votre node_moduleset vous devrez peut-être mettre à jour le cwdet le dernier runtimeArgs(qui est le modèle pour trouver vos tests) pour pointer vers les chemins appropriés. Mais une fois que vous avez défini ces deux propriétés, cela devrait fonctionner à peu près à partir de là.

dans le 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 devez configurer la version du nœud, ajoutez simplement un runtimeExecutablechamp comme celui-ci

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

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

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

Cela fonctionne pour moi sur une machine Windows 7. J'ai installé mocha dans le monde entier, mais cette configuration pointe vers l'installation du projet pour éviter d'avoir besoin d'un chemin de profil utilisateur (qui, d'ailleurs, j'ai essayé d'utiliser la variable% USERPROFILE% sans succès). Je suis maintenant en mesure de 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"
    }

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

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

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 sourceMapset 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 outFilespour inclure tout ce à quoi vous pourriez vouloir ajouter un point d'arrêt. Cela peut être plus fastidieux dans un monorepo et plusieurs projets dépendants.

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 de test, puis appuyez sur F5

Lors de l'utilisation de TypeScript, la configuration suivante fonctionne pour moi dans 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"
    ]
}

Les choses importantes à noter ici sont que les cartes source sont générées et que le répertoire de sortie pour le 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"
    }

S'il vous plaît noter que sourceMapsest réglé sur trueet que l' outDirest réglébuild

déboguer

1. Collez les points d'arrêt dans index.tstout autre fichier dactylographié importé
2. Ouvrez un terminal et exécutez: mocha --debug-brk ./build/test/appTests.js
3. Depuis VSC, exécutez la configuration de lancement 'Attach'

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

Il existe également une description de l'utilisation de l'option --debug-brk.

Enfin, voici une version alternative de la façon de déboguer du code avec des tests Mocha en utilisant le fichier tasks.json de VS Code et Gulp task runner.

Si vous avez une dépendance dans le test, il est également facile de l'attacher.

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

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

Mon launch.jsonressemble à:

  "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 --requireséparément argsdans launch.json.

La solution la plus simple

Ajoutez le code suivant au launch.json dans le dossier .vscode:

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

Vous voudrez peut-être cependant ajouter un argument de délai d'expiration:

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