Wie kann man mit Jest effektiv Funktionen innerhalb desselben Moduls verspotten?

Verspotten von Funktionen im selben Modul mit Jest

Beim Verspotten von Funktionen innerhalb desselben Moduls ist es wichtig, die Einschränkungen des Standard-Verspottens von Jest zu verstehen Mechanismus.

Problem:

Das Importieren des Moduls und das direkte Verspotten seiner exportierten Funktion, wie im Beispiel unten, kann zu unerwartetem Verhalten führen.

// module.js
export function bar() { return 'bar'; }
export function foo() { return `I am foo. bar is ${bar()}`; }

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

describe('module', () => {
  let barSpy;

  beforeEach(() => {
    barSpy = jest.spyOn(module, 'bar').mockImplementation(jest.fn());
  });

  it('foo', () => {
    module.bar.mockReturnValue('fake bar');
    expect(module.foo()).toEqual('I am foo. bar is fake bar');
    // Fails: Expected "I am foo. bar is fake bar" but received "I am foo. bar is bar"
  });
});

Erklärung:

Im obigen Beispiel ruft foo direkt die Originalleiste auf Funktion während der Importzeit. Auch wenn barSpy während des Testaufbaus korrekt aktualisiert wird, verweist foo immer noch auf die nicht verspottete Bar-Funktion, was zu einer falschen Ausgabe führt.

Lösung 1:

Importieren Sie das Modul in seine eigene Codedatei:

Um dieses Problem zu umgehen, kann das Modul in seine eigene Codedatei importiert werden, um dies sicherzustellen Alle exportierten Entitäten werden aus derselben Instanz importiert.

// module.js
export function bar() { return 'bar'; }
export function foo() { return `I am foo. bar is ${thisModule.bar()}`; }

// module.test.js
import * as module from './module';

describe('module', () => {
  it('foo', () => {
    spyOn(module, 'bar').and.returnValue('fake bar');
    expect(module.foo()).toEqual('I am foo. bar is fake bar');
  });
});

In diesem modifizierten Beispiel greift foo jetzt über die importierte Instanz module.bar auf bar zu, was ein einfaches Verspotten ermöglicht.

Lösung 2:

Manuell verspotten Importe:

Alternativ können die Importe im Test-Setup manuell gemockt werden, wodurch eine neue Instanz des Moduls erstellt wird, die von der nicht gemockten Version isoliert ist.

// module.test.js
jest.mock('../src/module');
const * as mockedModule = require('../src/module');

describe('module', () => {
  beforeEach(() => {
    mockedModule.bar.mockImplementation(jest.fn());
  });

  it('foo', () => {
    mockedModule.bar.mockReturnValue('fake bar');
    expect(mockedModule.foo()).toEqual('I am foo. bar is fake bar');
  });
});

Hier Ansatz wird die verspottete Instanz „mockedModule“ zum Testen verwendet, um Störungen durch die nicht verspotteten Importe zu verhindern.

Das obige ist der detaillierte Inhalt vonWie kann man mit Jest effektiv Funktionen innerhalb desselben Moduls verspotten?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!