Simulacro de dependencia en broma con mecanografiado

Al probar un módulo que tiene una dependencia en un archivo diferente. Al asignar ese módulo para ser jest.Mockmecanografiado da un error de que el método mockReturnThisOnce(o cualquier otro método jest.Mock) no existe en la dependencia, esto se debe a que se tecleó previamente. ¿Cuál es la forma correcta de obtener mecanografiado para heredar los tipos de jest.Mock?

He aquí un ejemplo rápido.

Dependencia

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')
}

Siento que este es un caso de uso muy común y no estoy seguro de cómo escribirlo correctamente. ¡Cualquier ayuda será muy apreciada!

Puede utilizar la conversión de tipos y test.tsdebería verse así:

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 transpiler no es consciente de que jest.mock('../dependency');cambia el tipo de, deppor lo tanto, debe usar el tipo de conversión. Como importado depno es una definición de tipo, debe obtener su tipo typeof dep.default.

Aquí hay algunos otros patrones útiles que encontré durante mi trabajo con Jest y TS

Cuando el elemento importado es una clase, no tiene que usar typeof, por ejemplo:

import { SomeClass } from './SomeClass';

jest.mock('./SomeClass');

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

Esta solución también es útil cuando tiene que simular algunos módulos nativos de nodo:

import { existsSync } from 'fs';

jest.mock('fs');

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

En caso de que no desee utilizar la simulación automática de broma y prefiera crear una manual

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()crea una instancia de objeto simulado TestedClassDependencypuede ser de clase, de tipo o de interfaz

Utilice el mockedayudante de ts-jestcomo se explica aquí

// 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)
})

y si

• tu usas tslint
• ts-jest está en tus dependencias de desarrollo,

agregue esta regla a su tslint.json:"no-implicit-dependencies": [true, "dev"]

Utilizo el patrón de @ types / jest / index.d.ts justo encima del type def para Mocked (línea 515):

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

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

Hay dos soluciones, ambas tienen la función deseada

1) Usa broma.

import * as dep from './dependency';

jest.mock('./dependency');

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

2) Usa broma.

import * as dep from './dependency';

jest.mock('./dependency');

const mockMyFunction = dep.default as jest.Mock;

No hay diferencia entre estas dos soluciones. El segundo es más corto y, por lo tanto, sugeriría usar ese.

Ambas soluciones de fundición permiten llamar a cualquier función simulada de broma en me mockMyFunctiongusta mockReturnValueo mockResolvedValue https://jestjs.io/docs/en/mock-function-api.html

mockMyFunction.mockReturnValue('value');

mockMyFunction se puede utilizar normalmente para esperar

expect(mockMyFunction).toHaveBeenCalledTimes(1);

Emitir as jest.Mock

Simplemente lanzando la función a jest.Mockdebería hacer el truco:

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

Esto es lo que hice con jest@24.8.0 y ts-jest@24.0.2 :

fuente:

class OAuth {

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

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

prueba:

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
  });
});

Así es como simular una clase no predeterminada y sus métodos estáticos:

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

Aquí debería haber alguna conversión de tipo del tipo de su clase a jest.MockedClasso algo así. Pero siempre termina con errores. Así que lo usé directamente y funcionó.

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

Pero, si es una función, puedes burlarte de ella y hacer el tipo de conversación.

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
>;

He encontrado esto en @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);
*/

Nota: Cuando lo haces const mockMyFunction = myFunctiony luego algo como mockFunction.mockReturnValue('foo'), también estás cambiando myFunction.

Fuente: https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/jest/index.d.ts#L1089

Una biblioteca reciente resuelve este problema con un complemento de babel: https://github.com/userlike/joke

Ejemplo:

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');
}

Tenga en cuenta que depy mockReturnValueOnceson totalmente seguros. Además, tsserver sabe que depencencyse importó y se le asignó, por deplo que todas las refactorizaciones automáticas que admite tsserver también funcionarán.

Nota: mantengo la biblioteca.