Ожидание

При написании тестов часто требуется проверить, соответствуют ли значения определенным условиям. expect предоставляет доступ к ряду «совпадений», позволяющих проверять различные вещи.

Для дополнительных матчеров Jest, поддерживаемых сообществом Jest, обратитесь к jest-extended.

Методы

Справочник

expect(value)

Функция expect используется всякий раз, когда вы хотите протестировать значение. Вряд ли вы будете вызывать expect самостоятельно. Вместо этого вы будете использовать expect вместе с функцией «совпадения», чтобы утверждать что-то о значении.

Это легче понять на примере. Предположим, у вас есть метод bestLaCroixFlavor(), который должен возвращать строку 'grapefruit'. Вот как вы бы проверили это:

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

В этом случае toBe является функцией совпадения. Ниже описано множество различных функций совпадения, которые помогут вам проверить различные вещи.

Аргументом функции expect должно быть значение, созданное вашим кодом, а любым аргументом совпадения — правильное значение. Если вы их перепутаете, тесты все равно будут работать, но сообщения об ошибках при провале тестов будут выглядеть странно.

expect.extend(matchers)

Вы можете использовать expect.extend для добавления собственных совпадений в Jest. Например, предположим, что вы тестируете библиотеку числовых утилит, и вам часто нужно утверждать, что числа находятся в определённых диапазонах других чисел. Вы можете абстрагировать это в матчер toBeWithinRange:

expect.extend({
  toBeWithinRange(received, floor, ceiling) {
    const pass = received >= floor && received <= ceiling;
    if (pass) {
      return {
        message: () =>
          `expected ${received} not to be within range ${floor} - ${ceiling}`,
        pass: true,
      };
    } else {
      return {
        message: () =>
          `expected ${received} to be within range ${floor} - ${ceiling}`,
        pass: false,
      };
    }
  },
});

test('numeric ranges', () => {
  expect(100).toBeWithinRange(90, 110);
  expect(101).not.toBeWithinRange(0, 100);
  expect({apples: 6, bananas: 3}).toEqual({
    apples: expect.toBeWithinRange(1, 10),
    bananas: expect.not.toBeWithinRange(11, 20),
  });
});

interface CustomMatchers<R = unknown> {
  toBeWithinRange(floor: number, ceiling: number): R;
}

declare global {
  namespace jest {
    interface Expect extends CustomMatchers {}
    interface Matchers<R> extends CustomMatchers<R> {}
    interface InverseAsymmetricMatchers extends CustomMatchers {}
  }
}

Асинхронные матчеры

expect.extend также поддерживает асинхронные матчеры. Асинхронные матчеры возвращают Promise, поэтому вам нужно будет ожидать возвращаемое значение. Давайте используем пример матчера, чтобы проиллюстрировать его использование. Мы собираемся реализовать матчер под названием toBeDivisibleByExternalValue, где делимое число будет взято из внешнего источника.

expect.extend({
  async toBeDivisibleByExternalValue(received) {
    const externalValue = await getExternalValueFromRemoteSource();
    const pass = received % externalValue == 0;
    if (pass) {
      return {
        message: () =>
          `expected ${received} not to be divisible by ${externalValue}`,
        pass: true,
      };
    } else {
      return {
        message: () =>
          `expected ${received} to be divisible by ${externalValue}`,
        pass: false,
      };
    }
  },
});

test('is divisible by external value', async () => {
  await expect(100).toBeDivisibleByExternalValue();
  await expect(101).not.toBeDivisibleByExternalValue();
});

API пользовательских матчеров

Матчеры должны возвращать объект (или Promise объекта) с двумя ключами. pass указывает, было ли совпадение, а message предоставляет функцию без аргументов, которая возвращает сообщение об ошибке в случае неудачи. Таким образом, когда pass ложно, message должно вернуть сообщение об ошибке, когда expect(x).yourMatcher() терпит неудачу. А когда pass истинно, message должно вернуть сообщение об ошибке, когда expect(x).not.yourMatcher() терпит неудачу.

Матчеры вызываются с аргументом, переданным в expect(x), а затем с аргументами, переданными в .yourMatcher(y, z):

expect.extend({
  yourMatcher(x, y, z) {
    return {
      pass: true,
      message: () => '',
    };
  },
});

Эти вспомогательные функции и свойства можно найти в this внутри пользовательского матчера:

this.isNot

Логическое значение, сообщая вам, был ли этот матчер вызван с модификатором отрицания .not, позволяя отобразить ясное и корректное подсказку матчера (см. пример кода).

this.promise

Строка, позволяющая отображать ясное и правильное подсказку матчера:

• 'rejects' если матчер был вызван с модификатором Promise .rejects
• 'resolves' если матчер был вызван с модификатором Promise .resolves
• '' если матчер не был вызван с модификатором Promise

this.equals(a, b)

Это функция глубокого равенства, которая вернёт true , если два объекта имеют одинаковые значения (рекурсивно).

this.expand

Логическое значение, сообщая вам, был ли этот матчер вызван с опцией expand . Когда Jest вызывается с флагом --expand, this.expand можно использовать для определения, ожидает ли Jest отображения полных различий и ошибок.

this.utils

Существует ряд полезных инструментов, доступных в this.utils, в основном состоящих из экспортов из jest-matcher-utils.

Наиболее полезными являются matcherHint, printExpected и printReceived, чтобы красиво отформатировать сообщения об ошибках. Например, посмотрите на реализацию матчера toBe:

const {diff} = require('jest-diff');
expect.extend({
  toBe(received, expected) {
    const options = {
      comment: 'Object.is equality',
      isNot: this.isNot,
      promise: this.promise,
    };

    const pass = Object.is(received, expected);

    const message = pass
      ? () =>
          // eslint-disable-next-line prefer-template
          this.utils.matcherHint('toBe', undefined, undefined, options) +
          '\n\n' +
          `Expected: not ${this.utils.printExpected(expected)}\n` +
          `Received: ${this.utils.printReceived(received)}`
      : () => {
          const diffString = diff(expected, received, {
            expand: this.expand,
          });
          return (
            // eslint-disable-next-line prefer-template
            this.utils.matcherHint('toBe', undefined, undefined, options) +
            '\n\n' +
            (diffString && diffString.includes('- Expect')
              ? `Difference:\n\n${diffString}`
              : `Expected: ${this.utils.printExpected(expected)}\n` +
                `Received: ${this.utils.printReceived(received)}`)
          );
        };

    return {actual: received, message, pass};
  },
});

Это будет выводить что-то вроде этого:

  expect(received).toBe(expected)

    Expected value to be (using Object.is):
      "banana"
    Received:
      "apple"

Когда утверждение терпит неудачу, сообщение об ошибке должно предоставить пользователю как можно больше информации, чтобы он смог быстро решить проблему. Вы должны создать точное сообщение об ошибке, чтобы пользователи ваших пользовательских утверждений имели хороший опыт разработки.

Пользовательские матчеры снимков

Чтобы использовать тестирование снимков внутри вашего пользовательского матчера, вы можете импортировать jest-snapshot и использовать его внутри вашего матчера.

Вот матчер снимка, который обрезает строку для сохранения заданной длины, .toMatchTrimmedSnapshot(length):

const {toMatchSnapshot} = require('jest-snapshot');

expect.extend({
  toMatchTrimmedSnapshot(received, length) {
    return toMatchSnapshot.call(
      this,
      received.substring(0, length),
      'toMatchTrimmedSnapshot',
    );
  },
});

it('stores only 10 characters', () => {
  expect('extra long string oh my gerd').toMatchTrimmedSnapshot(10);
});

/*
Stored snapshot will look like:

exports[`stores only 10 characters: toMatchTrimmedSnapshot 1`] = `"extra long"`;
*/

Также возможно создание пользовательских матчеров для встроенных снимков, снимки будут правильно добавлены к пользовательским матчерам. Однако встроенный снимок всегда будет пытаться добавить к первому аргументу или ко второму, когда первый аргумент является матчером свойства, поэтому невозможно принимать пользовательские аргументы в пользовательских матчерах.

const {toMatchInlineSnapshot} = require('jest-snapshot');

expect.extend({
  toMatchTrimmedInlineSnapshot(received, ...rest) {
    return toMatchInlineSnapshot.call(this, received.substring(0, 10), ...rest);
  },
});

it('stores only 10 characters', () => {
  expect('extra long string oh my gerd').toMatchTrimmedInlineSnapshot();
  /*
  The snapshot will be added inline like
  expect('extra long string oh my gerd').toMatchTrimmedInlineSnapshot(
    `"extra long"`
  );
  */
});

async

Если ваш пользовательский матчер встроенного снимка асинхронный, т.е. использует async-await, вы можете столкнуться с ошибкой типа «Несколько встроенных снимков для одного вызова не поддерживаются». Jest нуждается в дополнительной контекстной информации, чтобы найти, где пользовательский матчер встроенного снимка был использован для корректного обновления снимков.

const {toMatchInlineSnapshot} = require('jest-snapshot');

expect.extend({
  async toMatchObservationInlineSnapshot(fn, ...rest) {
    // The error (and its stacktrace) must be created before any `await`
    this.error = new Error();

    // The implementation of `observe` doesn't matter.
    // It only matters that the custom snapshot matcher is async.
    const observation = await observe(async () => {
      await fn();
    });

    return toMatchInlineSnapshot.call(this, recording, ...rest);
  },
});

it('observes something', async () => {
  await expect(async () => {
    return 'async action';
  }).toMatchTrimmedInlineSnapshot();
  /*
  The snapshot will be added inline like
  await expect(async () => {
    return 'async action';
  }).toMatchTrimmedInlineSnapshot(`"async action"`);
  */
});

Прерывание

Обычно jest пытается сопоставить каждый ожидаемый снимок в тесте.

Иногда может не иметь смысла продолжать тест, если предыдущий снимок завершился ошибкой. Например, когда вы делаете снимки состояния машины после различных переходов, вы можете прервать тест, как только один переход произвёл неверное состояние.

В этом случае вы можете реализовать пользовательский матчер снимка, который выбрасывает ошибку при первом несоответствии, вместо сбора всех несоответствий.

const {toMatchInlineSnapshot} = require('jest-snapshot');

expect.extend({
  toMatchStateInlineSnapshot(...args) {
    this.dontThrow = () => {};

    return toMatchInlineSnapshot.call(this, ...args);
  },
});

let state = 'initial';

function transition() {
  // Typo in the implementation should cause the test to fail
  if (state === 'INITIAL') {
    state = 'pending';
  } else if (state === 'pending') {
    state = 'done';
  }
}

it('transitions as expected', () => {
  expect(state).toMatchStateInlineSnapshot(`"initial"`);

  transition();
  // Already produces a mismatch. No point in continuing the test.
  expect(state).toMatchStateInlineSnapshot(`"loading"`);

  transition();
  expect(state).toMatchStateInlineSnapshot(`"done"`);
});

expect.anything()

expect.anything() соответствует любому значению, кроме null или undefined. Вы можете использовать его внутри toEqual или toBeCalledWith, вместо буквального значения. Например, если вы хотите проверить, что функция-заглушка вызывается с аргументом, не равным null:

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

expect.any(constructor)

expect.any(constructor) соответствует всему, что было создано с помощью данного конструктора, или если это примитив, который имеет указанный тип. Его можно использовать внутри toEqual или toBeCalledWith вместо литерального значения. Например, если вы хотите проверить, что вызывается функция-модель с числом:

class Cat {}
function getCat(fn) {
  return fn(new Cat());
}

test('randocall calls its callback with a class instance', () => {
  const mock = jest.fn();
  getCat(mock);
  expect(mock).toBeCalledWith(expect.any(Cat));
});

function randocall(fn) {
  return fn(Math.floor(Math.random() * 6 + 1));
}

test('randocall calls its callback with a number', () => {
  const mock = jest.fn();
  randocall(mock);
  expect(mock).toBeCalledWith(expect.any(Number));
});

expect.arrayContaining(array)

expect.arrayContaining(array) соответствует полученному массиву, который содержит все элементы в ожидаемом массиве. То есть, ожидаемый массив является подмножеством полученного массива. Следовательно, он соответствует полученному массиву, который содержит элементы, не присутствующие в ожидаемом массиве.

Его можно использовать вместо литерального значения:

• в toEqual или toBeCalledWith
• для соответствия свойству в objectContaining или toMatchObject

describe('arrayContaining', () => {
  const expected = ['Alice', 'Bob'];
  it('matches even if received contains additional elements', () => {
    expect(['Alice', 'Bob', 'Eve']).toEqual(expect.arrayContaining(expected));
  });
  it('does not match if received does not contain expected elements', () => {
    expect(['Bob', 'Eve']).not.toEqual(expect.arrayContaining(expected));
  });
});

describe('Beware of a misunderstanding! A sequence of dice rolls', () => {
  const expected = [1, 2, 3, 4, 5, 6];
  it('matches even with an unexpected number 7', () => {
    expect([4, 1, 6, 7, 3, 5, 2, 5, 4, 6]).toEqual(
      expect.arrayContaining(expected),
    );
  });
  it('does not match without an expected number 2', () => {
    expect([4, 1, 6, 7, 3, 5, 7, 5, 4, 6]).not.toEqual(
      expect.arrayContaining(expected),
    );
  });
});

expect.assertions(number)

expect.assertions(number) проверяет, что определенное количество утверждений было вызвано во время теста. Это часто полезно при тестировании асинхронного кода, чтобы убедиться, что утверждения в обратном вызове действительно были вызваны.

Например, предположим, что у нас есть функция doAsync, которая принимает два обратных вызова callback1 и callback2, она асинхронно вызовет оба из них в неизвестном порядке. Мы можем протестировать это с помощью:

test('doAsync calls both callbacks', () => {
  expect.assertions(2);
  function callback1(data) {
    expect(data).toBeTruthy();
  }
  function callback2(data) {
    expect(data).toBeTruthy();
  }

  doAsync(callback1, callback2);
});

Вызов expect.assertions(2) гарантирует, что оба обратных вызова были действительно вызваны.

expect.closeTo(number, numDigits?)

expect.closeTo(number, numDigits?) полезно при сравнении чисел с плавающей точкой в свойствах объектов или элементах массивов. Если вам нужно сравнить число, используйте .toBeCloseTo вместо него.

Необязательный аргумент numDigits ограничивает количество цифр для проверки после десятичной точки. Для значения по умолчанию 2, критерий теста равен Math.abs(expected - received) < 0.005 (that is, 10 ** -2 / 2).

Например, этот тест проходит с точностью 5 цифр:

test('compare float in object properties', () => {
  expect({
    title: '0.1 + 0.2',
    sum: 0.1 + 0.2,
  }).toEqual({
    title: '0.1 + 0.2',
    sum: expect.closeTo(0.3, 5),
  });
});

expect.hasAssertions()

expect.hasAssertions() проверяет, что хотя бы одно утверждение было вызвано во время теста. Это часто полезно при тестировании асинхронного кода, чтобы убедиться, что утверждения в обратном вызове действительно были вызваны.

Например, предположим, что у нас есть несколько функций, которые все работают с состоянием. prepareState вызывает обратный вызов с объектом состояния, validateState работает с этим объектом состояния, а waitOnState возвращает промис, который ожидает, пока все prepareState обратные вызовы завершатся. Мы можем протестировать это с помощью:

test('prepareState prepares a valid state', () => {
  expect.hasAssertions();
  prepareState(state => {
    expect(validateState(state)).toBeTruthy();
  });
  return waitOnState();
});

Вызов expect.hasAssertions() гарантирует, что обратный вызов prepareState действительно был вызван.

expect.not.arrayContaining(array)

expect.not.arrayContaining(array) соответствует полученному массиву, который не содержит все элементы ожидаемого массива. То есть, ожидаемый массив не является подмножеством полученного массива.

Это обратное expect.arrayContaining.

describe('not.arrayContaining', () => {
  const expected = ['Samantha'];

  it('matches if the actual array does not contain the expected elements', () => {
    expect(['Alice', 'Bob', 'Eve']).toEqual(
      expect.not.arrayContaining(expected),
    );
  });
});

expect.not.objectContaining(object)

expect.not.objectContaining(object) соответствует любому полученному объекту, который не соответствует ожидаемым свойствам рекурсивно. То есть, ожидаемый объект не является подмножеством полученного объекта. Следовательно, он соответствует полученному объекту, который содержит свойства, которых нет в ожидаемом объекте.

Это обратное expect.objectContaining.

describe('not.objectContaining', () => {
  const expected = {foo: 'bar'};

  it('matches if the actual object does not contain expected key: value pairs', () => {
    expect({bar: 'baz'}).toEqual(expect.not.objectContaining(expected));
  });
});

expect.not.stringContaining(string)

expect.not.stringContaining(string) соответствует полученному значению, если оно не является строкой или если это строка, которая не содержит точную ожидаемую строку.

Это обратное expect.stringContaining.

describe('not.stringContaining', () => {
  const expected = 'Hello world!';

  it('matches if the received value does not contain the expected substring', () => {
    expect('How are you?').toEqual(expect.not.stringContaining(expected));
  });
});

expect.not.stringMatching(string | regexp)

expect.not.stringMatching(string | regexp) соответствует полученному значению, если оно не является строкой или если это строка, которая не соответствует ожидаемой строке или регулярному выражению.

Это обратное expect.stringMatching.

describe('not.stringMatching', () => {
  const expected = /Hello world!/;

  it('matches if the received value does not match the expected regex', () => {
    expect('How are you?').toEqual(expect.not.stringMatching(expected));
  });
});

expect.objectContaining(object)

expect.objectContaining(object) соответствует любому полученному объекту, который рекурсивно соответствует ожидаемым свойствам. То есть, ожидаемый объект является подмножеством полученного объекта. Следовательно, он соответствует полученному объекту, который содержит свойства, присутствующие в ожидаемом объекте.

Вместо литеральных значений свойств в ожидаемом объекте вы можете использовать матчеры, expect.anything(), и так далее.

Например, предположим, что мы ожидаем, что функция onPress будет вызвана с объектом Event, и все, что нам нужно проверить, это то, что событие имеет свойства event.x и event.y. Мы можем сделать это с помощью:

test('onPress gets called with the right thing', () => {
  const onPress = jest.fn();
  simulatePresses(onPress);
  expect(onPress).toBeCalledWith(
    expect.objectContaining({
      x: expect.any(Number),
      y: expect.any(Number),
    }),
  );
});

expect.stringContaining(string)

expect.stringContaining(string) соответствует полученному значению, если это строка, которая содержит точную ожидаемую строку.

expect.stringMatching(string | regexp)

expect.stringMatching(string | regexp) соответствует полученному значению, если это строка, которая соответствует ожидаемой строке или регулярному выражению.

Его можно использовать вместо литерального значения:

• в toEqual или toBeCalledWith
• для соответствия элементу в arrayContaining
• для соответствия свойству в objectContaining или toMatchObject

Этот пример также показывает, как можно вложенно использовать несколько асимметричных матчеров, с expect.stringMatching внутри expect.arrayContaining.

describe('stringMatching in arrayContaining', () => {
  const expected = [
    expect.stringMatching(/^Alic/),
    expect.stringMatching(/^[BR]ob/),
  ];
  it('matches even if received contains additional elements', () => {
    expect(['Alicia', 'Roberto', 'Evelina']).toEqual(
      expect.arrayContaining(expected),
    );
  });
  it('does not match if received does not contain expected elements', () => {
    expect(['Roberto', 'Evelina']).not.toEqual(
      expect.arrayContaining(expected),
    );
  });
});

expect.addSnapshotSerializer(serializer)

Вы можете вызвать expect.addSnapshotSerializer для добавления модуля, который форматирует структуры данных, специфичные для приложения.

Для отдельного файла теста добавленный модуль предшествует любым модулям из конфигурации snapshotSerializers, которые предшествуют стандартным сериализаторам снимков для встроенных типов JavaScript и для элементов React. Последний добавленный модуль проверяется в первую очередь.

import serializer from 'my-serializer-module';
expect.addSnapshotSerializer(serializer);

// affects expect(value).toMatchSnapshot() assertions in the test file

Если вы добавляете сериализатор снимка в отдельные файлы тестов вместо добавления его в конфигурацию snapshotSerializers:

• Вы делаете зависимость явной вместо неявной.
• Вы избегаете ограничений конфигурации, которые могут привести к выходу из create-react-app.

См. настройка Jest для получения дополнительной информации.

.not

Если вы знаете, как что-то протестировать, .not позволяет протестировать обратное. Например, этот код проверяет, что лучший вкус La Croix не кокосовый:

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

.resolves

Используйте resolves для извлечения значения выполненного промиса, чтобы к нему можно было прицепить любой другой матчер. Если промис отклонен, утверждение отклоняется.

Например, этот код проверяет, что промис выполняется, и что полученное значение равно 'lemon':

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

Обратите внимание, что, поскольку вы все еще тестируете промисы, тест все еще асинхронный. Поэтому вам нужно сказать Jest подождать, вернув извлеченное утверждение.

В качестве альтернативы вы можете использовать async/await в сочетании с .resolves:

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

.rejects

Используйте .rejects для извлечения причины отклоненного промиса, чтобы к ней можно было прицепить любой другой матчер. Если промис выполнен, утверждение отклоняется.

Например, этот код проверяет, что промис отклоняется с причиной 'octopus':

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

Обратите внимание, что, поскольку вы все еще тестируете промисы, тест все еще асинхронный. Поэтому вам нужно сказать Jest подождать, вернув извлеченное утверждение.

В качестве альтернативы вы можете использовать async/await в сочетании с .rejects.

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

.toBe(value)

Используйте .toBe для сравнения примитивных значений или проверки ссылочной идентичности экземпляров объектов. Он вызывает Object.is для сравнения значений, что даже лучше для тестирования, чем оператор строгого равенства ===.

Например, этот код проверит некоторые свойства объекта can:

const can = {
  name: 'pamplemousse',
  ounces: 12,
};

describe('the can', () => {
  test('has 12 ounces', () => {
    expect(can.ounces).toBe(12);
  });

  test('has a sophisticated name', () => {
    expect(can.name).toBe('pamplemousse');
  });
});

Не используйте .toBe с числами с плавающей точкой. Например, из-за округления в JavaScript 0.2 + 0.1 не строго равно 0.3. Если у вас есть числа с плавающей точкой, попробуйте .toBeCloseTo вместо этого.

Хотя матчер .toBe проверяет ссылочную идентичность, он выводит глубокое сравнение значений, если утверждение отклоняется. Если различия между свойствами не помогают понять, почему тест терпит неудачу, особенно если отчет большой, то вы можете перенести сравнение в функцию expect. Например, чтобы проверить, являются ли элементы одним и тем же экземпляром:

• перепишите expect(received).toBe(expected) как expect(Object.is(received, expected)).toBe(true)
• перепишите expect(received).not.toBe(expected) как expect(Object.is(received, expected)).toBe(false)

.toHaveBeenCalled()

Также под псевдонимом: .toBeCalled()

Используйте .toHaveBeenCalledWith для обеспечения того, что функция-модель была вызвана со специфическими аргументами. Аргументы проверяются по тому же алгоритму, что и .toEqual.

Например, предположим, что у вас есть функция drinkAll(drink, flavour), которая принимает функцию drink и применяет ее ко всем доступным напиткам. Возможно, вы захотите проверить, что drink вызывается для 'lemon', но не для 'octopus', потому что вкус 'octopus' действительно странный, и зачем что-то должно быть с вкусом осьминога? Вы можете сделать это с помощью следующего набора тестов:

function drinkAll(callback, flavour) {
  if (flavour !== 'octopus') {
    callback(flavour);
  }
}

describe('drinkAll', () => {
  test('drinks something lemon-flavoured', () => {
    const drink = jest.fn();
    drinkAll(drink, 'lemon');
    expect(drink).toHaveBeenCalled();
  });

  test('does not drink something octopus-flavoured', () => {
    const drink = jest.fn();
    drinkAll(drink, 'octopus');
    expect(drink).not.toHaveBeenCalled();
  });
});

.toHaveBeenCalledTimes(number)

Также под псевдонимом: .toBeCalledTimes(number)

Используйте .toHaveBeenCalledTimes для обеспечения того, что функция-модель была вызвана ровно определенное количество раз.

Например, предположим, что у вас есть функция drinkEach(drink, Array<flavor>), которая принимает функцию drink и применяет ее к массиву переданных напитков. Возможно, вы захотите проверить, что функция напитка была вызвана ровно определенное количество раз. Вы можете сделать это с помощью следующего набора тестов:

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

.toHaveBeenCalledWith(arg1, arg2, ...)

Также под псевдонимом: .toBeCalledWith()

Используйте .toHaveBeenCalledWith для обеспечения того, что функция-модель была вызвана со специфическими аргументами. Аргументы проверяются по тому же алгоритму, что и .toEqual.

Например, предположим, что вы можете зарегистрировать напиток с помощью функции register, и applyToAll(f) должна применить функцию f ко всем зарегистрированным напиткам. Чтобы убедиться, что это работает, вы можете написать:

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

.toHaveBeenLastCalledWith(arg1, arg2, ...)

Также под псевдонимом: .lastCalledWith(arg1, arg2, ...)

Если у вас есть функция-модель, вы можете использовать .toHaveBeenLastCalledWith для проверки аргументов, с которыми она была вызвана в последний раз. Например, предположим, что у вас есть функция applyToAllFlavors(f), которая применяет f к ряду вкусов, и вы хотите убедиться, что при её вызове последним вкусом, к которому она применялась, был 'mango'. Вы можете написать:

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

.toHaveBeenNthCalledWith(nthCall, arg1, arg2, ....)

Также под псевдонимом: .nthCalledWith(nthCall, arg1, arg2, ...)

Если у вас есть функция-модель, вы можете использовать .toHaveBeenNthCalledWith для проверки аргументов, с которыми она была вызвана n-й раз. Например, предположим, что у вас есть функция drinkEach(drink, Array<flavor>), которая применяет f к ряду вкусов, и вы хотите убедиться, что при её вызове первым вкусом, к которому она применялась, был 'lemon', а вторым — 'octopus'. Вы можете написать:

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

.toHaveReturned()

Также под псевдонимом: .toReturn()

Если у вас есть функция-модель, вы можете использовать .toHaveReturned для проверки того, что функция-модель успешно вернула значение (то есть не сгенерировала ошибку) хотя бы один раз. Вызовы функции-модели, которые сгенерировали ошибку, не учитываются при подсчёте успешных возвратов.

Например, предположим, что у вас есть функция-модель drink, которая возвращает true. Вы можете написать:

test('drinks returns', () => {
  const drink = jest.fn(() => true);

  drink();

  expect(drink).toHaveReturned();
});

.toHaveReturnedTimes(number)

Также под псевдонимом: .toReturnTimes(number)

Используйте .toHaveReturnedTimes, чтобы убедиться, что функция-модель успешно вернула значение (то есть не сгенерировала ошибку) определённое количество раз. Вызовы функции-модели, которые сгенерировали ошибку, не учитываются при подсчёте успешных возвратов.

Например, предположим, что у вас есть функция-модель drink, которая возвращает true. Вы можете написать:

test('drink returns twice', () => {
  const drink = jest.fn(() => true);

  drink();
  drink();

  expect(drink).toHaveReturnedTimes(2);
});

.toHaveReturnedWith(value)

Также под псевдонимом: .toReturnWith(value)

Используйте .toHaveReturnedWith для проверки того, что функция-модель вернула конкретное значение.

Например, предположим, что у вас есть функция-модель drink, которая возвращает название напитка, который был выпит. Вы можете написать:

test('drink returns La Croix', () => {
  const beverage = {name: 'La Croix'};
  const drink = jest.fn(beverage => beverage.name);

  drink(beverage);

  expect(drink).toHaveReturnedWith('La Croix');
});

.toHaveLastReturnedWith(value)

Также под псевдонимом: .lastReturnedWith(value)

Используйте .toHaveLastReturnedWith для проверки конкретного значения, которое функция-модель вернула в последний раз. Если последний вызов функции-модели сгенерировал ошибку, этот матчер завершится неудачей независимо от ожидаемого значения возврата.

Например, предположим, что у вас есть функция-модель drink, которая возвращает название напитка, который был выпит. Вы можете написать:

test('drink returns La Croix (Orange) last', () => {
  const beverage1 = {name: 'La Croix (Lemon)'};
  const beverage2 = {name: 'La Croix (Orange)'};
  const drink = jest.fn(beverage => beverage.name);

  drink(beverage1);
  drink(beverage2);

  expect(drink).toHaveLastReturnedWith('La Croix (Orange)');
});

.toHaveNthReturnedWith(nthCall, value)

Также под псевдонимом: .nthReturnedWith(nthCall, value)

Используйте .toHaveNthReturnedWith для проверки конкретного значения, которое функция-модель вернула при n-ом вызове. Если n-ый вызов функции-модели сгенерировал ошибку, этот матчер завершится неудачей независимо от ожидаемого значения возврата.

Например, предположим, что у вас есть функция-модель drink, которая возвращает название напитка, который был выпит. Вы можете написать:

test('drink returns expected nth calls', () => {
  const beverage1 = {name: 'La Croix (Lemon)'};
  const beverage2 = {name: 'La Croix (Orange)'};
  const drink = jest.fn(beverage => beverage.name);

  drink(beverage1);
  drink(beverage2);

  expect(drink).toHaveNthReturnedWith(1, 'La Croix (Lemon)');
  expect(drink).toHaveNthReturnedWith(2, 'La Croix (Orange)');
});

.toHaveLength(number)

Используйте .toHaveLength для проверки, что у объекта есть свойство .length и оно установлено в определённое числовое значение.

Это особенно полезно для проверки размера массивов или строк.

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

.toHaveProperty(keyPath, value?)

Используйте .toHaveProperty для проверки существования свойства по заданному пути keyPath для объекта. Для проверки глубоко вложенных свойств в объекте вы можете использовать точечную нотацию или массив, содержащий путь к свойству для глубоких вложенных ссылок.

Вы можете указать необязательный аргумент value для сравнения полученного значения свойства (рекурсивно для всех свойств экземпляров объектов, также известного как глубокое равенство, как и матчер toEqual).

Следующий пример содержит объект houseForSale с вложенными свойствами. Мы используем toHaveProperty для проверки существования и значений различных свойств в объекте.

// Object containing house features to be tested
const houseForSale = {
  bath: true,
  bedrooms: 4,
  kitchen: {
    amenities: ['oven', 'stove', 'washer'],
    area: 20,
    wallColor: 'white',
    'nice.oven': true,
  },
  livingroom: {
    amenities: [
      {
        couch: [
          ['large', {dimensions: [20, 20]}],
          ['small', {dimensions: [10, 10]}],
        ],
      },
    ],
  },
  'ceiling.height': 2,
};

test('this house has my desired features', () => {
  // Example Referencing
  expect(houseForSale).toHaveProperty('bath');
  expect(houseForSale).toHaveProperty('bedrooms', 4);

  expect(houseForSale).not.toHaveProperty('pool');

  // Deep referencing using dot notation
  expect(houseForSale).toHaveProperty('kitchen.area', 20);
  expect(houseForSale).toHaveProperty('kitchen.amenities', [
    'oven',
    'stove',
    'washer',
  ]);

  expect(houseForSale).not.toHaveProperty('kitchen.open');

  // Deep referencing using an array containing the keyPath
  expect(houseForSale).toHaveProperty(['kitchen', 'area'], 20);
  expect(houseForSale).toHaveProperty(
    ['kitchen', 'amenities'],
    ['oven', 'stove', 'washer'],
  );
  expect(houseForSale).toHaveProperty(['kitchen', 'amenities', 0], 'oven');
  expect(houseForSale).toHaveProperty(
    'livingroom.amenities[0].couch[0][1].dimensions[0]',
    20,
  );
  expect(houseForSale).toHaveProperty(['kitchen', 'nice.oven']);
  expect(houseForSale).not.toHaveProperty(['kitchen', 'open']);

  // Referencing keys with dot in the key itself
  expect(houseForSale).toHaveProperty(['ceiling.height'], 'tall');
});

.toBeCloseTo(number, numDigits?)

Используйте toBeCloseTo для сравнения чисел с плавающей запятой на предмет приблизительного равенства.

Необязательный аргумент numDigits ограничивает количество цифр для проверки после десятичной точки. Для значения по умолчанию 2 критерием теста является Math.abs(expected - received) < 0.005 (то есть 10 ** -2 / 2).

Интуитивные сравнения на равенство часто приводят к ошибкам, потому что арифметика с десятичными (с основанием 10) значениями часто имеет ошибки округления в ограниченной точности двоичном (с основанием 2) представлении. Например, этот тест завершается неудачей:

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

Он завершается неудачей, потому что в JavaScript 0.2 + 0.1 на самом деле равно 0.30000000000000004.

Например, этот тест проходит с точностью в 5 цифр:

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

Поскольку проблема, которую решает toBeCloseTo, заключается в ошибках с плавающей запятой, она не поддерживает большие целочисленные значения.

.toBeDefined()

Используйте .toBeDefined для проверки, что переменная не является неопределённой. Например, если вы хотите проверить, что функция fetchNewFlavorIdea() возвращает что-то, вы можете написать:

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

Вы могли бы написать expect(fetchNewFlavorIdea()).not.toBe(undefined), но лучше избегать прямого обращения к undefined в вашем коде.

.toBeFalsy()

Используйте .toBeFalsy, когда вам неважно, что представляет собой значение, и вы хотите убедиться, что оно ложно в контексте булевой операции. Например, предположим, что у вас есть некоторый код приложения, который выглядит так:

drinkSomeLaCroix();
if (!getErrors()) {
  drinkMoreLaCroix();
}

Вам может неважно, что возвращает getErrors - оно может возвращать false, null или 0, и ваш код всё равно будет работать. Итак, если вы хотите проверить, что нет ошибок после выпитого напитка La Croix, вы можете написать:

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

В JavaScript существует шесть ложных значений: false, 0, '', null, undefined и NaN. Всё остальное истинно.

.toBeGreaterThan(number | bigint)

Используйте toBeGreaterThan для сравнения received > expected для числовых или больших целочисленных значений. Например, проверьте, что ouncesPerCan() возвращает значение больше 10 унций:

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

.toBeGreaterThanOrEqual(number | bigint)

Используйте toBeGreaterThanOrEqual для сравнения received >= expected для числовых или больших целочисленных значений. Например, проверьте, что ouncesPerCan() возвращает значение не меньше 12 унций:

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

.toBeLessThan(number | bigint)

Используйте toBeLessThan для сравнения received < expected для числовых или больших целочисленных значений. Например, проверьте, что ouncesPerCan() возвращает значение меньше 20 унций:

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

.toBeLessThanOrEqual(number | bigint)

Используйте toBeLessThanOrEqual для сравнения received <= expected для числовых или больших целочисленных значений. Например, проверьте, что ouncesPerCan() возвращает значение не более 12 унций:

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

.toBeInstanceOf(Class)

Используйте .toBeInstanceOf(Class) для проверки, что объект является экземпляром класса. Этот матчер использует instanceof в качестве основы.

class A {}

expect(new A()).toBeInstanceOf(A);
expect(() => {}).toBeInstanceOf(Function);
expect(new A()).toBeInstanceOf(Function); // throws

.toBeNull()

.toBeNull() эквивалентно .toBe(null), но сообщения об ошибках более информативны. Поэтому используйте .toBeNull(), когда нужно проверить, что значение равно null.

function bloop() {
  return null;
}

test('bloop returns null', () => {
  expect(bloop()).toBeNull();
});

.toBeTruthy()

Используйте .toBeTruthy, когда вам неважно, какое значение, и вы хотите убедиться, что оно истинно в контексте булевой операции. Например, предположим, что у вас есть некоторый код приложения, который выглядит так:

drinkSomeLaCroix();
if (thirstInfo()) {
  drinkMoreLaCroix();
}

Вам может неважно, что возвращает thirstInfo - это может быть true или сложный объект, и ваш код всё равно будет работать. Итак, если вы хотите проверить, что thirstInfo будет истинным после выпитого напитка La Croix, вы можете написать:

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

В JavaScript существует шесть ложных значений: false, 0, '', null, undefined и NaN. Всё остальное истинно.

.toBeUndefined()

Используйте .toBeUndefined для проверки, что переменная является неопределённой. Например, если вы хотите проверить, что функция bestDrinkForFlavor(flavor) возвращает undefined для вкуса 'octopus', потому что нет хорошего напитка с вкусом осьминога:

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

Вы могли бы написать expect(bestDrinkForFlavor('octopus')).toBe(undefined), но лучше избегать прямого обращения к undefined в вашем коде.

.toBeNaN()

Используйте .toBeNaN для проверки значения на NaN.

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

.toContain(item)

Используйте .toContain, когда нужно проверить, что элемент присутствует в массиве. Для проверки элементов массива используется ===, жёсткое сравнение на равенство. .toContain также может проверять, является ли строка подстрокой другой строки.

Например, если getAllFlavors() возвращает массив вкусов, и вы хотите убедиться, что lime присутствует в нём, вы можете написать:

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

Этот матчер также принимает другие итерируемые объекты, такие как строки, множества, списки узлов и коллекции HTML.

.toContainEqual(item)

Используйте .toContainEqual при необходимости проверки наличия элемента с определённой структурой и значениями в массиве. Для тестирования элементов в массиве этот согласователь рекурсивно проверяет равенство всех полей, а не проверяет идентичность объекта.

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

.toEqual(value)

Используйте .toEqual для рекурсивного сравнения всех свойств экземпляров объектов (также известного как «глубокое» равенство). Он вызывает Object.is для сравнения примитивных значений, что ещё лучше для тестирования, чем === оператор строгого равенства.

Например, .toEqual и .toBe ведут себя по-разному в этом наборе тестов, поэтому все тесты проходят:

const can1 = {
  flavor: 'grapefruit',
  ounces: 12,
};
const can2 = {
  flavor: 'grapefruit',
  ounces: 12,
};

describe('the La Croix cans on my desk', () => {
  test('have all the same properties', () => {
    expect(can1).toEqual(can2);
  });
  test('are not the exact same can', () => {
    expect(can1).not.toBe(can2);
  });
});

Если различия между свойствами не помогают понять, почему тест завершается неудачей, особенно если отчёт большой, можно перенести сравнение в функцию expect. Например, используйте метод equals класса Buffer для проверки, содержат ли буферы одинаковое содержимое:

• перепишите expect(received).toEqual(expected) как expect(received.equals(expected)).toBe(true)
• перепишите expect(received).not.toEqual(expected) как expect(received.equals(expected)).toBe(false)

.toMatch(regexp | string)

Используйте .toMatch для проверки соответствия строки регулярному выражению.

Например, вы можете не знать, что именно возвращает essayOnTheBestFlavor(), но вы знаете, что это очень длинная строка, и подстрока grapefruit должна быть в ней где-то. Вы можете протестировать это с помощью:

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

Этот согласователь также принимает строку, которую он попытается сопоставить:

describe('grapefruits are healthy', () => {
  test('grapefruits are a fruit', () => {
    expect('grapefruits').toMatch('fruit');
  });
});

.toMatchObject(object)

Используйте .toMatchObject для проверки соответствия JavaScript-объекта подмножеству свойств объекта. Он будет сопоставлять полученные объекты со свойствами, которые не находятся в ожидаемом объекте.

Вы также можете передать массив объектов, в этом случае метод вернёт true только если каждый объект в полученном массиве соответствует (в смысле toMatchObject, описанном выше) соответствующему объекту в ожидаемом массиве. Это полезно, если вы хотите проверить, что два массива совпадают по количеству элементов, в отличие от arrayContaining, которое допускает дополнительные элементы в полученном массиве.

Вы можете сопоставить свойства со значениями или со согласователями.

const houseForSale = {
  bath: true,
  bedrooms: 4,
  kitchen: {
    amenities: ['oven', 'stove', 'washer'],
    area: 20,
    wallColor: 'white',
  },
};
const desiredHouse = {
  bath: true,
  kitchen: {
    amenities: ['oven', 'stove', 'washer'],
    wallColor: expect.stringMatching(/white|yellow/),
  },
};

test('the house has my desired features', () => {
  expect(houseForSale).toMatchObject(desiredHouse);
});

describe('toMatchObject applied to arrays', () => {
  test('the number of elements must match exactly', () => {
    expect([{foo: 'bar'}, {baz: 1}]).toMatchObject([{foo: 'bar'}, {baz: 1}]);
  });

  test('.toMatchObject is called for each elements, so extra object properties are okay', () => {
    expect([{foo: 'bar'}, {baz: 1, extra: 'quux'}]).toMatchObject([
      {foo: 'bar'},
      {baz: 1},
    ]);
  });
});

.toMatchSnapshot(propertyMatchers?, hint?)

Это гарантирует, что значение соответствует последней созданной контрольной точке. Подробнее см. руководство по тестированию контрольных точек.

Вы можете указать необязательный propertyMatchers объект, который имеет асимметричные согласователи в качестве значений подмножества ожидаемых свойств, если полученное значение будет экземпляром объекта. Это похоже на toMatchObject с гибкими критериями для подмножества свойств, за которым следует тест контрольной точки как точные критерии для остальных свойств.

Вы можете указать необязательный hint строковый аргумент, который добавляется к имени теста. Хотя Jest всегда добавляет число в конец имени контрольной точки, краткие описательные подсказки могут быть более полезными, чем числа, для различения нескольких контрольных точек в одном блоке it или test. Jest сортирует контрольные точки по имени в соответствующем файле .snap.

.toMatchInlineSnapshot(propertyMatchers?, inlineSnapshot)

Гарантирует, что значение соответствует последней созданной контрольной точке.

Вы можете указать необязательный propertyMatchers объект, который имеет асимметричные согласователи в качестве значений подмножества ожидаемых свойств, если полученное значение будет экземпляром объекта. Это похоже на toMatchObject с гибкими критериями для подмножества свойств, за которым следует тест контрольной точки как точные критерии для остальных свойств.

Jest добавляет inlineSnapshot строковый аргумент к согласователю в файле теста (вместо внешнего файла .snap) в первый раз, когда тест выполняется.

Дополнительную информацию см. в разделе Встроенные контрольные точки.

.toStrictEqual(value)

Используйте .toStrictEqual для проверки того, что объекты имеют одинаковые типы и структуру.

Отличия от .toEqual:

• Проверяются ключи со свойствами undefined. Например, {a: undefined, b: 2} не соответствует {b: 2} при использовании .toStrictEqual.
• Проверяется разреженность массива. Например, [, 1] не соответствует [undefined, 1] при использовании .toStrictEqual.
• Проверяются равенство типов объектов. Например, экземпляр класса со свойствами a и b не будет равен литеральному объекту со свойствами a и b.

class LaCroix {
  constructor(flavor) {
    this.flavor = flavor;
  }
}

describe('the La Croix cans on my desk', () => {
  test('are not semantically the same', () => {
    expect(new LaCroix('lemon')).toEqual({flavor: 'lemon'});
    expect(new LaCroix('lemon')).not.toStrictEqual({flavor: 'lemon'});
  });
});

.toThrow(error?)

Также доступно под псевдонимом: .toThrowError(error?)

Используйте .toThrow для проверки того, что функция вызывает исключение при вызове. Например, если мы хотим проверить, что drinkFlavor('octopus') вызывает исключение, потому что вкус осьминога слишком отвратителен для питья, мы можем написать:

test('throws on octopus', () => {
  expect(() => {
    drinkFlavor('octopus');
  }).toThrow();
});

Вы можете указать необязательный аргумент для проверки того, что будет выброшено конкретное исключение:

• регулярное выражение: сообщение об ошибке соответствует шаблону
• строка: сообщение об ошибке содержит подстроку
• объект ошибки: сообщение об ошибке равно свойству message объекта
• класс ошибки: объект ошибки является экземпляром класса

Например, предположим, что drinkFlavor написан так:

function drinkFlavor(flavor) {
  if (flavor == 'octopus') {
    throw new DisgustingFlavorError('yuck, octopus flavor');
  }
  // Do some other stuff
}

Мы можем проверить, что эта ошибка будет выброшена несколькими способами:

test('throws on octopus', () => {
  function drinkOctopus() {
    drinkFlavor('octopus');
  }

  // Test that the error message says "yuck" somewhere: these are equivalent
  expect(drinkOctopus).toThrowError(/yuck/);
  expect(drinkOctopus).toThrowError('yuck');

  // Test the exact error message
  expect(drinkOctopus).toThrowError(/^yuck, octopus flavor$/);
  expect(drinkOctopus).toThrowError(new Error('yuck, octopus flavor'));

  // Test that we get a DisgustingFlavorError
  expect(drinkOctopus).toThrowError(DisgustingFlavorError);
});

.toThrowErrorMatchingSnapshot(hint?)

Используйте .toThrowErrorMatchingSnapshot для проверки того, что функция вызывает исключение, соответствующее последней созданной контрольной точке при вызове.

Вы можете указать необязательный hint строковый аргумент, который добавляется к имени теста. Хотя Jest всегда добавляет число в конец имени контрольной точки, краткие описательные подсказки могут быть более полезными, чем числа, для различения нескольких контрольных точек в одном блоке it или test. Jest сортирует контрольные точки по имени в соответствующем файле .snap.

Например, предположим, что у вас есть функция drinkFlavor, которая выбрасывает исключение всякий раз, когда вкус 'octopus', и она написана так:

function drinkFlavor(flavor) {
  if (flavor == 'octopus') {
    throw new DisgustingFlavorError('yuck, octopus flavor');
  }
  // Do some other stuff
}

Тест для этой функции будет выглядеть следующим образом:

test('throws on octopus', () => {
  function drinkOctopus() {
    drinkFlavor('octopus');
  }

  expect(drinkOctopus).toThrowErrorMatchingSnapshot();
});

И он сгенерирует следующую контрольную точку:

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

Дополнительную информацию о тестировании контрольных точек см. в статье React Tree Snapshot Testing.

.toThrowErrorMatchingInlineSnapshot(inlineSnapshot)

Используйте .toThrowErrorMatchingInlineSnapshot для проверки того, что функция вызывает исключение, соответствующее последней созданной контрольной точке при вызове.

Jest добавляет inlineSnapshot строковый аргумент к согласователю в файле теста (вместо внешнего файла .snap) в первый раз, когда тест выполняется.

Дополнительную информацию см. в разделе Встроенные контрольные точки.