<p>jest.mock फ़ैक्टरी एक परीक्षण के अंदर काम नहीं करता है</p>

jest.mock कॉल स्वचालित रूप से फ़ाइल के शीर्ष पर बेबेल-जेस्ट ट्रांसफ़ॉर्म के साथ फहराए जाते हैं। आप इस व्यवहार को jest.doMock साथ छोड़ सकते हैं। क्या आपने इसकी कोशिश की?

doMock साथ वही बात।

डॉक्स में, मैं पढ़ सकता हूँ

नोट: babel-jest का उपयोग करते समय, नकली कॉल को स्वचालित रूप से कोड ब्लॉक के शीर्ष पर फहराया जाएगा। यदि आप स्पष्ट रूप से इस व्यवहार से बचना चाहते हैं तो 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();
});

क्या आप जीएच रिपोजिटरी में इसका रेप्रो प्रदान कर सकते हैं?

ज़रूर। यहाँ यह है: 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 दायरे में काम क्यों नहीं किया। इसे शीर्ष पर ले जाया गया (परीक्षण फ़ाइल में मेरे आयात के नीचे) और यह काम करता है।

मेरे लिए यह बिना किसी फ़ैक्टरी के jest.mock() पर भी लागू होता है, नकली फ़ाइल वाले __mocks__ फ़ोल्डर का उपयोग करके।

--संपादित करें

स्पष्ट रूप से आयात विवरण से पहले jest.mock() कथन को ऊपर उठाना आवश्यक है। हालांकि @tleunen , इसका शायद मतलब है कि एक ही फाइल को अलग-अलग प्रतिक्रियाओं के साथ एक बार फिर

मेरे दिमाग में यह इसे और अधिक स्पष्ट कर देगा यदि jest.mock() को हमेशा describe और it ब्लॉक से बाहर रखा जाए। लेकिन इसके बाद दस्तावेज़ों में स्पष्ट रूप से कहा जाना चाहिए

तो jest.mock को फंक्शन स्कोप पर फहराया जा रहा है, इसलिए यह require s के साथ काम नहीं करेगा (और निश्चित रूप से import s जो मॉड्यूल स्कोप पर फहराया जाता है) यदि आप इसे describe अलावा किसी अन्य फ़ंक्शन के अंदर कॉल करें (जिसे विशेष रूप से जैस्मीन द्वारा माना जाता है)।
आपका jest.mock कॉल उसी फ़ंक्शन के शीर्ष पर फहराया जाएगा (मॉड्यूल नहीं), इसलिए यह आपकी अपेक्षा के अनुरूप काम नहीं करेगा।

आम तौर पर हम beforeEach और afterEach में अलग-अलग मॉक सेट करने की सलाह देते हैं यदि आप उन्हें परीक्षण मामलों में अलग-अलग चाहते हैं।

@cpojer इस पर विस्तार से विस्तार से फहराना चाहते हैं।

ऐसा इसलिए है क्योंकि जब मॉड्यूल प्रारंभ होता है (आयात का उपयोग करके) आपको अपने मॉड्यूल की आवश्यकता होती है। jest.mock बाद में कॉल किया जाता है। इसे हल करने का तरीका यह है:

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

आदि।

यदि आप इसे प्रत्येक से पहले करते हैं, तो मैं स्पष्ट नहीं हूं कि आप परीक्षणों में अंतर कैसे करेंगे (तो आप प्रत्येक परीक्षा के लिए एक अलग मॉक कैसे देंगे?)

इसे परीक्षणों के अंदर रखना निश्चित रूप से काम करता है।

क्या आप परीक्षण किए गए घटक के अंदर नकली मॉड्यूल पास कर सकते हैं?

क्या होगा यदि मैं उस फ़ाइल का आयात/आवश्यकता नहीं कर रहा हूं जिसका मैं नकल करना चाहता हूं (उदाहरण के लिए अन्य फ़ाइल की निर्भरता जो मैं आयात कर रहा हूं) लेकिन मैं इसे एक वर्णन/ब्लॉक तक सीमित करना चाहता हूं? या यहां तक ​​​​कि अगर मैं पहले/पहले सभी परीक्षण के लिए अलग-अलग नकल करना चाहता हूं? क्या वे मामले संभव हैं?

// 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 की आवश्यकता होती है

मेरे लिए काम नहीं किया, अभी भी परिणाम के लिए बी पास के मूल मॉक को देख रहा था

@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 का उपयोग करना क्यों संभव नहीं है?

शुक्रिया

मुझे लगता है कि यह अभी भी एक मुद्दा है जिसे फीचर अनुरोध के रूप में फिर से खोला जाना चाहिए। मैं अलगाव में परीक्षण लिखना चाहता हूं। किसी मॉक फोल्डर में चीजों को डंप करना या पहले के साथ रीवायर करना आमतौर पर मोक्स/अजीब डेटा इंस्टेंटेशन के जंक ड्रॉवर के साथ समाप्त होता है जो हर परीक्षण में फंस जाता है। मैं एक छोटा सा मॉक लिखना चाहता हूं और एक छोटा टेस्ट पास करना चाहता हूं।

हमारे पास व्यक्तिगत परीक्षणों को अलग करने का कोई वास्तविक तरीका नहीं है ( test.concurrent )। अगर हम टैप या एवा के समान एपीआई अपनाते हैं तो यह संभव होगा, लेकिन मुझे नहीं लगता कि वर्तमान वैश्विक एपीआई द्वारा लगाए गए बाधाओं के साथ यह संभव है। गलत साबित होने पर बहुत खुश!

पहले मोचा और प्रॉक्सीक्वायर में लिखे गए एक परीक्षण को दोबारा करने के लिए यहां कई तरीकों के साथ संघर्ष किया गया था, परीक्षण को अलग-अलग फाइलों के लिए अलग-अलग फाइलों में अलग करने के साथ समाप्त हुआ।

@gcox क्या आपने मॉड्यूल के शीर्ष-स्तर पर मॉकिंग (और बाद में मॉड्यूलए की आवश्यकता) की कोशिश की है और फिर प्रत्येक परीक्षण के लिए नकली के कार्यान्वयन को बदल दिया है जिसके लिए अलग-अलग व्यवहार की आवश्यकता है? ऐसा करने के लिए आप mockImplementation का उपयोग कर सकते हैं। इस तरह हमने इसे अपने परीक्षण सूट में हल किया है।

@antgonzales मुझे लगता है कि मॉड्यूल के शीर्ष पर मॉड्यूल आयात फहराए जाने पर ऐसा करना मुश्किल है। पहले से आयात किए गए मॉड्यूल के संदर्भों को संशोधित करना नोड में असंभव से असंभव लगता है।

@jkomusin निश्चित रूप से। यही वह नहीं है जो ओपी आईएमओ के लिए पूछ रहा था। मेरा मानना ​​​​है कि वे विशेष रूप से पूछ रहे थे, "मैं एक ही वस्तु के बजाय कई आसन्न परीक्षणों में एक अलग नकली वापस करने के लिए 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 उदाहरण में अधिकांश जानकारी है जिसे मैं पिछले कुछ घंटों से दस्तावेज़ों में खोज रहा हूं। मेरा सुझाव है कि इसे आधिकारिक दस्तावेज में शामिल किया जाना चाहिए जो कि इस समय बहुत कम है।

@schhumannd सही है। कृपया आधिकारिक दस्तावेज़ीकरण को अधिक स्पष्ट और स्पष्ट बनाएं।

पीआर हमेशा डॉक्स में सुधार का स्वागत करते हैं

मॉड्यूल उदाहरण के आधार पर
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')
  })
})

जेसन फाइलों, या मैप किए गए स्थिरांक जैसे गैर फ़ंक्शन निर्भरताओं का मज़ाक उड़ाने के बारे में क्या। कृपया इसे संभालने के तरीके के बारे में दस्तावेज़ीकरण को और स्पष्ट करें ...

@gcox आपका समाधान केवल एक ही है जिसे मैंने पाया है जब परीक्षण के तहत एक आयातित मॉड्यूल एक और मॉड्यूल आयात करता है जिसके लिए मेरे पास __mocks__ फ़ोल्डर में मैन्युअल मॉक था।

उदाहरण के लिए, परीक्षण फ़ाइल jest.mock('./ModuleA') कॉल करती है, जिसमें __mocks__/ModuleA.js में एक नकली है। लेकिन मॉड्यूलए परीक्षण के अधीन नहीं है, मॉड्यूलबी - जिसके लिए मॉड्यूलए की आवश्यकता है - वह परीक्षण के अधीन है। आपके समाधान के बिना, मॉड्यूलबी को मॉड्यूलए का वास्तविक कार्यान्वयन मिलेगा, नकली नहीं।

यह मजाक से वास्तव में अजीब व्यवहार की तरह लगता है। मैं उम्मीद करता हूं कि जब मैं एक मॉड्यूल पर jest.mock को कॉल करता हूं, तो परीक्षण के तहत कोई भी मॉड्यूल जो मॉक मॉड्यूल पर निर्भरता रखता है, नकली का उपयोग करेगा। क्या यह विचित्र लगता है कि यह उस तरह से काम नहीं करता है, या क्या मैं इस बारे में पूरी तरह से गलत तरीके से जा रहा हूं?

@SimenB आपके उदाहरण में, आपको

@SimenB ने मेरे लिए आपके सरल समाधान का काम किया। धन्यवाद! कई अलग-अलग तरीकों से समय बिताने से पहले काश इसे पहले पाया जा सकता था

मेरे मामले में मैं उस मॉड्यूल के लिए गलत पथ का मज़ाक उड़ा रहा था और आयात कर रहा था जिसे मैं स्टब करना चाहता था। मेरे पास फ़ाइल पथ में अलग आवरण था इसलिए मेरे संपादक ने सोचा कि यह ठीक है लेकिन बस विफल हो रहा था।

था

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

में बदला गया ( File का आवरण बदलकर file ):

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

मनाइए कि यह किसी और के लिए सहायक हो।

जैस्मीन spyOn() में ऐसी कोई समस्या नहीं है _inside_ परीक्षण। जेस्ट माना जाता है कि डिफ़ॉल्ट रूप से चमेली का उपयोग करता है? यह परीक्षण के अंदर क्यों काम नहीं करता है?

जैस्मीन उदाहरण:

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
निर्यात कास्ट 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
    });
  });
});

जेस्ट 26 के रूप में एक से अधिक बार नकल करने का कोई तरीका नहीं है एक मॉड्यूल एक Object निर्यात करता है जो अप्रत्यक्ष रूप से उपयोग किया जाता है (मेरा मतलब है कि Function अलावा कुछ और मजाक करना क्योंकि कोई mockFn.mockImplementation(fn) नकली Objects )। क्या यह सही है या मुझे कुछ याद आ रहा है? एक ही मॉड्यूल का परीक्षण करने के लिए एक से अधिक परीक्षण फ़ाइल होने का एकमात्र समाधान है।

आपको अपने मॉक के बाद myModuleToTest आयात करना होगा क्योंकि अगर यह आयात करता है
नकली से पहले कोई मतलब नहीं है। तो, आयात का उपयोग न करें .... शीर्ष पर या
कॉलबैक के अंदर क्योंकि यह वैसे भी फहराया गया है।

मंगलवार, 7 जुलाई, 2020, रात 10:24 बजे एंटोनियो रेडोंडो नोटिफिकेशन @github.com
लिखा था:

तो मूल रूप से, यदि आप किसी ऐसी वस्तु का उपहास करना चाहते हैं जिसका उपयोग अप्रत्यक्ष रूप से किया जाता है
कोड जो आप परीक्षण करते हैं jest.doMock() फ़ंक्शन काम नहीं करेगा:

'./myModuleTotest' से myModuleToTest आयात करें
यह ('काम करेगा', () => {
jest.doMock('./myOtherModule', () => {
वापसी {
__esमॉड्यूल: सच,
डिफ़ॉल्ट: 'डिफ़ॉल्ट 2',
फू: 'फू 2',
};
});

वापसी आयात ('../myOtherModule')। तब (myOtherModule => {
// मुझे नकली मॉड्यूल myOtherModule में दिलचस्पी नहीं है, लेकिन उस मॉड्यूल पर जो इसका उपयोग करता है
myModuleToTest.doSomethingToSomeProperty (); // इस बिंदु पर myOtherModule के मूल मॉड्यूल और इसके नकली संस्करण का उपयोग myModuleToTest द्वारा नहीं किया जाएगा
उम्मीद (myModuleToTest.someProperty).toBe('thisWillFail'); // परीक्षण पास नहीं होगा क्योंकि नकली संस्करण का उपयोग नहीं किया गया था
});});

जेस्ट 26 के अनुसार किसी ऑब्जेक्ट को निर्यात करने वाले मॉड्यूल का मजाक उड़ाने का कोई तरीका नहीं है (I
मतलब किसी फ़ंक्शन के अलावा कुछ और) जिसका उपयोग अप्रत्यक्ष रूप से किया जाता है। क्या इस
सही है या मुझे कुछ याद आ रहा है? तब एकमात्र समाधान अधिक हो रहा है
एक ही मॉड्यूल का परीक्षण करने के लिए एक से अधिक परीक्षण फ़ाइल।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपने टिप्पणी की थी।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/facebook/jest/issues/2582#issuecomment-655110424 , या
सदस्यता समाप्त
https://github.com/notifications/unsubscribe-auth/AAJR3UW6HARW44ZLKAUB7PLR2N77NANCNFSM4C4I7QSQ
.