When you're writing tests, you often need to check that values meet certain conditions. expect gives you access to a number of "matchers" that let you validate different things.

For additional Jest matchers maintained by the Jest Community check out jest-extended.

方法

参考

expect(value)

每次要测试一个值时都会使用expect函数。 你很少会自己调用expect。 相反，您将使用expect及 "matcher" 函数来断言某个值。

很容易理解这一点的一个例子。 假设你有一个方法bestLaCroixFlavor()，它应该返回字符串'grapefruit'。 以下是您如何测试：

  1. test('the best flavor is grapefruit', () => {
  2.   expect(bestLaCroixFlavor()).toBe('grapefruit');
  3. });

In this case, toBe is the matcher function. There are a lot of different matcher functions, documented below, to help you test different things.

expect的参数应该是您的代码产生的值，匹配器的任何参数应该是正确的值。 如果您混合使用，您的测试仍然可以工作，但是失败测试的错误信息将会显得奇怪。

expect.extend(matchers)

您可以使用expect.extend将自己的匹配器添加到Jest。 例如，假设您正在测试一个数字理论库，并且您经常断言数字可被其他数字整除。 您可以将其抽象为toBeDivisibleBy匹配器：

  1. expect.extend({
  2.   toBeDivisibleBy(received, argument) {
  3.     const pass = received % argument == 0;
  4.     if (pass) {
  5.       return {
  6.         message: () =>
  7.           `expected ${received} not to be divisible by ${argument}`,
  8.         pass: true,
  9.       };
  10.     } else {
  11.       return {
  12.         message: () => `expected ${received} to be divisible by ${argument}`,
  13.         pass: false,
  14.       };
  15.     }
  16.   },
  17. });
  19. test('even and odd numbers', () => {
  20.   expect(100).toBeDivisibleBy(2);
  21.   expect(101).not.toBeDivisibleBy(2);
  22. });

Note: In TypeScript, when using @types/jest for example, you can declare the new toBeWithinRange matcher like this:

  1. declare global {
  2.   namespace jest {
  3.     interface Matchers<R> {
  4.       toBeWithinRange(a: number, b: number): R;
  5.     }
  6.   }
  7. }

匹配者应该返回一个包含两个键的对象。 pass表示是否有匹配，而message 提供了一个没有参数的函数，在出现故障的情况下返回错误消息。 因此，当pass为false时，message应该返回当expect(x).yourMatcher()失败时的错误消息。 而当pass为true时， message应该返回当expect(x).not.yourMatcher()失败时的错误信息。

These helper functions and properties can be found on this inside a custom matcher:

this.isNot

一个布尔值让你知道这个匹配器被调用了否定的.not修饰符，允许你翻转你的断言。

this.equals(a, b)

这是一个深度相等的函数，如果两个对象具有相同的值（递归），则返回true。

this.expand

A boolean to let you know this matcher was called with an expand option. When Jest is called with the —expand flag, this.expand can be used to determine if Jest is expected to show full diffs and errors.

this.utils

在this.utils上有一些有用的工具，主要由jest-matcher-utils导出。

The most useful ones are matcherHint, printExpected and printReceived to format the error messages nicely. For example, take a look at the implementation for the toBe matcher:

  1. const diff = require('jest-diff');
  2. expect.extend({
  3.   toBe(received, expected) {
  4.     const pass = Object.is(received, expected);
  6.     const message = pass
  7.       ? () =>
  8.           this.utils.matcherHint('.not.toBe') +
  9.           '\n\n' +
  10.           `Expected value to not be (using Object.is):\n` +
  11.           `  ${this.utils.printExpected(expected)}\n` +
  12.           `Received:\n` +
  13.           `  ${this.utils.printReceived(received)}`
  14.       : () => {
  15.           const diffString = diff(expected, received, {
  16.             expand: this.expand,
  17.           });
  18.           return (
  19.             this.utils.matcherHint('.toBe') +
  20.             '\n\n' +
  21.             `Expected value to be (using Object.is):\n` +
  22.             `  ${this.utils.printExpected(expected)}\n` +
  23.             `Received:\n` +
  24.             `  ${this.utils.printReceived(received)}` +
  25.             (diffString ? `\n\nDifference:\n\n${diffString}` : '')
  26.           );
  27.         };
  29.     return {actual: received, message, pass};
  30.   },
  31. });

This will print something like this:

  1.   expect(received).toBe(expected)
  3.     Expected value to be (using Object.is):
  4.       "banana"
  5.     Received:
  6.       "apple"

When an assertion fails, the error message should give as much signal as necessary to the user so they can resolve their issue quickly. You should craft a precise failure message to make sure users of your custom assertions have a good developer experience.

expect.anything()

expect.anything() matches anything but null or undefined. You can use it inside toEqual or toBeCalledWith instead of a literal value. For example, if you want to check that a mock function is called with a non-null argument:

  1. test('map calls its argument with a non-null argument', () => {
  2.   const mock = jest.fn();
  3.   [1].map(x => mock(x));
  4.   expect(mock).toBeCalledWith(expect.anything());
  5. });

expect.any(constructor)

expect.any(constructor) matches anything that was created with the given constructor. You can use it inside toEqual or toBeCalledWith instead of a literal value. For example, if you want to check that a mock function is called with a number:

  1. function randocall(fn) {
  2.   return fn(Math.floor(Math.random() * 6 + 1));
  3. }
  5. test('randocall calls its callback with a number', () => {
  6.   const mock = jest.fn();
  7.   randocall(mock);
  8.   expect(mock).toBeCalledWith(expect.any(Number));
  9. });

expect.arrayContaining(array)

expect.arrayContaining(array) matches a received array which contains all of the elements in the expected array. That is, the expected array is a subset of the received array. Therefore, it matches a received array which contains elements that are not in the expected array.

You can use it instead of a literal value:

  • in toEqual or toBeCalledWith
  • to match a property in objectContaining or toMatchObject
  1. describe('arrayContaining', () => {
  2.   const expected = ['Alice', 'Bob'];
  3.   it('matches even if received contains additional elements', () => {
  4.     expect(['Alice', 'Bob', 'Eve']).toEqual(expect.arrayContaining(expected));
  5.   });
  6.   it('does not match if received does not contain expected elements', () => {
  7.     expect(['Bob', 'Eve']).not.toEqual(expect.arrayContaining(expected));
  8.   });
  9. });
  1. describe('Beware of a misunderstanding! A sequence of dice rolls', () => {
  2.   const expected = [1, 2, 3, 4, 5, 6];
  3.   it('matches even with an unexpected number 7', () => {
  4.     expect([4, 1, 6, 7, 3, 5, 2, 5, 4, 6]).toEqual(
  5.       expect.arrayContaining(expected),
  6.     );
  7.   });
  8.   it('does not match without an expected number 2', () => {
  9.     expect([4, 1, 6, 7, 3, 5, 7, 5, 4, 6]).not.toEqual(
  10.       expect.arrayContaining(expected),
  11.     );
  12.   });
  13. });

expect.assertions(number)

expect.assertions(number) verifies that a certain number of assertions are called during a test. This is often useful when testing asynchronous code, in order to make sure that assertions in a callback actually got called.

For example, let's say that we have a function doAsync that receives two callbacks callback1 and callback2, it will asynchronously call both of them in an unknown order. We can test this with:

  1. test('doAsync calls both callbacks', () => {
  2.   expect.assertions(2);
  3.   function callback1(data) {
  4.     expect(data).toBeTruthy();
  5.   }
  6.   function callback2(data) {
  7.     expect(data).toBeTruthy();
  8.   }
  10.   doAsync(callback1, callback2);
  11. });

The expect.assertions(2) call ensures that both callbacks actually get called.

expect.hasAssertions()

expect.hasAssertions() verifies that at least one assertion is called during a test. This is often useful when testing asynchronous code, in order to make sure that assertions in a callback actually got called.

For example, let's say that we have a few functions that all deal with state. prepareState calls a callback with a state object, validateState runs on that state object, and waitOnState returns a promise that waits until all prepareState callbacks complete. We can test this with:

  1. test('prepareState prepares a valid state', () => {
  2.   expect.hasAssertions();
  3.   prepareState(state => {
  4.     expect(validateState(state)).toBeTruthy();
  5.   });
  6.   return waitOnState();
  7. });

The expect.hasAssertions() call ensures that the prepareState callback actually gets called.

expect.objectContaining(object)

expect.objectContaining(object) matches any received object that recursively matches the expected properties. That is, the expected object is a subset of the received object. Therefore, it matches a received object which contains properties that are not in the expected object.

Instead of literal property values in the expected object, you can use matchers, expect.anything(), and so on.

For example, let's say that we expect an onPress function to be called with an Event object, and all we need to verify is that the event has event.x and event.y properties. We can do that with:

  1. test('onPress gets called with the right thing', () => {
  2.   const onPress = jest.fn();
  3.   simulatePresses(onPress);
  4.   expect(onPress).toBeCalledWith(
  5.     expect.objectContaining({
  6.       x: expect.any(Number),
  7.       y: expect.any(Number),
  8.     }),
  9.   );
  10. });

expect.stringContaining(string)

仅用于jest 19.0.0+

expect.stringContaining(string) matches any received string that contains the exact expected string.

expect.stringMatching(regexp)

expect.stringMatching(regexp) matches any received string that matches the expected regexp.

You can use it instead of a literal value:

  • in toEqual or toBeCalledWith
  • to match an element in arrayContaining
  • to match a property in objectContaining or toMatchObject

This example also shows how you can nest multiple asymmetric matchers, with expect.stringMatching inside the expect.arrayContaining.

  1. describe('stringMatching in arrayContaining', () => {
  2.   const expected = [
  3.     expect.stringMatching(/^Alic/),
  4.     expect.stringMatching(/^[BR]ob/),
  5.   ];
  6.   it('matches even if received contains additional elements', () => {
  7.     expect(['Alicia', 'Roberto', 'Evelina']).toEqual(
  8.       expect.arrayContaining(expected),
  9.     );
  10.   });
  11.   it('does not match if received does not contain expected elements', () => {
  12.     expect(['Roberto', 'Evelina']).not.toEqual(
  13.       expect.arrayContaining(expected),
  14.     );
  15.   });
  16. });

expect.addSnapshotSerializer(serializer)

You can call expect.addSnapshotSerializer to add a module that formats application-specific data structures.

For an individual test file, an added module precedes any modules from snapshotSerializers configuration, which precede the default snapshot serializers for built-in JavaScript types and for React elements. The last module added is the first module tested.

  1. import serializer from 'my-serializer-module';
  2. expect.addSnapshotSerializer(serializer);
  4. // affects expect(value).toMatchSnapshot() assertions in the test file

If you add a snapshot serializer in individual test files instead of to adding it to snapshotSerializers configuration:

  • You make the dependency explicit instead of implicit.
  • You avoid limits to configuration that might cause you to eject from create-react-app.

See configuring Jest for more information.

.not

If you know how to test something, .not lets you test its opposite. For example, this code tests that the best La Croix flavor is not coconut:

  1. test('the best flavor is not coconut', () => {
  2.   expect(bestLaCroixFlavor()).not.toBe('coconut');
  3. });

.resolves

仅用于jest 20.0.0+

Use resolves to unwrap the value of a fulfilled promise so any other matcher can be chained. If the promise is rejected the assertion fails.

For example, this code tests that the promise resolves and that the resulting value is 'lemon':

  1. test('resolves to lemon', () => {
  2.   // make sure to add a return statement
  3.   return expect(Promise.resolve('lemon')).resolves.toBe('lemon');
  4. });

Note that, since you are still testing promises, the test is still asynchronous. Hence, you will need to tell Jest to wait by returning the unwrapped assertion.

Alternatively, you can use async/await in combination with .resolves:

  1. test('resolves to lemon', async () => {
  2.   await expect(Promise.resolve('lemon')).resolves.toBe('lemon');
  3.   await expect(Promise.resolve('lemon')).resolves.not.toBe('octopus');
  4. });

.rejects

仅用于jest 20.0.0+

Use .rejects to unwrap the reason of a rejected promise so any other matcher can be chained. If the promise is fulfilled the assertion fails.

For example, this code tests that the promise rejects with reason 'octopus':

  1. test('rejects to octopus', () => {
  2.   // make sure to add a return statement
  3.   return expect(Promise.reject(new Error('octopus'))).rejects.toThrow(
  4.     'octopus',
  5.   );
  6. });

Note that, since you are still testing promises, the test is still asynchronous. Hence, you will need to tell Jest to wait by returning the unwrapped assertion.

Alternatively, you can use async/await in combination with .rejects.

  1. test('rejects to octopus', async () => {
  2.   await expect(Promise.reject(new Error('octopus'))).rejects.toThrow('octopus');
  3. });

.toBe(value)

Use .toBe to compare primitive values or to check referential identity of object instances.

For example, this code will validate some properties of the can object:

  1. const can = {
  2.   name: 'pamplemousse',
  3.   ounces: 12,
  4. };
  6. describe('the can', () => {
  7.   test('has 12 ounces', () => {
  8.     expect(can.ounces).toBe(12);
  9.   });
  11.   test('has a sophisticated name', () => {
  12.     expect(can.name).toBe('pamplemousse');
  13.   });
  14. });

Don't use .toBe with floating-point numbers. For example, due to rounding, in JavaScript 0.2 + 0.1 is not strictly equal to 0.3. If you have floating point numbers, try .toBeCloseTo instead.

Although the .toBe matcher checks referential identity, it reports a deep comparison of values if the assertion fails. If differences between properties do not help you to understand why a test fails, especially if the report is large, then you might move the comparison into the expect function. For example, to assert whether or not elements are the same instance:

  • rewrite expect(received).toBe(expected) as expect(Object.is(received, expected)).toBe(true)
  • rewrite expect(received).not.toBe(expected) as expect(Object.is(received, expected)).toBe(false)

.toHaveBeenCalled()

Also under the alias: .toBeCalled()

Use .toHaveBeenCalled to ensure that a mock function got called.

For example, let's say you have a drinkAll(drink, flavour) function that takes a drink function and applies it to all available beverages. You might want to check that drink gets called for 'lemon', but not for 'octopus', because 'octopus' flavour is really weird and why would anything be octopus-flavoured? You can do that with this test suite:

  1. function drinkAll(callback, flavour) {
  2.   if (flavour !== 'octopus') {
  3.     callback(flavour);
  4.   }
  5. }
  7. describe('drinkAll', () => {
  8.   test('drinks something lemon-flavoured', () => {
  9.     const drink = jest.fn();
  10.     drinkAll(drink, 'lemon');
  11.     expect(drink).toHaveBeenCalled();
  12.   });
  14.   test('does not drink something octopus-flavoured', () => {
  15.     const drink = jest.fn();
  16.     drinkAll(drink, 'octopus');
  17.     expect(drink).not.toHaveBeenCalled();
  18.   });
  19. });

.toHaveBeenCalledTimes(number)

Use .toHaveBeenCalledTimes to ensure that a mock function got called exact number of times.

For example, let's say you have a drinkEach(drink, Array<flavor>) function that takes a drink function and applies it to array of passed beverages. You might want to check that drink function was called exact number of times. You can do that with this test suite:

  1. test('drinkEach drinks each drink', () => {
  2.   const drink = jest.fn();
  3.   drinkEach(drink, ['lemon', 'octopus']);
  4.   expect(drink).toHaveBeenCalledTimes(2);
  5. });

.toHaveBeenCalledWith(arg1, arg2, …)

Also under the alias: .toBeCalledWith()

Use .toHaveBeenCalledWith to ensure that a mock function was called with specific arguments.

For example, let's say that you can register a beverage with a register function, and applyToAll(f) should apply the function f to all registered beverages. To make sure this works, you could write:

  1. test('registration applies correctly to orange La Croix', () => {
  2.   const beverage = new LaCroix('orange');
  3.   register(beverage);
  4.   const f = jest.fn();
  5.   applyToAll(f);
  6.   expect(f).toHaveBeenCalledWith(beverage);
  7. });

.toHaveBeenLastCalledWith(arg1, arg2, …)

Also under the alias: .lastCalledWith(arg1, arg2, …)

If you have a mock function, you can use .toHaveBeenLastCalledWith to test what arguments it was last called with. For example, let's say you have a applyToAllFlavors(f) function that applies f to a bunch of flavors, and you want to ensure that when you call it, the last flavor it operates on is 'mango'. You can write:

  1. test('applying to all flavors does mango last', () => {
  2.   const drink = jest.fn();
  3.   applyToAllFlavors(drink);
  4.   expect(drink).toHaveBeenLastCalledWith('mango');
  5. });

.toHaveLength(number)

Use .toHaveLength to check that an object has a .length property and it is set to a certain numeric value.

This is especially useful for checking arrays or strings size.

  1. expect([1, 2, 3]).toHaveLength(3);
  2. expect('abc').toHaveLength(3);
  3. expect('').not.toHaveLength(5);

.toHaveProperty(keyPath, value)

Use .toHaveProperty to check if property at provided reference keyPath exists for an object. For checking deeply nested properties in an object you may use dot notation or an array containing the keyPath for deep references.

Optionally, you can provide a value to check if it's equal to the value present at keyPath on the target object. This matcher uses 'deep equality' (like toEqual()) and recursively checks the equality of all fields.

The following example contains a houseForSale object with nested properties. We are using toHaveProperty to check for the existence and values of various properties in the object.

  1. // Object containing house features to be tested
  2. const houseForSale = {
  3.   bath: true,
  4.   bedrooms: 4,
  5.   kitchen: {
  6.     amenities: ['oven', 'stove', 'washer'],
  7.     area: 20,
  8.     wallColor: 'white',
  9.   },
  10. };
  12. test('this house has my desired features', () => {
  13.   // Example Referencing
  14.   expect(houseForSale).toHaveProperty('bath');
  15.   expect(houseForSale).toHaveProperty('bedrooms', 4);
  17.   expect(houseForSale).not.toHaveProperty('pool');
  19.   // Deep referencing using dot notation
  20.   expect(houseForSale).toHaveProperty('kitchen.area', 20);
  21.   expect(houseForSale).toHaveProperty('kitchen.amenities', [
  22.     'oven',
  23.     'stove',
  24.     'washer',
  25.   ]);
  27.   expect(houseForSale).not.toHaveProperty('kitchen.open');
  29.   // Deep referencing using an array containing the keyPath
  30.   expect(houseForSale).toHaveProperty(['kitchen', 'area'], 20);
  31.   expect(houseForSale).toHaveProperty(
  32.     ['kitchen', 'amenities'],
  33.     ['oven', 'stove', 'washer'],
  34.   );
  35.   expect(houseForSale).toHaveProperty(['kitchen', 'amenities', 0], 'oven');
  37.   expect(houseForSale).not.toHaveProperty(['kitchen', 'open']);
  38. });

.toBeCloseTo(number, numDigits)

Using exact equality with floating point numbers is a bad idea. Rounding means that intuitive things fail. For example, this test fails:

  1. test('adding works sanely with decimals', () => {
  2.   expect(0.2 + 0.1).toBe(0.3); // Fails!
  3. });

It fails because in JavaScript, 0.2 + 0.1 is actually 0.30000000000000004. Sorry.

Instead, use .toBeCloseTo. Use numDigits to control how many digits after the decimal point to check. For example, if you want to be sure that 0.2 + 0.1 is equal to 0.3 with a precision of 5 decimal digits, you can use this test:

  1. test('adding works sanely with decimals', () => {
  2.   expect(0.2 + 0.1).toBeCloseTo(0.3, 5);
  3. });

The default for numDigits is 2, which has proved to be a good default in most cases.

.toBeDefined()

Use .toBeDefined to check that a variable is not undefined. For example, if you want to check that a function fetchNewFlavorIdea() returns something, you can write:

  1. test('there is a new flavor idea', () => {
  2.   expect(fetchNewFlavorIdea()).toBeDefined();
  3. });

You could write expect(fetchNewFlavorIdea()).not.toBe(undefined), but it's better practice to avoid referring to undefined directly in your code.

.toBeFalsy()

Use .toBeFalsy when you don't care what a value is and you want to ensure a value is false in a boolean context. For example, let's say you have some application code that looks like:

  1. drinkSomeLaCroix();
  2. if (!getErrors()) {
  3.   drinkMoreLaCroix();
  4. }

You may not care what getErrors returns, specifically - it might return false, null, or 0, and your code would still work. So if you want to test there are no errors after drinking some La Croix, you could write:

  1. test('drinking La Croix does not lead to errors', () => {
  2.   drinkSomeLaCroix();
  3.   expect(getErrors()).toBeFalsy();
  4. });

In JavaScript, there are six falsy values: false, 0, '', null, undefined, and NaN. Everything else is truthy.

.toBeGreaterThan(number)

To compare floating point numbers, you can use toBeGreaterThan. For example, if you want to test that ouncesPerCan() returns a value of more than 10 ounces, write:

  1. test('ounces per can is more than 10', () => {
  2.   expect(ouncesPerCan()).toBeGreaterThan(10);
  3. });

.toBeGreaterThanOrEqual(number)

To compare floating point numbers, you can use toBeGreaterThanOrEqual. For example, if you want to test that ouncesPerCan() returns a value of at least 12 ounces, write:

  1. test('ounces per can is at least 12', () => {
  2.   expect(ouncesPerCan()).toBeGreaterThanOrEqual(12);
  3. });

.toBeLessThan(number)

To compare floating point numbers, you can use toBeLessThan. For example, if you want to test that ouncesPerCan() returns a value of less than 20 ounces, write:

  1. test('ounces per can is less than 20', () => {
  2.   expect(ouncesPerCan()).toBeLessThan(20);
  3. });

.toBeLessThanOrEqual(number)

To compare floating point numbers, you can use toBeLessThanOrEqual. For example, if you want to test that ouncesPerCan() returns a value of at most 12 ounces, write:

  1. test('ounces per can is at most 12', () => {
  2.   expect(ouncesPerCan()).toBeLessThanOrEqual(12);
  3. });

.toBeInstanceOf(Class)

Use .toBeInstanceOf(Class) to check that an object is an instance of a class. This matcher uses instanceof underneath.

  1. class A {}
  3. expect(new A()).toBeInstanceOf(A);
  4. expect(() => {}).toBeInstanceOf(Function);
  5. expect(new A()).toBeInstanceOf(Function); // throws

.toBeNull()

.toBeNull() is the same as .toBe(null) but the error messages are a bit nicer. So use .toBeNull() when you want to check that something is null.

  1. function bloop() {
  2.   return null;
  3. }
  5. test('bloop returns null', () => {
  6.   expect(bloop()).toBeNull();
  7. });

.toBeTruthy()

Use .toBeTruthy when you don't care what a value is and you want to ensure a value is true in a boolean context. For example, let's say you have some application code that looks like:

  1. drinkSomeLaCroix();
  2. if (thirstInfo()) {
  3.   drinkMoreLaCroix();
  4. }

You may not care what thirstInfo returns, specifically - it might return true or a complex object, and your code would still work. So if you want to test that thirstInfo will be truthy after drinking some La Croix, you could write:

  1. test('drinking La Croix leads to having thirst info', () => {
  2.   drinkSomeLaCroix();
  3.   expect(thirstInfo()).toBeTruthy();
  4. });

In JavaScript, there are six falsy values: false, 0, '', null, undefined, and NaN. Everything else is truthy.

.toBeUndefined()

Use .toBeUndefined to check that a variable is undefined. For example, if you want to check that a function bestDrinkForFlavor(flavor) returns undefined for the 'octopus' flavor, because there is no good octopus-flavored drink:

  1. test('the best drink for octopus flavor is undefined', () => {
  2.   expect(bestDrinkForFlavor('octopus')).toBeUndefined();
  3. });

You could write expect(bestDrinkForFlavor('octopus')).toBe(undefined), but it's better practice to avoid referring to undefined directly in your code.

.toBeNaN()

Use .toBeNaN when checking a value is NaN.

  1. test('passes when value is NaN', () => {
  2.   expect(NaN).toBeNaN();
  3.   expect(1).not.toBeNaN();
  4. });

.toContain(item)

Use .toContain when you want to check that an item is in an array. For testing the items in the array, this uses ===, a strict equality check. .toContain can also check whether a string is a substring of another string.

For example, if getAllFlavors() returns an array of flavors and you want to be sure that lime is in there, you can write:

  1. test('the flavor list contains lime', () => {
  2.   expect(getAllFlavors()).toContain('lime');
  3. });

.toContainEqual(item)

Use .toContainEqual when you want to check that an item with a specific structure and values is contained in an array. For testing the items in the array, this matcher recursively checks the equality of all fields, rather than checking for object identity.

  1. describe('my beverage', () => {
  2.   test('is delicious and not sour', () => {
  3.     const myBeverage = {delicious: true, sour: false};
  4.     expect(myBeverages()).toContainEqual(myBeverage);
  5.   });
  6. });

.toEqual(value)

Use .toEqual to compare recursively all properties of object instances (also known as "deep" equality).

For example, .toEqual and .toBe behave differently in this test suite, so all the tests pass:

  1. const can1 = {
  2.   flavor: 'grapefruit',
  3.   ounces: 12,
  4. };
  5. const can2 = {
  6.   flavor: 'grapefruit',
  7.   ounces: 12,
  8. };
  10. describe('the La Croix cans on my desk', () => {
  11.   test('have all the same properties', () => {
  12.     expect(can1).toEqual(can2);
  13.   });
  14.   test('are not the exact same can', () => {
  15.     expect(can1).not.toBe(can2);
  16.   });
  17. });

Note: .toEqual won't perform a deep equality check for two errors. Only the message property of an Error is considered for equality. It is recommended to use the .toThrow matcher for testing against errors.

If differences between properties do not help you to understand why a test fails, especially if the report is large, then you might move the comparison into the expect function. For example, use equals method of Buffer class to assert whether or not buffers contain the same content:

  • rewrite expect(received).toEqual(expected) as expect(received.equals(expected)).toBe(true)
  • rewrite expect(received).not.toEqual(expected) as expect(received.equals(expected)).toBe(false)

.toMatch(regexpOrString)

Use .toMatch to check that a string matches a regular expression.

For example, you might not know what exactly essayOnTheBestFlavor() returns, but you know it's a really long string, and the substring grapefruit should be in there somewhere. You can test this with:

  1. describe('an essay on the best flavor', () => {
  2.   test('mentions grapefruit', () => {
  3.     expect(essayOnTheBestFlavor()).toMatch(/grapefruit/);
  4.     expect(essayOnTheBestFlavor()).toMatch(new RegExp('grapefruit'));
  5.   });
  6. });

This matcher also accepts a string, which it will try to match:

  1. describe('grapefruits are healthy', () => {
  2.   test('grapefruits are a fruit', () => {
  3.     expect('grapefruits').toMatch('fruit');
  4.   });
  5. });

.toMatchObject(object)

Use .toMatchObject to check that a JavaScript object matches a subset of the properties of an object. It will match received objects with properties that are not in the expected object.

You can also pass an array of objects, in which case the method will return true only if each object in the received array matches (in the toMatchObject sense described above) the corresponding object in the expected array. This is useful if you want to check that two arrays match in their number of elements, as opposed to arrayContaining, which allows for extra elements in the received array.

You can match properties against values or against matchers.

  1. const houseForSale = {
  2.   bath: true,
  3.   bedrooms: 4,
  4.   kitchen: {
  5.     amenities: ['oven', 'stove', 'washer'],
  6.     area: 20,
  7.     wallColor: 'white',
  8.   },
  9. };
  10. const desiredHouse = {
  11.   bath: true,
  12.   kitchen: {
  13.     amenities: ['oven', 'stove', 'washer'],
  14.     wallColor: expect.stringMatching(/white|yellow/),
  15.   },
  16. };
  18. test('the house has my desired features', () => {
  19.   expect(houseForSale).toMatchObject(desiredHouse);
  20. });
  1. describe('toMatchObject applied to arrays', () => {
  2.   test('the number of elements must match exactly', () => {
  3.     expect([{foo: 'bar'}, {baz: 1}]).toMatchObject([{foo: 'bar'}, {baz: 1}]);
  4.   });
  6.   // .arrayContaining "matches a received array which contains elements that
  7.   // are *not* in the expected array"
  8.   test('.toMatchObject does not allow extra elements', () => {
  9.     expect([{foo: 'bar'}, {baz: 1}]).toMatchObject([{foo: 'bar'}]);
  10.   });
  12.   test('.toMatchObject is called for each elements, so extra object properties are okay', () => {
  13.     expect([{foo: 'bar'}, {baz: 1, extra: 'quux'}]).toMatchObject([
  14.       {foo: 'bar'},
  15.       {baz: 1},
  16.     ]);
  17.   });
  18. });

.toMatchSnapshot(optionalString)

This ensures that a value matches the most recent snapshot. Check out the Snapshot Testing guide for more information.

You can also specify an optional snapshot name. Otherwise, the name is inferred from the test.

.toThrow(error)

Also under the alias: .toThrowError(error)

Use .toThrow to test that a function throws when it is called. For example, if we want to test that drinkFlavor('octopus') throws, because octopus flavor is too disgusting to drink, we could write:

  1. test('throws on octopus', () => {
  2.   expect(() => {
  3.     drinkFlavor('octopus');
  4.   }).toThrow();
  5. });

Note: You must wrap the code in a function, otherwise the error will not be caught and the assertion will fail.

If you want to test that a specific error gets thrown, you can provide an argument to toThrow. The argument can be a string that should be contained in the error message, a class for the error, or a regex that should match the error message. For example, let's say that drinkFlavor is coded like this:

  1. function drinkFlavor(flavor) {
  2.   if (flavor == 'octopus') {
  3.     throw new DisgustingFlavorError('yuck, octopus flavor');
  4.   }
  5.   // Do some other stuff
  6. }

We could test this error gets thrown in several ways:

  1. test('throws on octopus', () => {
  2.   function drinkOctopus() {
  3.     drinkFlavor('octopus');
  4.   }
  6.   // Test that the error message says "yuck" somewhere: these are equivalent
  7.   expect(drinkOctopus).toThrowError(/yuck/);
  8.   expect(drinkOctopus).toThrowError('yuck');
  10.   // Test the exact error message
  11.   expect(drinkOctopus).toThrowError(/^yuck, octopus flavor$/);
  13.   // Test that we get a DisgustingFlavorError
  14.   expect(drinkOctopus).toThrowError(DisgustingFlavorError);
  15. });

.toThrowErrorMatchingSnapshot()

Use .toThrowErrorMatchingSnapshot to test that a function throws an error matching the most recent snapshot when it is called. For example, let's say you have a drinkFlavor function that throws whenever the flavor is 'octopus', and is coded like this:

  1. function drinkFlavor(flavor) {
  2.   if (flavor == 'octopus') {
  3.     throw new DisgustingFlavorError('yuck, octopus flavor');
  4.   }
  5.   // Do some other stuff
  6. }

The test for this function will look this way:

  1. test('throws on octopus', () => {
  2.   function drinkOctopus() {
  3.     drinkFlavor('octopus');
  4.   }
  6.   expect(drinkOctopus).toThrowErrorMatchingSnapshot();
  7. });

And it will generate the following snapshot:

  1. exports[`drinking flavors throws on octopus 1`] = `"yuck, octopus flavor"`;

Check out React Tree Snapshot Testing for more information on snapshot testing.