Mam następujący moduł, który próbuję przetestować w Jest:

// myModule.js

export function otherFn() {
  console.log('do something');
}

export function testFn() {
  otherFn();

  // do other things
}

Jak pokazano powyżej, eksportuje niektóre nazwane funkcje i, co ważne, testFnużywa otherFn.

W Jest, kiedy piszę mój test jednostkowy dla testFn, chcę mockować otherFnfunkcję, ponieważ nie chcę, aby błędy otherFnwpływały na mój test jednostkowy testFn. Mój problem polega na tym, że nie jestem pewien, jak najlepiej to zrobić:

// myModule.test.js
jest.unmock('myModule');

import { testFn, otherFn } from 'myModule';

describe('test category', () => {
  it('tests something about testFn', () => {
    // I want to mock "otherFn" here but can't reassign
    // a.k.a. can't do otherFn = jest.fn()
  });
});

Każda pomoc / wgląd jest mile widziany.

Użyj jest.requireActual()wewnątrzjest.mock()

jest.requireActual(moduleName)

Zwraca rzeczywisty moduł zamiast makiety, pomijając wszystkie sprawdzenia, czy moduł powinien otrzymać fałszywą implementację, czy nie.

Przykład

Wolę to zwięzłe użycie, gdy potrzebujesz i rozpowszechniasz w zwracanym obiekcie:

// myModule.test.js

jest.mock('./myModule.js', () => (
  {
    ...(jest.requireActual('./myModule.js')),
    otherFn: jest.fn()
  }
))

import { otherFn } from './myModule.js'

describe('test category', () => {
  it('tests something about otherFn', () => {
    otherFn.mockReturnValue('foo')
    expect(otherFn()).toBe('foo')
  })
})

Ta metoda jest również opisana w dokumentacji Jest's Manual Mocks (pod koniec przykładów ):

Aby upewnić się, że ręczna makieta i jej rzeczywista implementacja pozostają zsynchronizowane, warto wymagać, aby rzeczywisty moduł używał jest.requireActual(moduleName)w ręcznym makiecie i poprawił go za pomocą funkcji makiety przed wyeksportowaniem.

import m from '../myModule';

U mnie nie działa, użyłem:

import * as m from '../myModule';

m.otherFn = jest.fn();

Wygląda na to, że spóźniłem się na to przyjęcie, ale tak, jest to możliwe.

testFnwystarczy zadzwonić otherFn za pomocą modułu .

Jeśli testFnużywa modułu do wywołania, otherFnwówczas eksport modułu dla otherFnmoże być mockowany i testFnwywoła model.

Oto działający przykład:

myModule.js

import * as myModule from './myModule';  // import myModule into itself

export function otherFn() {
  return 'original value';
}

export function testFn() {
  const result = myModule.otherFn();  // call otherFn using the module

  // do other things

  return result;
}

myModule.test.js

import * as myModule from './myModule';

describe('test category', () => {
  it('tests something about testFn', () => {
    const mock = jest.spyOn(myModule, 'otherFn');  // spy on otherFn
    mock.mockReturnValue('mocked value');  // mock the return value

    expect(myModule.testFn()).toBe('mocked value');  // SUCCESS

    mock.mockRestore();  // restore otherFn
  });
});

Transpiled kod nie pozwoli Babel na pobranie powiązania, do którego otherFn()się odnosi. Jeśli używasz wyrażenia funkcji, powinieneś być w stanie uzyskać mockowanie otherFn().

// myModule.js
exports.otherFn = () => {
  console.log('do something');
}

exports.testFn = () => {
  exports.otherFn();

  // do other things
}

// myModule.test.js
import m from '../myModule';

m.otherFn = jest.fn();

Ale jak @kentcdodds wspomniał w poprzednim komentarzu, prawdopodobnie nie chciałbyś kpić otherFn(). Zamiast tego po prostu napisz nową specyfikację otherFn()i udawaj wszelkie niezbędne wywołania, które wykonuje.

Na przykład, jeśli otherFn()wysyła żądanie http ...

// myModule.js
exports.otherFn = () => {
  http.get('http://some-api.com', (res) => {
    // handle stuff
  });
};

Tutaj chciałbyś kpić http.geti aktualizować swoje potwierdzenia na podstawie twoich udawanych implementacji.

// myModule.test.js
jest.mock('http', () => ({
  get: jest.fn(() => {
    console.log('test');
  }),
}));

Wiem, że zadawano to dawno temu, ale właśnie natknąłem się na tę właśnie sytuację i w końcu znalazłem rozwiązanie, które zadziała. Więc pomyślałem, że podzielę się tutaj.

Dla modułu:

// myModule.js

export function otherFn() {
  console.log('do something');
}

export function testFn() {
  otherFn();

  // do other things
}

Możesz zmienić na następujące:

// myModule.js

export const otherFn = () => {
  console.log('do something');
}

export const testFn = () => {
  otherFn();

  // do other things
}

eksportowanie ich jako stałych zamiast funkcji. Uważam, że problem ma związek z podnoszeniem JavaScript i używanie constzapobiega temu zachowaniu.

Następnie w swoim teście możesz mieć coś takiego:

import * as myModule from 'myModule';


describe('...', () => {
  jest.spyOn(myModule, 'otherFn').mockReturnValue('what ever you want to return');

  // or

  myModule.otherFn = jest.fn(() => {
    // your mock implementation
  });
});

Twoje makiety powinny teraz działać tak, jak zwykle byś oczekiwał.

Rozwiązałem swój problem za pomocą kombinacji odpowiedzi, które znalazłem tutaj:

myModule.js

import * as myModule from './myModule';  // import myModule into itself

export function otherFn() {
  return 'original value';
}

export function testFn() {
  const result = myModule.otherFn();  // call otherFn using the module

  // do other things

  return result;
}

myModule.test.js

import * as myModule from './myModule';

describe('test category', () => {
  let otherFnOrig;

  beforeAll(() => {
    otherFnOrig = myModule.otherFn;
    myModule.otherFn = jest.fn();
  });

  afterAll(() => {
    myModule.otherFn = otherFnOrig;
  });

  it('tests something about testFn', () => {
    // using mock to make the tests
  });
});

Oprócz pierwszej odpowiedzi tutaj, możesz użyć babel-plugin-rewire do mockowania zaimportowanej nazwanej funkcji. Możesz przejrzeć tę sekcję powierzchownie, aby uzyskać informacje o ponownym okablowaniu funkcji .

Jedną z bezpośrednich korzyści dla twojej sytuacji jest to, że nie musisz zmieniać sposobu wywoływania drugiej funkcji ze swojej funkcji.

Opierając się na odpowiedzi Briana Adamsa, w ten sposób mogłem zastosować to samo podejście w TypeScript. Co więcej, za pomocą jest.doMock () można mockować funkcje modułu tylko w niektórych specyficznych testach pliku testowego i dostarczać dla każdego z nich indywidualne mockowe implementacje.

src / module.ts

import * as module from './module';

function foo(): string {
  return `foo${module.bar()}`;
}

function bar(): string {
  return 'bar';
}

export { foo, bar };

test / module.test.ts

import { mockModulePartially } from './helpers';

import * as module from '../src/module';

const { foo } = module;

describe('test suite', () => {
  beforeEach(function() {
    jest.resetModules();
  });

  it('do not mock bar 1', async() => {
    expect(foo()).toEqual('foobar');
  });

  it('mock bar', async() => {
    mockModulePartially('../src/module', () => ({
      bar: jest.fn().mockImplementation(() => 'BAR')
    }));
    const module = await import('../src/module');
    const { foo } = module;
    expect(foo()).toEqual('fooBAR');
  });

  it('do not mock bar 2', async() => {
    expect(foo()).toEqual('foobar');
  });
});

test / helpers.ts

export function mockModulePartially(
  modulePath: string,
  mocksCreator: (originalModule: any) => Record<string, any>
): void {
  const testRelativePath = path.relative(path.dirname(expect.getState().testPath), __dirname);
  const fixedModulePath = path.relative(testRelativePath, modulePath);
  jest.doMock(fixedModulePath, () => {
    const originalModule = jest.requireActual(fixedModulePath);
    return { ...originalModule, ...mocksCreator(originalModule) };
  });
}

Mockowanie funkcji modułu jest przenoszone do funkcji pomocniczej mockModulePartiallyznajdującej się w oddzielnym pliku, dzięki czemu może być używana z różnych plików testowych (które zwykle mogą znajdować się w innych katalogach). Polega na expect.getState().testPathnaprawieniu ścieżki do modułu ( modulePath), który jest mockowany (uczynienie go względnym do helpers.tszawierającego mockModulePartially). mocksCreatorfunkcja przekazana jako drugi argument mockModulePartiallypowinna zwrócić makiety modułu. Ta funkcja originalModulemoże opcjonalnie na niej polegać.