[jestjs] How do I run a single test using Jest?

I have a test 'works with nested children' within the file fix-order-test.js.

Running the below runs all the tests in the file.

jest fix-order-test

How do I run only a single test? The below does not work as it searches for a file of the regex specified.

jest 'works with nested children'

There is now a nice Jest plugin for this called jest-watch-typeahead it makes this process much simpler.

If you have jest running as a script command, something like npm test, you need to use the following command to make it work:

npm test -- -t "fix order test"

Just a little add-on, because it seems there was kind of a fight if to use ./node_modules/.bin/jest -i ... or just jest -i ... or npm test -- -i ...

1. Just calling jest works if you have it installed globally (as with npm install -g jest), a not-so-clean way of handling dependencies
2. If you have Jest installed only locally in the package and want to call the Jest script without the npm script detour, you can use npx jest -i ... => this is exactly what npx is for. It saves you from writing ./node_modules/.bin/....

npm test __tests__/filename.test.ts - to run a single file.

test.only('check single test', () => { expect(true).toBe(true)}); - to run a single test case

test.skip('to skip testcase, () => {expect(false).toBe(false_}); - to skip a test case

As mentioned in other answers, test.only merely filters out other tests in the same file. So tests in other files would still run.

So to run a single test, there are two approaches:

• Option 1: If your test name is unique, you can enter t while in watch mode and enter the name of the test you'd like to run.

• Option 2:

  1. Hit p while in watch mode to enter a regex for the filename you'd like to run. (Relevant commands like this are displayed when you run Jest in watch mode).
  2. Change it to it.only on the test you'd like to run.

With either of the approaches above, Jest will only run the single test in the file you've specified.

I took me a while to find this so I'd like to add it here for people like me who use yarn:

yarn test -i "src/components/folderX/folderY/.../Filename.ts" -t "name of test"

So filename after -i and testname after -t.

Here is my take:

./node_modules/.bin/jest --config test/jest-unit-config.json --runInBand src/components/OpenForm/OpenForm.spec.js -t 'show expanded'

Notes:

• ./node_modules/.bin/... is a wonderful way, to access the locally installed Jest (or Mocha or...) binary that came with the locally installed package. (Yes, in your npm scripts you can jest with nothing before, but this is handy on command line... (that's also a good start for your debugging config, whichever IDE you are using...)
• Your project might not have a set of configuration options. But if it does (peek into the scripts in package.json), this is, what you need.
• --runInBand – as said, don't know about your configuration, but if you concentrate on developing/fixing a single test, you rather do not want to deal with web workers...
• Yes, you can give the whole, explicit path to your file
• Optionally, you can use -t to not run all tests in that file, but only a single one (here: the one, that has something with ‘show expanded’ in its name). Same effect can be achieved by glueing .only() into that file.

Use:

npm run test -- test-name

This will only work if your test specification name is unique.

The code above would reference a file with this name: test-name.component.spec.ts

With the latest Jest version, you can use one of the following to only run one test, and the same for a test suite.

it.only('test 1', () => {})

test.only('test 1', () => {})

fit('test 1', () => {})

jest 'test 1' may work too if the test name is unique.

Full command to run a single Jest test

Command:

node <path-to-jest> -i <you-test-file> -c <jest-config> -t "<test-block-name>"

• <path-to-jest>:
  • Windows: node_modules\jest\bin\jest.js
  • Others: node_modules/.bin/jest
• -i <you-test-file>: path to the file with tests (js or ts)
• -c <jest-config>: path to a separate Jest config file (JSON), if you keep your Jest configuration in package.json, you don't have to specify this parameter (Jest will find it without your help)
• -t <the-name-of-test-block>: actually it's a name (the first parameter) of describe(...), it(...), or test(...) block.

Example:

describe("math tests", () => {

  it("1 + 1 = 2", () => {
    expect(1 + 1).toBe(2);
  });

  it("-1 * -1 !== -1", () => {
    expect(-1 * -1).not.toBe(-1);
  });

});

So, the command

node node_modules/jest/bin/jest.js -i test/math-tests.js -c test/tests-config.json -t "1 + 1 = 2"

will test it("1 + 1 = 2", ...), but if you change the -t parameter to "math tests" then it will run both tests from the describe("math tests",...) block.

Remarks:

1. For Windows, replace node_modules/.bin/jest with node_modules\jest\bin\jest.js.
2. This approach allows you to debug the running script. To enable debugging add '--inspect-brk' parameter to the command.

Running a single Jest test via NPM scripts in 'package.json'

Having Jest installed, you can simplify the syntax of this command (above) by using NPM scripts. In "package.json" add a new script to the "scripts" section:

"scripts": {
  "test:math": "jest -i test/my-tests.js -t \"math tests\"",
}

In this case, we use an alias 'jest' instead of writing the full path to it. Also, we don't specify the configuration file path since we can place it in "package.json" as well and Jest will look into it by default. Now you can run the command:

npm run test:math

And the "math tests" block with two tests will be executed. Or, of course, you can specify one particular test by its name.

Another option would be to pull the <the-name-of-test-block> parameter outside the "test:math" script and pass it from the NPM command:

package.json:

"scripts": {
  "test:math": "jest -i test/my-tests.js -t",
}

Command:

npm run test:math "math tests"

Now you can manage the name of the run test(s) with a much shorter command.

Remarks:

1. The 'jest' command will work with NPM scripts because

npm makes "./node_modules/.bin" the first entry in the PATH environment variable when running any lifecycle scripts, so this will work fine, even if your program is not globally installed (NPM blog) 2. This approach doesn't seem to allow debugging because Jest is run via its binary/CLI, not via node.

Running a selected Jest test in Visual Studio Code

If you are using Visual Studio Code you can take advantage of it and run the currently selected test (in the code editor) by pressing the F5 button. To do this, we will need to create a new launch configuration block in the ".vscode/launch.json" file. In that configuration, we will use predefined variables which are substituted with the appropriate (unfortunately not always) values when running. Of all available we are only interested in these:

• ${relativeFile} - the current opened file relative to ${workspaceFolder}
• ${selectedText} - the current selected text in the active file

But before writing out the launch configuration we should add the 'test' script in our 'package.json' (if we haven't done it yet).

File package.json:

"scripts": {
  "test": "jest"
}

Then we can use it in our launch configuration.

Launch configuration:

{
  "type": "node",
  "request": "launch",
  "name": "Run selected Jest test",
  "runtimeExecutable": "npm",
  "runtimeArgs": [
    "run-script",
    "test"
  ],
  "args": [
    "--",
    "-i",
    "${relativeFile}",
    "-t",
    "${selectedText}"
  ],
  "console": "integratedTerminal",
}

It actually does the same as the commands described earlier in this answer. Now that everything is ready, we can run any test we want without having to rewrite the command parameters manually.

Here's all you need to do:

1. Select currently created launch config in the debug panel:

   

2. Open the file with tests in the code editor and select the name of the test you want to test (without quotation marks):

   

3. Press F5 button.

And voilà!

Now to run any test you want. Just open it in the editor, select its name, and press F5.

Unfortunately, it won't be "voilà" on a Windows machines because they substitute (who knows why) the ${relativeFile} variable with the path having reversed slashes and Jest wouldn't understand such a path.

Remarks:

1. To run under the debugger, don't forget to add the '--inspect-brk' parameter.
2. In this configuration example, we don't have the Jest configuration parameter assuming that it's included in 'package.json'.

As said a previous answer, you can run the command

jest -t 'fix-order-test'

If you have an it inside of a describe block, you have to run

jest -t '<describeString> <itString>'

You can also use f or x to focus or exclude a test. For example

fit('only this test will run', () => {
   expect(true).toBe(false);
});

it('this test will not run', () => {
   expect(true).toBe(false);
});

xit('this test will be ignored', () => {
   expect(true).toBe(false);
});

In Visual Studio Code, this lets me run/debug only one Jest test, with breakpoints: Debugging tests in Visual Studio Code

My launch.json file has this inside:

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "node",
      "request": "launch",
      "name": "Jest All",
      "program": "${workspaceFolder}/node_modules/.bin/jest",
      "args": ["--runInBand"],
      "console": "integratedTerminal",
      "internalConsoleOptions": "neverOpen",
      "windows": {
        "program": "${workspaceFolder}/node_modules/jest/bin/jest",
      }
    },
    {
      "type": "node",
      "request": "launch",
      "name": "Jest Current File",
      "program": "${workspaceFolder}/node_modules/.bin/jest",
      "args": ["${relativeFile}"],
      "console": "integratedTerminal",
      "internalConsoleOptions": "neverOpen",
      "windows": {
        "program": "${workspaceFolder}/node_modules/jest/bin/jest",
      }
    }
  ]
}

And this in file package.json:

  "scripts": {
    "test": "jest"
  }

• To run one test, in that test, change test (or it) to test.only (or it.only). To run one test suite (several tests), change describe to describe.only.
• Set breakpoint(s) if you want.
• In Visual Studio Code, go to Debug View (Shift + Cmd + D or Shift + Ctrl + D).
• From the dropdown menu at top, pick Jest Current File.
• Click the green arrow to run that test.

Jest documentation recommends the following:

If a test is failing, one of the first things to check should be whether the test is failing when it's the only test that runs. In Jest it's simple to run only one test - just temporarily change that test command to a test.only

test.only('this will be the only test that runs', () => {
   expect(true).toBe(false);
});

or

it.only('this will be the only test that runs', () => {
   expect(true).toBe(false);
});