Jest: विशिष्ट मॉड्यूल फ़ंक्शन का नकल कैसे करें?

गहन विश्लेषण पर, ऐसा प्रतीत होता है कि जेस्ट-मॉक पूरे मॉड्यूल के लिए एक एएसटी उत्पन्न करता है, फिर उस एएसटी का उपयोग एक नकली मॉड्यूल बनाने के लिए करता है जो मूल के निर्यात के अनुरूप होता है: https://github.com/facebook/jest/tree/master/packages / मजाक-मजाक

अन्य परीक्षण ढांचे, जैसे कि पायथन का नकली (https://docs.python.org/3/library/unittest.mock-examples.html), आपको विशिष्ट कार्यों का मजाक उड़ाने देता है। यह एक मौलिक परीक्षण अवधारणा है।

मैं मॉड्यूल के एक हिस्से का मजाक उड़ाने की क्षमता की अत्यधिक अनुशंसा करता हूं। मुझे लगता है कि मजाक से निर्यात को सशर्त रूप से अनदेखा करने के लिए जेस्ट-मॉक को बदला जाना चाहिए, और मूल कार्यान्वयन का संदर्भ देना चाहिए।

तुम कर सकते हो:

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() कॉल करते हैं, तो हाँ, आप नकली संस्करण को कॉल करेंगे। लेकिन अगर आप myModule.bar() कॉल करते हैं, जो आंतरिक रूप से foo() कॉल करता है, तो foo यह संदर्भित करता है _आपका अधिलेखित संस्करण नहीं है। यदि आप मुझ पर विश्वास नहीं करते हैं, तो आप इसका परीक्षण कर सकते हैं।

इसलिए, आपके द्वारा वर्णित उदाहरण मेरी समस्या के लिए अपर्याप्त है। क्या आप कुछ जानते हैं जो मैं नहीं जानता?

@cpojer

मुझे विश्वास है कि मैं इसे अच्छी तरह समझता हूं। जिस तरह से बेबल मॉड्यूल को संकलित करता है, वह इसे समझना आसान नहीं बनाता है और मैं आपके भ्रम को समझता हूं। मुझे नहीं पता कि यह मॉड्यूल के साथ वास्तविक ES2015 वातावरण में कैसे व्यवहार करेगा, मुख्यतः क्योंकि ऐसा कोई वातावरण अभी मौजूद नहीं है (शायद क्रोम कैनरी के नवीनतम संस्करणों को छोड़कर, जिसे मैंने अभी तक कोशिश नहीं की है)। क्या होता है यह समझाने के लिए, हमें आपके बेबेल कोड के संकलित आउटपुट को देखना होगा। यह कुछ इस तरह दिखेगा:

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

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

इस मामले में, यह वास्तव में सही है कि आप फू का मजाक नहीं उड़ा सकते हैं और मैं आपके प्रारंभिक मुद्दे को सही ढंग से नहीं पढ़ने के लिए क्षमा चाहता हूं, हालांकि इसने इस बारे में कोई धारणा नहीं बनाई कि कैसे 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 का उपयोग नहीं करते हैं।

जबकि ES2015 मॉड्यूल में उनके निर्यात के लिए अपरिवर्तनीय बाइंडिंग हो सकती है, अंतर्निहित संकलित कोड जो अभी बेबल संकलित करता है, ऐसी किसी भी बाधा को लागू नहीं करता है। मूल रूप से समर्थित मॉड्यूल के साथ सख्त ES2015 मॉड्यूल वातावरण में आप जो पूछ रहे हैं, उसका समर्थन करने के लिए मुझे वर्तमान में कोई रास्ता नहीं दिख रहा है। जिस तरह से jest-mock काम करता है वह यह है कि यह मॉड्यूल कोड को अलगाव में चलाता है और फिर मॉड्यूल के मेटाडेटा को पुनः प्राप्त करता है और नकली फ़ंक्शन बनाता है। दोबारा, इस मामले में foo के स्थानीय बाध्यकारी को संशोधित करने का कोई तरीका नहीं होगा। यदि आपके पास इसे प्रभावी ढंग से कार्यान्वित करने के बारे में विचार हैं, तो कृपया यहां योगदान दें या पुल अनुरोध के साथ। मैं आपको याद दिलाना चाहता हूं कि इस परियोजना के लिए हमारे पास एक आचार संहिता है जिसे आप यहां पढ़ सकते हैं: https://code.facebook.com/pages/876921332402685/open-source-code-of-conduct

आपके उदाहरण में सही समाधान फू का मजाक उड़ाना नहीं है, बल्कि उस उच्च-स्तरीय एपीआई का मजाक उड़ाना है जिसे फू कॉल कर रहा है (जैसे XMLHttpRequest या इसके बजाय आपके द्वारा उपयोग किया जाने वाला अमूर्त)।

@cpojer आपके विस्तृत विवरण के लिए धन्यवाद। मुझे खेद है कि अगर मैंने आपको अपनी भाषा से ठेस पहुँचाई है, तो मैं अपने इंजीनियरिंग लेखन में बहुत कुशल हूँ और मैं अपनी बात ASAP तक पहुँचाना चाहता हूँ। चीजों को परिप्रेक्ष्य में रखने के लिए, मैंने इस मुद्दे को समझने की कोशिश में 5 घंटे का समय बिताया और 2 विस्तृत टिप्पणियाँ लिखीं, फिर आपने इसे एक संक्षिप्त संदेश के साथ बंद कर दिया, जो मेरे दोनों बयानों के बिंदु को पूरी तरह से चूक गया। यही कारण है कि मेरे अगले संदेश में कहा गया था कि आपको "मौलिक गलतफहमी" थी, क्योंकि या तो 1) आप उस बिंदु को समझ नहीं पाए जो मैं बना रहा था, या 2) आपको require() समझ में नहीं आया, जो शुक्र है कि विकल्प 1 था।

मैं अपनी समस्या के संभावित समाधान पर विचार करूंगा, अब इसके आसपास जाने के लिए मैंने निचले स्तर के एपीआई का मज़ाक उड़ाया, लेकिन निश्चित रूप से फ़ंक्शन को सीधे नकल करने का एक तरीका होना चाहिए, क्योंकि यह काफी उपयोगी होगा।

मैं मानता हूं कि ऐसा करने में सक्षम होना उपयोगी होगा, लेकिन जेएस में इसे बिना (शायद धीमी) स्थिर विश्लेषण के बिना करने का कोई अच्छा तरीका नहीं है :(

@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 16 का उपयोग कर रहे हैं तो jest.clearAllMocks() कॉल कर सकते हैं।

अरे @cpojer! मैं जेस्ट 16 का उपयोग कर रहा हूं। न तो jest.clearAllMocks() या someModule.function2.mockClear() मेरे लिए काम करता है। वे केवल तभी काम करते हैं जब नकली एक संपूर्ण मॉड्यूल होता है, आयातित मॉड्यूल का कार्य नहीं। मेरे प्रोजेक्ट में, बाद के परीक्षणों में फ़ंक्शन का मज़ाक उड़ाया जाता है। यदि यह अपेक्षित नहीं है तो मैं देखूंगा कि क्या मैं एक छोटे से नमूना प्रोजेक्ट में दोहरा सकता हूं और एक नया मुद्दा बना सकता हूं। अच्छा विचार?

@cpojer -

आपके उदाहरण में सही समाधान फू का मजाक उड़ाना नहीं है, बल्कि उस उच्च-स्तरीय एपीआई का मजाक उड़ाना है जिसे फू कॉल कर रहा है (जैसे XMLHttpRequest या इसके बजाय आपके द्वारा उपयोग किया जाने वाला अमूर्त)।

मैं जेस्ट के लिए नया हूँ और मैं इसी तरह की समस्या से जूझ रहा हूँ। मैं axios का उपयोग कर रहा हूं, जो हुड के नीचे XMLHttpRequest का उपयोग करता है, और मैं axios का मजाक नहीं बनाना चाहता, बल्कि वास्तविक XMLHttpRequest का मजाक उड़ाना चाहता हूं। ऐसा लगता है कि मुझे इसके तरीकों को खुद ही लागू करना होगा, कुछ इस तरह। क्या यह सही तरीका है?

धन्यवाद!

हाँ, ऐसा कुछ आपको सही रास्ते पर ले जाना चाहिए! :) एक अच्छे एपीआई के रूप में jest.fn उपयोग करें, हालांकि :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")

समाधान की तलाश में इस पर आने वाले किसी भी व्यक्ति के लिए, एक फ़ाइल में कई कॉन्स्ट/फ़ंक्शंस निर्यात करते समय, और उन्हें उस फ़ाइल में आयात करते समय निम्नलिखित मेरे लिए काम कर रहा है जिसका मैं परीक्षण कर रहा हूं

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

@ainesophour , यकीन नहीं है कि मैं यहाँ क्या गलत कर रहा हूँ। लेकिन ऐसा लगता है कि यह काम नहीं करता
मैं वर्तमान में जेस्ट 18.1 (और क्रिएट-रिएक्शन-ऐप 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 आपको जेस्ट के परीक्षण के लिए अपनी doSmth विधि और अपनी टेस्ट विधि का नकल करना होगा कि इसे बुलाया गया था या नहीं। यदि आप अपने मॉकिंग कोड का स्निपेट प्रदान कर सकते हैं तो मैं जांच सकता हूं कि क्या गलत है

@ainesophaur ... test() पद्धति का मज़ाक उड़ाने के लिए हैं? यह हिस्सा: test: jest.fn(() => {console.log('I didnt call the original')}),

@ainesophour मैंने आपके कोड की भी कोशिश की। लेकिन यह मेरे काम नहीं आया। यह कभी भी नकली कार्य निष्पादित नहीं करता है। तो, उम्मीद कभी पूरी नहीं होती है।

मुझे लगता है कि यह ऊपर बताए गए कार्यों की आवश्यकता के तरीके में निहित है ... काश इसके लिए कोई समाधान होता।

@cpojer आंशिक रूप से

@rantonmattei और @huyph मुझे आपकी नकली परिभाषाओं और आपके द्वारा

एक निर्भरता से एक फ़ाइल का मज़ाक उड़ा रहा है

इस उदाहरण में वास्तविक कार्य परिभाषा प्रतिक्रिया-मूल द्वारा की जाती है।

यह __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;

मुझे उपरोक्त के लिए उपयोग की जाने वाली परीक्षण फ़ाइल नहीं मिल रही है, लेकिन यह कुछ ऐसा था जैसे मॉड्यूल की आवश्यकता होती है, जेस्ट इसे __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 साझा करने के लिए धन्यवाद। मैं अभी भी इसे जेस्ट 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 द्वारा module.restartCheckExpiryDateTimeout का पता नहीं लगाया जाएगा क्योंकि saveSession वास्तविक परिभाषित restartCheckExpiryDateTimeout फ़ंक्शन को कॉल कर रहा है।

मैं एक कॉन्स को saveSession असाइन करूंगा और फिर saveSession.restartCheckExpiryDateTimeout = () => {...logic} करूंगा। फिर saveSession.saveSession भीतर से, केवल restartCheckExpiryDateTimeout बजाय saveSession.restartCheckExpiryDateTimeout कॉल करें। वास्तविक फ़ंक्शन saveSession बजाय अपना नया कॉन्स निर्यात करें जो तब आपके तरीकों को परिभाषित करता है। फिर जब आप अपने someVar.saveSession() कॉल करते हैं तो यह आंतरिक रूप से saveSession.restartCheckExpiryDateTimeout() कॉल करेगा जो अब नकली है।

मुझे यह जोड़ना चाहिए था कि restartCheckExpiryDateTimeout() एक निर्यात किया गया फ़ंक्शन है। saveSession() भीतर स्थानीय रूप से परिभाषित फ़ंक्शन नहीं ... (ऊपर मेरी टिप्पणी अपडेट की गई)। उस स्थिति में, मुझे लगता है कि module.saveSession() को सही module.restartCheckExpiryDateTimeout() को कॉल करना चाहिए जिसका मजाक उड़ाया गया है।

लेकिन मैं वह दूंगा जो आप ऊपर सुझाएंगे, हालांकि। saveSession() और restartCheckExpiryDateTimeout() को दूसरे कॉन्स्ट पर ले जाना। धन्यवाद

मैं समझता हूं कि इसे saveSession के दायरे में परिभाषित नहीं किया गया है। सेवसेशन है
माता-पिता के दायरे में भाई विधि को बुलाओ। मैं इसमें कई बार भागा
और मैंने जो सुझाव दिया वह इसके लिए काम करता है

8 मई, 2017 को रात 8:38 बजे, "हुय फाम" नोटिफिकेशन @github.com ने लिखा:

मुझे यह जोड़ना चाहिए था कि पुनरारंभ करेंचेकएक्सपिरीडेटटाइमआउट() एक निर्यात किया गया है
समारोह। saveSession() के भीतर स्थानीय रूप से परिभाषित फ़ंक्शन नहीं है ...

हालांकि आप जो सुझाव देते हैं वह मैं एक बार में दूंगा। धन्यवाद

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

बस कोशिश की..मैंने पाया कि:

यह काम नहीं करता है: (यानी मूल पुनरारंभ चेकएक्सपिरीडेटटाइमआउट() अभी भी कहा जाता है)

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

यह काम करता है: (यानी नकली पुनरारंभ चेकएक्सपिरीडेटटाइमआउट() को इसके बजाय कहा जाता है)। अंतर तीर के रूप के बजाय function() का उपयोग है, और this. बजाय session.

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

इन कोडों को मजाक में ट्रांसपिल करने में समस्या हो सकती है ....

उन्हें पूजो के बजाय क्लास ऑब्जेक्ट के रूप में निर्यात करने का प्रयास करें। मेरा मानना ​​है कि
ट्रांसपिलर चर को अलग तरह से फहराता है। हम एक काम करने के लिए मिल जाएगा
परीक्षण, मैं वादा करता हूं .. मुझे इस परियोजना पर लगभग आधा साल हो गया है
उसने मजाक का इस्तेमाल किया लेकिन मुझे यह समस्या अच्छी तरह याद है और मुझे अंततः याद है
एक समाधान ढूँढना।

9 मई, 2017 को दोपहर 12:53 बजे, "ह्यू फाम" नोटिफिकेशन @github.com ने लिखा:

बस कोशिश की..मैंने पाया कि:

यह काम नहीं करता है: (यानी मूल पुनरारंभचेकएक्सपिरीडेटटाइमआउट() है
अभी भी बुलाओ)

निर्यात सत्र = {
सेव सत्र: () => {
session.restartCheckExpiryDateTimeout ();
},
पुनरारंभ करेंचेकएक्सपिरीडेटटाइमआउट: () => {},
}

यह काम नहीं करता है: (यानी मूल पुनरारंभ करेंचेकएक्सपायरीडेटटाइमआउट() है
अभी भी बुलाओ)

निर्यात सत्र = {
सेव सेशन: फंक्शन () {
this.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 पैटर्न के लिए, जेस्ट आपके उदाहरण की तरह, फ़ंक्शन को सफलतापूर्वक नकल कर सकता है।

@ainesophour काम नहीं कर रहा है।

मापांक:

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

ऊपर मेरी पिछली कुछ टिप्पणियों को देखें। विशेष रूप से अंतिम। आपका
निर्यात की गई विधियाँ स्थानीय रूप से स्कोप किए गए सिबलिंग मेथड बनाम को कॉल कर रही हैं
वास्तविक निर्यात विधि (जहां आपका नकली है)

31 मई, 2017 को दोपहर 2:00 बजे, "नोवालाइन" नोटिफिकेशन @github.com ने लिखा:

@ainesophour https://github.com/ainesophour काम नहीं कर रहा है।

मापांक:

निर्यात स्थिरांक getMessage = (संख्या: संख्या): स्ट्रिंग => {
वापसी Her name is ${genName(num)} ;
};
निर्यात समारोह genName (संख्या: संख्या): स्ट्रिंग {
वापसी 'नोवालिन';
}

परीक्षण:

फंक्शन मॉकफंक्शन () {
मूलांक मूल = आवश्यकता। आवश्यकता वास्तविक ('../मॉड्यूलए');
वापसी {
...मूल,
genName: jest.fn(() => 'एमिली')
}
}jest.mock('../moduleA', () => mockFunctions());const moduleA = आवश्यकता ('../moduleA');
वर्णन करें ('मॉक फंक्शन', () => {

यह ('टी -0', () => {
उम्मीद (jest.isMockFunction(moduleA.genName)).toBeTruthy();
})

यह ('टी -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);

});

});

परीक्षा परिणाम:

असफल मज़ाक-उदाहरण/__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)

नकली समारोह
टी-0 (1ms)
टी-1 (22ms)

टेस्ट सूट: 1 विफल, 1 कुल
टेस्ट: 1 असफल, 1 उत्तीर्ण, कुल 2
स्नैपशॉट: कुल 0
समय: 0.215s, अनुमानित 1s

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

@ainesophour : मैंने export class Session { } प्रयास किया। और यह मेरे लिए काम नहीं करता है।

मेरे लिए काम करने वाला एकमात्र तरीका उपरोक्त मेरी टिप्पणी में है: जहां function तीर () => बजाय सिंटैक्स का उपयोग किया जाता है। यहां:

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

यह जेस्ट 20.0.3 . पर है

मैं जो करता हूं वह कार्यों के लिए एक कॉन्स रैपर बनाता है, और उसके बाद उस रैपर को निर्यात करता है (जैसे निर्यात कॉन्स एफएनएस)। फिर मॉड्यूल के अंदर 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()
})

@ मिलुओशी यही एकमात्र तरीका है जिससे मैं भी ऐसा करने में सक्षम था। जब हम इस पद्धति का उपयोग करते हैं तो क्या कोई प्रदर्शन या ऐसा कुछ नुकसान होता है? ऐसा लगता है कि कोड को बदलने के लिए "गलत" है ताकि आप इसका परीक्षण कर सकें।

मैं वास्तव में सिर्फ लिखने का एक तरीका चाहूंगा:
jest.mock('src/folder/file.func, () => {return 'whatever i want'})

यहां मुख्य टुकड़ा .func

@miluoshi @Rdlenke यदि आपके कोड में नामित निर्यात शामिल हैं तो आप import * as model भी कर सकते हैं और फिर model.generateImagePreview = jest.fn(() => Promise.resolve); अधिलेखित कर सकते हैं

आप इसे सिनॉन के साथ कैसे परखेंगे? जैसा कि पहले उल्लेख किया गया है (देखें https://github.com/facebook/jest/issues/936#issuecomment-214939935), जिस तरह से ESM काम करता है, उससे func2 भीतर func1 func2 का मजाक उड़ाना असंभव हो जाता है, इसलिए मैं जरूरी नहीं कि इसे बुनियादी कहूंगा।

हो सकता है कि एक बेबेल मोड लिखा जा सकता है जो किसी भी "testImport" फ़ंक्शन में पढ़ता है
और पहले मॉड्यूल में कार्यों को निर्यात करने के लिए कोड को फिर से लिखता है
परीक्षण चल रहा है?

सोम, 18 दिसंबर, 2017 को शाम 5:00 बजे, जिम मूडी नोटिफिकेशन @github.com ने लिखा:

आप सही कह रहे हैं https://github.com/simenb , मैंने कुछ बदल दिया था
मेरे परीक्षण में सिनॉन पर स्विच करने के बीच में ऐसा लगता है कि यह पास हो गया है।
जब मैंने इसे वापस किया, तब भी यह काम नहीं कर रहा है। मुझे लगता है कि यह कोई समस्या नहीं है
जिसे सुलझा लिया गया है।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे 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

यह ई - मेल प्रिंट करने से पहले पर्यावरण पर विचार करें
चेतावनी: कंप्यूटर वायरस ईमेल के माध्यम से प्रेषित किए जा सकते हैं। प्राप्तकर्ता
वायरस की उपस्थिति के लिए इस ईमेल और किसी भी अनुलग्नक की जांच करनी चाहिए।
डेवेलर लिमिटेड किसी भी वायरस से होने वाले किसी भी नुकसान के लिए कोई दायित्व स्वीकार नहीं करता है
इस ईमेल द्वारा प्रेषित। ई-मेल संचरण की गारंटी नहीं दी जा सकती
सुरक्षित या त्रुटि मुक्त क्योंकि जानकारी को इंटरसेप्ट किया जा सकता है, दूषित किया जा सकता है, खो दिया जा सकता है,
नष्ट हो जाते हैं, देर से पहुंचते हैं या अपूर्ण होते हैं, या वायरस होते हैं। प्रेषक
इसलिए किसी भी त्रुटि या चूक के लिए उत्तरदायित्व स्वीकार नहीं करता है
इस संदेश की सामग्री, जो ई-मेल संचरण के परिणामस्वरूप उत्पन्न होती है।

चेतावनी: हालांकि डेवेलर लिमिटेड ने इसके लिए उचित सावधानी बरती है
सुनिश्चित करें कि इस ईमेल में कोई वायरस मौजूद नहीं है, कंपनी स्वीकार नहीं कर सकती
इस ईमेल के उपयोग से होने वाले किसी भी नुकसान या क्षति के लिए जिम्मेदारी या
संलग्नक।

डेवेलर लिमिटेड इंग्लैंड और वेल्स में पंजीकृत एक लिमिटेड कंपनी है। |
कंपनी पंजीकरण संख्या 09817616 | पंजीकृत कार्यालय: SUITE 1 SECOND
फ्लोर एवरडीन हाउस, डेनस्ली रोड, बोर्नमाउथ, यूनाइटेड किंगडम, 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);
  });
});

@ जिम-मूडी अगर मैं इस मुद्दे को सही ढंग से समझता हूं, तो यह आपके उदाहरण के लिए काम करना चाहिए:

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

(यह _only_ काम करता है अगर कार्यों को कॉन्स्ट के रूप में निर्यात किया जाता है, जैसे आपके उदाहरण में)

@dinvlad मेरे हीरो!

@Dinvlad के उत्तर के बाद, मुझे लगता है कि जेस्ट ऑब्जेक्ट पेज पर मॉक फ़ंक्शन पेज पर निम्नलिखित मॉक संबंधित डॉक्स को जोड़ना, दिखाना या लिंक करना मॉकिंग पर जेस्ट डॉक्स में सुधार हो सकता है:

• jest.isMockFunction(fn)
• jest.genMockFromModule(मॉड्यूलनाम)
• jest.mock (मॉड्यूलनाम, फ़ैक्टरी, विकल्प)
• jest.unmock (मॉड्यूलनाम)
• jest.doMock (मॉड्यूलनाम, फ़ैक्टरी, विकल्प)
• jest.dontMock (मॉड्यूलनाम)

मेरा उपयोग मामला यह है कि जेस्ट के एक नए उपयोगकर्ता के रूप में मैं कुछ mocha + sinon.js कोड को जेस्ट में माइग्रेट कर रहा हूं। मेरे पास पहले से ही जासूस और उम्मीदें थीं इसलिए मैंने सोचा कि यह आसान होगा। लेकिन इस धागे को पढ़ने और मॉक फ़ंक्शंस पर जेस्ट डॉक्स पढ़ने के बाद मुझे यह आभास हो रहा था कि इस तरह से जेस्ट का उपयोग करने से मेरे परीक्षणों को फिर से लिखने या ईएसएम या बैबेल की विस्तृत समझ ... या अन्य भ्रम की आवश्यकता हो सकती है।

जेस्ट के लिए धन्यवाद - यह मेरे परीक्षणों को लिखने/समझने और निष्पादित करने में तेज़ बना रहा है। :)

दस्तावेज़ों को स्पष्ट करने वाले पीआर का बहुत स्वागत है! मैं

ES मॉड्यूल सिंटैक्स के साथ केवल विशिष्ट मॉड्यूल का नकल करने के लिए, आप मूल मॉड्यूल को पुनर्स्थापित करने के लिए

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 उपयोग कर सकते हैं, हो सकता है? डिफ़ॉल्ट रूप से यह अंतर्निहित फ़ंक्शन को कॉल करता है

मदद के लिए धन्यवाद, मैंने कोशिश की, लेकिन परीक्षण से पता चलता है कि इसे कभी भी कॉल नहीं किया गया था, भले ही इसे बुलाया गया क्योंकि मैंने कंसोल डाल दिया। लॉग और यह प्रिंट किया

परीक्षण फ़ाइल

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 क्या आप अपने jest.spyOn() .mockImplementation() जोड़ सकते हैं? जैस्मीन से आने वाले किसी व्यक्ति के रूप में, मैंने जैस्मीन के जासूसों के समान कार्यक्षमता प्राप्त करने के लिए इस टिप को महत्वपूर्ण पाया। उदाहरण के लिए

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

यदि आप mockImplementation() , तो jest.spyOn() एक ऐसी वस्तु उत्पन्न करता है जो _not_ एक नकली (afaiu) है और यह वास्तव में मूल कार्यान्वयन को रोकता है। यदि आपको मूल कार्यान्वयन रखना है, तो शायद यह उपयोग करने लायक है

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

सुनिश्चित नहीं है कि यह आवश्यक है, लेकिन निश्चित रूप से यह _ चाहिए_ काम करता है।

मूल अनुरोध पर वापस जा रहे हैं...

क्या आप सिर्फ एक आयात * के आसपास एक प्रॉक्सी लपेट नहीं सकते थे? जैसे

आयात * './myfile.js' से परीक्षण के रूप में;

कॉन्स्ट हैंडलर = {
/** अवरोधन: गुण प्राप्त करना */
प्राप्त करें (लक्ष्य, प्रोपकी, रिसीवर) {
कंसोल.लॉग ( GET ${propKey} );
वापसी 123;
},

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

कास्ट पी = नया प्रॉक्सी (परीक्षण);

मंगलवार, 30 जनवरी, 2018 को शाम 4:24 बजे, डेनिस लॉगिनोव नोटिफिकेशन @github.com
लिखा था:

@WangHansen https://github.com/wanghansen क्या आप जोड़ सकते हैं
.mockImplementation () आपके jest.spyOn () के लिए? जैसे कोई से आ रहा है
जैस्मीन, मैंने इस टिप को समान कार्यक्षमता प्राप्त करने के लिए महत्वपूर्ण पाया:
जैस्मीन के जासूस। उदाहरण के लिए

कॉन्स्ट मॉकमॉड्यूल फंक्शन = जेस्ट
.spyOn (मॉड्यूल, 'फ़ंक्शन')
.mockImplementation(() => 'hello');...expect(mockModuleFunction.mock).toBeCalled();

यदि आप mockImplementation() का उपयोग नहीं करते हैं, तो jest.spyOn() एक उत्पन्न करता है
वह वस्तु जो नकली नहीं है (afaiu) और यह वास्तव में मूल निवासी को प्रभावित करती है
कार्यान्वयन। यदि आपको मूल कार्यान्वयन रखना है, तो शायद यह है
उपयोग करने लायक

कॉन्स्ट मॉड्यूलफंक्शन = मॉड्यूल.फंक्शन; जेस्ट। स्पाईऑन (मॉड्यूल, 'फंक्शन')। मॉक इम्प्लीमेंटेशन (मॉड्यूलफंक्शन); ...

सुनिश्चित नहीं है कि यह आवश्यक है, लेकिन यह सुनिश्चित है कि इसे काम करना चाहिए ।

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

--

डैरेन क्रेसवेल
अनुबंध डेवलपर | डेवेलर लिमिटेड
ई-मेल: [email protected]
फ़ोन:
वेबसाइट: http://www.develer.co.uk

यह ई - मेल प्रिंट करने से पहले पर्यावरण पर विचार करें
चेतावनी: कंप्यूटर वायरस ईमेल के माध्यम से प्रेषित किए जा सकते हैं। प्राप्तकर्ता
वायरस की उपस्थिति के लिए इस ईमेल और किसी भी अनुलग्नक की जांच करनी चाहिए।
डेवेलर लिमिटेड किसी भी वायरस से होने वाले किसी भी नुकसान के लिए कोई दायित्व स्वीकार नहीं करता है
इस ईमेल द्वारा प्रेषित। ई-मेल संचरण की गारंटी नहीं दी जा सकती
सुरक्षित या त्रुटि मुक्त क्योंकि जानकारी को इंटरसेप्ट किया जा सकता है, दूषित किया जा सकता है, खो दिया जा सकता है,
नष्ट हो जाते हैं, देर से पहुंचते हैं या अपूर्ण होते हैं, या वायरस होते हैं। प्रेषक
इसलिए किसी भी त्रुटि या चूक के लिए उत्तरदायित्व स्वीकार नहीं करता है
इस संदेश की सामग्री, जो ई-मेल संचरण के परिणामस्वरूप उत्पन्न होती है।

चेतावनी: हालांकि डेवेलर लिमिटेड ने इसके लिए उचित सावधानी बरती है
सुनिश्चित करें कि इस ईमेल में कोई वायरस मौजूद नहीं है, कंपनी स्वीकार नहीं कर सकती
इस ईमेल के उपयोग से होने वाले किसी भी नुकसान या क्षति के लिए जिम्मेदारी या
संलग्नक।

डेवेलर लिमिटेड इंग्लैंड और वेल्स में पंजीकृत एक लिमिटेड कंपनी है। |
कंपनी पंजीकरण संख्या 09817616 | पंजीकृत कार्यालय: SUITE 1 SECOND
फ्लोर एवरडीन हाउस, डेनस्ली रोड, बोर्नमाउथ, यूनाइटेड किंगडम, BH7 7DU

@dinvlad @iampeterbanjo @SimenB आपकी सभी मदद के लिए फिर से धन्यवाद, लेकिन दुर्भाग्य से, आपके द्वारा सुझाए गए तरीकों में से कोई भी काम नहीं किया। मुझे आश्चर्य है कि ऐसा इसलिए है क्योंकि फ़ंक्शन को next(err) के रूप में बुलाया जाता है। तर्क यह है कि, जब कोई अनुरोध विफल हो जाता है, तो उसे errorHandler पर कॉल करके return next(err) में भेज दिया जाएगा। निश्चित रूप से फ़ंक्शन को कॉल किया जा रहा है क्योंकि जब मैंने console.log जोड़ा, तो यह प्रिंट हो रहा है। लेकिन परीक्षण बताते हैं कि इसे कभी नहीं कहा जाता है

@dinvlad मैंने आपकी विधि की कोशिश की, यह काम नहीं किया, लेकिन वैसे भी आपकी मदद के लिए धन्यवाद। मैं बस सोच रहा था कि आपको mockImplementation पर कॉल करने की आवश्यकता क्यों है, आधिकारिक दस्तावेज़ के अनुसार jest.spyOn , आप इसे केवल तभी कॉल करते हैं जब आप मूल फ़ंक्शन को ओवरराइड करना चाहते हैं।

@WangHansen हाँ आप सही कह रहे हैं कि इसकी आवश्यकता केवल तभी होती है जब कोई मूल विधि को ओवरराइड करना चाहता है। मैं उन परिस्थितियों के लिए सिर्फ एक विचार फेंक रहा था।

आपके लिए असफल होने का एक कारण अतुल्यकालिकता है। यदि आपकी विधि कॉलबैक और/या वादे (या async/प्रतीक्षा) का उपयोग कर रही है, तो आपको यह सुनिश्चित करना होगा कि आपकी परीक्षण विधि समाप्त होने से पहले आपकी अपेक्षाओं को वास्तव में निष्पादित किया गया है। उस पर जोर देने के लिए एक विशेष विधि expect.assertions(N) है। यह भी सुनिश्चित करें कि कॉलबैक/वादों के अंदर कोड को कॉल किए जाने के बाद ही आपकी अपेक्षा निष्पादित की जाती है। मुझे यकीन है कि आपने उस पर ध्यान दिया है, लेकिन सिर्फ संदर्भ के लिए, https://facebook.github.io/jest/docs/en/asynchronous.html

यह दुर्भाग्यपूर्ण है कि आंतरिक रूप से उपयोग किए जाने वाले fns का मजाक उड़ाते हुए @seibelj वर्णन करता है कि मॉड्यूल 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)
})

यह अभी भी थोड़े हैकी लगता है और दस्तावेज़ सहायक नहीं थे। मैं जेस्ट और इसके पीछे की टीम के लिए आभारी हूं लेकिन यह एक सामान्य उपयोग के मामले की तरह लगता है जिसमें कम से कम "आधिकारिक" समाधान होना चाहिए।

@sarahdayan , और जो भी ब्याज का हो सकता है -
मैंने बेबेल-प्लगइन-रीवायर का उपयोग कर समाप्त कर दिया है।
मुझे उस प्लगइन को खोजने में कुछ समय लगा, लेकिन 'एक समाधान पर्याप्त सुसंगत था जो हैकी महसूस नहीं करता था।

ज्यादातर मामलों में, हम एक मॉड्यूल से एक या अधिक कार्यों का मजाक नहीं बनाना चाहते हैं। यदि आप ग्लोबल जेस्ट के मॉकिंग सिस्टम का उपयोग करते हैं तो आप इसे 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 साथ mockImplementationOnce someFunction फ़ंक्शन को मॉक करने की भी अनुमति देता है। mockImplementation एपीआई।

मैंने उपरोक्त सभी वार्तालापों को पढ़ा है, लेकिन मेरे लिए कोई भी समाधान काम नहीं करता है।
यदि आप अभी भी इस परीक्षण मामले के समाधान की तलाश में हैं, तो उत्तर बैबेल-प्लगइन-रीवायर है , यह प्लगइन उस परिदृश्य मामले को हल करने के लिए है जिस पर हमने चर्चा की थी।
कृपया उस परिवाद पर एक नज़र डालें, आप मुझे बाद में धन्यवाद देंगे।

तो ऊपर दिए गए पूरे सूत्र को संक्षेप में प्रस्तुत करने के लिए:

1. मान लीजिए कि आपके पास m फ़ंक्शन के साथ एक मॉड्यूल है f , g और h जहां g और h कॉल f । हम f का उपहास करना चाहेंगे ताकि g और h असली f बजाय नकली कॉल करें। दुर्भाग्य से यह सीधे करना संभव नहीं है जब तक कि f को हमेशा exports माध्यम से कॉल नहीं किया जाता है जैसा कि cpojer ने वर्णित किया है । यह असंभव है यदि आपका मॉड्यूल टाइपस्क्रिप्ट में ES6 आयात/निर्यात सिंटैक्स का उपयोग करता है (और मुझे लगता है कि यह बैबेल में भी सच है)।
2. हालांकि, मान लीजिए कि हम f को दूसरे मॉड्यूल m2 । फिर m import {f} from 'm2' जैसा स्टेटमेंट होगा और जब g और h कॉल f , तो वे वास्तव में m2.f को कॉल कर रहे हैं m2 = require('./m2') (बेबेल/टाइपस्क्रिप्ट अनुवाद इस तरह दिखेगा)। यह f मज़बूती से मजाक बनाना संभव बनाता है जैसा कि ग्रेपैंट्स द्वारा वर्णित किया गया है । दूसरे शब्दों में, आप कॉल को मज़बूती से केवल तभी मॉक कर सकते हैं जब वे एक मॉड्यूल सीमा को पार करते हैं । नोट: ग्रेपैंट्स समाधान अब यह त्रुटि संदेश उत्पन्न करता है: " jest.mock() मॉड्यूल फ़ैक्टरी को किसी भी आउट-ऑफ-स्कोप वैरिएबल को संदर्भित करने की अनुमति नहीं है - अमान्य वैरिएबल एक्सेस: __असाइन"। मुझे संदेह है कि यह जेस्ट में एक बग है; समाधान के रूप में, Object.assign जैसा कि नीचे दिखाया गया है।
3. लेकिन अगर, एक या दो कार्यों का मजाक उड़ाने के बजाय, आप एक या दो कार्यों को छोड़कर हर चीज का मजाक उड़ाना चाहते हैं, तो डार्कोविक जैसे कोड का उपयोग करें।

(2) का उदाहरण:

~~~ जेएस
// मॉड्यूल m.js
आयात {f} './m2' से
निर्यात समारोह जी () {वापसी 'एफ लौटा' + एफ (); };

// मॉड्यूल m2.js
निर्यात समारोह एफ () {वापसी 'असली एफ'; }

// test.js
आयात * './m' से m के रूप में

jest.mock('./m2', () => Object.assign(
आवश्यकता। आवश्यकता वास्तविक ('./m2'), {
f: jest.fn().mockReturnValue('MOCK')
}));

परीक्षण ('मजाक', () => {
उम्मीद (मिलीग्राम ())। toEqual ('f MOCK लौटा');
});
~~~

इसका परीक्षण करते समय मैं #2649 में भाग गया: एक परीक्षण के अंदर jest.mock पर कॉल करने का कोई प्रभाव नहीं पड़ता है, और यदि आप इसे वैश्विक दायरे में कहते हैं तो आप अन्य परीक्षणों से पहले unmock नहीं कर सकते। बहुत कष्टप्रद।

धन्यवाद!! @sarahdayan
कुछ समय से इसकी तलाश कर रहे थे

यदि दस्तावेज़ों की कमी है, तो उन्हें स्पष्ट करने के लिए पीआर का हमेशा स्वागत है

हेलो सब लोग!

मैंने थोड़ा इधर-उधर खेला और उस समस्या को हल करने के लिए निम्नलिखित विचार था:

• एक मॉड्यूल का नकली, लेकिन नकली मॉड्यूल में प्रोटोटाइप श्रृंखला में मूल मॉड्यूल होता है।
• नकली मॉड्यूल में गुण जोड़ने के लिए एक विधि प्रदान करें (जो प्रोटोटाइप से गुणों को ओवरराइड करेगा)
• नकली मॉड्यूल से गुणों को हटाने के लिए एक विधि भी प्रदान करें (फिर से प्रोटोटाइप से एक का उपयोग करने के लिए)।

// 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 के उत्तर के आधार पर इसने मेरे लिए काम किया:

मेरे मामले में, मैं नोड_मॉड्यूल्स में एक निर्भरता का मजाक उड़ाना चाहता था, इसे 'साझा-घटक' कहते हैं। यह कई नामित घटकों का निर्यात करता है। मैं इन नामित निर्यातों में से केवल एक जोड़े का मज़ाक उड़ाना चाहता था, और बाकी को असली चीज़ के रूप में छोड़ देना चाहता था।

तो __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
}))

@MajorBreakfast जो React.lazy साथ काम करता है?

const mockLazy = jest.fn();

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

मुझे अभी भी ReferenceError: React is not defined ।

एक स्वतंत्र निर्यात फ़ंक्शन मॉड्यूल का मजाक उड़ाने के लिए:
फ़ाइल से डिफ़ॉल्ट निर्यात के सभी व्यक्तिगत फ़ंक्शन भाग को निर्यात करें।

उदाहरण:
डेटादाओ.जेएस

फ़ंक्शन गेटडेटा ()
फ़ंक्शन सेटडेटा ()
फ़ंक्शन हटाएंडेटा ()
निर्यात {getData, setData, deleteData}

अब आप डिफ़ॉल्ट नामकरण द्वारा फ़ाइल से सभी कार्यों को अपने जेस्ट परीक्षण में आयात कर सकते हैं;

dataDao.spec.js

आयात * डेटाडाओ के रूप में '../dataDao' से;
// आयात पर निर्दिष्ट डिफ़ॉल्ट नाम को संदर्भित करने वाले मॉड्यूल पर जासूसी करें
jest.spyOn (डेटाडाओ, 'गेटडेटा')
jest.spyOn (डेटाडाओ, 'सेटडाटा')
jest.spyOn (डेटाडाओ, 'डिलीटडेटा')

@vchinthakunta , जो काम कर सकता है, लेकिन यह निर्यात/आयात वाक्यविन्यास के एक प्रमुख उद्देश्य के उल्लंघन की तरह दिखता है: अन्य मॉड्यूल अब विशिष्ट विधियों या डेटा फ़ील्ड को आयात करने में सक्षम नहीं होंगे

import { justThisThing } from 'someModule';

क्या मुझे वहां कुछ याद आ रहा है?

@MajorBreakfast जो React.lazy साथ काम करता है?

const mockLazy = jest.fn();

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

मुझे अभी भी ReferenceError: React is not defined ।

मुझे लगता है कि 'रिएक्ट' यहां लोअरकेस होना चाहिए क्योंकि यह आयात का संदर्भ दे रहा है?

jest.mock('react'...)

मुझे अपना कोड निम्नलिखित का उपयोग करके काम कर रहा है जो मैंने यहां देखे गए अन्य समाधानों की तुलना में आसान है। इसके लिए आपको require का उपयोग करने या default निर्यात सेट करने की आवश्यकता नहीं है।

हेल्पर्स/नेविगेशन.जेएस

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

...

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

नेविगेशन.जेएस का उपयोग करने वाला घटक

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

यह एक सामान्य पर्याप्त समस्या की तरह लगता है। क्या जेस्ट डॉक्स में इसके बारे में कुछ है?

तो, क्या एक ही मॉड्यूल के भीतर किसी फ़ंक्शन का मज़ाक उड़ाने का कोई समाधान है?

निम्नलिखित विधि ने मेरे लिए काम किया, चाल परीक्षण के अंत में नकली फ़ंक्शन को वापस रीसेट करना है।
यह उदाहरण 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 का उपयोग कहां कर रहे हैं? वैसे भी, यह केवल तभी काम करेगा जब आपका नकली फ़ंक्शन एक निर्यातित कॉन्स्ट फ़ंक्शन नहीं है

तो, क्या एक ही मॉड्यूल के भीतर _ फ़ंक्शन का मज़ाक उड़ाने का कोई समाधान है?

बहुत खोज करने के बाद, इस समस्या का समाधान आपके निर्यात को एक ही वस्तु में संग्रहीत करना है जिसे आपके फ़ंक्शन और मॉक संदर्भित कर सकते हैं। नीचे दिए गए लेख सभी समान सहमति पर आए।

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

यह मेरे लिए आश्चर्य की बात है कि किसी ने भी एक अलग समाधान का उल्लेख नहीं किया है, यदि यह आपके कोड के लिए काम करने योग्य है, तो इन सभी समस्याओं को पूरी तरह से समाप्त कर देता है और वांछित कोड का परीक्षण बहुत ही सरल बनाता है:

_उस एकल फ़ंक्शन को स्थानांतरित करें जिसे आप अपने मॉड्यूल में मॉक करना चाहते हैं।_

गंभीरता से। यदि आपका मॉड्यूल इस तरह लिखा गया है कि आपको इसके आंतरिक भागों को अन्य आंतरिक भागों से अलग परीक्षण करने की आवश्यकता है, तो लगभग निश्चित रूप से आपकी कक्षा एकल उत्तरदायित्व सिद्धांत का उल्लंघन कर रही है (हाँ, यह वास्तविक वर्ग नहीं है, लेकिन मॉड्यूल एक वर्ग की तरह काम कर रहा है, मॉड्यूल कोड का एक यूनिट कंटेनर है)। उस चूसने वाले को विभाजित करें, और उछाल, आप आवश्यकता का मजाक उड़ा सकते हैं।

यदि नकली फ़ंक्शन निजी राज्य के समूह पर निर्भर करता है, तो यह अभी भी एक अच्छा कारण नहीं है कि आप अपने मॉड्यूल को किसी भी तरह विभाजित न करें। तथ्य यह है कि यह आंतरिक स्थिति के एक समूह पर निर्भर करता है, मेरे लिए यह दर्शाता है कि मॉड्यूल की चिंताओं को स्पष्ट रूप से नहीं सोचा गया है। शायद विभाजित करने के लिए एक तीसरा मॉड्यूल भी है, जो किसी प्रकार के डेटा वर्ग या डीटीओ का प्रतिनिधित्व करता है, जिसे तर्क के रूप में पारित किया जा सकता है।

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

जब परीक्षण बहुत कठिन हो जाता है, तो यह लगभग हमेशा रिफैक्टरिंग की आवश्यकता होने का संकेत होता है ...

कोई परीक्षण टॉमफूलरी की आवश्यकता नहीं है:

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 जैसी एकल लॉश विधि का केवल उपहास करना चाहता था और इसे आसानी से करने में सक्षम था:

मॉड्यूल.जेएस

const lodash = require('lodash');

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

टेस्ट.जेएस

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

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

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

उम्मीद है की वो मदद करदे :)

टाइपस्क्रिप्ट के साथ काम करने वाली हमारी टीम के लिए काम करने वाली कुछ चीज थी const जिसे हम सीधे फंक्शन को एक्सपोर्ट करने के बजाय एक्सपोर्ट करते हैं।
काम नहीं कर रहा:
export function doSomething(a, b) {}
काम में हो:
export const doSomething = function (a, b) {}

मैंने निर्यात को बदल दिया जैसे @arbielsk क्या करता है, यह काम करता है! लेकिन मुझे नहीं पता कि दो तरह के निर्यात में क्या अंतर है...

@dgrcode क्या आपको कभी अपने उदाहरण का हल मिला? जहाँ तक मैं बता सकता हूँ, आप जो करने की कोशिश कर रहे हैं वह जेस्ट के माध्यम से मजाक करके समर्थित नहीं है। विशेष रूप से, मुझे लगता है कि सिर्फ मजाक करना मूल रूप से आयात को फिर से शुरू करना है ताकि मॉड्यूल के बाहरी दृश्य नकली तरीकों को देख सकें। हालांकि, आपके उदाहरण में, foo और bar एक ही मॉड्यूल में हैं और इसलिए foo के bar दृष्टिकोण का मजाक नहीं उड़ाया जा सकता।

मेरा मानना ​​है कि आपके विकल्प या तो हैं:
1) अपने कोड को फिर से व्यवस्थित करें ताकि foo एक मॉड्यूल आयात करे जिसमें bar
2) बेबेल-प्लगइन-रीवायर का प्रयोग करें

कृपया मुझे सुधारें अगर मैं गलत समझ रहा हूँ!

मुझे थोड़ी अलग आवश्यकता थी: मैं एक फ़ंक्शन के लिए एक संपूर्ण मॉड्यूल _except_ का नकल करना चाहता था। शुरुआती बिंदु के रूप में @MajorBreakfast के समाधान का उपयोग करते

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

@dgrcode क्या आपको कभी अपने उदाहरण का हल मिला? जहाँ तक मैं बता सकता हूँ, आप जो करने की कोशिश कर रहे हैं वह जेस्ट के माध्यम से मजाक करके समर्थित नहीं है। विशेष रूप से, मैं _थिंक_ कि मजाक करना मूल रूप से आयात को फिर से जोड़ना है ताकि मॉड्यूल के बाहरी दृश्य नकली तरीकों को देख सकें। हालांकि, आपके उदाहरण में, foo और bar एक ही मॉड्यूल में हैं और इसलिए foo के bar दृष्टिकोण का मजाक नहीं उड़ाया जा सकता।

मेरा मानना ​​है कि आपके विकल्प या तो हैं:

1. अपने कोड को फिर से व्यवस्थित करें ताकि foo एक मॉड्यूल आयात करे जिसमें bar
2. बेबेल-प्लगइन-रीवायर का उपयोग करें

कृपया मुझे सुधारें अगर मैं गलत समझ रहा हूँ!

वह वास्तव में मेरा मामला था
मॉड्यूल का मज़ाक कैसे उड़ाया जा सकता है, इसकी मेरी समझ पूरी तरह से गड़बड़ हो गई थी ‍♂

मूल रूप से
यदि 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 एस्लिंट नियम को आपकी पीठ मिल गई है।

export const करने से आप spyOn फ़ंक्शन कर सकते हैं जो _same_ मॉड्यूल के भीतर से अन्य फ़ंक्शन द्वारा उपयोग किए जाते हैं।

// 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 बेबेल प्लगइन का उपयोग करें

यदि आप फ़ंक्शन एक्सप्रेशन (यानी 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');
  });
});

उदाहरण के लिए डॉक्स देखें।

नोट: बेबेल ट्रांसपिलेशन की आवश्यकता है

विकल्प 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 आप सही प्रतीत होते हैं। क्षमा करें, मुझे सीआरए के साथ इसका परीक्षण करना चाहिए था।

मुझे यहां काम करने के लिए विकल्प 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 । मुझे यकीन नहीं है कि react-scripts में जेस्ट को कैसे कॉन्फ़िगर किया गया है, लेकिन मुझे लगता है कि किसी भी तरह से कॉन्फ़िगरेशन को अपडेट करने का एक तरीका हो सकता है।

यह सुधार *.css और *.svg फ़ाइलों के लिए ट्रांस्फ़ॉर्म को हटा देता है, इसलिए App.tsx त्रुटियों पर ध्यान न दें।

क्या इसे काम करने के लिए कुछ विशेष करने की आवश्यकता है?
मैं कहूंगा कि मेरे पास सुंदर मानक सेटअप है (टीएस के बिना) और यह बॉक्स से बाहर काम नहीं करता है।

मैं इसे आज रात थोड़ा और देखूंगा और देख सकता हूं कि यह संभव है या नहीं।

@danielhusar मैंने कल रात देखा और बॉक्स समाधान से बाहर नहीं निकल सका। कुंजी जेस्ट कॉन्फिग transformer जिसे CRA आपको package.json#jest में ओवरराइड करने की अनुमति देता है । Js और ts फ़ाइलें babel-jest का उपयोग करके ट्रांसपाइल की जाती हैं लेकिन react-scripts आपको .babelrc कॉन्फ़िग फ़ाइल का उपयोग करने और test env को सेट करने से रोकता है जिसे वे react-scripts test में सेट करते हैं यहाँ ।

काश मैं और गहरी खुदाई कर पाता लेकिन अभी मेरे पास समय नहीं है।

हम्म मैं अभी भी इसे काम करने के लिए थोड़ा संघर्ष कर रहा हूं (मेरे कस्टम सेटअप पर, क्रे नहीं)।
(जेस्ट और बेबेल-जेस्ट दोनों का नवीनतम संस्करण)

यह मेरा मज़ाक config है:

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',
  },
};

और मेरा बेबलर्क:

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

मॉड्यूल को आंशिक रूप से नकल करने के तरीके के बारे में उनके दस्तावेज़ीकरण में जेस्ट का एक बहुत ही सरल और स्पष्ट उदाहरण है। यह ES आयात दोनों के साथ काम करता है और Node को स्टेटमेंट की आवश्यकता होती है।
https://jestjs.io/docs/hi/jest-object#jestrequireactualmodulename

@johncmunson यह एक अच्छी बात है। हालाँकि, यह उदाहरण आपने एक मॉड्यूल का मज़ाक उड़ाते हुए दिखाया है केवल तभी काम करता है जब आपको केवल jest.mock _once_ चलाने की आवश्यकता होती है और कोई भी नकली विधि उस मॉड्यूल से किसी अन्य निर्यात का उपयोग नहीं करती है।

ऊपर से उदाहरण लें...मैंने यह दिखाने के लिए bar जोड़ा है कि मैं कैसे मॉड्यूल को foo और 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
आयात * './hello' से testModule के रूप में;

वर्णन करें ('हैलो परीक्षण करें', फ़ंक्शन () {
बाद में (() => {
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 फ़ंक्शन को कॉल करें, नकली नहीं ।

काश यह इतना आसान होता लेकिन जो मैं देखता हूं उससे इस धागे के उदाहरणों के लिए मदद नहीं मिलती है। अगर मुझे यहां कुछ याद आ रहा है तो कृपया मुझे बताएं। मैं सहर्ष गलती स्वीकार करूंगा।

समाधान की तलाश में इस पर आने वाले किसी भी व्यक्ति के लिए, एक फ़ाइल में कई कॉन्स्ट/फ़ंक्शंस निर्यात करते समय, और उन्हें उस फ़ाइल में आयात करते समय निम्नलिखित मेरे लिए काम कर रहा है जिसका मैं परीक्षण कर रहा हूं

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

यह मूल कार्यों और स्पष्ट मॉक को बहाल करने के लिए जीवन को आसान बनाने का लाभ है।

समाधान की तलाश में इस पर आने वाले किसी भी व्यक्ति के लिए, एक फ़ाइल में कई कॉन्स्ट/फ़ंक्शंस निर्यात करते समय, और उन्हें उस फ़ाइल में आयात करते समय निम्नलिखित मेरे लिए काम कर रहा है जिसका मैं परीक्षण कर रहा हूं

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(..) का उपयोग करने की आवश्यकता है। : झुका हुआ आदमी:

मेरे मोक्स निम्नलिखित का उपयोग करके काम कर रहे हैं:

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();
};

कॉमनजेएस में स्थानांतरित होने के बाद:

"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. funcA का मज़ाक उड़ाने के लिए
   ...

इसके अलावा, आपको इस दस्तावेज़ पर एक नज़र डालने की ज़रूरत है: https://nodejs.org/api/modules.html#modules_exports_shortcut , यह देखने के लिए कि वास्तव में require क्या करता है

इस स्टैक ओवरफ्लो पोस्ट में समाधान ने मेरे लिए काम किया
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();
  });

इस स्टैक ओवरफ्लो पोस्ट में समाधान ने मेरे लिए काम किया
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();
  });

शुक्रिया!

मॉड्यूल को आंशिक रूप से नकल करने के तरीके के बारे में उनके दस्तावेज़ीकरण में जेस्ट का एक बहुत ही सरल और स्पष्ट उदाहरण है। यह ES आयात दोनों के साथ काम करता है और Node को स्टेटमेंट की आवश्यकता होती है।
https://jestjs.io/docs/hi/jest-object#jestrequireactualmodulename

मॉक किए गए फ़ंक्शन को मॉड्यूल के भीतर से कॉल किए जाने पर काम नहीं करता है।

साथ ही, मैंने पाया कि कभी-कभी यह कार्य करने के लिए उपयोगी हो सकता है जिस तरह से आप मूल फ़ंक्शन को नहीं बदलते हैं लेकिन कुछ कस्टम (अतिरिक्त) चर के साथ फ़ंक्शन को कॉल करते हैं:

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

मेरे मामले में मुझे काम करने के लिए कॉन्फ़िगरेशन पास करने की आवश्यकता थी जिसके बिना यह डिफ़ॉल्ट का उपयोग करेगा।

ऐसा करने का यही एकमात्र तरीका है, इसलिए यदि आप कुछ बेहतर या आसान विचारों के साथ आते हैं, तो सुनकर खुशी होगी :)

एफडब्ल्यूआईडब्ल्यू मैंने https://github.com/magicmark/jest-how-do-i-mock-x/blob/master/src/function-in-same-module/README में चलने योग्य उदाहरणों के साथ विभिन्न दृष्टिकोणों को एक साथ खींचा है

यह ओपीएस प्रश्न/मुद्दे का उत्तर नहीं देता है, लेकिन इसमें कुछ रिफैक्टरिंग शामिल एक समाधान है। मैंने अपने कार्यों को अलग-अलग फाइलों में अलग पाया है, और फिर उन आयातों का मज़ाक उड़ाया है, यह करना सबसे आसान काम है।

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

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

```जेएस
// बेबल.config.js

मॉड्यूल.एक्सपोर्ट = {
प्रीसेट: [
[
'@ बेबेल/प्रीसेट-एनवी',
{
लक्ष्य: {
नोड: 'वर्तमान',
},
},
],
],
};

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

मैंने हाल ही में इस मुद्दे में भाग लिया है। प्रस्तावित समाधानों में से कोई भी मेरे लिए काम नहीं करता क्योंकि मैं कोड बदलने में असमर्थ हूं। बेबेल-प्लगइन-रीवायर भी मेरे लिए काम नहीं करता है। क्या यह जांचने के लिए कोई अन्य समाधान है कि उसी मॉड्यूल के भीतर किसी अन्य फ़ंक्शन द्वारा फ़ंक्शन को कॉल किया गया था? यह ईमानदारी से ऐसा लगता है जैसे इसे काम करना चाहिए या वहां एक बेबेल प्लगइन होना चाहिए जो ऐसा करता है। कोई भी सहायताकाफी प्रशंसनीय होगी!

मैंने हाल ही में इस मुद्दे में भाग लिया है। प्रस्तावित समाधानों में से कोई भी मेरे लिए काम नहीं करता क्योंकि मैं कोड बदलने में असमर्थ हूं। बेबेल-प्लगइन-रीवायर भी मेरे लिए काम नहीं करता है। क्या यह जांचने के लिए कोई अन्य समाधान है कि उसी मॉड्यूल के भीतर किसी अन्य फ़ंक्शन द्वारा फ़ंक्शन को कॉल किया गया था? यह ईमानदारी से ऐसा लगता है जैसे इसे काम करना चाहिए या वहां एक बेबेल प्लगइन होना चाहिए जो ऐसा करता है। कोई भी सहायताकाफी प्रशंसनीय होगी!

क्या आपने https://github.com/facebook/jest/issues/936#issuecomment -659597840 चेक किया है? वहां एक न्यूनतम रेप्रो है जो एक ही फाइल में फ़ंक्शन कॉल को नकली करता है।