<p>jest.mock 팩토리가 테스트 내에서 작동하지 않습니다.</p>

jest.mock 호출은 babel-jest 변환을 사용하여 파일의 맨 위로 자동으로 호이스트됩니다. jest.doMock 하여 이 동작을 생략할 수 있습니다. 당신은 그것을 시도 했습니까?

doMock 입니다.

문서에서 읽을 수 있습니다

참고: babel-jest 사용할 때 mock에 대한 호출은 자동으로 코드 블록의 맨 위로 올라갑니다. 이 동작을 명시적으로 피하려면 doMock 사용하십시오.

하지만... 테스트는 코드 블록이죠? 그래서 제 경우에는 어떤 차이점도 기대하지 않습니다.

다음은 전체 테스트입니다.

it('renders with the enabled feature', () => {
  jest.mock('services/feature', () => ({
      isEnabled: () => true
  }));

  const component = renderer.create(
      <MyComponent />
  );

  const tree = component.toJSON();
  expect(tree).toMatchSnapshot();
});

GH 저장소에서 이에 대한 재현을 제공할 수 있습니까?

확신하는. 여기 있습니다: https://github.com/tleunen/jest-issue-2582

두 테스트 중 하나에 "활성화됨"을 렌더링하는 모의가 있지만 두 테스트 모두 "비활성화됨"으로 렌더링됩니다.
다음을 참조하십시오.
https://github.com/tleunen/jest-issue-2582/blob/master/src/MyComponent.js
https://github.com/tleunen/jest-issue-2582/blob/master/src/__tests__/MyComponent.spec.js

감사 해요.

이 문제에 대해 @thymikee @cpojer에 대한 조언이 있습니까?
동일한 파일에 여러 테스트가 있고 각각에 대해 다른 모의 응답을 갖고 싶습니다.

이 문제를 발견해서 다행입니다. 왜 jest.mock() 가 describe 범위에서 작동하지 않는지 머리가 아팠습니다. 상단(테스트 파일에서 내 가져오기 아래)으로 이동하면 작동합니다.

나를 위해 그것은 또한 조롱된 파일을 포함하는 __mocks__ 폴더를 사용하여 공장 없이 jest.mock() 적용됩니다.

--편집하다

jest.mock() 문을 import 문 앞에 올려놓는 것은 분명히 필요합니다. 그러나 @tleunen , 이것은 아마도 다른 응답으로 동일한 파일을 두 번 이상 조롱하는 것이 불가능하다는 것을 의미합니다. 팩토리 기능을 보다 동적으로 만들어 각 테스트 케이스에서 다른 결과를 제공할 수 있습니다.

내 생각에는 jest.mock() 가 항상 describe 및 it 블록 외부에 있으면 더 명확해질 것입니다. 그러나 이것은 문서에 명확하게 명시되어야 합니다.

따라서 jest.mock 는 함수 범위로 호이스트되고 있으므로 require s(그리고 확실히 모듈 범위로 호이스트되는 import s가 아님)와 함께 작동하지 않는 이유는 다음과 같습니다. describe (Jasmine에 의해 특별히 처리됨) 이외의 함수 내에서 호출합니다.
jest.mock 호출은 바로 그 함수(모듈이 아님)의 맨 위로 호이스트되므로 예상대로 작동하지 않습니다.

일반적으로 테스트 케이스에서 서로 다르게 하려면 beforeEach 및 afterEach 서로 다른 모의를 설정하는 것이 좋습니다.

@cpojer 는 이에 대해 자세히 설명할 수 있으며 상위 범위에 대한 호출을 호이스트하려는 경우입니다.

모듈이 초기화될 때(가져오기 사용) 모듈이 필요하기 때문입니다. jest.mock 는 나중에 호출됩니다. 이를 해결하는 방법은 다음과 같습니다.

beforeEach(() => { // or the specific test
  jest.mock('MyModule', () => …);
  const MyModule = require('MyModule');
  …
});

등.

beforeEach에서 이 작업을 수행했다면 테스트를 어떻게 구분할지 잘 모르겠습니다(그래서 각 테스트에 대해 다른 모의를 제공하는 방법은 무엇입니까?)

테스트 자체에 넣는 것은 물론 작동합니다.

그런 다음 테스트된 구성 요소 내부에 모의 모듈을 전달할 수 있습니까?

조롱하려는 파일(예: 가져오고 있는 다른 파일의 종속성)을 가져오거나 필요로 하지 않지만 범위가 describe/it 블록으로 지정되기를 원하면 어떻게 합니까? 또는 beforeEach/beforeAll 테스트에 대해 다르게 조롱하고 싶어도? 그런 경우가 가능한가요?

// A.js depends on B.js
import A from './A';

describe('myTest', () => {

    describe('myFirstScope', () => {
        beforeAll(() => {
            jest.mock('./B', () => ({
                myFirstMethod: jest.fn(),
            }));
        });

        // tests here
    });

    describe('mySecondScope', () => {
        beforeAll(() => {
            jest.mock('./B', () => ({
                mySecondMethod: jest.fn(),
            }));
        });

        // tests here
    });
});

이 경우 B를 조롱한 후 A가 필요합니다. ( import 사용하지 않고 require ).

B를 조롱한 후 A 필요

나를 위해 일하지 않았고 여전히 B의 원래 모의가 결과로 전달되는 것을보고있었습니다.

@GoldAnna 이 문제에 대한 해결 방법을 찾았습니까?

@alayor 나는하지 않았다

이 문제에 여러 번 부딪쳤지만 이제는 제대로 테스트하지 않거나 작성자가 의도한 대로 jest 를 사용하지 않거나 두 가지를 조합한 것이라고 확신합니다. 추가 증거는 jest 의 문서에 있는 모의 관련 예제 중 거의 나에게 실제 예제처럼 보이지 않는다는 것입니다.

즉, 다음은 저에게 효과적이며 다음 테스트는 모두 통과합니다. ModuleB 의 원래 버전으로 돌아가려면 jest.resetModules() 및 jest.unmock('./moduleB') ...를 모두 호출해야 합니다. 순서는 중요하지 않습니다.

// Module A
const ModuleB = require('./moduleB');
const ModuleA = function() {
  this.title = new ModuleB().title;
  return this;
};
module.exports = ModuleA;

// Module B
const ModuleB = function() {
  this.title = 'Module B - Original'
  return this;
};
module.exports = ModuleB;

// Tests
describe('Jest a few tests', () => {
  it('should do something', () => {
    jest.resetModules();
    jest.mock('./moduleB', () => function() {
      this.title = 'Module B - Mock 1'
      return this;
    });
    const ModuleA = require('./moduleA');
    const moduleA = new ModuleA();
    expect(moduleA.title).toEqual('Module B - Mock 1');
  });

  it('should do something else', () => {
    jest.resetModules();
    jest.mock('./moduleB', () => function() {
      this.title = 'Module B - Mock 2'
      return this;
    });
    const ModuleA = require('./moduleA');
    const moduleA = new ModuleA();
    expect(moduleA.title).toEqual('Module B - Mock 2');
  });

  it('should do something original', () => {
    jest.resetModules();
    jest.unmock('./moduleB');
    const ModuleA = require('./moduleA');
    const moduleA = new ModuleA();
    expect(moduleA.title).toEqual('Module B - Original');
  });
});

이봐,

여기에는 아무 것도 작동하지 않습니다.
누군가 jest.mock을 내부에서 사용할 수 없는 이유를 설명해 주시겠습니까?

감사합니다

나는 이것이 여전히 기능 요청으로 다시 열려야 하는 문제라고 생각합니다. 테스트를 따로 작성하고 싶습니다. 모의 폴더에 물건을 버리거나 beforeEach로 다시 배선하면 일반적으로 모든 테스트에 포함되는 모의/이상한 데이터 인스턴스화의 정크 서랍으로 끝납니다. 나는 작은 모의를 작성하고 작은 테스트를 통과하고 싶습니다.

개별 테스트를 격리하는 실제 방법은 없습니다( test.concurrent ). 탭이나 ava와 유사한 API를 채택했다면 가능하겠지만 현재 글로벌 API가 부과하는 제약 조건으로는 불가능하다고 생각합니다. 잘못된 것으로 판명되어 매우 기쁩니다!

이전에 mocha 및 proxyquire로 작성된 테스트를 리팩터링하기 위해 여기에서 여러 가지 방법으로 어려움을 겪었고 결국 다른 모의에 대해 테스트를 다른 파일로 분리했습니다.

@gcox 모듈의 최상위 수준에서 모의(그리고 이후에 moduleA 요구)를 시도한 다음 다른 동작이 필요한 각 테스트에 대해 모의 구현을 변경해 보셨습니까? 이를 위해 mockImplementation 을 사용할 수 있습니다. 이것이 우리가 테스트 스위트에서 이 문제를 해결한 방법입니다.

@antgonzales 모듈 가져오기가 모듈의 맨 위로

@jkomusin 확실히. 그것은 OP가 요구한 것이 아닙니다, IMO. 나는 그들이 특히 " require('whatever') 가 동일한 객체가 아닌 여러 인접 테스트에서 다른 모의를 반환하도록 강제하려면 어떻게 해야 합니까?"라고 묻고 있다고 생각합니다.

테스트 간에 모의 반환 값을 변경하려면 다음과 같이 할 수 있습니다.

jest.mock('whatever');

// Get the mock function
const whatever = require('whatever');

test('test 1', () => {
  whatever.mockImplementation(() => 'hello');
});

test('test 2', () => {
  whatever.mockImplementation(() => 'world');
});

@gcox 답변은 저에게 효과가 있었지만 @SimenB 도 효과가

@rafaeleyng 하지만 모듈에서 내보내는 것이 함수가 아닌 경우 @SimenB 가 작동하지 않습니다 ...

@gcox 예제에는 지난 몇 시간 동안 문서에서 검색한 대부분의 정보가 포함되어 있습니다. 어쨌든 현재로서는 매우 드문 공식 문서에 포함되어야 한다고 제안합니다.

@schumand 가 맞습니다. 공식 문서를 더 명확하고 선명하게 만드십시오.

PR은 항상 문서 개선을 환영합니다 🙂

모듈 예제 기반
https://github.com/facebook/jest/issues/2582#issuecomment -378677440 ❤️

헤야, 연결된 문제를 통해 이것을 찾았고 알아냈습니다.

jest.mock('child_process')
const childProcess = require('child_process')

describe('foo', () => {
  test('bar', () => {
    childProcess.execSync.mockImplentation(jest.fn().mockReturnValueOnce('wibble'))
    // code that itself requires child_process
    expect(childProcess.execSync.mock.results[0]).toEqual('wibble')
  })

  test('baz', () => {
    childProcess.execSync.mockImplentation(jest.fn().mockReturnValueOnce('wobble'))
    // code that itself requires child_process
    expect(childProcess.execSync.mock.results[0]).toEqual('wobble')
  })
})

필요한 코드에서 여러 함수/메서드를 모의해야 하는 경우 전역으로 수행할 때 팩토리를 사용하는 대신 별도로 설정해야 합니다.

저처럼 단일 기능만 있으면 전체를 단순화할 수 있습니다.

jest.mock('child_process')
const { execSync } = require('child_process')

describe('foo', () => {
  test('bar', () => {
    execSync.mockImplentation(jest.fn().mockReturnValueOnce('wibble'))
    // code that itself requires child_process
    expect(execSync.mock.results[0]).toEqual('wibble')
  })

  test('baz', () => {
    execSync.mockImplentation(jest.fn().mockReturnValueOnce('wobble'))
    // code that itself requires child_process
    expect(execSync.mock.results[0]).toEqual('wobble')
  })
})

json 파일이나 매핑된 상수와 같은 비함수 종속성을 조롱하는 것은 어떻습니까? 이것을 처리하는 방법에 대한 문서를 더 명확하게 만드십시오 ...

@gcox 귀하의 솔루션은 테스트 중인 가져온 모듈이 __mocks__ 폴더에 수동 모의가 있었던 다른 모듈을 가져올 때 찾은 유일한 솔루션입니다.

예를 들어, 테스트 파일 호출 jest.mock('./ModuleA') 에 실물 크기의 모형이있는, __mocks__/ModuleA.js . 그러나 ModuleA는 테스트 중이 아니며 ModuleA가 필요한 ModuleB는 테스트 중인 것입니다. 솔루션이 없으면 ModuleB는 모의가 아닌 ModuleA의 실제 구현을 얻게 됩니다.

이것은 농담의 정말 이상한 행동처럼 보입니다. 모듈에서 jest.mock을 호출할 때 모의 모듈에 대한 종속성이 있는 테스트 중인 모든 모듈이 모의를 사용할 것으로 예상합니다. 그런 식으로 작동하지 않는 것이 이상하게 보입니까, 아니면 완전히 잘못 진행되고 있습니까?

@SimenB 귀하의 예에서 조롱된 모듈이 필요하고 테스트에서 실행하면 작동합니다. 위에서 설명한 시나리오도 효과가 있을 것으로 예상하십니까? 정말 고마워.

@SimenB 가 나를 위해 더 간단한 솔루션을 제공했습니다. 감사 해요! 내가 다양한 방법으로 시간을 보내기 전에 Wish를 더 일찍 찾을 수 있었습니다.

제 경우에는 스텁하려는 모듈에 대한 잘못된 경로를 조롱하고 가져왔습니다. 파일 경로에 대소문자가 다르기 때문에 편집자는 괜찮다고 생각했지만 실패했습니다.

였다

const { stubMethod } = require("./path/to/File");
jest.mock("./path/to/File");

다음으로 변경됨( File 를 file ):

const { stubMethod } = require("./path/to/file");
jest.mock("./path/to/file");

이것이 다른 사람을 돕기를 바랍니다.

Jasmine spyOn() 는 _inside_ 테스트에서 그런 문제가 없습니다. Jest는 기본적으로 재스민을 사용한다고 가정합니까? 테스트 내부에서 작동하지 않는 이유는 무엇입니까?

재스민 예:

spyOn(require('moduleB'), 'functionA').and.callFake(() => true);

모의 모듈과 관련하여 내가 잘 이해하지 못하는 것은 항상 테스트 기능에서 주로 모듈을 사용하려는 것처럼 설명된다는 것입니다. 예를 들어 문서에서 doMock 함수에 대한 예제 코드를 보면 다음과 같습니다.

test('moduleName 2', () => {
  jest.doMock('../moduleName', () => {
    return {
      __esModule: true,
      default: 'default2',
      foo: 'foo2',
    };
  });
  return import('../moduleName').then(moduleName => {
    expect(moduleName.default).toEqual('default2');
    expect(moduleName.foo).toEqual('foo2');
  });
});

이 예에서는 테스트 함수 내에서만 새로 조롱된 "moduleName" 버전에 액세스할 수 있습니다. 나에게는 "비 테스트" 코드가 모듈의 모의 버전에도 액세스할 수 있다는 것이 훨씬 더 중요합니다. 예를 들어, "moduleName" 가져온 테스트 내에서 사용 중인 클래스는 여전히 조롱된 버전이 아닌 원래 버전을 사용하고 있습니다.

관련이있는 것 같습니다 : https://github.com/facebook/jest/issues/3236

팁 - 기본 값을 내보내는 모듈이 있는 경우, 예:

```auth.js
내보내기 const isUserAdmin = getSetting('관리자');

And you want to use a mock value instead, in the test, then a simple require and assignment seems to do the trick:

```deleteUser.js
const auth = require('../auth');

describe('deleteUser', () => {
  it('can delete if admin', () => {
    auth.isUserAdmin = true;

    // call method that depends on isUserAdmin value
    // and assert on the result
  });
});

따라서 기본적으로 코드에서 간접적으로 사용되는 객체를 모의하려는 경우 jest.doMock() 함수를 테스트하면 작동하지 않습니다.

import myModuleToTest from './myModuleTotest'

describe('Given my module', () => {
  it('property1 will work as expect', () => {
    // Testing parts of the module that don't need to be mocked
  })

  it('property2 will work as expected', () => {
    jest.doMock('./myOtherModule', () => {
      return {
        __esModule: true,
        default: 'default2',
        foo: 'foo2',
      };
    });

    import('./myOtherModule').then(myOtherModule => {
      // I'm not interested on the mocked module myOtherModule but on the module that makes use of it
      myModuleToTest.doSomethingToSomeProperty(); // At this point myOtherModule's original module and not its mocked version will be used by myModuleToTest
      expect(myModuleToTest.someProperty).toBe('thisWillFail'); // The test won't pass because the mocked version wasn't used
    });
  });
});

Jest 26 현재 간접적으로 사용되는 Object 를 내보내는 모듈을 두 번 이상 조롱할 수 있는 방법이 없습니다( mockFn.mockImplementation(fn) 가 없기 때문에 Function 이외의 다른 것을 조롱하는 것을 의미합니다 mockFn.mockImplementation(fn) 조롱 Objects ). 이게 맞나요 아니면 제가 놓치고 있는 부분이 있나요? 유일한 솔루션은 동일한 모듈을 테스트하기 위해 둘 이상의 테스트 파일을 갖는 것입니다.

모의 객체를 가져온 후에 myModuleToTest를 가져와야 합니다.
조롱이 의미가 없기 전에. 따라서 import ....를 사용하지 마십시오.
어쨌든 호이스트되기 때문에 콜백 내부.

2020년 7월 7일 화요일 오후 10:24 Antonio Redondo [email protected]
썼다:

따라서 기본적으로 간접적으로 사용되는 객체를 조롱하려는 경우
jest.doMock() 함수를 테스트하는 코드는 작동하지 않습니다.

'./myModuleTotest'에서 myModuleToTest 가져오기
it('일할 것입니다', () => {
jest.doMock('./myOtherModule', () => {
반품 {
__esModule: 참,
기본값: 'default2',
foo: 'foo2',
};
});

return import('../myOtherModule').then(myOtherModule => {
// 모의 모듈 myOtherModule에는 관심이 없지만 이를 사용하는 모듈에는 관심이 없습니다.
myModuleToTest.doSomethingToSomeProperty(); // 이 시점에서 모의 ​​버전이 아닌 myOtherModule의 원래 모듈이 myModuleToTest에서 사용됩니다.
기대(myModuleToTest.someProperty).toBe('thisWillFail'); // 모의 버전이 사용되지 않았기 때문에 테스트가 통과하지 않습니다.
});});

Jest 26에서는 객체를 내보내는 모듈을 조롱할 수 있는 방법이 없습니다(I
간접적으로 사용되는 함수 이외의 다른 것을 의미합니다. 이거야?
정확하거나 내가 뭔가를 놓치고 있습니까? 유일한 해결책은 더 많은
동일한 모듈을 테스트하기 위해 하나 이상의 테스트 파일.

—
당신이 댓글을 달았기 때문에 이것을 받는 것입니다.
이 이메일에 직접 답장하고 GitHub에서 확인하세요.
https://github.com/facebook/jest/issues/2582#issuecomment-655110424 또는
구독 취소
https://github.com/notifications/unsubscribe-auth/AAJR3UW6HARW44ZLKAUB7PLR2N77NANCNFSM4C4I7QSQ
.