Jest: 特定のモジュール機能をモックする方法は？

詳細に分析すると、jest-mockはモジュール全体のASTを生成し、そのASTを使用して、元のエクスポートに準拠するモックモジュールを作成しているようです： https ：

Pythonのモック（https://docs.python.org/3/library/unittest.mock-examples.html）などの他のテストフレームワークを使用すると、特定の関数をモックできます。 これは基本的なテストの概念です。

モジュールの一部をモックする機能を強くお勧めします。 jest-mockは、モックからのエクスポートを条件付きで無視し、元の実装を参照するように変更する必要があると思います。

できるよ：

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

const myModule = require('myModule');
myModule.foo = jest.fn();

http://facebook.github.io/jest/docs/api.html#mock-functionsを参照して

requireがどのように機能するかについて根本的な誤解があると思います。 require()を呼び出すと、モジュールのインスタンスを取得できません。 モジュールの関数への参照を持つオブジェクトを取得します。 必要なモジュールの値を上書きすると、独自の参照が上書きされますが、実装は元の参照を保持します。

あなたの例では、 myModule.foo()を呼び出すと、はい、モックバージョンを呼び出します。 ただし、内部でfoo()を呼び出すmyModule.bar()を呼び出す場合、それがfoo()するfooは_上書きされたバージョンではありません_。 あなたが私を信じていないなら、あなたはそれを試すことができます。

したがって、あなたが説明した例は、私が抱えている問題には不十分です。 私が知らないことを知っていますか？

@cpojer

私はこれをよく理解していると信じています。 しかし、babelがモジュールをコンパイルする方法は、これを理解しやすくするものではなく、私はあなたの混乱を理解しています。 モジュールを備えた実際のES2015環境でこれがどのように動作するかは正確にはわかりません。主な理由は、そのような環境が現在存在しないためです（Chrome Canaryの最新バージョンを除いて、まだ試していません）。 何が起こるかを説明するために、私たちはあなたのbabelコードのコンパイルされた出力を見る必要があります。 次のようになります。

var foo = function foo() {};
var bar = function bar() { foo(); };

exports.foo = foo;
exports.bar = bar;

この場合、fooをモックできないことは確かに正しいです。最初の問題を正しく読んでいないことをお詫びしますが、 fooがどのように呼び出されたかについてexports.foo()と想定しました。

ただし、コードを次のように変更した場合：

var foo = function foo() {};
var bar = function bar() { exports.foo(); };

exports.foo = foo;
exports.bar = bar;

次に、テストファイルで次のことを行います。

var module = require('../module');
module.foo = jest.fn();
module.bar();

期待どおりに動作します。 これは、ES2015を使用しないFacebookで行っていることです。

ES2015モジュールには、エクスポートするものに対して不変のバインディングがある場合がありますが、babelが現在コンパイルする基になるコンパイル済みコードは、そのような制約を強制しません。 現在、ネイティブにサポートされているモジュールを使用する厳密なES2015モジュール環境であなたが求めているものを正確にサポートする方法はありません。 jest-mock機能する方法は、モジュールコードを分離して実行し、モジュールのメタデータを取得してモック関数を作成することです。 繰り返しますが、この場合、 fooのローカルバインディングを変更する方法はありません。 これを効果的に実装する方法についてアイデアがある場合は、ここまたはプルリクエストで貢献してください。 このプロジェクトの行動規範があり、ここで読むことができます： https ：

この例の正しい解決策は、fooをモックするのではなく、fooが呼び出している高レベルのAPI（XMLHttpRequestや代わりに使用する抽象化など）をモックすることです。

@cpojer詳しい説明ありがとうございます。 私の言語であなたを怒らせたら申し訳ありません、私は私のエンジニアリングの執筆で非常に効率的です、そして私はできるだけ早く私の主張を伝えたいです。 全体像を把握するために、私はこの問題を理解するために5時間費やし、2つの詳細なコメントを書きました。その後、両方のステートメントの要点を完全に見逃した短いメッセージで閉じました。 そのため、次のメッセージでは、「根本的な誤解」があると述べました。これは、1）私が言っていることを理解していなかったか、2） require()理解していなかったためです。これは、ありがたいことにオプション1でした。

私は自分の問題の可能な解決策を考え、それを回避するために、今のところ低レベルのAPIをモックしましたが、関数を直接モックする方法があるはずです。それは非常に便利です。

私はこれができると便利だと同意しますが、JSには（おそらく遅い）静的分析を前もって行わずにそれを行う良い方法はありません:(

@cpojer ：5か月後にここに飛び込むことが道であるかどうかはわかりませんが、これに関する他の会話は見つかりませんでした。

上記の提案から飛び降りて、同じモジュール内のある関数を別の関数からモックアウトするためにこれを行いました。

jest.unmock('./someModule.js');
import someModule from './someModule.js';

it('function1 calls function 2', () => {
    someModule.function2 = jest.fn();

    someModule.function1(...);

    expect(someModule.function2).toHaveBeenCalledWith(...);
});

これは1つのテストで機能しますが、1つのit(...);ブロックだけに分離された方法でこれを達成する方法を見つけられませんfunction2をテストすることを困難にします。 任意のヒント？

あなたは呼び出すことができます.mockClearに機能上のbeforeEachまたはお電話jest.clearAllMocks()あなたは冗談16を使用している場合。

ねえ@cpojer！ Jest 16を使用しています。 jest.clearAllMocks()もsomeModule.function2.mockClear()機能しません。 これらは、モックがモジュール全体であり、インポートされたモジュールの機能ではない場合にのみ機能します。 私のプロジェクトでは、関数は後続のテストでモックされたままです。 これが予期されていない場合は、小さなサンプルプロジェクトで複製して、新しい問題を作成できるかどうかを確認します。 良いアイデア？

@ cpojer-

この例の正しい解決策は、fooをモックするのではなく、fooが呼び出している高レベルのAPI（XMLHttpRequestや代わりに使用する抽象化など）をモックすることです。

私はJestを初めて使用し、同様の問題に苦しんでいます。 私が使用していますaxiosをボンネットの下に使用する、 XMLHttpRequest 、私はモックしたくないaxios 、実際の模擬するためにXMLHttpRequest 。 私が、自分で何かそのメソッドを実装しなければならないと思われ、これを。 これは正しいアプローチですか？

ありがとう！

ええ、このようなものはあなたを正しい道に導くはずです！ :) jest.fnをより良いAPIとして使用しますが、：D

ここでのコメントに関する@cpojer ： https ：

ES2015でそれをどのように行いますか？

// myModyle.js
export foo = (string) => "foo-" + string
export bar = (string2) => foo(string2)

// myModule.test.js
var module = require('./myModule');

// how do I mock foo here so this test passes?
expect(bar("hello")).toEqual("test-hello")

解決策を探しているこれに出くわした人にとって、1つのファイルに多くのconst /関数をエクスポートし、私がテストしているファイルにそれらをインポートするとき、以下は私のために働いているようです

`` javascript function mockFunctions() { const original = require.requireActual('../myModule'); return { ...original, //Pass down all the exported objects test: jest.fn(() => {console.log('I didnt call the original')}), someFnIWantToCurry: {console.log('I will curry the original') return jest.fn((...args) => original.someFnIWantToCurry(...args)}), } jest.mock('../myModule', () => mockFunctions()); const storage = require.requireMock('../myModule');

@ainesophaur 、ここで何が間違っているのかわからない。 しかし、それは機能しないようです
私は現在jest18.1（およびcreate-react-app 0.9.4）を使用しています

...<codes from comment above>..

// Let's say the original myModule has a function doSmth() that calls test()
storage.doSmth();
expect(storage.test).toHaveBeenCalled();

その後、テストは次のように失敗します。

expect(jest.fn()).toHaveBeenCalled()
Expected mock function to have been called.

@huyph jestが呼び出されたかどうかをテストするには、doSmthメソッドとtestメソッドをモックする必要があります。 モックコードのスニペットを提供できれば、何が問題なのかを確認できます

@ainesophaur ...test()メソッドをモックするためのものだと思いましたか？ この部分： test: jest.fn(() => {console.log('I didnt call the original')}),

@ainesophaur私もあなたのコードを試しました。 しかし、それは私にとってはうまくいきませんでした。 モック関数を実行することはありません。 したがって、期待は決して満たされません。

これは、上記のような作業が必要な方法に固有のものだと思います...これに対する解決策があればいいのにと思います。

@cpojer部分的にモックするモジュールに関して何か新しいことはありますか？

@ rantonmattei ＆ @ huyphモック定義のスニペットと実行中のテストを確認する必要があります。 実際の実装ファイルが必要/インポートされる前に、モックを定義する必要があります。 JESTを使用してからしばらく経ちましたが、node_modulesライブラリであろうとアプリ内のファイルであろうと、最終的に必要なものすべてをモックするようになったのを覚えています。 ATMの時間は少し足りませんが、Jestを使用して取り組んだプロジェクトのテストをいくつか紹介します。

依存関係からファイルをモックする

この例の実際の関数定義は、react-nativeによって行われます。ファイル「react-native / Libraries / Utilities /dismissKeyboard.js」をモックしています。

これは__mocks__/react-native/Libraries/Utilities/dismissKeyboard.js下のモックファイルです

function storeMockFunctions() {
  return jest.fn().mockImplementation(() => true);
}
jest.mock('react-native/Libraries/Utilities/dismissKeyboard', () => storeMockFunctions(), { virtual: true });
const dismissKeyboard = require('react-native/Libraries/Utilities/dismissKeyboard');
exports = module.exports = storeMockFunctions;

上記で使用したテストファイルが見つかりませんが、モジュールが必要なようなものでした。jestはそれを__mocks__で見つけて、次のようなことを行うことができました。

expect(dismissKeyboard.mock.calls).toHaveLength(1);

制御するファイルをモックする
実際の関数定義

export const setMerchantStores = (stores) => storage.set('stores', stores);

モック付きのテストファイル

const { storeListEpic, offerListEpic } = require('../merchant');

function storeMockFunctions() {
  const original = require.requireActual('../../common/Storage');
  return {
    ...original,
    setMerchantStores: jest.fn((...args) => original.setMerchantStores(...args)),
    setMerchantOffers: jest.fn((...args) => original.setMerchantOffers(...args)),
  };
}
jest.mock('../../common/Storage', () => storeMockFunctions());
import * as storage from '../../common/Storage';

afterEach(() => {
  storage.setMerchantStores.mockClear();
});

it('handle storeListEpic type STORE_LIST_REQUEST -> STORE_LIST_SUCCESS', async () => {
  const scope = nock('http://url')
  .get('/api/merchant/me/stores')
  .reply(200, storeData);
  const result = await storeListEpic(ActionsObservable.of(listStores())).toPromise();
  expect(storage.setMerchantStores.mock.calls).toHaveLength(1);
  expect(await storage.getMerchantStores()).toEqual({ ids: storesApiData.result, list: storesApiData.entities.store});
});

@ainesophaurを共有していただきありがとうございます。 私はまだそれをjest18.1で動作させることができません。 これが私のコードです：

it('should save session correctly', () => {

  function mockFunctions() {
    const original = require.requireActual('./session');
    return {
      ...original,
      restartCheckExpiryDateTimeout: jest.fn((() => {
        console.log('I didn\'t call the original');
      })),
    }
  }

  jest.mock('./session', () => mockFunctions());
  const mockSession = require('./session');

  // NOTE: saveSession() will call the original restartCheckExpiryDateTimeout() instead of my
  // mock one. However, mockSession.restartCheckExpiryDateTimeout() does call the mock one
  mockSession.saveSession('', getTomorrowDate(), 'AUTH');

  // mockSession.restartCheckExpiryDateTimeout(); // does print out "I didn't call the original"

  expect(mockSession.restartCheckExpiryDateTimeout).toHaveBeenCalled();
});

session.js

export function saveSession(sessionId, sessionExpiryDate, authToken) {
  ....
  restartCheckExpiryDateTimeout(sessionExpiryDate);
  ...
}
....

export function restartCheckExpiryDateTimeout(...) {
....
}

この問題を解決する方法が見つかりません。 これを再開できますか？ @cpojer

@huyphエクスポートsaveSessionは、モジュールを経由してmodule.restartCheckExpiryDateTimeoutを呼び出す代わりに、ローカルで定義されたrestartCheckExpiryDateTimeoutを呼び出します。つまり、モックされたmodule.restartCheckExpiryDateTimeout saveSession 、 saveSessionが実際に定義されたrestartCheckExpiryDateTimeout関数を呼び出しているため、 saveSessionによって検出されません。

saveSessionをconstに割り当ててから、 saveSession.restartCheckExpiryDateTimeout = () => {...logic}ます。 。次に、 saveSession.saveSession内から、 restartCheckExpiryDateTimeoutだけでなく、 saveSession.restartCheckExpiryDateTimeout呼び出します。 メソッドを定義する実際の関数saveSession代わりに、新しいconstをエクスポートします。 次に、 someVar.saveSession()呼び出すと、内部的にsaveSession.restartCheckExpiryDateTimeout()が呼び出されますが、これは現在モックされています。

restartCheckExpiryDateTimeout()はエクスポートされた関数であることを追加する必要があります。 saveSession()内でローカルに定義された関数ではありません...（上記の私のコメントを更新しました）。 その場合、 module.saveSession()は、モックされた正しいmodule.restartCheckExpiryDateTimeout()を呼び出す必要があると思います。

しかし、私はあなたが提案することを上に示します。 saveSession()とrestartCheckExpiryDateTimeout()両方を別の定数に移動します。 ありがとう

saveSessionのスコープで定義されていないことを理解しています。 saveSessionは
親スコープで兄弟メソッドを呼び出します。 私はこれに何度も遭遇しました
そして私が提案したことはそれのために働いた

2017年5月8日午後8時38分、「HuyPham」 [email protected]は次のように書いています。

restartCheckExpiryDateTimeout（）がエクスポートされることを追加する必要があります
関数。 saveSession（）内でローカルに定義された関数ではありません。

しかし、私はあなたが提案することを上にあげます。 ありがとう

—
あなたが言及されたのであなたはこれを受け取っています。
このメールに直接返信し、GitHubで表示してください
https://github.com/facebook/jest/issues/936#issuecomment-300029003 、またはミュート
スレッド
https://github.com/notifications/unsubscribe-auth/AEeBdsmpOOmzvcUHB3D_-Z7MChIzt10Pks5r37WYgaJpZM4IPGAH
。

試してみました..私はそれを見つけました：

これは機能しません:(つまり、元のrestartCheckExpiryDateTimeout（）は引き続き呼び出されます）

export session = {
   saveSession: () => {
      session.restartCheckExpiryDateTimeout();
   },
   restartCheckExpiryDateTimeout: () => {},
}

これは機能します（つまり、代わりにモックのrestartCheckExpiryDateTimeout（）が呼び出されます）。 違いは、矢印形式の代わりにfunction()を使用することと、 this.代わりにsession.

export session = {
   saveSession: function() {
      this.restartCheckExpiryDateTimeout();
   },
   restartCheckExpiryDateTimeout: () => {},
}

これらのコードをトランスパイルする冗談で問題になる可能性があります...。

それらをpojoではなくクラスオブジェクトとしてエクスポートしてみてください。 私は信じています
トランスパイラーは変数を異なる方法で巻き上げます。 私たちは働くようになります
テスト、約束します。私がプロジェクトに参加してから約半年が経ちました。
それは冗談を使っていましたが、私はこの問題をよく覚えています、そして私は最終的に覚えています
解決策を見つける。

2017年5月9日午前0時53分、「HuyPham」 [email protected]は次のように書いています。

試してみました..私はそれを見つけました：

これは機能しません:(つまり、元のrestartCheckExpiryDateTimeout（）は
まだ呼ばれる）

エクスポートセッション= {
saveSession：（）=> {
session.restartCheckExpiryDateTimeout（）;
}、
restartCheckExpiryDateTimeout：（）=> {}、
}

これは機能しません:(つまり、元のrestartCheckExpiryDateTimeout（）は
まだ呼ばれる）

エクスポートセッション= {
saveSession：function（）{
this.restartCheckExpiryDateTimeout（）;
}、
restartCheckExpiryDateTimeout：（）=> {}、
}

これらのコードをトランスパイルする冗談で問題になる可能性があります...。

—
あなたが言及されたのであなたはこれを受け取っています。
このメールに直接返信し、GitHubで表示してください
https://github.com/facebook/jest/issues/936#issuecomment-300060975 、またはミュート
スレッド
https://github.com/notifications/unsubscribe-auth/AEeBdrRQExycPYiGtvm7qYi5G87w6b6Oks5r3_FlgaJpZM4IPGAH
。

@sorahn同じ問題。 es6 + babel 、モックする方法は？
@cpojerつまり、 es6 + babel 、 export const function xx() {} 、多くの関数をエクスポートします。 Jestは、呼び出されたモジュール（ファイル）内の関数をモックする方法がありません。同じモジュール（ファイル）内の他の関数によって？ 私はそれをテストします、それは私が正しいようです。 commonjsパターンの場合のみ、Jestは例のように関数を正常にモックできます。

@ainesophaurが機能していません。

モジュール：

export const getMessage = (num: number): string => {
  return `Her name is ${genName(num)}`;
};

export function genName(num: number): string {
  return 'novaline';
}

テスト：

function mockFunctions() {
  const original = require.requireActual('../moduleA');
  return {
    ...original,
    genName: jest.fn(() => 'emilie')
  }
}
jest.mock('../moduleA', () => mockFunctions());
const moduleA = require('../moduleA');

describe('mock function', () => {

  it('t-0', () => {
    expect(jest.isMockFunction(moduleA.genName)).toBeTruthy();
  })

  it('t-1', () => {

    expect(moduleA.genName(1)).toBe('emilie');
    expect(moduleA.genName).toHaveBeenCalled();
    expect(moduleA.genName.mock.calls.length).toBe(1);
    expect(moduleA.getMessage(1)).toBe('Her name is emilie');
    expect(moduleA.genName.mock.calls.length).toBe(2);

  });

});

テスト結果：

FAIL  jest-examples/__test__/mock-function-0.spec.ts
  ● mock function › t-1

    expect(received).toBe(expected)

    Expected value to be (using ===):
      "Her name is emilie"
    Received:
      "Her name is novaline"

      at Object.it (jest-examples/__test__/mock-function-0.spec.ts:22:35)
      at Promise.resolve.then.el (node_modules/p-map/index.js:42:16)

  mock function
    ✓ t-0 (1ms)
    ✕ t-1 (22ms)

Test Suites: 1 failed, 1 total
Tests:       1 failed, 1 passed, 2 total
Snapshots:   0 total
Time:        0.215s, estimated 1s

上記の私の最後のいくつかのコメントを見てください。 具体的には最後のもの。 あなたの
エクスポートされたメソッドは、ローカルスコープの兄弟メソッドと
実際にエクスポートされたメソッド（モックがある場所）

2017年5月31日午前2:00、「novaline」 [email protected]は次のように書いています。

@ainesophaurhttps ：//github.com/ainesophaurが機能していません。

モジュール：

export const getMessage =（num：number）：string => {
Her name is ${genName(num)}返す;
};
エクスポート関数genName（num：number）：string {
'novaline'を返します。
}

テスト：

関数mockFunctions（）{
const original = require.requireActual（ '../ moduleA'）;
戻る {
...オリジナル、
genName：jest.fn（（）=> 'emilie'）
}
} jest.mock（ '../ moduleA'、（）=> mockFunctions（））; const moduleA = require（ '../ moduleA'）;
describe（ 'モック関数'、（）=> {

it（ 't-0'、（）=> {
expect（jest.isMockFunction（moduleA.genName））。toBeTruthy（）;
}）

it（ 't-1'、（）=> {

expect(moduleA.genName(1)).toBe('emilie');
expect(moduleA.genName).toHaveBeenCalled();
expect(moduleA.genName.mock.calls.length).toBe(1);
expect(moduleA.getMessage(1)).toBe('Her name is emilie');
expect(moduleA.genName.mock.calls.length).toBe(2);

}）;

}）;

テスト結果：

FAIL jest-examples / __ test __ / mock-function-0.spec.ts
●モック機能› t-1

expect(received).toBe(expected)

Expected value to be (using ===):
  "Her name is emilie"
Received:
  "Her name is novaline"

  at Object.it (jest-examples/__test__/mock-function-0.spec.ts:22:35)
  at Promise.resolve.then.el (node_modules/p-map/index.js:42:16)

モック関数
✓t-0（1ms）
✕t-1（22ms）

テストスイート：1つ失敗、合計1つ
テスト：1つ失敗、1つ合格、合計2つ
スナップショット：合計0
時間：0.215秒、推定1秒

—
あなたが言及されたのであなたはこれを受け取っています。
このメールに直接返信し、GitHubで表示してください
https://github.com/facebook/jest/issues/936#issuecomment-305091749 、またはミュート
スレッド
https://github.com/notifications/unsubscribe-auth/AEeBdv6SafXlTtKo3DNeFWhbL6gV9l0Gks5r_QHjgaJpZM4IPGAH
。

@ainesophaur ： export class Session { }試しました。 そして、それは私にとってはうまくいきません。

私にとって有効な唯一のアプローチは、上記のコメントにあります。ここでは、矢印() =>代わりにfunction構文が使用されています。 ここ：

export const session = {
   saveSession: function() {
      this.restartCheckExpiryDateTimeout();
   },
   restartCheckExpiryDateTimeout: () => {},
}

これはJest20.0.3にあります

私がやっていることは、関数のconstラッパーを作成してから、そのラッパーをエクスポートすることです（export const fnsなど）。 次に、モジュール内でfns.functionNameを使用すると、fns.functionName関数をjest.fn（）できます。

タイプスクリプトで記述されたユーザー定義モジュールのモック関数を作成する場合、およびモック関数を呼び出す場合は、関数のモックバージョンを呼び出すため、カバレッジレポートでカバーされる元の関数です。

もともとテストでインポートされた2つの関数があります
import { getCurrentDate, getStartEndDatesForTimeFrame } from ./../_helpers/date';
ご覧のとおり、 getStartEndDatesForTimeFrameはgetCurrentDate依存しています。 次の設定では、 getCurrentDateテストが適切に機能し、モックバージョンを使用します。 一方、何らかの理由でgetStartEndDatesForTimeFrameテストはモックされたgetCurrentDate使用しませんが、元の実装を使用するため、テストは失敗します。 私は多くの異なるセットアップを試しました（ Date.now = jest.fn(() => "2017-11-16T20:33:09.071Z");ように、それを機能させることができませんでした。何かアイデアはありますか？

export const getCurrentDate = () => new Date();
export const getStartEndDatesForTimeFrame = (timeFrame) => {
  ...
  const todayDate = getCurrentDate();
  ...
  switch (timeframe) {
    case TimeFrames.TODAY:
      console.log(todayDate); // this always prints the real value in tests instead of the mocked one
      start = new Date(todayDate.getFullYear(), todayDate.getMonth(), todayDate.getDate(), 0, 0, 0);
      end = new Date(
        todayDate.getFullYear(),
        todayDate.getMonth(),
        todayDate.getDate(), 23, 59, 59,
      );
      break;
  ...
  return { start: start.toISOString(), end: end.toISOString() }
};

function mockFunctions() {
  const original = require.requireActual('../../_helpers/date');
  return {
    ...original,
    getCurrentDate: jest.fn(() => '2017-11-16T20:33:09.071Z'),
  }
}
jest.mock('../../_helpers/date', () => mockFunctions());
const dateModule = require.requireMock('../../_helpers/date');

describe('getCurrentDate', () => {
  it('returns the mocked date', () => {
    expect(dateModule.getCurrentDate()).
      toBe('2017-11-16T20:33:09.071Z'); // this works well and returns the mocked value
  });
});

describe('getStartEndDatesForTimeFrame', () => {
  it('returns the start and end dates for today', () => {
    expect(dateModule.getStartEndDatesForTimeFrame('today')).toEqual(
      { 'start': '2017-11-15T23:00:00.000Z', 'end': '2017-11-16T22:59:59.000Z' }
    ); // this one uses the original getCurrentDate instead of the mocked one :(
  });
});

したがって、 getStartEndDatesForTimeFrameは、モックされた時刻ではなく現在の時刻を使用するため、失敗します。

@ainesophaurの提案に従って、オブジェクト内のすべての関数をエクスポートし、ローカルスコープの兄弟メソッドの代わりにこれらのエクスポートされたオブジェクトのメソッドを呼び出すことで、それを機能させることができました。

// imageModel.js
const model = {
  checkIfImageExists,
  getImageUrl,
  generateImagePreview
}
export default model

async function checkIfImageExists(...) {}
async function getImageUrl() {}
async function generateImagePreview() {
  // I am calling it as `model` object's method here, not as a locally scoped function
  return model.getImageUrl(...)
}

// imageModel.test.js
import imageModel from './imageModel'

test('should mock getImageUrl called within the same file', async () => {
  imageModel.getImageUrl = jest.fn().mockReturnValueOnce(Promise.resolve())

  await imageModel.generateImagePreview()

  expect(imageModel.getImageUrl).toBeCalled()
})

@miluoshiそれが私もできた唯一の方法です。 この方法を使用すると、パフォーマンスの低下などはありますか？ テストできるようにコードを変更するのは「間違っている」ようです。

私は本当にただ書く方法が欲しいです：
jest.mock('src/folder/file.func, () => {return 'whatever i want'})

ここで重要なのは.func

@miluoshi @Rdlenkeコードが名前付きエクスポートで構成されている場合は、 import * as modelから、 model.generateImagePreview = jest.fn(() => Promise.resolve);上書きすることもできます。

それをsinonでどのようにテストしますか？ 前述のように（https://github.com/facebook/jest/issues/936#issuecomment-214939935を参照）、ESMの動作方法により、 func2内でfunc1 func2をモックすることは不可能です。私は必ずしもそれを基本とは言いません。

たぶん、任意の「testImport」関数を読み込むbabelmodを作成できます。
そして、コードを書き直して、モジュール内の関数をエクスポートする前に
テスト実行？

2017年12月18日月曜日の午後5時に、JimMoodynotifications @ github.comは次のように書いています。

あなたは正しいです@SimenBhttps ：//github.com/simenb 、私は何かを変更しました
私のテストでは、Sinonに切り替える間に、合格したように見えます。
それを元に戻しても、まだ機能していません。 問題ないと思います
それは解決されました。

—
あなたが言及されたのであなたはこれを受け取っています。
このメールに直接返信し、GitHubで表示してください
https://github.com/facebook/jest/issues/936#issuecomment-352488400 、またはミュート
スレッド
https://github.com/notifications/unsubscribe-auth/AQRY9a5-s2_bjCWKNw5WiAJW-JeBf8W3ks5tBpoygaJpZM4IPGAH
。

-

ダレン・クレスウェル
契約開発者| Develer Limited
Eメール： [email protected]
電話：
ウェブサイト： http ：

この電子メールを印刷する前に、環境に配慮してください
警告：コンピュータウイルスは電子メールで送信される可能性があります。 受信者
この電子メールと添付ファイルでウイルスの存在を確認する必要があります。
Develer Limitedは、ウイルスによって引き起こされたいかなる損害についても責任を負いません。
このメールで送信されます。 電子メールの送信は保証できません
情報が傍受されたり、破損したり、失われたりする可能性があるため、安全またはエラーが発生しません。
破壊された、遅れて到着した、不完全な、またはウイルスが含まれている。 送り主
したがって、エラーや脱落については責任を負いません。
電子メール送信の結果として発生するこのメッセージの内容。

警告： Develer Limitedは合理的な予防策を講じていますが、
このメールにウイルスが含まれていないことを確認してください。会社はこれを受け入れることができません。
この電子メールの使用に起因する損失または損害に対する責任または
添付ファイル。

Develer Limitedは、イングランドおよびウェールズで登録された有限会社です。 |
会社登録番号09817616 | 登録事務所：SUITE 1 SECOND
FLOOR EVERDENE HOUSE、DEANSLEIGH ROAD、ボーンマス、イギリス、BH7 7DU

回避策を提供してくれた

非同期で動作する例が役立つと思われる場合は、次のようにします。

//reportError.js
const functions = {};

functions._reportToServer = (error, auxData) => {
  // do some stuff
};

functions.report = (error, auxData = {}) => {
  if (shouldReportToServer()) {
    functions._reportToServer(error, auxData);
  }
};
export default functions;

// reportError.jest.js
import reportError from 'app/common/redux/lib/reportError';
reportError._reportToServer = jest.fn();

describe('test reportError', () => {
  it('reports ERROR to server as as error', () => {
   reportError.report(new Error('fml'), {});
    expect(reportError._reportToServer).toHaveBeenCalledTimes(1);
  });
});

@ jim-moody問題を正しく理解していれば、これはあなたの例でうまくいくはずです：

const spyOnExampleFunc2 = jest.spyOn(example, 'func2');
example.func1();
expect(spyOnExampleFunc2).toBeCalled();

（この_only_は、例のように、関数がconstとしてエクスポートされた場合にのみ機能します）

@dinvlad私のヒーロー！

@dinvladの回答に続いて、 jestオブジェクトページの次のモック関連ドキュメントをモック関数ページに追加、例で表示、またはリンクすると、モックに関するjestドキュメントが改善される可能性があると思います。

• jest.isMockFunction（fn）
• jest.genMockFromModule（moduleName）
• jest.mock（moduleName、factory、options）
• jest.unmock（moduleName）
• jest.doMock（moduleName、factory、options）
• jest.dontMock（moduleName）

私のユースケースは、jestの新しいユーザーとして、mocha + sinon.jsコードをjestに移行することです。 私はすでにスパイと期待を持っていたので、それは簡単だろうと思いました。 しかし、このスレッドを読み、モック関数に関するjestのドキュメントを読んだ後、この方法でjestを使用するには、テストを書き直したり、ESMやBabelを詳細に理解したりする必要があるかもしれないという印象を受けました。

Jestに感謝します-それは私のテストを書き/理解しやすくし、実行するのを速くします。 :)

ドキュメントを明確にするPRは大歓迎です！ 🙂

ESモジュール構文で特定のモジュールのみをモックするには、 require.requireActualを使用して元のモジュールを復元し、モックするモジュールを上書きします。

import { foo } from './example';

jest.mock('./example', () => (
  ...require.requireActual('./example'),
  foo: jest.fn()
));

test('foo should be a mock function', () => {
  expect(foo('mocked!')).toHaveBeenCalledWith('mocked!');
});

逆さまに感じますが、それは私が出くわした最も簡単な方法です。 @joshjgへの帽子のヒント。

長い議論のどこかで迷子になりました。質問がありました。関数の実際の実装が呼び出されたかどうかをテストする方法はありますか？

私の理解では、 jest.fn()を使用する必要がある場合は元の関数をオーバーライドしますが、使用しない場合は、コンソールからjest.fn() function or a spyである必要があるというエラーが表示されます。

リクエストが渡されるミドルウェアをテストしようとしているので、それをモックすると、すべてのロジックが失われ、データが次のミドルウェアに渡されません。 インポートしてモックしない場合、この関数が呼び出されたことをテストできますか？

jest.spyOnを使用できますか？ デフォルトでは、基になる関数を呼び出します

助けてくれてありがとう、試しましたが、console.logを入れて印刷したので呼び出されたのに、呼び出されなかったことがテストで示されました。

テストファイル

import errorHandler from '../../controller/errorHandler'

describe('auth test', () => {
  describe('test error: ', () => {
    const test1 = jest.spyOn(errorHandler, 'handleClientError')
    test('should return 400', (done) => {
      request(app)
      .post('/auth/error')
      .then((res) => {
        expect(res.statusCode).toBe(400)
        expect(test1).toBeCalled()
        done()
      })
    })

errorHandler

module.exports = {
  handleClientError () {
    console.log('err')
  }
}

コンソール

console.log src/controller/errorHandler.js:10
      err

  ● auth test › test error:  ›  should return 400

    expect(jest.fn()).toBeCalled()

    Expected mock function to have been called.

      18 |         expect(res.statusCode).toBe(400)
    > 19 |         expect(test1).toBeCalled()
      20 |         done()
      21 |       })
      22 |     })

関数はhandleClientErrorまたはlogErrorと呼ばれていますか？

@WangHansenあなたの例から、あなたのコードはexpect(errorHandler.handleClientError).toBeCalled() // > trueはずです

@WangHansenあなた.mockImplementation()あなたにjest.spyOn() ？ ジャスミンから来た人として、私はこのヒントがジャスミンのスパイと同じ機能を達成するために重要であることに気づきました。 例えば

const mockModuleFunction = jest
  .spyOn(module, 'function')
  .mockImplementation(() => 'hello');
...
expect(mockModuleFunction.mock).toBeCalled();

mockImplementation()使用しない場合、 jest.spyOn()はモック（afaiu）ではないオブジェクトを生成し、実際にはネイティブ実装に従います。 ネイティブ実装を維持する必要がある場合は、使用する価値があるかもしれません

const moduleFunction = module.function;
jest.spyOn(module, 'function').mockImplementation(moduleFunction);
...

これが必要かどうかはわかりませんが、機能するはずです。

元のリクエストに戻ります...

インポートの周りにプロキシをラップするだけではいけませんか*？ 例えば

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

constハンドラー= {
/ **インターセプト：プロパティの取得* /
get（target、propKey、receiver）{
console.log（ GET ${propKey} ）;
123を返します。
}、

/** Intercepts: checking whether properties exist */
has(target, propKey) {
    console.log(`HAS ${propKey}`);
    return true;
}};

const p = new Proxy（test）;

4：24 PMで火、2018年1月30日には、デニス・ロジノブ[email protected]
書きました：

@WangHansenhttps ：//github.com/wanghansen追加できますか
.mockImplementation（）をjest.spyOn（）に？ から来る誰かとして
ジャスミン、私はこのヒントがと同じ機能を達成するために重要だと思いました
ジャスミンのスパイ。 例えば

const mockModuleFunction = jest
.spyOn（module、 'function'）
.mockImplementation（（）=> 'hello'）; ... expect（mockModuleFunction.mock）.toBeCalled（）;

mockImplementation（）を使用しない場合、jest.spyOn（）は
モック（afaiu）ではなく、実際にはネイティブに依存するオブジェクト
実装。 ネイティブ実装を維持する必要がある場合は、多分それは
使用する価値がある

const moduleFunction = module.function; jest.spyOn（module、 'function'）。mockImplementation（moduleFunction）; .. ..

これが必要かどうかはわかりませんが、機能するはずです。

—
あなたが言及されたのであなたはこれを受け取っています。
このメールに直接返信し、GitHubで表示してください
https://github.com/facebook/jest/issues/936#issuecomment-361648414 、またはミュート
スレッド
https://github.com/notifications/unsubscribe-auth/AQRY9VXyHNYatwOOY6EV637WGQH9k5Plks5tP0I9gaJpZM4IPGAH
。

-

ダレン・クレスウェル
契約開発者| Develer Limited
Eメール： [email protected]
電話：
ウェブサイト： http ：

この電子メールを印刷する前に、環境に配慮してください
警告：コンピュータウイルスは電子メールで送信される可能性があります。 受信者
この電子メールと添付ファイルでウイルスの存在を確認する必要があります。
Develer Limitedは、ウイルスによって引き起こされたいかなる損害についても責任を負いません。
このメールで送信されます。 電子メールの送信は保証できません
情報が傍受されたり、破損したり、失われたりする可能性があるため、安全またはエラーが発生しません。
破壊された、遅れて到着した、不完全な、またはウイルスが含まれている。 送り主
したがって、エラーや脱落については責任を負いません。
電子メール送信の結果として発生するこのメッセージの内容。

警告： Develer Limitedは合理的な予防策を講じていますが、
このメールにウイルスが含まれていないことを確認してください。会社はこれを受け入れることができません。
この電子メールの使用に起因する損失または損害に対する責任または
添付ファイル。

Develer Limitedは、イングランドおよびウェールズで登録された有限会社です。 |
会社登録番号09817616 | 登録事務所：SUITE 1 SECOND
FLOOR EVERDENE HOUSE、DEANSLEIGH ROAD、ボーンマス、イギリス、BH7 7DU

@dinvlad @iampeterbanjo @SimenBすべてのご協力に改めて感謝しますが、残念ながら、あなたが提案した方法はどれもうまくいきませんでした。 関数がnext(err)形式で呼び出されているからだろうか。 ロジックは、リクエストが失敗した場合、 return next(err)呼び出すことによってerrorHandler渡されます。 console.logを追加すると印刷されるため、関数が呼び出されていることは確かです。 しかし、テストはそれが決して呼び出されないことを示唆しています

@dinvlad私はあなたの方法を試しました、それはjest.spyOnの公式ドキュメントによると、なぜmockImplementationを呼び出す必要があるのか​​、元の関数をオーバーライドする場合にのみ呼び出す必要があるのではないかと思っていました。

@WangHansenはい、元のメソッドをオーバーライドしたい場合にのみ必要になるのは正しいです。 私はちょうどそれらの状況のた​​めのアイデアを投げていました。

それがあなたのために失敗したかもしれない1つの理由は非同期性です。 メソッドがコールバックやPromises（またはasync / await）を使用している場合は、テストメソッドが終了する前に、期待値が実際に実行されていることを確認する必要があります。 それを主張するための特別なメソッドexpect.assertions(N)があります。 また、callback / promises内のコードが呼び出された後にのみ期待が実行されることを確認してください。 あなたはそれを見たと確信していますが、参考のために、 https：//facebook.github.io/jest/docs/en/asynchronous.html

@seibeljが説明しているように、内部で使用されているfnsを

私の意見では、テストはビジネスロジックの実装方法を推進するべきではありません😕（少なくともこの程度ではありません）

そのような振る舞いを冗談で実装する計画はありますか？

やあ、
ちょっと議論全体に遅れましたが、議論全体を読んでください-私はまだそれを行うことができませんでした。
@greypantsの有望なソリューションは、元の関数をまだ呼び出しているため、実際には機能しませんでした。
この議論の開始以来、何か変わったことはありますか？ 私は何かが足りないのですか？

@greypantsのソリューションを少し適応させた

import Module from './module'
import { getJSON } from './helpers'

jest.mock('./helpers', () =>
  Object.assign(require.requireActual('./helpers'), {
    getJSON: jest.fn()
  })
)

test('should use the mock', async () => {
  getJSON.mockResolvedValue('foo')
  await expect(module().someAsyncThingThatUsesGetJSON()).resolves.toEqual('foo')
})

test('should use the actual module', () => {
  expect(module().someFunctionThatUsesAHelper()).toBe(true)
})

これはまだちょっとハッキーな感じがして、ドキュメントはそれほど役に立ちませんでした。 Jestとその背後にいるチームに感謝しますが、少なくとも「公式」ソリューションが必要な一般的なユースケースのようです。

@sarahdayan 、そしてそれが興味を持っているかもしれない人-
私はbabel-plugin-rewireを使用することになりました。
そのプラグインを見つけるのに少し時間がかかりましたが、 'ハッキーを感じないように十分に首尾一貫したソリューションでした。

ほとんどの場合、モジュールから1つ以上の関数をモックしたくありません。 グローバルジェストのモックシステムを使用している場合は、 genMockFromModuleとrequireActualを使用してそれを実現できます。 次に例を示します。

//  __mocks__/myModule.js
const moduleMock = jest.genMockFromModule('./../myModule');

// in most cases we don't want to mock `someFunction`
moduleMock.someFunction = jest.fn(
  (...args) => require.requireActual('./../myModule').someFunction(...args)
)

module.exports = moduleMock;

このソリューションでは、モジュール全体がモックされたときにsomeFunction元の実装を使用して、モジュールの他の関数にモックを使用できます。また、 mockImplementationOnceまたはmockImplementation someFunction関数をモックすることもできます。 mockImplementation API。

上記のすべての会話を読みましたが、1つの解決策がうまくいきません。
このテストケースの解決策をまだ探している場合、答えはbabel-plugin-rewireです。このプラグインは、説明したシナリオケースを解決するためのものです。
そのlibを見てください、後で私に感謝します。

したがって、上記のスレッド全体を要約すると、次のようになります。

1. 関数f 、 g 、 hを持つモジュールmがあり、 gとhがf呼び出すとします。 fをモックして、 gとhが実際のfではなくモックを呼び出すようにします。 残念ながら、 cpojerが説明しているように、 fが常にexportsを介して呼び出されない限り、これを直接行うできません。 モジュールがTypeScriptでES6インポート/エクスポート構文を使用している場合、これは不可能です（Babelでも同じことが当てはまると思います）。
2. ただし、 fを別のモジュールm2ます。 次に、 mにはimport {f} from 'm2'ようなステートメントがあり、 gとhがfを呼び出すと、実際にはm2.f呼び出します。 m2 = require('./m2') （Babel / TypeScriptの翻訳はこのようになります）。 これにより、greypantsで説明されているf確実にモックすることができます。 つまり、モジュールの境界を越えた場合にのみ、呼び出しを確実にモックできます。 注： greypantsのソリューションでは、次のエラーメッセージが生成されるようになりました：「 jest.mock()のモジュールファクトリは、スコープ外の変数を参照できません-無効な変数アクセス：__ assign」。 これはJestのバグだと思います。 回避策として、以下に示すようにObject.assignを使用します。
3. ただし、1つまたは2つの関数をモックする代わりに、1つまたは2つの関数を除くすべて場合は、 darkowicのようなコードを使用し

（2）の例：

~~~ js
//モジュールm.js
'./m2'から{f}をインポートします
エクスポート関数g（）{return'f returns '+ f（）; };

//モジュールm2.js
エクスポート関数f（）{return '実際のf'; }

// test.js
インポート* as m from './ m'

jest.mock（ './ m2'、（）=> Object.assign（
require.requireActual（ './ m2'）、{
f：jest.fn（）。mockReturnValue（ 'MOCK'）
}））;

test（ 'モック'、（）=> {
expect（mg（））。toEqual（ 'fがMOCKを返しました'）;
}）;
~~~

これをテストしているときに、＃2649に遭遇しました。テスト内でjest.mockを呼び出しても効果はなく、グローバルスコープで呼び出すと、他のテストの前にunmockを呼び出すことはできません。 とてもうるさい。

ありがとう！！ @sarahdayan
しばらくこれを探していました

ドキュメントが不足している場合、PRはいつでもそれらを明確にすることを歓迎します🙂

皆さんこんにちは！

私は少し遊んで、その問題を解決するために次のアイデアを思いつきました：

• モジュールをモックしますが、モックされたモジュールはプロトタイプチェーンに元のモジュールを持っています。
• モックモジュールにプロパティを追加するメソッドを提供します（プロトタイプのプロパティをオーバーライドします）
• また、モックされたモジュールからプロパティを削除する方法も提供します（プロトタイプのプロパティを再度使用するため）。

// m1.js
export const f = () => "original f"

// __mocks__/m1.js
const originalM1 = require.requireActual("../m1");
// set the original as a prototype
let mockModule: any = Object.create(originalM1);
const __setMock = (name, value) => {
  mockModule[name] = value;
};
const __removeMock = (name) => {
  Reflect.deleteProperty(mockModule, name);
};
// enhance the mocked module to allow overriding original exports
module.exports = Object.assign(mockModule, { __setMock, __removeMock });


// m1.test.js
import { f } from "./m1";

jest.mock("./m1");

test("mocking stuff", () => {
  // here nothing is mocked - the original module is used
  expect(f()).toBe("original f");

  // override the export f of the module
  require("./m1").__setMock("f", () => "mocked f");
  expect(f()).toBe("mocked f");

  // set it back to the original
  require("./m1").__removeMock("f");
  expect(f()).toBe("original f");

  //override with another value
  require("./m1").__setMock("f", () => "another mocked f");
  expect(f()).toBe("another mocked f");
});

私の2セント：

私は多くの解決策をテストしました（それらのすべてではないにしても）そして私のために働いた唯一のものはこれです（冗談23）：

// importedModule.js
export const funcB = () => {
  return "not mocked";
};
export const funcA = () => {
  return mockProxy.funcB(); // this works but it's soooo hacky
};

export const mockProxy = {
  funcB
};

// moduleToTest.js
import { funcA } from "./moduleImported.js";

export default function() {
  return funcA();
}

// test
let moduleImported = require("./moduleImported.js");
moduleImported.mockProxy.funcB = jest.fn(() => "mocked");
const funcToTest = require("./moduleToTest.js").default; // or import

it("should return mocked", function() {
  expect(funcToTest()).toBe("mocked");
});

私はこれをやろうとするのは良い考えではないという結論に達しました：

• test.jsは、 importedModule.js実装の詳細についてよく知っています。
• 解決策は、脆弱にし、誰もの目的を理解していないだろうmockProxyを見て、 importedModule.js

誰かがこれが機能する解決策を見つけましたか？

私が使用しているもの：

"jest": "^21.2.1",
"jest-cli": "^21.2.1",

@jamesoneこれを読んだことがありますか

@thomaskempelの回答に基づいて、これは私にとっては

私の場合、node_modulesの依存関係をモックしたかったので、「shared-components」と呼びましょう。 多数の名前付きコンポーネントをエクスポートします。 これらの名前付きエクスポートのいくつかだけをモックし、残りは本物のままにしておきたかったのです。

したがって、 __mocks__/shared-components.jsには次のものがあります。

const original = require.requireActual('shared-components');

module.exports = {
...original,
moduleNameToOverride: jest.fn().mockImplementation(() => {
      return 'whatever';
    }),
}

私の場合、実装をスタブ化していた。 うまくいけば、これは将来誰かを助けるでしょう。

私は最近同じ問題に直面しました。このスレッドでの会話は私がよりよく理解するのに役立ちました、そして私はここに私の発見を要約しましたhttps://medium.com/@DavideRama/mock -spy-exported-functions-within-a-single- module-in-jest-cdf2b61af642

@qwertieのソリューションに触発された

mockGet = jest.fn()
jest.mock('my-module', () => ({
  ...jest.requireActual('my-module'),
  get: mockGet
}))

React.lazy動作する@MajorBreakfast ？

const mockLazy = jest.fn();

jest.mock('React', () => ({
    ...jest.requireActual('React'),
    lazy: mockLazy
}));

私はまだReferenceError: React is not defined取得します。

独立したエクスポート汎用モジュールをモックするには：
デフォルトのエクスポートの一部である個々の関数をすべてファイルからエクスポートします。

例：
dataDao.js

関数getData（）
関数setData（）
関数deleteData（）
エクスポート{getData、setData、deleteData}

これで、デフォルトの名前付けで、ファイルからjestテストにすべての関数をインポートできます。

dataDao.spec.js

import * as dataDao from '../ dataDao';
//インポート時に割り当てられたデフォルト名を参照するモジュールをスパイします
jest.spyOn（dataDao、 'getData'）
jest.spyOn（dataDao、 'setData'）
jest.spyOn（dataDao、 'deleteData'）

@vchinthakunta 、動作する可能性がありますが、エクスポート/インポート構文の主な目的に違反しているようです。他のモジュールは、を介して特定のメソッドまたはデータフィールドをインポートできなくなります。

import { justThisThing } from 'someModule';

私はそこに何かが欠けていますか？

React.lazy動作する@MajorBreakfast ？

const mockLazy = jest.fn();

jest.mock('React', () => ({
    ...jest.requireActual('React'),
    lazy: mockLazy
}));

私はまだReferenceError: React is not defined取得します。

「React」はインポートを参照しているので、ここでは小文字にする必要があると思いますか？

jest.mock('react'...)

私はここで見た他のソリューションよりも簡単な以下を使用してコードを動作させました。 requireたり、 defaultエクスポートを設定したりする必要はありません。

helpers / Navigation.js

export const initHeader = () => {
    // initialise header
    ...
}

...

export const anotherHelperFunction = () => {
    // do stuff
    ...
}

Navigation.jsを使用するコンポーネント

import { initHeader } from '../helpers/navigation';

jest.mock('../helpers/navigation');

...

describe('Test component', () => {

    it('should reinitialise header', () => {
        const mockHeaderInit = jest.fn();
        initHeader.mockImplementation(mockHeaderInit);

        const component = mountComponent(mockProps);
        component.simulate('click');

        expect(mockHeaderInit).toBeCalled();
    }
}

mockGet = jest.fn()
jest.mock('my-module', () => ({
  ...jest.requireActual('my-module'),
  get: mockGet
}))

ReferenceError: mockGet is not defined

       4 | const mockGet = jest.fn();
       5 | jest.mock('./browserStorage', () => ({
       6 |   ...jest.requireActual('./browserStorage'),
    >  7 |   get: mockGet,
         |        ^
       8 | }));

jest.mockが持ち上げられている場合は、 doMockか、

jest.mock('./browserStorage', () => ({
  ...jest.requireActual('./browserStorage'),
  get: jest.fn(),
}));

const {get: mockGet} = require('./browserStorage');

これはよくある問題のようです。 jestのドキュメントにこれについて何かありますか？

それで、同じモジュール内の関数をモックするための解決策はあり

次の方法でうまくいきました。トリックは、テストの最後にモックされた関数をリセットすることです。
この例のモックは、jsonwebtokenモジュールの関数を検証します。

  test('perform my test', async () => {
    // save the real jwt.verify function
    const verify = jwt.verify
    // mock it.
    jwt.verify = jest.fn().mockReturnValue({ sub: 0 })
    // do the test
    ...
    // set the real function back.
    jwt.verify = verify
  })

次の方法でうまくいきました。トリックは、テストの最後にモックされた関数をリセットすることです。
この例のモックは、jsonwebtokenモジュールの関数を検証します。

  test('perform my test', async () => {
    // save the real jwt.verify function
    const verify = jwt.verify
    // mock it.
    jwt.verify = jest.fn().mockReturnValue({ sub: 0 })
    // do the test
    ...
    // set the real function back.
    jwt.verify = verify
  })

const verifyどこで使用していますか？ とにかく、これはモックされた関数がエクスポートされたconst関数でない場合にのみ機能します

それで、_同じモジュール内で_関数をモックするための解決策はありますか？

多くの検索を行った後、この問題の解決策は、関数とモックが参照できる単一のオブジェクトにエクスポートを保存することです。 以下の記事はすべて同じコンセンサスに達しました。

https://github.com/facebook/jest/issues/936#issuecomment -438975674
https://medium.com/@qjli/how -to-mock-specific-module-function-in-jest-715e39a391f4
https://luetkemj.github.io/170421/mocking-modules-in-jest

コードで実行可能であれば、これらすべての問題を完全に排除し、目的のコードのテストを非常に簡単にする別のソリューションについて誰も言及していないのは驚きです。

_モックしたい単一の関数を独自のモジュールに移動します。_

真剣に。 モジュールの内部を他の内部とは別にテストする必要があるようにモジュールが作成されている場合、ほぼ確実に、クラスは単一責任の原則に違反しています（はい、実際のクラスではありませんが、モジュールはクラスのように機能しています。モジュールはコードのユニットコンテナです）。 その吸盤を分割し、ブーム、あなたは必要なものをあざけることができます。

モックされた関数が一連のプライベート状態に依存している場合でも、これはモジュールを何らかの方法で分割しない理由にはなりません。 それが多くの内部状態に依存しているという事実は、私には、モジュールの懸念が明確に考えられていないことを意味します。 おそらく、分割する3番目のモジュールもあります。これは、引数として渡すことができる、ある種のデータクラスまたはDTOを表します。

また、テストのためだけにプライベートな関数をエクスポートしていますか？ 外部コードがモックされた関数を直接呼び出すだけでなく、それ自体が呼び出す必要のある他の関数も呼び出すのはなぜですか？ ここで何らかの切断が起こっているに違いありません。 たぶん、モックされた関数はそのままにしておく必要がありますが、すべての関数を半分に分割し、半分を削除して別のモジュールに入れる必要があります。 あなたはその考えを理解します。

テストが非常に困難になると、ほとんどの場合、リファクタリングが必要な兆候です...

テストの不正行為は必要ありません：

const tomfoolery = require('tomfoolery'); // no longer required

このスレッドを読み、提案されたソリューションをテストした後でも、これを機能させることはできません。 私が読んだことから、何人かの人々がこの作品を作りましたが、私はどのように理解することができません。

テストに合格するために次の例に追加する必要があるコードを誰かに教えてもらえますか？

// a.js
export const foo = () => 'foo-' + bar()
export const bar = () => 'bar'

// a.test.js
import {
  foo,
  bar
} from './a'

describe('foo', () => {
  it('should return foo-MOCKED_BAR', () => {
    expect(foo()).toBe('foo-MOCKED_BAR')
  })

  it('should have the mocked implementation of bar', () => {
    expect(bar()).toBe('MOCKED_BAR')
  })
})

describe('bar', () => {
  it('should have the original implementation of bar', () => {
    expect(bar()).toBe('bar')
  })
})

describe('foo and bar together', () => {
  it('should have the original implementation of both', () => {
    expect(foo()).toBe('foo-bar')
  })
})

ありがとう！

lodash.randomのような単一のlodashメソッドのみをモックしたかったので、次の方法で簡単に実行できました。

module.js

const lodash = require('lodash');

module.exports = function() {
  return lodash.random();
}

test.js

const lodash = require('lodash');
const module = require('./module.js);

it('mocks lodash', () => {
    jest.spyOn(lodash, 'random').mockImplementationOnce(() => {
      return 2;
    });

    expect(module()).toEqual(2)
});

お役に立てば幸いです:)

typescriptを使用するチームで機能したのは、関数を直接エクスポートするのではなく、エクスポートするconstを作成すること
動作しない：
export function doSomething(a, b) {}
働く：
export const doSomething = function (a, b) {}

@arbielskのようにエクスポートを変更しました、動作します！ しかし、2種類のエクスポートの違いは何ですか...

@dgrcode例の解決策を見つけたことがありますか？ 私の知る限り、あなたがやろうとしていることは、Jestを介したモックではサポートされていません。 具体的には、モックインは基本的にインポートを再配線して、モジュールの外部ビューにモックされたメソッドが表示されるようにすることfooとbarが同じモジュール内にあるため、 fooのbarのビューをモックアウトすることはできません。

私はあなたの選択肢が次のいずれかであると信じています：
1） fooがbarを含むモジュールをインポートするように、コードを再編成します
2） babel-plugin-rewireを使用する

誤解している場合は訂正してください！

少し異なる要件がありました。1つの関数を除いてモジュール全体をモックしたかったのです。 @MajorBreakfastのソリューションを出発点として使用して、私は次のことを思いつきました。

jest.mock('my-module', () => ({
  ...jest.genMockFromModule('my-module'),
  myFunction: jest.requireActual('my-module').myFunction
}))

@dgrcode例の解決策を見つけたことがありますか？ 私の知る限り、あなたがやろうとしていることは、Jestを介したモックではサポートされていません。 具体的には、モックインは基本的にインポートを再配線して、モジュールの外部ビューにモックされたメソッドが表示されるようにすることだと思います。 ただし、この例では、 fooとbarが同じモジュール内にあるため、 fooのbarのビューをモックアウトすることはできません。

私はあなたの選択肢が次のいずれかであると信じています：

1. fooがbarを含むモジュールをインポートするように、コードを再編成します
2. babel-plugin-rewireを使用する

誤解している場合は訂正してください！

それは実際に私の場合でした
モジュールをモックする方法についての私の理解はすべて台無しになりました🤦‍♂

基本的
2つの関数が同じモジュール内にあり、相互に呼び出す場合

fooがbar呼び出している場合

function bar() {
  return 'some-result'
}

function foo(){
  return bar()  // <-- the function I want to mock 
}

barを新しいファイルに入れます（モックされます）

barメソッドを新しいファイルに移動しました。これで、上記の例の多くを使用できるようになりました。
@ yoni-abtechに感謝します🤣

このスレッド全体を読んで何度もテストした後の私が見る方法には、3つのオプションがあります。

オプション1- constを使用してすべての関数を宣言します

これには、宣言よりも関数式の使用を義務付ける必要があります。 幸いなことに、 func-style eslintルールがあなたを取り戻しました。

export const使用すると、 _same_モジュール内から他の関数​​によって使用されるspyOn関数を使用できます。

// hello.js
export const message = () => {
  return 'Hello world';
}

export const foo = () => {
  return message();
}

// hello.test.js
import * as testModule from './hello.js';

describe('test spyon with function expressions', function () {
  afterAll(() => {
    jest.restoreAllMocks();
  });
  it('should NOT mock message in foo', function () {
    const actual = testModule.foo();

    expect(actual).toBe('Hello world');
  });

  it('should mock message in foo', function () {
    jest.spyOn(testModule, 'message').mockReturnValue('my message');

    const actual = testModule.foo();

    expect(actual).toBe('my message');
    expect(testModule.message).toHaveBeenCalledTimes(1);
  });
});

オプション2- rewire babelプラグインを使用する

関数式の使用を義務付けたくない場合（つまり、 const ）、これは良いアプローチかもしれません。

これにより、同じモジュールから関数を_再配線_ （別名モック）することができます。 コードは以下のように見えると想像できましたが、テストしていません。 また、彼らのドキュメントから、モジュールからエクスポートされていない同じモジュール内の関数を再配線できるようです👍、 message関数をエクスポートせずに以下の例を想像してください。

例：

// hello.js
export function message() {
  return 'Hello world';
}

export function foo() {
  return message();
}

// hello.test.js
import * as testModule from './hello.js';

describe('test rewire api', function() {
  it('should NOT mock message in foo', function () {
    const actual = testModule.foo();

    expect(actual).toBe('Hello world');
  });

  it('should mock message in foo', function () {
    testModule.__RewireAPI__.__Rewire__('message', jest.fn().mockReturnValue('my message'));

    const actual = testModule.foo();

    expect(actual).toBe('my message');
    expect(testModule.message).toHaveBeenCalledTimes(1);
    testModule.__RewireAPI__.__ResetDependency__('message');
  });
});

例については、ドキュメントを参照してください。

注：バベルの転写が必要です

オプション3-すべての機能を別々のモジュール/ファイルに分割する

このオプションは最も好ましくありませんが、通常のmock機能で問題なく機能することは明らかです。

PS：このトレッドは非常に啓発的で、しばしば面白いものでしたが、この概要が他の人がスレッド全体を読む必要性を軽減することを願っています。 ✌️

@nickofthymeに感謝し

@nickofthymeあなたのoption 1は私のアプリとcreate react app両方で失敗します：

 FAIL  src/hello.test.js
  test spyon with function expressions
    ✓ should NOT mock message in foo (3ms)
    ✕ should mock message in foo (6ms)

  ● test spyon with function expressions › should mock message in foo

    expect(received).toBe(expected) // Object.is equality

    Expected: "my message"
    Received: "Hello world"

      17 |     const actual = testModule.foo();
      18 |
    > 19 |     expect(actual).toBe("my message");
         |                    ^
      20 |     expect(testModule.message).toHaveBeenCalledTimes(1);
      21 |   });
      22 | });

      at Object.toBe (src/hello.test.js:19:20)

Test Suites: 1 failed, 1 total
Tests:       1 failed, 1 passed, 2 total
Snapshots:   0 total
Time:        1.848s
Ran all test suites related to changed files.

@danielhusarあなたは正しいようです。 申し訳ありませんが、これをCRAでテストする必要がありました。

オプション1で説明したモックをここで機能させyarn test:helloスクリプトを使用してテストします。

結果

> yarn test:hello
yarn run v1.16.0
$ jest --config=jest.config.js -t=hello --verbose
 PASS  src/hello/hello.test.ts
  test hello
    ✓ should NOT mock message in foo (3ms)
    ✓ should mock message in foo (1ms)

Test Suites: 1 skipped, 1 passed, 1 of 2 total
Tests:       1 skipped, 2 passed, 3 total
Snapshots:   0 total
Time:        1.392s
Ran all test suites with tests matching "hello".
✨  Done in 2.36s.

ts-jestを使用してカスタムjest.config.jsファイルを使用し、 react-scripts介さずに、 jest --config=./jest.config.js直接呼び出す必要があります。 react-scriptsでjestがどのように構成されているかはわかりませんが、何らかの方法で構成を更新する方法があると思います。

この修正により、 *.css *.svgファイルとApp.tsxエラーは無視してください。

それを機能させるために行う必要がある特別なことはありますか？
私はかなり標準的なセットアップ（tsなし）を持っていて、そのままでは機能しないと思います。

今夜はもう少し見て、それが可能かどうかを確認します。

@danielhusar昨夜調べた使えるソリューションを得ることができませんでした。 重要なのは、CRAがpackage.json#jestオーバーライドできるjest構成transformer package.json#jestです。 JSとTSファイルを使用してtranspiledいるbabel-jestが、 react-scriptsブロック使用してからあなたを.babelrc設定ファイルをし、設定をtest ENV彼らがどのセットreact-scripts testここ。

もっと深く掘り下げられたらいいのに、今は時間がない。

うーん、私はまだそれを機能させるのに少し苦労しています（私のカスタムセットアップでは、craではありません）。
（jestとbabel-jestの両方の最新バージョン）

これは私の冗談の設定です：

module.exports = {
  name: 'my-app',
  testURL: 'http://localhost/',
  setupFiles: ['<rootDir>/setup-jest.js'],
  setupFilesAfterEnv: ['<rootDir>/setup-test.js'],
  testMatch: ['**/__tests__/**/*.test.js?(x)', '**/?(*.)+(spec|test).js?(x)'],
  testEnvironment: 'jest-environment-jsdom-fifteen',
  snapshotSerializers: ['enzyme-to-json/serializer'],
  globals: {
    ENV: 'test',
  },
  transform: {
    '^.+\\.[t|j]sx?$': 'babel-jest',
  },
};

そして私のbabelrc：

{
  "presets": [
    "@babel/react",
    ["@babel/env", {
      "corejs": "3",
      "useBuiltIns": "entry",
      "loose": true,
      "exclude": [
        "es.string.split"
      ]
    }],
    "@babel/flow"
  ],
  "plugins": [
    "array-includes",
    "lodash",
    "@babel/plugin-syntax-dynamic-import",
    "@babel/plugin-syntax-class-properties",
    "@babel/plugin-proposal-class-properties",
    "@babel/plugin-proposal-object-rest-spread",
    "@babel/plugin-proposal-optional-chaining"
  ],
  "env": {
    "test": {
      "plugins": ["dynamic-import-node"]
    }
  }
}

オプション1で苦労している人にとっては、 () => (expression)関数の代わりに() => { return expression }を使用することが重要です。

オプション1を次のように変更することで、機能するようになりました。

import * as test from './test';

export const message = () => {
    return 'Hello world';
  }

  export const foo = () => {
    return test.message();
  }

きれいではありませんが、動作するはずです。

@nickofthyme 、オプション1はあなたが持っているので正しいです。 ただし、コードを次のように変更すると、次のようになります。

const foo = () => {}
export { foo }

それからそれは壊れます。 おそらく、新しいオブジェクトリテラルを作成し、それをエクスポートするためです。

興味深い観察。 ありがとう@maletor

Jestのドキュメントには、モジュールを部分的にモックする方法の非常に単純で明確な例があります。 これは、ESimportステートメントとNoderequireステートメントの両方で機能します。
https://jestjs.io/docs/en/jest-object#jestrequireactualmodulename

@johncmunsonそれは良い点です。 ただし、モジュールのモックを示したこの例は、 jest.mock _once_を実行する必要があるだけで、モックされたメソッドのいずれもそのモジュールからの別のエクスポートを使用しない場合にのみ機能します。

上記の例を見てください... fooとbar間でモジュールを異なる方法でモックする方法を示すために、 barを追加しました。

export const message = (): string => {
  return 'Hello world';
}

export const foo = (): string => {
  return message();
}

export const bar = (): (() => string) => {
  return foo;
}

jest.mockをjest.requireActualと一緒に使用すると、次のようになると思います。

import * as mockTestModule from './hello';

jest.mock('./hello');
const actualTestModule = jest.requireActual('./hello');

describe('test hello', function () {
  afterAll(() => {
    jest.restoreAllMocks();
  });

  // first test doesn't depend on any other method of the module so no mocks
  it('should NOT mock message in foo', function () {
    const actual = actualTestModule.foo();

    expect(actual).toBe('Hello world');
  });

  // the second I want to mock message in foo
  it('should mock message in foo', function () {
    jest.spyOn(mockTestModule, 'message').mockReturnValue('my message');
    const actual = actualTestModule.foo();

    expect(actual).toBe('my message'); // fails
    expect(mockTestModule.message).toHaveBeenCalledTimes(1); // never called
  });

  it('should mock foo in bar', function () {
    jest.spyOn(mockTestModule, 'foo').mockReturnValue('my message');
    const actual = actualTestModule.bar();

    expect(actual()).toBe('my message'); // fails
    expect(mockTestModule.message).toHaveBeenCalledTimes(1); // never called
  });
});

jest.doMock別々にモックしてみても、同じ結果が得られました。

`` `ts
import * as testModule from './ hello';

describe（ 'test hello'、function（）{
afterAll（（）=> {
jest.restoreAllMocks（）;
}）;

it('should NOT mock message in foo', function () {
  const actual = testModule.foo();

  expect(actual).toBe('Hello world');
});

it('should mock message in foo', function () {
  jest.doMock('./hello', () => {
    // Require the original module to not be mocked...
    const originalModule = jest.requireActual('./hello');

    return {
      ...originalModule,
      message: jest.fn().mockReturnValue('my message'),
    };
  });
  const actual = testModule.foo();

  expect(actual).toBe('my message'); // fails
  expect(testModule.message).toHaveBeenCalledTimes(1); // never called
});

it('should mock foo in bar', function () {
  jest.doMock('./hello', () => {
    // Require the original module to not be mocked...
    const originalModule = jest.requireActual('./hello');

    return {
      ...originalModule,
      foo: jest.fn().mockReturnValue('my message'),
    };
  });
  const actual = testModule.bar()();

  expect(actual).toBe('my message'); // fails
  expect(testModule.foo).toHaveBeenCalledTimes(1); // never called
});

}）;
`` `

このアプローチの問題は、実際のモジュールを要求し、次にfooを呼び出すと、モックではなく実際のmessage関数を呼び出すことです。

私はそれがこれほど単純であることを望みますが、私が見るところ、これはこのスレッドの例には役立ちません。 ここで何かが足りない場合はお知らせください。 私は喜んで過ちを認めます。

解決策を探しているこれに出くわした人にとって、1つのファイルに多くのconst /関数をエクスポートし、私がテストしているファイルにそれらをインポートするとき、以下は私のために働いているようです

function mockFunctions() {
  const original = require.requireActual('../myModule');
  return {
    ...original, //Pass down all the exported objects
    test: jest.fn(() => {console.log('I didnt call the original')}),
    someFnIWantToCurry: {console.log('I will curry the original') return jest.fn((...args) => original.someFnIWantToCurry(...args)}),
  }
jest.mock('../myModule', () => mockFunctions());
const storage = require.requireMock('../myModule');
`

以下は機能し、少し短いです：

const module = require('./module');
jest.spyOn(module, 'myFn').mockImplementation(() => 'val');

活字体で、ちょうどimportの代わりにrequire ：

import * as module from './module';

これには、元の機能を簡単に復元し、モックをクリアできるという利点があります。

解決策を探しているこれに出くわした人にとって、1つのファイルに多くのconst /関数をエクスポートし、私がテストしているファイルにそれらをインポートするとき、以下は私のために働いているようです

function mockFunctions() {
  const original = require.requireActual('../myModule');
  return {
    ...original, //Pass down all the exported objects
    test: jest.fn(() => {console.log('I didnt call the original')}),
    someFnIWantToCurry: {console.log('I will curry the original') return jest.fn((...args) => original.someFnIWantToCurry(...args)}),
  }
jest.mock('../myModule', () => mockFunctions());
const storage = require.requireMock('../myModule');
`

以下は機能し、少し短いです：

const module = require('./module');
jest.spyOn(module, 'myFn').mockImplementation(() => 'val');

活字体で、ちょうどimportの代わりにrequire ：

import * as module from './module';

これには、元の機能を簡単に復元し、モックをクリアできるという利点があります。

そうです、オブジェクトにgetterしか定義されていない場合も、このメソッドは機能しません。 エラーメッセージは次のようになります。

Test suite failed to run

    TypeError: Cannot set property useContent of #<Object> which has only a getter

この場合、おそらくjest.mock(..)を使用する必要があります。 ：bowing_man：

私のモックは以下を使用して動作しています。

import { unsubscribe } from "../lib/my-lib"
import { MyComponent } from "./index"

test("unsubscribe gets called", () => {
    const module = require("../lib/my-lib")
    jest.spyOn(
        module,
        "unsubscribe"
    ).mockImplementation(() => jest.fn())

    const { getByTestId } = render(() => <MyComponent  />)

    let button = getByTestId("trigger.some.action.button")

    fireEvent.press(button)

    expect(unsubscribe).toHaveBeenCalled()
})

それほどエレガントに見えず、簡単に拡張できないので、非常にうまく機能し、今のところ私の場合に適しています。しかし、誰かが他の素晴らしい構文を提案できるなら！ これは、機能しているように見える唯一の構文です。

es6モジュールコード：

export const funcA = () => {};
export const funcB = () => {
  funcA();
};

CommonJSにトランスパイルした後：

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.funcB = exports.funcA = void 0;

var funcA = function funcA() {};

exports.funcA = funcA; // You can mock or add a spy  on this `funcA`

var funcB = function funcB() {
  funcA();  // This is still original `funcA`
};

exports.funcB = funcB;

この状況を解決する方法はたくさんあります。

1. モック/スパイされたfuncA使用できるように、このようにコードを変更する必要があります

function funcA() {}
exports.funcA = funcA;

function funcB() {
  exports.funcA(); // Now, this `exports.funcA` is added a spy or mocked. Keep the same reference to `funcA`
}
exports.funcB = funcB;

または、

export let funcA = () => {};
export const funcB = () => {
  exports.funcA();
};

ユニットテストの結果：

 PASS  myModule.test.ts (9.225s)
  funcB
    ✓ should call funcA (3ms)

-------------|---------|----------|---------|---------|-------------------
File         | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s 
-------------|---------|----------|---------|---------|-------------------
All files    |     100 |      100 |     100 |     100 |                   
 myModule.ts |     100 |      100 |     100 |     100 |                   
-------------|---------|----------|---------|---------|-------------------
Test Suites: 1 passed, 1 total
Tests:       1 passed, 1 total
Snapshots:   0 total
Time:        10.967s

1. rewireパッケージを使用してfuncAをモックします
   ..。

さらに、次のドキュメントを確認する必要があります： https ： requireが正確に何をするかを確認する

このstackoverflowの投稿の解決策は私のために働いた
https://stackoverflow.com/a/53402206/1217998

基本的に最初に、変換したいすべての関数をjest.fnに変換します

jest.mock('../../utils', () => {
  const actualUtils = jest.requireActual('../../utils');
  const originalImplementation = actualUtils.someFun;

  return {
    ...actualUtils,
    someFun: jest.fn()
      .mockImplementation(originalImplementation),
  };
});
const utils = require('../../utils');

その後、必要に応じて通常のように使用したり、このようにモックしたりできます

jest.spyOn(utils, 'someFun').mockReturnValueOnce(true);

これを使用して、元の実装を取得できます

beforeEach(() => {
    jest.clearAllMocks();
  });

このstackoverflowの投稿の解決策は私のために働いた
https://stackoverflow.com/a/53402206/1217998

基本的に最初に、変換したいすべての関数をjest.fnに変換します

jest.mock('../../utils', () => {
  const actualUtils = jest.requireActual('../../utils');
  const originalImplementation = actualUtils.someFun;

  return {
    ...actualUtils,
    someFun: jest.fn()
      .mockImplementation(originalImplementation),
  };
});
const utils = require('../../utils');

その後、必要に応じて通常のように使用したり、このようにモックしたりできます

jest.spyOn(utils, 'someFun').mockReturnValueOnce(true);

これを使用して、元の実装を取得できます

beforeEach(() => {
    jest.clearAllMocks();
  });

ありがとうございました！

Jestのドキュメントには、モジュールを部分的にモックする方法の非常に単純で明確な例があります。 これは、ESimportステートメントとNoderequireステートメントの両方で機能します。
https://jestjs.io/docs/en/jest-object#jestrequireactualmodulename

モジュール内からモック関数を呼び出した場合は動作しません。

また、元の関数を変更せずに、いくつかのカスタム（追加）変数を使用して関数を呼び出す方法で関数をモックすることが役立つ場合があることもわかりました。

jest.mock('./someModule', () => {
  const moduleMock = require.requireActual('./someModule');
  return {
    ...moduleMock,
    // will mock this function 
    someFunction: (args) =>
      moduleMock.someFunction({
        ...args,
        customArgument,
      }),
  };
});

私の場合、関数にcome configを渡す必要がありました。これがないと、デフォルトのものが使用されます。

これが私がこれを行うために見つけた唯一の方法なので、あなたがより良いまたはより簡単なアイデアを思いついた場合は、聞いて喜んでいます:)

FWIW https://github.com/magicmark/jest-how-do-i-mock-x/blob/master/src/function-in-same-module/READMEで、実行可能な例を使用してさまざまなアプローチをまとめました

これはOPの質問/問題には答えませんが、リファクタリングを伴う解決策です。 関数を異なるファイルに分割し、それらのインポートをモックするのが最も簡単な方法であることがわかりました。

// package.json
...
"scripts": {
    "test": "jest",

...
"devDependencies": {
    "@babel/preset-env": "^7.11.5",
    "jest": "^24.9.0",
...

`` `js
// babel.config.js

module.exports = {
プリセット：[
[
'@ babel / preset-env'、
{{
ターゲット：{
ノード： '現在'、
}、
}、
]、
]、
};

```js
// module-utils.js

export const isBabaYaga = () => {
  return false
}

// module.js

import { isBabaYaga } from './module-utils'

export const isJohnWickBabaYaga = () => {
  return isBabaYaga()
}

// modules.test.js

import { isJohnWickBabaYaga } from './module';

jest.mock('./module-utils', () => ({
    isBabaYaga: jest.fn(() => true)
}))

test('John Wick is the Baba Yaga', () => {

    // when
    const isBabaYaga = isJohnWickBabaYaga()

    // then
    expect(isBabaYaga).toBeTruthy()
});

PASS  src/module.test.js
✓ John Wick is the Baba Yaga (4ms)

最近、この問題が発生しました。 コードを変更できないため、提案されたソリューションはどれも機能しません。 babel-plugin-rewireも私には機能しません。 関数が同じモジュール内の別の関数によって呼び出されたことをテストするための他の解決策はありますか？ これは正直に言うと、うまくいくか、これを行うbabelプラグインがあるはずです。 どんな助けでも大歓迎です！

最近、この問題が発生しました。 コードを変更できないため、提案されたソリューションはどれも機能しません。 babel-plugin-rewireも私には機能しません。 関数が同じモジュール内の別の関数によって呼び出されたことをテストするための他の解決策はありますか？ これは正直に言うと、うまくいくか、これを行うbabelプラグインがあるはずです。 どんな助けでも大歓迎です！

https://github.com/facebook/jest/issues/936#issuecomment -659597840をチェックアウトしましたか？ そこには、モック関数が同じファイルで呼び出す最小限の再現があります。