Имитация зависимости в jest с машинописным текстом

При тестировании модуля, который имеет зависимость в другом файле. При назначении этого модуля в качестве jest.Mockмашинописного текста возникает ошибка, что метод mockReturnThisOnce(или любой другой метод jest.Mock) не существует в зависимости, это потому, что он был ранее типизирован. Как правильно заставить машинописный текст наследовать типы от jest.Mock?

Вот небольшой пример.

Зависимость

const myDep = (name: string) => name;
export default myDep;

test.ts

import * as dep from '../depenendency';
jest.mock('../dependency');

it('should do what I need', () => {
  //this throws ts error
  // Property mockReturnValueOnce does not exist on type (name: string)....
  dep.default.mockReturnValueOnce('return')
}

Мне кажется, что это очень распространенный вариант использования, и я не знаю, как правильно его вводить. Любая помощь приветствуется!

Вы можете использовать приведение типов, и оно test.tsдолжно выглядеть так:

import * as dep from '../dependency';
jest.mock('../dependency');

const mockedDependency = <jest.Mock<typeof dep.default>>dep.default;

it('should do what I need', () => {
  //this throws ts error
  // Property mockReturnValueOnce does not exist on type (name: string)....
  mockedDependency.mockReturnValueOnce('return');
});

Транспилятор TS не знает, что jest.mock('../dependency');меняет тип, depпоэтому вам нужно использовать приведение типа. Поскольку импортированный depне является определением типа, вы должны получить его тип typeof dep.default.

Вот еще несколько полезных шаблонов, которые я нашел во время работы с Jest и TS.

Когда импортированный элемент является классом, вам не обязательно использовать typeof, например:

import { SomeClass } from './SomeClass';

jest.mock('./SomeClass');

const mockedClass = <jest.Mock<SomeClass>>SomeClass;

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

import { existsSync } from 'fs';

jest.mock('fs');

const mockedExistsSync = <jest.Mock<typeof existsSync>>existsSync;

Если вы не хотите использовать автоматический макет jest и предпочитаете создавать ручной

import TestedClass from './TestedClass';
import TestedClassDependency from './TestedClassDependency';

const testedClassDependencyMock = jest.fn<TestedClassDependency>(() => ({
  // implementation
}));

it('Should throw an error when calling playSomethingCool', () => {
  const testedClass = new TestedClass(testedClassDependencyMock());
});

testedClassDependencyMock()создает фиктивный экземпляр объекта, TestedClassDependencyможет быть либо классом, либо типом, либо интерфейсом

Используйте mockedпомощника, ts-jestкак описано здесь

// foo.spec.ts
import { mocked } from 'ts-jest/utils'
import { foo } from './foo'
jest.mock('./foo')

// here the whole foo var is mocked deeply
const mockedFoo = mocked(foo, true)

test('deep', () => {
  // there will be no TS error here, and you'll have completion in modern IDEs
  mockedFoo.a.b.c.hello('me')
  // same here
  expect(mockedFoo.a.b.c.hello.mock.calls).toHaveLength(1)
})

test('direct', () => {
  foo.name()
  // here only foo.name is mocked (or its methods if it's an object)
  expect(mocked(foo.name).mock.calls).toHaveLength(1)
})

и если

• ты используешь tslint
• ts-jest находится в ваших dev-зависимостях,

добавьте это правило в свой tslint.json:"no-implicit-dependencies": [true, "dev"]

Я использую шаблон из @ types / jest / index.d.ts чуть выше type def для Mocked (строка 515):

import { Api } from "../api";
jest.mock("../api");

const myApi: jest.Mocked<Api> = new Api() as any;
myApi.myApiMethod.mockImplementation(() => "test");

Есть два решения, оба используют желаемую функцию.

1) Используйте jest.MockedFunction

import * as dep from './dependency';

jest.mock('./dependency');

const mockMyFunction = dep.myFunction as jest.MockedFunction<typeof dep.myFunction>;

2) Используйте jest.Mock

import * as dep from './dependency';

jest.mock('./dependency');

const mockMyFunction = dep.default as jest.Mock;

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

Оба решения для кастинга позволяют вызывать любую шутливую фиктивную функцию на mockMyFunctionлайке mockReturnValueили mockResolvedValue https://jestjs.io/docs/en/mock-function-api.html

mockMyFunction.mockReturnValue('value');

mockMyFunction может использоваться обычно для ожидания

expect(mockMyFunction).toHaveBeenCalledTimes(1);

В ролях as jest.Mock

Простое приведение функции к jest.Mockдолжно помочь:

(dep.default as jest.Mock).mockReturnValueOnce('return')

Вот что я сделал с jest@24.8.0 и ts-jest@24.0.2 :

источник:

class OAuth {

  static isLogIn() {
    // return true/false;
  }

  static getOAuthService() {
    // ...
  }
}

контрольная работа:

import { OAuth } from '../src/to/the/OAuth'

jest.mock('../src/utils/OAuth', () => ({
  OAuth: class {
    public static getOAuthService() {
      return {
        getAuthorizationUrl() {
          return '';
        }
      };
    }
  }
}));

describe('createMeeting', () => {
  test('should call conferenceLoginBuild when not login', () => {
    OAuth.isLogIn = jest.fn().mockImplementationOnce(() => {
      return false;
    });

    // Other tests
  });
});

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

jest.mock('../src/to/the/OAuth', () => ({
  OAuth: class {
    public static getOAuthService() {
      return {
        getAuthorizationUrl() {
          return '';
        }
      };
    }
  }
}));

Здесь должно быть какое-то преобразование типа из типа вашего класса в jest.MockedClassили что-то в этом роде. Но это всегда заканчивается ошибками. Я просто использовал его напрямую, и он работал.

test('Some test', () => {
  OAuth.isLogIn = jest.fn().mockImplementationOnce(() => {
    return false;
  });
});

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

jest.mock('../src/to/the/Conference', () => ({
  conferenceSuccessDataBuild: jest.fn(),
  conferenceLoginBuild: jest.fn()
}));
const mockedConferenceLoginBuild = conferenceLoginBuild as 
jest.MockedFunction<
  typeof conferenceLoginBuild
>;
const mockedConferenceSuccessDataBuild = conferenceSuccessDataBuild as 
jest.MockedFunction<
  typeof conferenceSuccessDataBuild
>;

Я нашел это в @types/jest:

/**
  * Wrap a function with mock definitions
  *
  * @example
  *
  *  import { myFunction } from "./library";
  *  jest.mock("./library");
  *
  *  const mockMyFunction = myFunction as jest.MockedFunction<typeof myFunction>;
  *  expect(mockMyFunction.mock.calls[0][0]).toBe(42);
*/

Примечание: когда вы делаете const mockMyFunction = myFunctionчто-то подобное mockFunction.mockReturnValue('foo'), вы тоже меняетесь myFunction.

Источник: https://github.com/DefinitiTyped/DefinitiTyped/blob/master/types/jest/index.d.ts#L1089

Недавняя библиотека решает эту проблему с помощью плагина babel: https://github.com/userlike/joke

Пример:

import { mock, mockSome } from 'userlike/joke';

const dep = mock(import('./dependency'));

// You can partially mock a module too, completely typesafe!
// thisIsAMock has mock related methods
// thisIsReal does not have mock related methods
const { thisIsAMock, thisIsReal } = mockSome(import('./dependency2'), () => ({ 
  thisIsAMock: jest.fn() 
}));

it('should do what I need', () => {
  dep.mockReturnValueOnce('return');
}

Имейте в виду, что depи mockReturnValueOnceполностью безопасны. Кроме того, tsserver знает, что он depencencyбыл импортирован и назначен, depпоэтому все автоматические рефакторинги, поддерживаемые tsserver, тоже будут работать.

Примечание: я поддерживаю библиотеку.