Jest: 특정 모듈 기능을 조롱하는 방법은 무엇입니까?

심층 분석에서 jest-mock은 전체 모듈에 대한 AST를 생성한 다음 해당 AST를 사용하여 원본의 내보내기를 준수하는 모의 모듈을 생성하는 것으로 보입니다. https://github.com/facebook/jest/tree/master/packages / 농담 조롱

Python의 모의(https://docs.python.org/3/library/unittest.mock-examples.html)와 같은 다른 테스트 프레임워크를 사용하면 특정 기능을 모의할 수 있습니다. 이것은 기본적인 테스트 개념입니다.

모듈의 일부를 조롱하는 기능을 적극 권장합니다. jest-mock은 조건부로 mocking에서 내보내기를 무시하고 원래 구현을 참조하도록 변경되어야 한다고 생각합니다.

넌 할 수있어:

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 _덮어쓴 버전이 아닙니다_. 당신이 나를 믿지 않는다면, 당신은 그것을 테스트 할 수 있습니다.

따라서 귀하가 설명한 예는 내가 가진 문제에 적합하지 않습니다. 내가 모르는 것을 알고 있습니까?

@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://code.facebook.com/pages/876921332402685/open-source-code-of-conduct 에서 읽을 수 있는 이 프로젝트에 대한 행동 강령이 있음을 상기시키고 싶습니다.

예제에서 올바른 솔루션은 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(...);
});

이것은 하나의 테스트에서 작동하지만 하나의 it(...); 블록으로 분리된 방식으로 이를 수행하는 방법을 찾지 못했습니다. 위에서 설명한 것처럼 모든 테스트에 영향을 미치므로 다른 테스트에서 실제 function2 를 테스트하기 어렵습니다. 팁이 있나요?

당신은 호출 할 수 있습니다 .mockClear 에서 함수에 beforeEach 또는 전화 jest.clearAllMocks() 당신이 농담 (16) 사용하는 경우.

안녕하세요 @cpojer입니다! 저는 Jest 16을 사용하고 있습니다. jest.clearAllMocks() 또는 someModule.function2.mockClear() 둘 다 저에게 적합하지 않습니다. 그들은 모의가 가져온 모듈의 기능이 아닌 전체 모듈일 때만 작동합니다. 내 프로젝트에서 함수는 후속 테스트에서 모의 ​​상태로 유지됩니다. 이것이 예상되지 않은 경우 작은 샘플 프로젝트에서 복제하고 새 문제를 만들 수 있는지 확인하겠습니다. 좋은 생각?

@cpojer -

예제에서 올바른 솔루션은 foo를 조롱하는 것이 아니라 foo가 호출하는 상위 수준 API(예: XMLHttpRequest 또는 대신 사용하는 추상화)를 조롱하는 것입니다.

저는 Jest를 처음 사용하고 비슷한 문제로 어려움을 겪고 있습니다. 나는 후드 아래에서 XMLHttpRequest 사용하는 axios 를 사용하고 있으며 axios 를 조롱하고 싶지 않지만 실제 XMLHttpRequest 를 조롱하고 싶습니다. 내가 자신에 의해 같은 메서드를 구현해야 할 것 같습니다 이 . 이것이 올바른 접근 방식입니까?

감사 해요!

네, 이와 같은 것이 당신을 올바른 길로 인도할 것입니다! :) jest.fn 를 더 멋진 API로 사용하세요. :D

여기에서 귀하의 의견에 관한 @cpojer : https://github.com/facebook/jest/issues/936#issuecomment -214939935

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")

솔루션을 찾고 있는 이 문제를 접하는 사람에게는 하나의 파일에서 많은 const/function을 내보내고 테스트 중인 파일로 가져올 때 다음이 저에게 도움이 되는 것 같습니다.

`` 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 , 내가 여기서 뭘 잘못하고 있는지 잘 모르겠습니다. 그러나 그것은 작동하지 않는 것 같습니다
저는 현재 jest 18.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 메서드와 테스트 메서드를 조롱해야 합니다. 조롱 코드의 스니펫을 제공할 수 있다면 무엇이 잘못되었는지 확인할 수 있습니다.

@ainesophaur ... test() 메서드를 조롱하기 위한 것입니까? 이 부분: test: jest.fn(() => {console.log('I didnt call the original')}),

@ainesophaur 귀하의 코드도 시도했습니다. 그러나 그것은 나를 위해 작동하지 않았습니다. 모의 함수를 실행하지 않습니다. 따라서 기대는 결코 충족되지 않습니다.

나는 이것이 위에서 언급한 것과 같은 작업을 요구하는 방식에 내재되어 있다고 생각합니다. 이에 대한 해결책이 있었으면 합니다.

@cpojer 부분적으로 모의 모듈과 관련하여 새로운 것이 있습니까?

@rantonmattei & @huyph 모의 정의 스니펫과 실행 중인 테스트를 확인해야 합니다. 실제 구현 파일이 필요/가져오기 전에 모의를 정의해야 합니다. JEST로 작업한 지 꽤 되었지만, node_modules 라이브러리든 내 앱의 파일이든 간에 내가 필요한 모든 것을 모의하기 위해 결국 JEST를 얻었음을 기억합니다. 저는 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를 공유해 주셔서 감사합니다. 나는 여전히 jest 18.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 는 실제 정의된 restartCheckExpiryDateTimeout 함수를 호출하므로 module.restartCheckExpiryDateTimeout 는 saveSession 의해 감지되지 않습니다.

saveSession 를 const 에 할당한 다음 saveSession.restartCheckExpiryDateTimeout = () => {...logic} 합니다. 그 때는 내에서 saveSession.saveSession 전화 saveSession.restartCheckExpiryDateTimeout 대신의 restartCheckExpiryDateTimeout . 메소드를 정의하는 실제 함수 saveSession 대신 새 const를 내보냅니다. 그런 다음 someVar.saveSession() 호출하면 내부적으로 saveSession.restartCheckExpiryDateTimeout() 가 호출되며 현재 조롱됩니다.

restartCheckExpiryDateTimeout() 가 내보낸 함수라고 추가했어야 합니다. saveSession() 내에서 로컬로 정의된 함수가 아닙니다 ... (위의 내 의견을 업데이트함). 이 경우 module.saveSession() 는 조롱되는 올바른 module.restartCheckExpiryDateTimeout() 를 호출해야 한다고 생각합니다.

그러나 나는 당신이 위에서 제안한 것을 줄 것입니다. saveSession() 및 restartCheckExpiryDateTimeout() 를 모두 다른 const로 이동합니다. 감사 해요

나는 그것이 saveSession의 범위에 정의되어 있지 않다는 것을 이해합니다. 세이브세션은
부모 범위에서 형제 메서드를 호출합니다. 나는 이것에 여러 번 부딪쳤다.
그리고 내가 제안한 것은 효과가 있었다

2017년 5월 8일 오후 8시 38분에 "Huy Pham" [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일 오전 12시 53분에 "Huy Pham" [email protected]이 작성했습니다.

방금 시도했습니다. 나는 그것을 발견했습니다.

이것은 작동하지 않습니다: (즉, 원래의 restartCheckExpiryDateTimeout()은
여전히 호출됨)

내보내기 세션 = {
세이브세션: () => {
session.restartCheckExpiryDateTimeout();
},
restartCheckExpiryDateTimeout: () => {},
}

이것은 작동하지 않습니다: (즉, 원래의 restartCheckExpiryDateTimeout()은
여전히 호출됨)

내보내기 세션 = {
세이브세션: 함수() {
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() {} , export many function , 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시 "novaline" [email protected]에서 다음과 같이 썼습니다.

@ainesophaur https://github.com/ainesophaur 가 작동하지 않습니다.

기준 치수:

내보내기 const getMessage = (숫자: 숫자): 문자열 => {
반환 Her name is ${genName(num)} ;
};
내보내기 함수 genName(num: number): string {
반환 '노바린';
}

시험:

함수 mockFunctions() {
const 원본 = require.requireActual('../moduleA');
반품 {
...원래의,
genName: jest.fn(() => '에밀리')
}
}jest.mock('../moduleA', () => mockFunctions()); const moduleA = require('../moduleA');
describe('모의 함수', () => {

it('t-0', () => {
기대(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: () => {},
}

이것은 Jest 20.0.3에 있습니다.

내가 하는 일은 함수에 대한 const 래퍼를 만든 다음 해당 래퍼를 내보내는 것입니다(예: const fns 내보내기). 그런 다음 모듈 내부에서 fns.functionName을 사용하고 fns.functionName 함수를 jest.fn()할 수 있습니다.

typescript로 작성된 사용자 정의 모듈의 mock 함수를 작성할 때 그리고 우리가 호출할 때 mock 함수는 해당 함수의 mocked 버전을 호출하기 때문에 Coverage 보고서에서 다루는 원래 함수입니다.

테스트에서 원래 가져온 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" 함수에서 읽는 babel 모드를 작성할 수 있습니다.
하기 전에 모듈의 기능을 내보내도록 코드를 다시 작성합니다.
테스트 실행?

2017년 12월 18일 월요일 오후 5시에 Jim Moody [email protected]이 다음과 같이 썼습니다.

당신 말이 맞아요 @SimenB https://github.com/simenb , 내가 뭔가를 바꿨습니다
내 테스트에서 Sinon으로 전환하는 사이에 통과한 것처럼 보입니다.
되돌렸을 때 여전히 작동하지 않습니다. 문제가 아닌거 같은데
해결되었습니다.

—
당신이 언급되었기 때문에 이것을 받는 것입니다.
이 이메일에 직접 답장하고 GitHub에서 확인
https://github.com/facebook/jest/issues/936#issuecomment-352488400 또는 음소거
스레드
https://github.com/notifications/unsubscribe-auth/AQRY9a5-s2_bjCWKNw5WiAJW-JeBf8W3ks5tBpoygaJpZM4IPGAH
.

--

대런 크레스웰
계약 개발자 | 개발자 제한
이메일: [email protected]
핸드폰:
웹사이트: http://www.develer.co.uk

이 전자 메일을 인쇄하기 전에 환경을 생각하십시오
경고: 컴퓨터 바이러스는 이메일을 통해 전송될 수 있습니다. 받는 사람
이 이메일과 모든 첨부 파일에 바이러스가 있는지 확인해야 합니다.
Developer Limited는 바이러스로 인한 피해에 대해 책임을 지지 않습니다.
이 이메일로 전송됩니다. 이메일 전송을 보장할 수 없음
정보가 가로채거나, 손상되거나, 손실될 수 있으므로 안전하거나 오류가 없습니다.
파괴되거나 늦게 도착하거나 불완전하게 도착하거나 바이러스를 포함합니다. 발신인
따라서 본 문서의 오류나 누락에 대해 책임을 지지 않습니다.
이메일 전송의 결과로 발생하는 이 메시지의 내용.

경고: Develer Limited가 합당한 예방 조치를 취했지만
이 이메일에 바이러스가 없는지 확인하십시오. 회사는 수락할 수 없습니다.
이 이메일 또는
첨부 파일.

Developer Limited는 잉글랜드와 웨일즈에 등록된 유한 회사입니다. |
사업자등록번호 09817616 | 등록 사무실: SUITE 1 SECOND
FLOOR EVERDENE HOUSE, DEANSLEIGH ROAD, 본머스, 영국, BH7 7DU

해결 방법에 대해 @ainesophaur 에게 감사드립니다.

누구든지 비동기식 작업이 아닌 예제가 유용하다고 생각하는 경우 여기에 내 것이 있습니다.

//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.isMockFunction(fn)
• jest.genMockFromModule(모듈 이름)
• jest.mock(모듈 이름, 공장, 옵션)
• jest.unmock(모듈 이름)
• jest.doMock(모듈 이름, 공장, 옵션)
• jest.dontMock(모듈 이름)

내 사용 사례는 jest의 새로운 사용자로서 일부 mocha + sinon.js 코드를 jest로 마이그레이션하는 것입니다. 이미 간첩과 기대가 있었기에 쉬울 줄 알았다. 그러나 이 스레드를 읽고 Mock 함수에 대한 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()
      })
    })

오류 핸들러

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() 있습니까? Jasmine에서 온 사람으로서 저는 이 팁이 Jasmine의 스파이와 동일한 기능을 달성하는 데 중요하다는 것을 알았습니다. 예

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 * 주위에 프록시를 래핑할 수 없습니까? 예

'./myfile.js'에서 테스트로 * 가져오기;

const 핸들러 = {
/** 가로채기: 속성 가져오기 */
get(대상, propKey, 수신기) {
console.log( GET ${propKey} );
반환 123;
},

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

const p = 새로운 프록시(테스트);

2018년 1월 30일 화요일 오후 4:24 Denis Loginov [email protected]
썼다:

@WangHansen https://github.com/wanghansen 추가할 수 있나요?
.mockImplementation() to your jest.spyOn()? 에서 오는 사람으로서
Jasmine, 나는 이 팁이
재스민의 스파이. 예

const mockModuleFunction = 농담
.spyOn(모듈, '함수')
.mockImplementation(() => '안녕하세요');...expect(mockModuleFunction.mock).toBeCalled();

mockImplementation()을 사용 하지 않으면 jest.spyOn()이 생성합니다.
모의(afaiu)가 아닌 객체이며 실제로 네이티브
구현. 네이티브 구현을 유지해야 한다면 아마도
사용할 가치

const moduleFunction = module.function;jest.spyOn(모듈, '함수').mockImplementation(moduleFunction);...

이것이 필요한지는 확실하지 않지만 작동 해야 한다는 것은 확실합니다.

—
당신이 언급되었기 때문에 이것을 받는 것입니다.
이 이메일에 직접 답장하고 GitHub에서 확인
https://github.com/facebook/jest/issues/936#issuecomment-361648414 또는 음소거
스레드
https://github.com/notifications/unsubscribe-auth/AQRY9VXyHNYatwOOY6EV637WGQH9k5Plks5tP0I9gaJpZM4IPGAH
.

--

대런 크레스웰
계약 개발자 | 개발자 제한
이메일: [email protected]
핸드폰:
웹사이트: http://www.develer.co.uk

이 전자 메일을 인쇄하기 전에 환경을 생각하십시오
경고: 컴퓨터 바이러스는 이메일을 통해 전송될 수 있습니다. 받는 사람
이 이메일과 모든 첨부 파일에 바이러스가 있는지 확인해야 합니다.
Developer Limited는 바이러스로 인한 피해에 대해 책임을 지지 않습니다.
이 이메일로 전송됩니다. 이메일 전송을 보장할 수 없음
정보가 가로채거나, 손상되거나, 손실될 수 있으므로 안전하거나 오류가 없습니다.
파괴되거나 늦게 도착하거나 불완전하게 도착하거나 바이러스를 포함합니다. 발신인
따라서 본 문서의 오류나 누락에 대해 책임을 지지 않습니다.
이메일 전송의 결과로 발생하는 이 메시지의 내용.

경고: Develer Limited가 합당한 예방 조치를 취했지만
이 이메일에 바이러스가 없는지 확인하십시오. 회사는 수락할 수 없습니다.
이 이메일 또는
첨부 파일.

Developer Limited는 잉글랜드와 웨일즈에 등록된 유한 회사입니다. |
사업자등록번호 09817616 | 등록 사무실: SUITE 1 SECOND
FLOOR EVERDENE HOUSE, DEANSLEIGH ROAD, 본머스, 영국, BH7 7DU

@dinvlad @iampeterbanjo @SimenB 모든 도움에 다시 한 번 감사드립니다. 하지만 안타깝게도 제안하신 방법 중 어느 것도 효과가 없었습니다. next(err) 형식으로 함수가 호출되기 때문인지 궁금합니다. 요청이 실패했을 때 논리는, 그것은에 전달 될 것입니다 errorHandler 호출하여 return next(err) . console.log 추가했을 때 인쇄 중이기 때문에 함수가 호출되고 있습니다. 그러나 테스트에 따르면 결코 호출되지 않습니다.

@dinvlad 나는 당신의 방법을 시도했지만 작동하지 않았지만 어쨌든 도움을 주셔서 감사합니다. jest.spyOn 의 공식 문서에 따르면 왜 mockImplementation 를 호출해야 하는지 궁금합니다. 원래 함수를 재정의하려는 경우에만 호출합니다.

@WangHansen 예, 원래 방법을 재정의하려는 경우에만 필요하다는 것이 맞습니다. 나는 단지 그 상황에 대한 아이디어를 던지고 있었다.

실패했을 수 있는 한 가지 이유는 비동기성입니다. 메서드가 콜백 및/또는 약속(또는 async/await)을 사용하는 경우 테스트 메서드가 종료되기 전에 예상이 실제로 실행되는지 확인해야 합니다. 그것을 주장하는 특별한 방법 expect.assertions(N) 이 있습니다. 또한 콜백/약속 내부의 코드가 호출된 후에만 예상이 실행되는지 확인하십시오. 나는 당신이 그것을 보았을 것이라고 확신하지만 참조 용으로 https://facebook.github.io/jest/docs/en/asynchronous.html

@seibelj가 설명하는 것처럼 내부적으로 사용되는 fns를 조롱하는 것은 모듈 impl을 변경하지 않고는 불가능합니다.

내 생각에 테스트는 비즈니스 로직이 구현되는 방식을 주도해서는 안 됩니다 😕 (적어도 이 정도까지는 아님)

농담으로 그러한 행동을 구현할 계획이 있습니까?

안녕하세요,
전체 토론에 다소 늦었지만 전체 토론을 통해 읽었습니다. 아직까지는 그렇게 하지 못했습니다.
@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를 사용하게 되었습니다.
그 플러그인을 찾는 데 시간이 걸렸지만 '핵심이라고 느끼지 않을 만큼 일관된 솔루션이었습니다.

대부분의 경우 우리는 모듈에서 하나 이상의 기능을 모의하고 싶지 않습니다 . global jest의 조롱 시스템을 사용하는 경우 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.

위의 모든 대화를 읽었지만 나에게 맞는 솔루션은 없습니다.
이 테스트 케이스에 대한 솔루션을 여전히 찾고 있다면, 대답은 babel-plugin-rewire 입니다 . 이 플러그인은 우리가 논의한 시나리오 케이스를 해결하기 위한 것입니다.
그 라이브러리를 살펴보십시오. 나중에 다시 감사할 것입니다.

위의 전체 스레드를 요약하면 다음과 같습니다.

1. f , g 및 h 함수가 있는 m 모듈이 있다고 가정합니다. 여기서 g 및 h 호출 f . 우리는 g 와 h 가 실제 f 대신에 mock을 호출하도록 f 를 모의하고 싶습니다. 불행하게도이 직접하지 않는 한 할 수 없습니다 f 항상 통해이라고 exports 로 cpojer 설명 . 이것은 모듈이 TypeScript에서 ES6 가져오기/내보내기 구문을 사용하는 경우 불가능합니다(바벨에서도 마찬가지입니다).
2. 그러나 f 를 다른 모듈 m2 로 이동한다고 가정합니다. 그러면 m 는 import {f} from 'm2' 와 같은 명령문을 갖게 되며 g 및 h 가 f 를 호출할 때 실제로는 m2.f 호출합니다 m2 = require('./m2') (바벨/TypeScript 번역이 표시되는 방식입니다). 이렇게 하면 greypants 에서 설명한 대로 f 안정적으로 조롱할 수 있습니다. 즉, 모듈 경계를 넘는 경우에만 호출을 안정적으로 모의할 수 있습니다 . 참고: greypants의 솔루션은 이제 " jest.mock() 의 모듈 팩토리는 범위를 벗어난 변수를 참조할 수 없습니다. - 잘못된 변수 액세스: __assign"이라는 오류 메시지를 생성합니다. 나는 이것이 Jest의 버그라고 생각합니다. 이 문제를 해결하려면 아래와 같이 Object.assign 를 사용하십시오.
3. 그러나 하나 또는 두 개의 함수를 조롱하는 대신 하나 또는 두 개의 함수를 제외한 모든 경우 darkowic과 같은 코드를 사용하십시오.

(2)의 예:

~~~js
// 모듈 m.js
'./m2'에서 {f} 가져오기
내보내기 함수 g() { 반환 'f 반환 ' + f(); };

// 모듈 m2.js
export function f() { return '실제 f'; }

// 테스트.js
*를 './m'에서 m으로 가져오기

jest.mock('./m2', () => Object.assign(
require.requireActual('./m2'), {
f: jest.fn().mockReturnValue('모의')
}));

test('조롱', () => {
기대(mg()).toEqual('모의 반환');
});
~~~

이것을 테스트하는 동안 #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센트:

나는 많은 솔루션을 테스트했고(모두는 아닐지라도) 나를 위해 일한 유일한 솔루션은 이것입니다(jest 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 https://github.com/facebook/jest/issues/936#issuecomment -410080252 읽어 보셨나요?

이것은 @thomaskempel 의 답변을 기반으로 저에게

제 경우에는 node_modules에서 종속성을 조롱하고 싶었습니다. 이를 '공유 구성 요소'라고 부를 수 있습니다. 여러 명명된 구성 요소를 내보냅니다. 나는 이러한 명명된 내보내기 중 몇 개만 조롱하고 나머지는 진짜로 남겨두고 싶었습니다.

따라서 __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- 모듈-인-제스트-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()
함수 삭제 데이터()
{getData, setData, deleteData} 내보내기

이제 기본 이름 지정으로 파일의 모든 기능을 jest 테스트로 가져올 수 있습니다.

dataDao.spec.js

* '../dataDao'에서 dataDao로 가져오기;
// 가져올 때 할당된 기본 이름을 참조하는 모듈을 감시합니다.
jest.spyOn(dataDao, 'getData')
jest.spyOn(dataDao, 'setData')
jest.spyOn(dataDao, '데이터 삭제')

@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 내보내기를 설정할 필요가 없습니다.

도우미/내비게이션.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 모듈의 verify 기능을 모의합니다.

  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 모듈의 verify 기능을 모의합니다.

  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

아무도 다른 솔루션을 언급하지 않았다는 사실이 놀랍습니다. 이 솔루션이 코드에 적합하다면 이러한 모든 문제를 완전히 제거하고 원하는 코드를 매우 간단하게 테스트할 수 있습니다.

_모의하려는 단일 함수를 자체 모듈로 이동합니다._

진지하게. 모듈이 다른 내부 부품과 별도로 내부 부품을 테스트해야 하는 방식으로 작성된 경우 클래스가 단일 책임 원칙을 위반하는 것이 거의 확실합니다(예, 실제 클래스는 아니지만 모듈은 클래스처럼 작동합니다. 모듈은 코드의 단위 컨테이너임). 그 빨판을 나누고 붐, 당신은 요구를 조롱 할 수 있습니다.

모의 함수가 여러 개인 상태에 의존하는 경우 여전히 모듈을 어떻게든 분할하지 않는 좋은 이유가 아닙니다. 많은 내부 상태에 의존한다는 바로 그 사실은 나에게 모듈의 문제가 명확하게 고려되지 않았음을 의미합니다. 아마도 어떤 종류의 데이터 클래스 또는 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 메서드만 조롱하고 싶었고 다음과 같이 쉽게 할 수 있었습니다.

모듈.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 가 하는 했는데 작동합니다! 하지만 두 종류의 수출의 차이점이 무엇인지 모르겠습니다 ...

@dgrcode 귀하의 예제에 대한 솔루션을 찾은 적이 있습니까? 내가 말할 수 있는 한, 당신이 하려는 것은 Jest를 통한 조롱으로 지원되지 않습니다. 특히, 조롱은 기본적으로 모듈의 외부 보기가 조롱된 메서드를 볼 수 있도록 가져오기를 다시 연결하는 것이라고 생각 합니다. 그러나, 귀하의 예제에서, foo 및 bar 같은 모듈에 있고 그래서 foo 의의보기 bar 밖으로 조롱 할 수 없습니다.

귀하의 옵션은 다음 중 하나라고 생각합니다.
1) foo 가 bar 를 포함하는 모듈을 가져오도록 코드를 재구성합니다.
2) babel-plugin-rewire 사용

제가 오해하고 있는 부분이 있다면 정정해주세요!

약간 다른 요구 사항이 있었습니다. 하나의 함수에 대해 전체 모듈 _except_을 모의하고 싶었습니다. @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 ) 이것이 좋은 접근 방식이 될 수 있습니다.

이를 통해 동일한 모듈에서 함수를 _rewire_ (일명 모의)할 수 있습니다. 코드가 아래와 같이 보일 것이라고 상상할 수 있지만 테스트하지는 않았습니다. 또한 그들의 문서 에서 모듈 👍에서 내보내지 않은 동일한 모듈의 함수를 다시 연결할 수 있는 것처럼 보입니다. 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');
  });
});

예제는 문서 를 참조하십시오.

참고: babel 변환이 필요합니다.

옵션 3 - 모든 기능을 별도의 모듈/파일로 분리

이 옵션은 가장 불리하지만 일반적인 mock 기능에서는 분명히 잘 작동합니다.

추신: 이 트레드는 매우 계몽적이고 종종 재미있었지만, 이 시놉시스가 다른 사람들이 전체 스레드를 읽을 필요성을 완화하기를 바랍니다. ✌️

@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.

그것은 사용자 정의하여 필요 jest.config.js 사용하여 파일 ts-jest 하고 전화 jest --config=./jest.config.js 직접하지 통해 react-scripts . jest가 react-scripts 에 어떻게 구성되어 있는지 잘 모르겠지만 어떻게든 구성을 업데이트할 수 있는 방법이 있을 수 있다고 생각합니다.

이 수정은 *.css 및 *.svg 파일에 대한 변환을 제거하므로 App.tsx 오류를 무시하십시오.

작업을 수행하기 위해 수행해야 하는 특정 작업이 있습니까?
나는 꽤 표준적인 설정(ts 없이)을 가지고 있고 그것은 기본적으로 작동하지 않는다고 말할 것입니다.

오늘 밤에 조금 더 살펴보고 그것이 가능한지 확인하겠습니다.

@danielhusar 어젯밤에 조사한 결과 즉시 사용 가능한 솔루션을 얻을 수 없었습니다. 핵심은 CRA가 package.json#jest 에서 재정의 할 수 있는 jest config transformer 입니다. js 및 ts 파일은 babel-jest 사용하여 변환되지만 react-scripts 는 .babelrc 구성 파일을 사용하고 test 설정한 환경 을 설정하는 것을 차단 합니다 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는 문서에 모듈을 부분적으로 모의하는 방법에 대한 매우 간단하고 명확한 예가 있습니다. 이것은 ES import 및 Node require 문 모두에서 작동합니다.
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 따로 조롱을 시도했지만 여전히 같은 결과를 얻었습니다.

```t
* import *를 './hello'에서 testModule로;

describe('테스트 안녕하세요', 함수() {
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 함수를 호출하고 모의는 호출 하지 않는다는 것입니다.

이렇게 간단했으면 좋겠지만 이 스레드의 예제에는 도움이 되지 않습니다. 여기에 누락된 것이 있으면 알려주십시오. 기꺼이 잘못을 인정하겠습니다.

솔루션을 찾고 있는 이 문제를 접하는 사람에게는 하나의 파일에서 많은 const/function을 내보내고 테스트 중인 파일로 가져올 때 다음이 저에게 도움이 되는 것 같습니다.

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

Typescript에서 import 대신 require :

import * as module from './module';

이것은 원래 기능을 쉽게 복원하고 모의를 명확하게 하는 이점이 있습니다.

솔루션을 찾고 있는 이 문제를 접하는 사람에게는 하나의 파일에서 많은 const/function을 내보내고 테스트 중인 파일로 가져올 때 다음이 저에게 도움이 되는 것 같습니다.

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

Typescript에서 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. 이렇게 코드를 변경해야 mocked/spied 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. funcA 를 조롱하기 위해 rewire 패키지를 사용하십시오.
   ...

게다가 require 가 정확히 무엇을 하는지 보려면 https://nodejs.org/api/modules.html#modules_exports_shortcut 문서를 살펴봐야 합니다.

이 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는 문서에 모듈을 부분적으로 모의하는 방법에 대한 매우 간단하고 명확한 예가 있습니다. 이것은 ES import 및 Node require 문 모두에서 작동합니다.
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,
      }),
  };
});

제 경우에는 기본 구성을 사용하지 않고 작동하도록 구성을 전달해야 했습니다.

이것이 내가 이것을 할 수 있는 유일한 방법이므로 더 낫거나 더 쉬운 아이디어가 떠오르면 기꺼이 듣게 될 것입니다. :)

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을 확인하셨습니까? 동일한 파일에서 함수 호출을 조롱하는 최소한의 재현이 있습니다.