Debugging doesn't seem to attach the process?

[CodeFatherG]

According to https://marketplace.visualstudio.com/items?itemName=Orta.vscode-jest#how-to-debug-tests the extension should just be able to work?

I can't seem to get this working. If I press debug in test viewer on my side bar

I get the following output but don't hit my breakpoint?

PS C:\Users\gdare\Documents\probi-oh>  c:; cd 'c:\Users\gdare\Documents\probi-oh'; ${env:NODE_OPTIONS}=' --require "c:/Users/gdare/AppData/Local/Programs/Microsoft VS Code/resources/app/extensions/ms-vscode.js-debug/src/bootloader.js"  --inspect-publish-uid=http'; ${env:VSCODE_INSPECTOR_OPTIONS}=':::{"inspectorIpc":"\\\\.\\pipe\\node-cdp.18996-a53e16fa-128.sock","deferredMode":false,"waitForDebugger":"","execPath":"C:\\Program Files\\nodejs\\node.exe","onlyEntrypoint":false,"autoAttachMode":"always","fileCallback":"C:\\Users\\gdare\\AppData\\Local\\Temp\\node-debug-callback-8c45391863625d09"}'; & 'C:\Program Files\nodejs\npm.cmd' 'test' '--' '--runInBand' '--watchAll=false' '--testNamePattern' 'AndCondition should correctly identify required cards for complex nested conditions$' '--runTestsByPath' 'C:\Users\gdare\Documents\probi-oh\test\condition.test.ts' 
Debugger attached.
Waiting for the debugger to disconnect...
Debugger attached.

> [email protected] test
> jest --runInBand --watchAll=false --testNamePattern AndCondition should correctly identify required cards for complex nested conditions$ --runTestsByPath C:\Users\gdare\Documents\probi-oh\test\condition.test.ts

Debugger attached.
 FAIL  test/condition.test.ts                                                                                                                                                   
  Condition
    ○ skipped should evaluate correctly for card name                                                                                                                           
    ○ skipped should evaluate correctly for tag                                                                                                                                 
    ○ skipped should evaluate correctly with quantity                                                                                                                           
    ○ skipped should evaluate correctly with different operators                                                                                                                
    ○ skipped should throw error for unknown operator                                                                                                                           
    ○ skipped should evaluate correctly with quantity and <= operator                                                                                                           
    ○ skipped should evaluate correctly with exact quantity                                                                                                                     
    ○ skipped should handle cards with multiple tags                                                                                                                            
    ○ skipped should evaluate greater than or equal correctly                                                                                                                   
    ○ skipped should evaluate less than or equal correctly                                                                                                                      
    ○ skipped should evaluate equal correctly                                                                                                                                   
    ○ skipped should handle card tags                                                                                                                                           
    ○ skipped should only pick one required card                                                                                                                                
    ○ skipped should pick all required card                                                                                                                                     
    Location targets                                                                                                                                                            
      ○ skipped should evaluate correctly for deck                                                                                                                              
      ○ skipped should evaluate correctly for hand                                                                                                                              
  AndCondition                                                                                                                                                                  
    × should correctly identify required cards for complex nested conditions (6 ms)                                                                                             
    ○ skipped should evaluate correctly                                                                                                                                         
    ○ skipped should fail if one condition fails                                                                                                                                
    ○ skipped should evaluate correctly with multiple conditions                                                                                                                
    ○ skipped should fail if any condition fails                                                                                                                                
    ○ skipped should log error for undefined condition in AndCondition                                                                                                          
    ○ skipped should fail when a single card fulfills multiple conditions                                                                                                       
    ○ skipped should handle satisfying the condition non linearly                                                                                                               
    ○ skipped should handle complex nested AND conditions (A AND B AND C)                                                                                                       
    ○ skipped should pass when different cards fulfill each condition                                                                                                           
    ○ skipped should handle a single condition                                                                                                                                  
    ○ skipped should handle conditions with different quantities                                                                                                                
    ○ skipped should return an empty array when not all conditions can be met                                                                                                   
    ○ skipped should handle complex combinations of cards                                                                                                                       
  OrCondition                                                                                                                                                                   
    ○ skipped should evaluate correctly                                                                                                                                         
    ○ skipped should fail if all conditions fail                                                                                                                                
    ○ skipped should evaluate correctly with multiple conditions                                                                                                                
    ○ skipped should pass if any condition passes                                                                                                                               
    ○ skipped should log error for undefined condition in AndCondition                                                                                                          
    ○ skipped should handle an empty array of conditions                                                                                                                        
    ○ skipped should handle a single condition                                                                                                                                  
  Complex nested conditions                                                                                                                                                     
    Grob Tests                                                                                                                                                                  
      ○ skipped OR with AND                                                                                                                                                     
      ○ skipped OR with AND                                                                                                                                                     
      ○ skipped OR with AND                                                                                                                                                     
  conditionHasAnd                                                                                                                                                               
    ○ skipped should return false for a simple Condition                                                                                                                        
    ○ skipped should return true for an AndCondition                                                                                                                            
    ○ skipped should return false for a simple OrCondition                                                                                                                      
    ○ skipped should return true for a nested OrCondition containing an AndCondition                                                                                            
    ○ skipped should throw an error for an unknown condition type                                                                                                               
                                                                                                                                                                                
  ● AndCondition › should correctly identify required cards for complex nested conditions                                                                                       
                                                                                                                                                                                
    expect(received).toBe(expected) // Object.is equality

    Expected: 3
    Received: 0

      355 |
      356 |         const requiredCards = complexAnd.requiredCards(hand);
    > 357 |         expect(requiredCards.length).toBe(3);
          |                                      ^
      358 |         expect(requiredCards.map(card => card.name).sort()).toEqual(['Card A', 'Card B', 'Card C']);
      359 |     });
      360 |

      at Object.<anonymous> (test/condition.test.ts:357:38)

-----------------|---------|----------|---------|---------|----------------------------------------------------------------------------------------------------                 
File             | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s                                                                                                   
-----------------|---------|----------|---------|---------|----------------------------------------------------------------------------------------------------
All files        |   50.67 |    31.38 |      40 |   52.94 | 
 card-details.ts |     100 |      100 |     100 |     100 | 
 card.ts         |   29.41 |     4.16 |   29.41 |   29.41 | 36,60-136,142
 condition.ts    |   57.62 |    46.37 |   54.16 |   59.39 | 49,57-81,94-99,126,142,148,153-165,175,181-214,251-254,272-280,303,321-332,342-345,358,361-364,391
 deck.ts         |   62.96 |     37.5 |   55.55 |      60 | 31-35,47,57,67-72
 game-state.ts   |   17.77 |        0 |    4.34 |   22.85 | 40-111
-----------------|---------|----------|---------|---------|----------------------------------------------------------------------------------------------------
Jest: "global" coverage threshold for statements (80%) not met: 50.67%
Jest: "global" coverage threshold for branches (80%) not met: 31.38%
Jest: "global" coverage threshold for lines (80%) not met: 52.94%
Jest: "global" coverage threshold for functions (80%) not met: 40%
Test Suites: 1 failed, 1 total
Tests:       1 failed, 44 skipped, 45 total
Snapshots:   0 total
Time:        2.091 s
Ran all test suites within paths "C:\Users\gdare\Documents\probi-oh\test\condition.test.ts".

At the moment I have a launch.json I use but it tests the whole file so It makes it harder to test specific functions

{
    "version": "1.0.0",
    "configurations": [
        {
            "type": "node",
            "request": "launch",
            "name": "Jest: current file",
            //"env": { "NODE_ENV": "test" },
            "program": "${workspaceFolder}/node_modules/.bin/jest",
            "args": ["${fileBasenameNoExtension}", "--config", "jest.config.js"],
            "console": "integratedTerminal",
            "disableOptimisticBPs": true,
            "windows": {
                "program": "${workspaceFolder}/node_modules/jest/bin/jest"
            }
        }
    ]
}

Where have I gone wrong?

[bjarketrux]

I have the same problem. I don't know why, but if I use yarn instead of npm it works!

Execute: npm install -g yarn

Then in the launch.json add "runtimeExecutable": "yarn". (You might need a clean launch.json file, see the setup tool.

See if that works for you.