Puntos de interrupción de Mocha usando Visual Studio Code

¿Es posible agregar puntos de interrupción a las pruebas de Mocha usando Visual Studio Code?

Normalmente, cuando se depura el código, es necesario configurar launch.json, estableciendo el atributo del programa en el archivo javascript a ejecutar. Sin embargo, no estoy seguro de cómo hacer esto para Mocha.

¿Sabía que solo debe ingresar a su configuración de inicio, colocar el cursor después o entre sus otras configuraciones y presionar ctrl- spacepara obtener una configuración mocha válida y actual generada automáticamente?

Lo que funciona perfectamente bien para mí. Incluyendo detenerse en puntos de interrupción. (También tuve uno anterior, ahora desactualizado, que ya no funcionaba por varias razones relacionadas con el entorno).

A partir de VSCode 1.21.1 (marzo de 2018) esto 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
    }
}

En una nota al debug-brk margen : está desaprobado (para cualquiera con Node> = Versión 8 al menos).

Si no desea usar --debug-brk+ Adjuntar o establecer una ruta absoluta a su instalación global de mocha (que se detendrá si mantiene su launch.json bajo control de versiones y tiene múltiples desarrolladores en diferentes máquinas), instale mocha como una dependencia de desarrollo y agregue esto a su 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"
  }
}

Soporte completo de depuración en sus pruebas con solo presionar F5.

--no-timeoutsse asegura de que sus pruebas no agoten el tiempo de espera porque se detuvo en un punto de interrupción, y --colorsse asegura de que Mocha genere colores aunque no detecte que VS Code admite colores.

Otra forma es usar la --debug-brkopción de línea de comando de mocha y la configuración de Attachinicio predeterminada del depurador de código de Visual Studio.

Explicación más profunda sugerida (de André)

Para hacer esto:

Ejecute mocha desde la línea de comando usando este comando:

mocha --debug-brk

Ahora, en VS Code, haga clic en el ícono Depurar, luego seleccione Attachde la opción al lado del botón de inicio. Agregue puntos de interrupción en VS Code y luego haga clic en iniciar.

Hice que esto funcione en VSCode en OS X 10.10. Simplemente reemplace su ./settings/launch.jsonarchivo con esto.

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

También está disponible como resumen aquí .

Los valores clave que necesita cambiar son program, que deben establecerse en el _mochaejecutable y args, que deben ser una matriz de sus archivos de prueba.

La forma en que lo hice funcionar en VS Code (1.8.2) en Mac OS X es:

{
    "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 debe instalarse en el directorio de módulos npm.

1. Ir al Debug > Add Configuration...menú
2. Seleccionar Node.jsentorno
3. Seleccione la Mocha Testsopción de la lista desplegable que aparece
4. Escriba la ruta de su archivo de prueba como último elemento de la argspropiedad
5. Agrega un breakpoint
6. Haga clic en el Debugicono
7. Seleccionar Mocha Testscomo configuración
8. Presione el Start debuggingbotón
9. :-)

He descubierto una forma de hacer esto que clasifico como una solución alternativa . Espero que el equipo de Visual Studio Code proporcione una solución más definitiva para esto, pero mientras tanto esto es lo que he hecho:

1. He creado un ./settings/mocha.jsarchivo que ejecuta mocha programáticamente pasando argumentos como una lista de archivos que se ejecutarán. Puedes ver el archivo completo aquí ;

2. He creado una configuración de inicio que ejecutará ./settings/mocha.jscomo programy pasará los archivos / patrones de archivo que necesitamos probar como argumentos:

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

   Ejemplo completo de launch.json

Entonces esto es el equivalente a hacer mocha test/unit/*.js test/unit/**/*.jsy ahora podemos usar puntos de interrupción en nuestras pruebas de moca.

Si agrega la variable $ {file} al final de la lista de argumentos, puede comenzar a depurar directamente desde el archivo que tiene abierto:

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

Perdón por agregar otra respuesta, pero ninguna de las anteriores funcionó para mí a partir de VS Code 1.8.1 y el depurador de nodo estándar incluido en él. Esta es la forma en que lo resolví (con la guía de las respuestas anteriores aquí y de los documentos oficiales de depuración de VS Code Node.js ), por lo que hay una depuración de clic / pulsación de tecla:

• Asegúrese de que mocha esté instalado como devDependencyen packages.json:"devDependencies": { "mocha": "^3.2", ... }
• Ejecute npm installen el directorio de su package.jsonpara asegurarse de que mocha ahora esté instalado ennode_modules/
• Abra .vscode/launch.json(o en VS Code, presione F1, comience a escribir "iniciar" y seleccione "Depurar: Abrir launch.json")
• Haga clic en el botón azul "Agregar configuración" en la parte inferior derecha (o simplemente copie y pegue uno de los otros); este paso es opcional ... quiero decir, puede reutilizar una configuración existente. Pero sugiero agregar uno para que sea menos confuso.
• Cambie lo siguiente en su launch.json, luego elija el nuevo nombre de configuración en la ventana de depuración en VS Code y haga clic en la flecha verde para comenzar a depurar sus pruebas de nodo + mocha.

En la nueva configuración 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
}, ...]

Esto supone que el patrón test/**/*.jsfuncionará para el lugar donde coloque sus pruebas. Cambie según corresponda.

Siéntase libre de cambiar el puerto siempre que lo cambie en las propiedades argsy portpara que coincida.

Las diferencias clave para mí fueron asegurarme de que mocha estuviera adentro node_modules, usar programpara apuntar al ejecutable y argsnecesitar debug-brk=xapuntar al puerto especificado en port. El resto de lo anterior solo hace que las cosas sean más bonitas y fáciles.

Depende de usted y de su equipo si coloca .vscode/launch.jsonel repositorio o no. Es un archivo solo IDE, pero todo su equipo podría usarlo así, no hay problema, ya que todas las rutas e instalaciones son relativas y explícitas.

Sugerencia: package.jsonPuede incluir una scriptsetiqueta que también inicie mocha con algo como "test": "./node_modules/.bin/mocha", pero VS Code no la usa, sino que se usa cuando npm testse ejecuta en la línea de comando. Este me confundió un poco. Anotarlo aquí en caso de que otros también se confundan.

EDITAR: VS Code 1.9.0 ha agregado una opción "Agregar configuración" en el menú desplegable de configuración de depuración, y puede elegir "Node.js Mocha Tests" que ayudan a simplificar la mayor parte de lo anterior. Aún debe asegurarse de que mocha esté en su node_modulesy es posible que deba actualizar cwdy último runtimeArgs(que es el patrón para encontrar sus pruebas) para que apunte a las rutas adecuadas. Pero una vez que establezca esas dos propiedades, debería funcionar prácticamente desde allí.

en launch.json, agregue 1 configuración más a continuación

{
      "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 necesita configurar la versión del nodo, simplemente agregue un runtimeExecutablecampo como este

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

Para cualquiera que use Windows. Si ha instalado mocha globalmente, configurar el programa en la siguiente ruta funcionó para mí (intercambie su nombre de usuario).

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

Esto me funciona en una máquina con Windows 7. Tengo mocha instalado globalmente, pero esta configuración apunta a la instalación del proyecto para evitar la necesidad de una ruta de perfil de usuario (que por cierto, intenté usar la variable% USERPROFILE% sin éxito). Ahora puedo establecer puntos de interrupción en mis pruebas de moca. ¡Hurra!

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

Para aquellos que usan gruñido o gulp, la configuración es bastante 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');};

En VSCode versión 1.13.0 (macOS), lo tienen integrado en configuraciones -> Mocha Tests.

Cuando utilice Babel o genere archivos javascript pero coloque puntos de interrupción en la fuente, debe asegurarse de habilitar sourceMapsy definir outFiles. Aquí hay una configuración de ejemplo que funcionó para mí.

    {
        "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: deberá modificar outFilespara incluir todo lo que desee agregar un punto de interrupción. Esto puede resultar más tedioso cuando se trata de un monorepo y múltiples proyectos dependientes.

1) Ir a

.vscode

luego

launch.json

expediente

2) Agregue la siguiente configuración en 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) Establezca puntos de interrupción en el archivo de prueba y luego presione F5

Cuando uso TypeScript, la siguiente configuración me funciona en 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"
    ]
}

Lo importante a tener en cuenta aquí es que los mapas de origen se generan y que el directorio de salida para js está configurado en 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"
    }

Tenga en cuenta que sourceMapsestá configurado en truey que outDirestá configurado enbuild

depurar

1. Pegue puntos de interrupción en index.tscualquier otro archivo mecanografiado importado
2. Abra una terminal y ejecute: mocha --debug-brk ./build/test/appTests.js
3. Desde VSC, ejecute la configuración de lanzamiento 'Adjuntar'

Aquí hay un ejemplo de configuración de lanzamiento (launch.json) de Microsoft, que funciona con Mocha y permite usar el depurador.

Además, hay una descripción de cómo usar la opción --debug-brk.

Finalmente, aquí hay una versión alternativa de cómo depurar código con pruebas Mocha usando el archivo tasks.json de VS Code y el ejecutor de tareas Gulp.

Si tiene alguna dependencia en la prueba, también es fácil adjuntarla.

Por ejemplo, también estoy usando mongo-unit-helperpruebas unitarias integradas con la base de datos.

package.json el guión es: mocha --recursive --require ./test/mongo-unit-helper.js --exit"

Mi launch.jsonapariencia es:

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

Solución es poner --requirepor separado en argsen launch.json.

Solución más simple

Agregue el siguiente código a launch.json dentro de la carpeta .vscode:

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

Sin embargo, es posible que desee agregar también un argumento de tiempo de espera:

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