Wie kann ich einen ES6-Modulimport mit Jest verspotten?

Ich fange an zu denken, dass dies nicht möglich ist, aber ich möchte trotzdem fragen.

Ich möchte testen, ob eines meiner ES6-Module ein anderes ES6-Modul auf eine bestimmte Weise aufruft. Mit Jasmine ist das super einfach -

Der App-Code:

// myModule.js
import dependency from './dependency';

export default (x) => {
  dependency.doSomething(x * 2);
}

Und der Testcode:

//myModule-test.js
import myModule from '../myModule';
import dependency from '../dependency';

describe('myModule', () => {
  it('calls the dependency with double the input', () => {
    spyOn(dependency, 'doSomething');

    myModule(2);

    expect(dependency.doSomething).toHaveBeenCalledWith(4);
  });
});

Was ist das Äquivalent zu Jest? Ich denke, das ist so einfach zu tun, aber ich habe mir die Haare ausgerissen, um es herauszufinden.

Am nächsten komme ich, indem ich das imports durch requires ersetze und es in die Tests / Funktionen verschiebe. Beides möchte ich nicht tun.

// myModule.js
export default (x) => {
  const dependency = require('./dependency'); // yuck
  dependency.doSomething(x * 2);
}

//myModule-test.js
describe('myModule', () => {
  it('calls the dependency with double the input', () => {
    jest.mock('../dependency');

    myModule(2);

    const dependency = require('../dependency'); // also yuck
    expect(dependency.doSomething).toBeCalledWith(4);
  });
});

Für Bonuspunkte würde ich gerne dafür sorgen, dass das Ganze funktioniert, wenn die darin enthaltene Funktion dependency.jsein Standardexport ist. Ich weiß jedoch, dass das Ausspionieren von Standardexporten in Jasmine nicht funktioniert (oder zumindest könnte ich es nie zum Laufen bringen), also hoffe ich nicht, dass es auch in Jest möglich ist.

Ich konnte dies mit einem Hack lösen import *. Es funktioniert sogar sowohl für benannte als auch für Standardexporte!

Für einen benannten Export:

// dependency.js
export const doSomething = (y) => console.log(y)

// myModule.js
import { doSomething } from './dependency';

export default (x) => {
  doSomething(x * 2);
}

// myModule-test.js
import myModule from '../myModule';
import * as dependency from '../dependency';

describe('myModule', () => {
  it('calls the dependency with double the input', () => {
    dependency.doSomething = jest.fn(); // Mutate the named export

    myModule(2);

    expect(dependency.doSomething).toBeCalledWith(4);
  });
});

Oder für einen Standardexport:

// dependency.js
export default (y) => console.log(y)

// myModule.js
import dependency from './dependency'; // Note lack of curlies

export default (x) => {
  dependency(x * 2);
}

// myModule-test.js
import myModule from '../myModule';
import * as dependency from '../dependency';

describe('myModule', () => {
  it('calls the dependency with double the input', () => {
    dependency.default = jest.fn(); // Mutate the default export

    myModule(2);

    expect(dependency.default).toBeCalledWith(4); // Assert against the default
  });
});

Wie Mihai Damian unten zu Recht hervorhob, mutiert dies das Modulobjekt von dependencyund wird daher auf andere Tests übertragen. Wenn Sie diesen Ansatz verwenden, sollten Sie den ursprünglichen Wert speichern und ihn nach jedem Test erneut zurücksetzen. Um dies mit Jest einfach zu machen, verwenden Sie die spyOn () -Methode anstelle der Methode jest.fn(), die die einfache Wiederherstellung des ursprünglichen Werts unterstützt, und vermeiden Sie daher das zuvor erwähnte "Lecken".

Sie müssen das Modul verspotten und den Spion selbst einstellen:

import myModule from '../myModule';
import dependency from '../dependency';
jest.mock('../dependency', () => ({
  doSomething: jest.fn()
}))

describe('myModule', () => {
  it('calls the dependency with double the input', () => {
    myModule(2);
    expect(dependency.doSomething).toBeCalledWith(4);
  });
});

So verspotten Sie den Standardexport eines ES6-Abhängigkeitsmoduls mithilfe von Scherz:

import myModule from '../myModule';
import dependency from '../dependency';

jest.mock('../dependency');

// If necessary, you can place a mock implementation like this:
dependency.mockImplementation(() => 42);

describe('myModule', () => {
  it('calls the dependency once with double the input', () => {
    myModule(2);

    expect(dependency).toHaveBeenCalledTimes(1);
    expect(dependency).toHaveBeenCalledWith(4);
  });
});

Die anderen Optionen haben in meinem Fall nicht funktioniert.

Hinzufügen zu mehr Antwort von Andreas. Ich hatte das gleiche Problem mit ES6-Code, wollte aber die Importe nicht mutieren. Das sah hackig aus. Also habe ich das gemacht

import myModule from '../myModule';
import dependency from '../dependency';
jest.mock('../dependency');

describe('myModule', () => {
  it('calls the dependency with double the input', () => {
    myModule(2);
  });
});

Und dependency.js im Ordner "__ mocks __" parallel zu dependency.js hinzugefügt . Das hat bei mir funktioniert. Dies gab mir auch die Möglichkeit, geeignete Daten aus der Scheinimplementierung zurückzugeben. Stellen Sie sicher, dass Sie den richtigen Pfad zu dem Modul angeben, das Sie verspotten möchten.

Beim schnellen Vorlauf bis 2020 fand ich diesen Link als Lösung. Verwenden nur der ES6-Modulsyntax https://remarkablemark.org/blog/2018/06/28/jest-mock-default-named-export/

// esModule.js
export default 'defaultExport';
export const namedExport = () => {};

// esModule.test.js
jest.mock('./esModule', () => ({
  __esModule: true, // this property makes it work
  default: 'mockedDefaultExport',
  namedExport: jest.fn(),
}));

import defaultExport, { namedExport } from './esModule';
defaultExport; // 'mockedDefaultExport'
namedExport; // mock function

Außerdem müssen Sie wissen (was ich eine Weile gebraucht habe, um herauszufinden), dass Sie im Test nicht jest.mock () aufrufen können. Sie müssen es auf der obersten Ebene des Moduls aufrufen. Sie können jedoch mockImplementation () in einzelnen Tests aufrufen, wenn Sie verschiedene Mocks für verschiedene Tests einrichten möchten.

Die Frage ist bereits beantwortet, aber Sie können sie folgendermaßen lösen:

dependency.js

const doSomething = (x) => x
export default doSomething;

myModule.js:

import doSomething from "./dependency";

export default (x) => doSomething(x * 2);

myModule.spec.js:

jest.mock('../dependency');
import doSomething from "../dependency";
import myModule from "../myModule";

describe('myModule', () => {
  it('calls the dependency with double the input', () => {
    doSomething.mockImplementation((x) => x * 10)

    myModule(2);

    expect(doSomething).toHaveBeenCalledWith(4);
    console.log(myModule(2)) // 40
  });
});

Ich habe das anders gelöst. Angenommen, Sie haben Ihre dependency.js

export const myFunction = () => { }

Ich erstelle außerdem eine depdency.mock.js-Datei mit folgendem Inhalt:

export const mockFunction = jest.fn();

jest.mock('dependency.js', () => ({ myFunction: mockFunction }));

und im Test, bevor ich die Datei importiere, die die von mir verwendete Abhängigkeit hat:

import { mockFunction } from 'dependency.mock'
import functionThatCallsDep from './tested-code'

it('my test', () => {
    mockFunction.returnValue(false);

    functionThatCallsDep();

    expect(mockFunction).toHaveBeenCalled();

})