Punkty przerwania mokka przy użyciu programu Visual Studio Code

Czy można dodać punkty przerwania do testów Mocha przy użyciu programu Visual Studio Code?

Zwykle podczas debugowania kodu należy skonfigurować plik launch.json, ustawiając atrybut programu na plik javascript do wykonania. Nie wiem jednak, jak to zrobić dla Mocha.

Czy wiesz, że po prostu wchodzisz do konfiguracji uruchamiania, umieszczasz kursor za lub między innymi konfiguracjami i naciskasz ctrl- spaceaby uzyskać aktualną, prawidłową konfigurację mokki automatycznie wygenerowaną?

Co dla mnie działa doskonale. W tym zatrzymywanie się w punktach przerwania. (Miałem też poprzedni, teraz przestarzały, który już nie działał z różnych powodów związanych z ustawieniami).

Od VSCode 1.21.1 (marzec 2018) daje to:

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

Na marginesie: debug-brk został usunięty (dla każdego, kto ma Node> = wersja co najmniej 8).

Jeśli nie chcesz używać --debug-brk+ Dołącz lub określ absolutną ścieżkę do swojej globalnej instalacji mokki (która będzie hamować, jeśli utrzymasz swój plik launch.json pod kontrolą wersji i masz wielu programistów na różnych maszynach), zainstaluj mokkę jako zależność od deweloperów i dodaj to do swojego 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"
  }
}

Pełna obsługa debugowania w testach po prostu naciskając klawisz F5.

--no-timeoutszapewnia, że ​​testy nie przekroczą limitu czasu, ponieważ zatrzymałeś się w punkcie przerwania, i --colorsupewnia się, że Mocha wyświetla kolory, mimo że nie wykrywa, że ​​VS Code obsługuje kolory.

Innym sposobem jest użycie --debug-brkopcji wiersza polecenia mokka i domyślnego Attachustawienia uruchamiania debugera Visual Studio Code.

Sugerowane głębsze wyjaśnienie (od André)

Aby to zrobić:

Uruchom mokkę z wiersza poleceń za pomocą tego polecenia:

mocha --debug-brk

Teraz w programie VS Code kliknij ikonę Debug, a następnie wybierz Attachopcję obok przycisku Start. Dodaj punkty przerwania w kodzie VS, a następnie kliknij przycisk Start.

Wykonałem tę pracę na VSCode na OS X 10.10. Po prostu zastąp ./settings/launch.jsonplik tym.

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

Jest również dostępny jako streszczenie tutaj .

Kluczowe wartości, które musisz zmienić, to program, które powinny być ustawione na _mochaplik wykonywalny, a argsktóre powinny być tablicą plików testowych.

Sposób działania w programie VS Code (1.8.2) w systemie Mac OS X to:

{
    "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 musi zostać zainstalowana w katalogu modułów npm.

1. Przejdź do Debug > Add Configuration...menu
2. Wybierz Node.jsśrodowisko
3. Wybierz Mocha Testsopcję z wyświetlonej listy rozwijanej
4. Wpisz ścieżkę do pliku testowego jako ostatni element argswłaściwości
5. Dodać breakpoint
6. Kliknij Debugikonę
7. Wybierz Mocha Testsjako konfigurację
8. Naciśnij Start debuggingprzycisk
9. :-)

Znalazłem sposób, aby to zrobić, który klasyfikuję jako obejście . Oczekuję, że zespół Visual Studio Code zapewni bardziej ostateczne rozwiązanie tego problemu, ale w międzyczasie zrobiłem to:

1. Stworzyłem ./settings/mocha.jsplik, który uruchamia mocha programowo przekazując argumenty jako listę plików do uruchomienia. Możesz zobaczyć pełny plik tutaj ;

2. Stworzyłem konfigurację uruchamiania, która będzie działać ./settings/mocha.jsjako programi przekazuje pliki / wzorce plików, które musimy przetestować jako argumenty:

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

   Pełny przykład launch.json

To jest odpowiednik robienia mocha test/unit/*.js test/unit/**/*.jsi teraz możemy używać punktów przerwania w naszych testach mokka.

Jeśli dodasz zmienną $ {file} na końcu listy argumentów, możesz rozpocząć debugowanie bezpośrednio z otwartego pliku:

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

Przepraszam za dodanie kolejnej odpowiedzi, ale żadna z poprzednich nie działała dla mnie od wersji VS Code 1.8.1 i standardowego debugera Node w nim zawartego. Oto sposób, w jaki go rozwiązałem (ze wskazówkami z poprzednich odpowiedzi tutaj i z oficjalnej dokumentacji debugowania VS Code Node.js ), więc jest debugowanie jednym kliknięciem / naciśnięciem klawisza:

• Zapewnić mokka jest instalowany jako devDependencyIN packages.json:"devDependencies": { "mocha": "^3.2", ... }
• Uruchom npm installw swoim katalogu, package.jsonaby upewnić się, że mocha jest teraz zainstalowana wnode_modules/
• Otwórz .vscode/launch.json(lub w VS Code, naciśnij F1, zacznij pisać „launch” i wybierz „Debug: Open launch.json”)
• Kliknij niebieski przycisk „Dodaj konfigurację” w prawym dolnym rogu (lub po prostu skopiuj i wklej jedną z pozostałych); ten krok jest opcjonalny ... mam na myśli, możesz ponownie użyć istniejącej konfiguracji. Ale proponuję dodać jeden, aby był mniej zagmatwany.
• Zmień następujące elementy w swoim launch.json, a następnie wybierz nową nazwę konfiguracji w oknie debugowania w programie VS Code i kliknij zieloną strzałkę, aby rozpocząć debugowanie testów węzła + mokka!

W nowej konfiguracji w 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
}, ...]

Zakłada się, że wzór test/**/*.jsbędzie działał w miejscu, w którym umieścisz testy. Zmień odpowiednio.

Krępuj się zmienić port tak długo, jak zmienić go w oba argsi portwłaściwości do meczu.

Kluczową różnicą dla mnie było upewnienie się, że mokka jest włączona node_modules, użycie programdo wskazania pliku wykonywalnego i argskonieczność debug-brk=xwskazania portu określonego w port. Reszta powyższego sprawia, że ​​wszystko jest ładniejsze i łatwiejsze.

To od Ciebie i Twojego zespołu zależy, czy umieścisz .vscode/launch.jsonw repozytorium, czy nie. Jest to plik tylko IDE, ale cały Twój zespół mógłby go używać w ten sposób, nie ma problemu, ponieważ wszystkie ścieżki i instalacje są względne i jawne.

Wskazówka: package.jsonmoże zawierać scriptstag, który również uruchamia mokkę z czymś podobnym "test": "./node_modules/.bin/mocha", ale nie jest używany przez VS Code - zamiast tego jest używany, gdy npm testjest uruchamiany w wierszu poleceń. To mnie trochę zdezorientowało. Zauważmy to tutaj na wypadek, gdyby inni też się zdezorientowali.

EDYCJA: VS Code 1.9.0 dodał opcję „Dodaj konfigurację” w menu rozwijanym konfiguracji debugowania i można wybrać opcję „Testy mokki Node.js”, które pomogą uprościć większość powyższych. Nadal musisz upewnić się, że mokka jest w twoim node_modulesi być może będziesz musiał zaktualizować cwdostatnią runtimeArgs(co jest wzorem do wyszukiwania twoich testów), aby wskazywały odpowiednie ścieżki. Ale kiedy ustawisz te dwie właściwości, powinno to działać prawie od tego momentu.

w pliku launch.json dodaj poniżej jeszcze 1 konfigurację

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

jeśli chcesz skonfigurować wersję węzła, po prostu dodaj runtimeExecutabletakie pole

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

Dla każdego, kto używa systemu Windows. Jeśli zainstalowałeś mokkę globalnie, to ustawienie programu na następującą ścieżkę zadziałało (zamień swoją nazwę użytkownika).

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

To działa u mnie na komputerze z systemem Windows 7. Mam mocha zainstalowaną globalnie, ale ta konfiguracja wskazuje na instalację projektu, aby uniknąć potrzeby ścieżki profilu użytkownika (przy okazji próbowałem użyć zmiennej% USERPROFILE% bez powodzenia). Mogę teraz ustawić punkty przerwania w moich testach mokki. 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"
    }

Dla tych, którzy używają chrząknięcia lub łyka, konfiguracja jest dość prosta.

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

W wersji VSCode 1.13.0 (macOS) mają to wbudowane w konfiguracjach -> Mocha Tests.

Używając Babel lub generując pliki javascript, ale umieszczając punkty przerwania w źródle - musisz upewnić się, że jest włączony sourceMapsi zdefiniowany outFiles. Oto przykładowa konfiguracja, która dla mnie zadziałała.

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

Uwaga - musisz zmodyfikować, outFilesaby uwzględnić wszystko, do czego chcesz dodać punkt przerwania. Może to być bardziej uciążliwe w przypadku monorepo i wielu zależnych projektów.

1) Idź do

.vscode

następnie

launch.json

plik

2) Dodaj następującą konfigurację w 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) Ustaw punkty przerwania w pliku testowym, a następnie naciśnij F5

W przypadku korzystania z języka TypeScript następująca konfiguracja działa dla mnie w programie 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"
    ]
}

Ważną rzeczą, na którą należy zwrócić uwagę, jest to, że generowane są mapy źródłowe i że katalog wyjściowy dla js jest ustawiony na 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"
    }

Należy pamiętać, że sourceMapsjest ustawiony na truei że outDirjest ustawiony nabuild

debugować

1. Umieść punkty przerwania w index.tsdowolnym innym zaimportowanym pliku maszynopisu
2. Otwórz terminal i uruchom: mocha --debug-brk ./build/test/appTests.js
3. W VSC uruchom konfigurację uruchamiania „Dołącz”

Oto przykład konfiguracji uruchamiania (launch.json) firmy Microsoft, która współpracuje z Mocha i umożliwia korzystanie z debuggera.

Jest tam również opis korzystania z opcji --debug-brk.

Wreszcie, oto alternatywna wersja sposobu debugowania kodu za pomocą testów Mocha przy użyciu pliku tasks.json programu VS Code i modułu uruchamiającego zadania Gulp.

Jeśli masz jakąś zależność w teście, łatwo go również dołączyć.

Na przykład używam mongo-unit-helperrównież testów jednostkowych zintegrowanych z bazą danych.

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

Mój launch.jsonwygląd wygląda tak:

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

Rozwiązaniem jest umieścić --requireoddzielnie argsw launch.json.

Najprostsze rozwiązanie

Dodaj następujący kod do launch.json w folderze .vscode:

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

Możesz jednak dodać również argument limitu czasu:

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