Punkty przerwania mokka przy użyciu programu Visual Studio Code

101

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.

André Vermeulen
źródło

Odpowiedzi:

83

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).

wprowadź opis obrazu tutaj

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).

Frank Nocke
źródło
2
Miałem jakiś niestandardowy kod potrzebny do zainicjowania dokumentu i wyłączenia wymiany modułu Hot. Przekaż ten argument w "args"bloku:"--require", "${workspaceFolder}/tools/testSetup.js",
Kent Bull
1
VS Code 1.29.1: Nie ma Ctrl+Spaceautomatycznie generowanej konfiguracji Mocha Tests debug-brk. Mimo to debugowanie z punktami przerwania działało dobrze.
Antony
@Antony Tak, przez długi czas debug-brknie jest już używany, obsługiwany lub automatycznie wstawiany. Moja notatka dodatkowa tylko to wyjaśniła, ponieważ wspomina o tym wiele innych odpowiedzi.
Frank Nocke,
1
Musiałem wstawić przecinek po prawym nawiasie klamrowym mojej (jedynej) innej konfiguracji dla ctrl + space aby działała.
GOTO 0
2
Aktualny przykład poprawnej konfiguracji dla Mocha, patrz: github.com/Microsoft/vscode-recipes/tree/master/ ...
Nux
70

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.

felixfbecker
źródło
12
Dla każdego, kto ma kłopoty. Zwróć uwagę na mokkę, a nie na mokkę. Mając tylko mokkę, uruchomi testy w kodzie VS, ale punkty przerwania nie zostaną trafione
tkarls
1
Dla tych, którzy używają TypeScript, jest to odpowiednia odpowiedź, o ile ustawisz sourceMaps: true. Dzięki miliardowi!
Bryan Rayner,
Aby dodać niestandardowe parametry testowe zgodne z npm, dodaj coś takiego npm_config_myparamdo bloku env. W przypadku CLI może to wyglądać npm --myparam=myvalue test.
bvj
44

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.

Wolfgang Kluge
źródło
1
W ten sposób jest znacznie łatwiej, praktycznie nie ma konfiguracji
André Vermeulen
Musisz dodać "request": "attach"plik do launch.json, jeśli nie istnieje - w przeciwnym razie będzie narzekać, że musisz określić program lub inny błąd.
wesoły
Wydaje się to być VS Codespecyficzne. Nie działa w normalnym VS 2015
Pavel P
świetna rada Dzięki :)
Gaurav Rawat
1
Zauważ, że --debug-brkjest to obecnie przestarzałe , dlatego sugeruję automatyczne tworzenie nowej konfiguracji debugowania w vscode , tak, również specjalnie dla mokki.
Frank Nocke
24

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.

GPX
źródło
U mnie nie działa (w systemie Windows) - ale wydaje się dobrym rozwiązaniem, jeśli działa :)
Wolfgang Kluge
Tak. Przepraszamy OpenDebug process has terminated unexpectedly
Wolfgang Kluge
Można spróbować ustawić "runtimeExecutable"się "C:/Program Files/nodejs/node.exe"lub wszędzie tam, gdzie jest zainstalowany węzeł?
GPX
Na pewno - ale bez zmian.
Wolfgang Kluge
Nie używam systemu Windows, więc nie mogę dalej pomóc. Jednak miej oko na to - mówią o tym problemie z OpenDebug.
GPX
11

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.

mikebz
źródło
To utknęło mnie na wieki. Błędnie użyłem ścieżki z „która mokka” zamiast node_modules. Dzięki!
PMac
11
  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. :-)
Tak
źródło
6

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.

Dário
źródło
U mnie nie działa, nie mogę znaleźć plików testowych, ścieżki są poprawne, próbowałem również z pełnymi ścieżkami.
Simone Gianni
1
U mnie to też działa vscode 0.10.6. Z punktami przerwania w plikach .ts, z sourcemaps, dodałem 'sourceMaps': true, 'outDir': './build'do mojej konfiguracji uruchamiania.
pyrho
4

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"
        }
Eugene Kulabuhov
źródło
2

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.

Jon Adams
źródło
2

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"
    },
Alongkorn Chetasumon
źródło
1

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"
JayChase
źródło
1

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"
    }
rspring1975
źródło
1

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');};
Leandro Rodrigues
źródło
1

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

Obsydian
źródło
To samo w systemie Windows.
sfratini
1

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.

ubershmekel
źródło
1

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

MERLIN THOMAS
źródło
0

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”
Bruno Grieder
źródło
0

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.

airen
źródło
0

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"
            ],
        }
Cap Baracudas
źródło