Ich habe das folgende Modul, das ich in Jest testen möchte:

// myModule.js

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

export function testFn() {
  otherFn();

  // do other things
}

Wie oben gezeigt, werden einige benannte Funktionen exportiert und vor allem testFnverwendet otherFn.

Wenn ich im Scherz meinen Komponententest für schreibe testFn, möchte ich die otherFnFunktion verspotten , da ich nicht möchte, dass Fehler otherFnmeinen Komponententest beeinflussen testFn. Mein Problem ist, dass ich nicht sicher bin, wie ich das am besten machen kann:

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

Jede Hilfe / Einsicht wird geschätzt.

Einsatz im jest.requireActual()Innernjest.mock()

jest.requireActual(moduleName)

Gibt das eigentliche Modul anstelle eines Mocks zurück und umgeht alle Überprüfungen, ob das Modul eine Mock-Implementierung erhalten soll oder nicht.

Beispiel

Ich bevorzuge diese prägnante Verwendung, wenn Sie sie benötigen und innerhalb des zurückgegebenen Objekts verbreiten:

// myModule.test.js

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

describe(...)

Auf diese Methode wird auch in der Dokumentation zu Jest's Manual Mocks (gegen Ende der Beispiele ) verwiesen :

Um sicherzustellen, dass ein manueller Mock und seine tatsächliche Implementierung synchron bleiben, kann es hilfreich sein, das reale Modul jest.requireActual(moduleName)in Ihrem manuellen Mock zu verwenden und es vor dem Export mit Mock-Funktionen zu ändern.

import m from '../myModule';

Funktioniert bei mir nicht, ich habe verwendet:

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

m.otherFn = jest.fn();

Sieht so aus, als wäre ich zu spät zu dieser Party, aber ja, das ist möglich.

testFnmuss nur otherFn mit dem Modul anrufen .

Wenn testFndas Modul zum Aufrufen verwendet otherFnwird, kann der Modulexport für otherFnverspottet werden und testFnruft den Mock auf.

Hier ist ein Arbeitsbeispiel:

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

Mit dem transpilierten Code kann babel die Bindung, otherFn()auf die verwiesen wird, nicht abrufen . Wenn Sie eine Funktionsexpression verwenden, sollten Sie in der Lage sein, eine Verspottung zu erreichen 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();

Aber wie @kentcdodds im vorherigen Kommentar erwähnt, möchten Sie wahrscheinlich nicht verspotten otherFn(). Schreiben Sie einfach eine neue Spezifikation für otherFn()und verspotten Sie alle erforderlichen Anrufe.

Wenn Sie otherFn()beispielsweise eine http-Anfrage stellen ...

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

Hier möchten Sie http.getIhre Behauptungen basierend auf Ihren verspotteten Implementierungen verspotten und aktualisieren.

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

Ich weiß, dass dies vor langer Zeit gefragt wurde, aber ich bin gerade in diese Situation geraten und habe endlich eine Lösung gefunden, die funktionieren würde. Also dachte ich, ich würde hier teilen.

Für das Modul:

// myModule.js

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

export function testFn() {
  otherFn();

  // do other things
}

Sie können Folgendes ändern:

// myModule.js

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

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

  // do other things
}

Exportieren sie als Konstanten anstelle von Funktionen. Ich glaube, das Problem hat mit dem Heben in JavaScript zu tun und die Verwendung constverhindert dieses Verhalten.

Dann können Sie in Ihrem Test so etwas wie das Folgende haben:

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

Ihre Mocks sollten jetzt so funktionieren, wie Sie es normalerweise erwarten würden.

Ich habe mein Problem mit einer Mischung der Antworten gelöst, die ich hier gefunden habe:

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

Zusätzlich zur ersten Antwort hier können Sie babel-plugin-rewire verwenden , um auch importierte benannte Funktionen zu verspotten. Sie können den Abschnitt oberflächlich auf die Neuverdrahtung benannter Funktionen überprüfen .

Einer der unmittelbaren Vorteile für Ihre Situation besteht darin, dass Sie nicht ändern müssen, wie Sie die andere Funktion von Ihrer Funktion aus aufrufen.