Fausse dépendance en plaisanterie avec le manuscrit

Question

Lors du test d'un module qui a une dépendance dans un fichier différent. Lors de l'affectation que le module jest.Mock tapuscrit donne une erreur que la méthode mockReturnThisOnce(ou tout autre plaisanterie.Se moquer de la méthode) n'existe pas sur la dépendance, c'est parce qu'il est déjà tapé. Quelle est la bonne façon d'obtenir copie dactylographiée d'hériter les types de plaisanterie.Maquette?

Voici un exemple rapide.

La dépendance

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

J'ai l'impression que c'est un très commun de cas d'utilisation, et pas sûr de la façon appropriée de ce type. Toute aide serait grandement appréciée!

Answer 1

Vous pouvez utiliser le type coulée et votre test.ts devrait ressembler à ceci:

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 n'est pas au courant qu' jest.mock('../dependency'); des changements de type d' dep vous devez donc utiliser la conversion de type. Comme importés dep n'est pas une définition de type, vous devez obtenir son type avec typeof dep.default.

Voici quelques autres modèles utiles que j'ai trouvé lors de mon travail avec la Plaisanterie et TS

Lors de l'élément importé est une classe, alors vous n'avez pas à utiliser typeof par exemple:

import { SomeClass } from './SomeClass';

jest.mock('./SomeClass');

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

Cette solution est également utile lorsque vous avez à se moquer de certains nœud modules natifs:

import { existsSync } from 'fs';

jest.mock('fs');

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

Dans le cas où vous ne souhaitez pas utiliser la plaisanterie automatique de la maquette et préfèrent créer un manuel

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() crée se moquaient de l'instance d'un objet TestedClassDependency peut être soit la classe ou du type ou de l'interface

Answer 2

J'utilise le modèle de @ types / jest / index.d.ts juste au-dessus du type def pour Mocked (ligne 515):

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

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

Answer 3

Voici ce que j'ai fait avec jest@24.8.0 et ts-jest@24.0.2:

source:

class OAuth {

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

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

test:

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

C'est une façon de se moquer d'un non-classe par défaut et il est statique méthodes:

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

Ici devrait être un certain type de conversion à partir du type de votre classe afin d' jest.MockedClass ou quelque chose comme ça. Mais il finit toujours avec des erreurs. Donc j'ai simplement utilisé directement, et cela a fonctionné.

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

Mais, si c'est une fonction, vous pouvez simuler et de faire le type de conversation.

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

Answer 4

Puisque nous parlons d'un test, une façon rapide et sale est simplement de dire à TypeScript d'ignorer cette ligne:

 //@ts-ignore
dep.default.mockReturnValueOnce('return')