Jest: उम्मीदों के लिए मानव-पठनीय संदर्भ

अरे! तो हम वास्तव में इसे जैस्मीन में रखते थे लेकिन पाया कि एफबी पर हजारों से अधिक परीक्षण फाइलें, किसी ने इसका इस्तेमाल नहीं किया। तो अभी के लिए हम अनुमानित जानकारी और एक स्टैक ट्रेस के साथ एक अच्छा त्रुटि संदेश प्रिंट कर रहे हैं जो उम्मीद की ओर ले जाएगा (बिल्कुल आपके स्क्रीनशॉट की तरह)। मैं सहमत हूं कि हम उस लाइन को प्रिंट कर सकते हैं जो फेंकता है लेकिन अक्सर दावा कई पंक्तियों में लंबा होता है:

expect(a).toEqual({
  …
});

तो यह वास्तव में इतना अच्छा नहीं लगेगा और हमें जेएस को पार्स करने और प्रासंगिक जानकारी निकालने के लिए एक पार्सर का उपयोग करना होगा (और लंबी लाइनों को ध्वस्त करना) या इसे सुंदर बनाने के समान कुछ।

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

हम वास्तव में इसे जैस्मीन में इस्तेमाल करते थे लेकिन पाया कि एफबी पर हजारों से अधिक परीक्षण फाइलें, किसी ने इसका इस्तेमाल नहीं किया

@cpojer तो पैटर्न प्रत्येक दावे को it में लपेटना है? और/या केवल लाइन नंबरों पर भरोसा करें?

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

मैं सहमत हूं कि हम उस लाइन को प्रिंट कर सकते हैं जो फेंकता है लेकिन अक्सर अभिकथन कई लाइनें लंबी होती है

एक पंक्ति में रिफैक्टरिंग से अभिकथन में अधिक अर्थ संबंधी जानकारी को प्रोत्साहित किया जा सकता है? शायद?

const adminUser = {
  …
}
expect(a).toEqual(adminUser);

व्यक्तिगत रूप से मुझे लगता है कि हम अभी के लिए पर्याप्त जानकारी दिखा रहे हैं लेकिन पुनर्विचार करने में प्रसन्नता हो रही है

ऊपर दिए गए उदाहरण से पता चलता है कि जब तक आप हर चीज के चारों ओर वर्बोज़ (IMO) रैपर नहीं जोड़ते, तब तक यह पता लगाना मुश्किल है कि कौन सा दावा विफल रहा। यह एक पारदर्शी वातावरण में विशेष रूप से सच है जहां सोर्समैप लाइन नंबर हमेशा सटीक नहीं होते हैं। मेरा मानना ​​​​है कि संक्षिप्त परीक्षण के रूप में जल्दी और सटीक समझ टूट गई और कहां महत्वपूर्ण है।

अगर आपके पास किसी ऐसी चीज़ के लिए विचार हैं जो बहुत जटिल नहीं है लेकिन अधिक संदर्भ जोड़ता है जो मुद्दों को तेज़ी से हल करने में मदद करता है, तो मुझे बताएं।

मैंने ऊपर कुछ सुझाव दिए हैं:

• अभिकथन विधियों के लिए अतिरिक्त वैकल्पिक पैरामीटर
• जंजीर संदर्भ संदेश

क्या आप कुछ आसान या अलग खोज रहे हैं?

अरे @timoxley! हमने पहले ही ऐसा कुछ जोड़ने के बारे में सोचा था।

इसलिए पहले विकल्प के साथ समस्या यह है कि कुछ मिलानकर्ताओं के पास वैकल्पिक तर्क होते हैं, और इससे चीजें अधिक जटिल हो जाती हैं।

उदाहरण के लिए यहाँ दूसरे मामले में हम यह नहीं जान पाएंगे कि तर्क एक निकटता है या एक त्रुटि संदेश

expect(555).toBeCloseTo(111, 2, 'reason why');
expect(555).toBeCloseTo(111, 'reason why');

दूसरा सुझाव काम नहीं करेगा क्योंकि जैसे ही कुछ अपेक्षा के अनुरूप नहीं होगा मैचर फेंक देगा

expect(1).toBe(2)/* will throw here */.because('reason');

मैचर के निष्पादित होने से पहले हम कारण संलग्न कर सकते हैं, जैसे:

expect(1).because('reason').toBe(2);
// or 
because('reason').expect(1).toBe(2);

लेकिन यह एपीआई वास्तव में उतना अच्छा नहीं दिखता है।

दूसरा विकल्प expect . में दूसरा तर्क जोड़ना होगा

expect(1, 'just because').toBe(2);

लेकिन यह पिछले विकल्प के समान ही है।

मुझे लगता है कि यह बहुत उपयोगी नहीं है इसका कारण यह है कि इंजीनियर परीक्षण लिखने में समय बर्बाद नहीं करना चाहते हैं। हम उनके लिए इसे कठिन बनाने के लिए जो कुछ भी करते हैं, वह केवल बदतर परीक्षणों की ओर ले जाएगा।

अतीत में, सबसे अच्छा समाधान वास्तव में कस्टम मिलानकर्ता बनाना था। हम जेस्ट के अगले संस्करण में expect.extend पेश करेंगे और यह आपको आसानी से मैचर्स बनाने की अनुमति देगा जैसे:

expect(a).toEqualMySpecificThing(…)

जो आपको अधिक अभिव्यंजक विफलता संदेश लिखने की अनुमति देगा। मैंने देखा है कि यह रिले जैसी परियोजनाओं में बहुत उपयोग किया जाता है। सभी मैचर्स देखें: https://github.com/facebook/relay/blob/master/src/tools/__mocks__/RelayTestUtils.js#L281

निष्क्रियता के कारण बंद हो रहा है लेकिन अगर अच्छे विचार हैं तो फिर से खोलने में खुशी होगी।

@cpojer @dmitriiabramov देरी के लिए खेद है।

expect के लिए दूसरा तर्क या .because के साथ एक कारण का पीछा करना बहुत अच्छा होगा। ऐसा होने या न होने के लिए क्या करने की आवश्यकता है?

इंजीनियर टेस्ट लिखने में समय बर्बाद नहीं करना चाहते

@cpojer सहमत! डिबगिंग परीक्षणों में समय बर्बाद न करने के अलावा, यही कारण है कि मेरा मानना ​​​​है कि अधिक विफलता संदर्भ के साथ कम वर्बोज़ एपीआई बेहतर होगा।

कुछ ठोस संख्याओं के लिए, उपरोक्त मेरी टिप्पणी से सरल उदाहरण का उपयोग करके, समकक्ष दावे + टेप के साथ संदर्भ प्राप्त करने के लिए, जेस्ट को प्रोग्रामर को औपचारिक बॉयलरप्लेट की मात्रा को लगभग दोगुना लिखने की आवश्यकता होती है:

• 1.8x लाइनें (6 बनाम 11)
• 2x इंडेंटेशन (1 बनाम 2)
• 2x माता-पिता/कर्ली (24 बनाम 48) !

इसमें सुधार किया जा सकता है!

// tape
test('api works', t => {
  t.deepEquals(api(), [], 'api without magic provides no items')
  t.deepEquals(api(0), [], 'api with zero magic also provides no items')
  t.deepEquals(api(true), [1,2,3], 'api with magic enabled provides all items')
  t.end()
})

// jest
describe('api works', () => {
  test('api without magic provides no items', () => {
    expect(api()).toEqual([])
  })
  test('api with zero magic also provides no items', () => {
    expect(api(0)).toEqual([])
  })
  test('api with magic enabled provides all items', () => {
    expect(api(true)).toEqual([1,2,3])
  })
})

अद्यतन : मुझे लगता है कि आप तीर के साथ एक पंक्ति पर मज़ाक परीक्षण लिख सकते हैं:

// jest
describe('api works', () => {
  test('api without magic provides no items', () => expect(api()).toEqual([]))
  test('api with zero magic also provides no items', () => expect(api(0)).toEqual([]))
  test('api with magic enabled provides all items', () => expect(api(true)).toEqual([1,2,3]))
})

यह कुछ लंबी लाइनों के लिए बनाता है, लेकिन उन आँकड़ों में सुधार करता है जिनकी हमने पहले तुलना की थी:

• 0.8x लाइनें (6 बनाम 5)
• 1x इंडेंटेशन (1 बनाम 1)
• 1.75x माता-पिता/कर्ली (24 बनाम 42)

हालांकि मुझे लगता है कि लाइन की शुरुआत में, लाइनब्रेक के बिना परीक्षण विवरण होने से, तर्क को दृष्टि से पार्स करना कठिन हो जाता है क्योंकि यह परीक्षण के "मांस" को रखता है, यानी वास्तविक दावा, कुछ मनमानी कॉलम स्थिति पर।

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

/* api without magic provides no items */ expect(api()).toEqual([])
/* api with zero magic also provides no items */ expect(api(0)).toEqual([])
/* api with magic enabled provides all items */ expect(api(true)).toEqual([1,2,3])

आदर्श रूप से सभी अभिकथन कोड एक ही कॉलम में बड़े करीने से पंक्तिबद्ध होंगे ताकि इसे मानव द्वारा आसानी से पार्स किया जा सके। इस सोच के आधार पर, मैं $#$4 expect #$ के दूसरे तर्क के वैकल्पिक सुझाव के बजाय पीछे वाले .because फॉर्म का दृढ़ता से चयन करूंगा।

बातचीत जारी रखने के लिए धन्यवाद। ध्यान दें, कि आपको विवरण ब्लॉक की भी आवश्यकता नहीं है, जिससे चीजें छोटी हो जाती हैं। .because दुर्भाग्य से काम नहीं करेगा क्योंकि जब मैचर फेंकता है (जो .because से पहले होता है), हमारे पास नाम निकालने का कोई तरीका नहीं होगा।

प्रत्येक मैचर फ़ंक्शन के अंतिम तर्क का प्रयोग करें?

यह केवल तभी काम करेगा जब हम इसे expect के दूसरे तर्क के रूप में जोड़ दें।
अस्पष्टता के कारण हम इसे प्रत्येक मैचर फ़ंक्शन के लिए अंतिम तर्क के रूप में नहीं जोड़ सकते हैं
जैसे

expect(obj).toHaveProperty('a.b.c', 'is that a reason or a value of the property?');

निष्क्रियता के कारण बंद हो रहा है लेकिन अगर अच्छे विचार हैं तो फिर से खोलने में खुशी होगी।

@cpojer यह स्पष्ट नहीं है कि expect(value).toBe(something, 'because message') के चमेली (और अन्य) तरीके से इंकार कर दिया गया है?

एक उदाहरण redux-saga/redux-अवलोकन योग्य सामग्री का परीक्षण कर रहा है जहां आप एक राज्य मशीन का परीक्षण कर रहे हैं। यह किस राज्य में विफल हुआ, इसके बारे में एक वर्णनात्मक संदेश प्राप्त करना बहुत उपयोगी है। उस उदाहरण का आविष्कार किया गया है, इसलिए विवरण भी हैं, हालांकि ..

@jayphelps हम अब चमेली के तरीके का उपयोग नहीं कर रहे हैं क्योंकि हम सभी चमेली मैचर्स को फिर से लिखते हैं

@dmitriiabramov क्षमा करें मेरा प्रश्न स्पष्ट नहीं था। क्या इसे करने की चमेली _वे_ को वापस जोड़ने के लिए शासित किया गया है? वे वही करते हैं जो वे अनुमति देते हैं।

@jayphelps जैसा कि मैंने पहले कहा था, यह अस्पष्टता के कारण सभी मैचर्स के लिए काम नहीं करेगा।

expect(obj).toHaveProperty('a.b.c', 'is that a reason or a value of the property?');

और सिंग जेस्ट मैचर्स को थर्ड पार्टी पैकेज के साथ बढ़ाया जा सकता है, मुझे नहीं लगता कि तर्क सूची के साथ खिलवाड़ करना एक अच्छा विचार है

सबसे साफ विकल्प शायद इसे expect के दूसरे तर्क के रूप में रखना है, क्योंकि यह हमेशा एक तर्क लेता है।

expect(123, 'jest because').toEqual(123);

मुझे यकीन नहीं है कि क्या हम एपीआई को अधिभारित करना चाहते हैं। हमने फेसबुक टेस्ट सूट में लगभग कभी इसका इस्तेमाल नहीं किया, और विशेष मामलों के लिए मुझे लगता है कि एक नया परीक्षण परिभाषित करना आसान है:

beforeEach(someSharedSetup);
test('reason or description', () => expect(1).toBe(1));

यह बस कुछ पंक्तियाँ और है :)

या आप इसे किसी अन्य describe() कॉल में भी डाल सकते हैं।

@dmitriiabramov कष्टप्रद मामले तब होते हैं जब आप राज्य का निर्माण करते हैं, जैसे कि साग, महाकाव्य, आदि के लिए एक राज्य मशीन में। प्रत्येक परीक्षण के लिए पिछले राज्य परिवर्तनों की आवश्यकता होती है, उन्हें अलग करने के लिए बिना किसी लाभ के एक टन दोहराव की आवश्यकता होती है AFAIK।

it('stuff', () => {
  const generator = incrementAsync();

  expect(generator.next().value).toBe(
    call(delay, 1000)
  );

  expect(generator.next().value).toBe(
    put({ type: 'INCREMENT' })
  );

  expect(generator.next()).toBe(
    { done: true, value: undefined }
  );
});

या आप इसे किसी अन्य विवरण() कॉल में भी डाल सकते हैं।

क्या आप इसे विस्तृत कर सकते हैं? नेस्टिंग वर्णन कॉल AFAIK सिर्फ अनुभाग शीर्षकों को विभाजित करने के लिए था, परीक्षण अभी भी एक साथ चल रहे हैं, है ना?

परीक्षण सूट (फ़ाइलें) एक साथ चलते हैं, test() कॉल नहीं चलते हैं।

मैं सोचने लगा हूँ कि कुछ ऐसा है

test('111' () => {
  jest.debug('write something only if it fails');
  expect(1).toBe(2);
});

एक बात हो सकती है

इस चर्चा और इस भंडार से मुझे लगता है कि एक अच्छा और अर्थपूर्ण होगा:

it('has all the methods', () => {
  since('cookie is a method').expect(reply.cookie).toBeDefined();
  since('download is a method').expect(reply.download).toBeDefined();
  since('end is a method').expect(reply.end).toBeDefined();
  // ...
});

उपयोग because एक के समान है, लेकिन यह केवल अर्थपूर्ण रूप से अधिक समझ में आता है।

यदि आप इसे पसंद करते हैं तो मैं since कार्यक्षमता को जोड़कर एक पीआर तैयार करने में सक्षम हो सकता हूं।

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

कृपया यह न कहें "सरल होने के लिए अपने परीक्षण सूट को फिर से लिखें"। केवल एक चीज जो इंजीनियरों को _writing_ परीक्षण सूट से अधिक नफरत है, वह है _rewriting_ परीक्षण सूट।

एक और प्रस्ताव जो मैंने कहीं देखा है, मैं भूल जाता हूं कि यह इसी मुद्दे में कहां था, इस स्पष्टीकरण के साथ कि यह काम क्यों नहीं करेगा। मुझे शायद कुछ नींद आ जानी चाहिए :)

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

const since = (text) => {
  return new Proxy(global, {
    get: (orig, key) => {
      return (...args) => {
        try {
          const stack = orig[key](...args);
          return new Proxy(stack, {
            get: (orig, key) => {
              return (...args) => {
                try {
                  const ret = orig[key](...args);

                  // ... implement recursion here

                } catch (err) {
                  console.log('2', key, text, err);
                  throw err;
                }
              }
            }
          });
        } catch (err) {
          console.log('1', key, text, err);
          throw err;
        }
      };
    }
  });
};

तीन यथार्थवादी विकल्प हैं:

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

संपादित करें: इसे क्रिया में देखें:

describe('Test', () => {
  it('works', () => {
    since('It fails!').expect('a').toEqual('b');
  });
});

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

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

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

क्षमा करें यदि मुझसे गलती हुई है, लेकिन मुझे यहां इस सुविधा के लिए कोई _technological_ प्रतिवाद नहीं दिख रहा है। और "इसे नहीं जोड़ा जाना चाहिए क्योंकि यह अच्छा नहीं लगेगा" जैसी चीजें सिर्फ हास्यास्पद हैं।

क्या हम फिर से खोल सकते हैं? यहां तक ​​कि jest.debug() जैसा कि ऊपर @aaronabramov द्वारा सुझाया गया है, मेरे लिए मददगार होगा।

This:

it('has all the methods', () => {
    since('cookie is a method', () => expect(reply.cookie).toBeDefined());
});

can be supported by adding this:


// setupTestFrameworkScriptFile.js
// http://facebook.github.io/jest/docs/configuration.html#setuptestframeworkscriptfile-string
global.since = (explanation, fn) => {
    try {
        fn();
    } catch(e) {
        e.message = explanation + '\n' + e.message;
        throw e;
    }
};

साथ ही, जैस्मीन-कस्टम-संदेश अनुरोध के समान दिखता है:

describe('test', function() {
  it('should be ok', function() {
    since(function() {
      return {'tiger': 'kitty'};
    }).
    expect(3).toEqual(4); // => '{"tiger":"kitty"}'
  });
});

क्या इसे फिर से खोलने की कोई योजना है? ऐसा लगता है कि हाल ही में इस मुद्दे के डुप्लिकेट बने हैं। परीक्षण विफल होने पर मैं कस्टम संदेश प्रदर्शित करना भी चाहता हूं।

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

पीआर के रूप में स्वीकार किए जाने के लिए दूसरे तर्क () या बाद से () प्रारूप को स्वीकार करने में क्या लगेगा? मैं इसमें मदद करने के लिए कुछ समय देने को तैयार हूं।

मैंने अभी सूत्र को पढ़ा है और दोनों पक्षों में अच्छे तर्क देखे हैं। मैं निश्चित रूप से उसी कारण से एक कस्टम त्रुटि संदेश प्रदान करने के लिए एक तंत्र चाहता हूं @timoxley मूल रूप से पोस्ट किया गया है। अभी मैं कुछ ऐसा कर रहा हूँ:

import assert from 'assert'
import chalk from 'chalk'

test('api works', () => {
  assert.deepEqual(
    api(),
    [],
    chalk.red('api without magic provides no items')
  )
  assert.deepEqual(
    api(0),
    [],
    chalk.red('api with zero magic also provides no items')
  )
  assert.deepEqual(
    api(true),
    [1, 2, 3],
    chalk.red('api with magic enabled provides all items')
  )
})

यह वास्तव में उल्लेखनीय रूप से अच्छी तरह से काम करता है, लेकिन मैं लाल रंग (अन्यथा बिना रंग के प्रिंट) प्राप्त करने के लिए चाक का उपयोग करने से बचना चाहता हूं और मैं इसे expect द्वारा समर्थित होना पसंद करूंगा।

मुझे वास्तव में परवाह नहीं है कि इसे ईमानदारी से कैसे लागू किया जाता है। लेकिन यहां since का एक विकल्प दिया गया है ताकि अगर दूसरे इसे पसंद करते हैं तो वहां कुछ और फेंक दें:

const expectWithMessage = expect.withMessage(
  'api with magic enabled provides all items'
)
expectWithMessage(api(true)).toEqual([1, 2, 3])

// could be rewritten like
expect
  .withMessage('api with magic enabled provides all items')(api(true))
  .toEqual([1, 2, 3])

मुझे यकीन नहीं है कि मुझे यह since से बेहतर पसंद है। मैं जो कुछ भी अच्छा हूँ, मैं वास्तव में इसे प्राप्त करना पसंद करूंगा :)

ओह, और टिप्पणी को संबोधित करने के लिए:

मुझे लगता है कि यह बहुत उपयोगी नहीं है इसका कारण यह है कि इंजीनियर परीक्षण लिखने में समय बर्बाद नहीं करना चाहते हैं। हम उनके लिए इसे कठिन बनाने के लिए जो कुछ भी करते हैं, वह केवल बदतर परीक्षणों की ओर ले जाएगा।

मैं सहमत हूं कि हम परीक्षण लिखना कठिन नहीं बनाना चाहते हैं। इसलिए यह एक योगात्मक परिवर्तन होगा। इसलिए जो लोग अपने परीक्षणों को डीबग करना आसान बनाने के लिए "समय बर्बाद" नहीं करना चाहते हैं, वे केवल सहायक संदेशों को छोड़ सकते हैं, लेकिन फिर वे एक कोडबेस में आ जाएंगे जिसमें इस तरह के उपयोगी संदेश होंगे और फिर वे धन्यवाद देंगे इंजीनियर जिन्होंने दावे को थोड़ा समझाने के लिए समय लिया: पलक:

हाय @cpojer इस पर कोई अपडेट?

इस मुद्दे को छोड़कर जेस्ट मेरे लिए बहुत अच्छा काम कर रहा है ... फिलहाल मैं एक लूप के भीतर एक असफल दावे को ठीक करने के लिए संघर्ष कर रहा हूं जैसे
expectationsArray.forEach(expectation => expect(...))

यह पता लगाना मुश्किल है कि कस्टम त्रुटि संदेश के बिना कौन सी उम्मीदें विफल हो जाती हैं (जब तक कि मैं इसे गलत नहीं कर रहा हूं ..?)

आपको धन्यवाद

@ एमजे-एयरवॉलेक्स उदाहरण के लिए लूप में test के साथ अपेक्षाओं को लपेटने के लिए आप अच्छे हैं:

const expectationsArray = [[0, 'a'], [1, 'b']];

expectationsArray.forEach(([expectation, desc]) => {
  test(`test ${desc}`, () => {
    expect(expectation).toBeGreaterThanOrEqual(2);
  });
});

उम्मीदों के दौरान कस्टम संदेश प्रदान करने की आवश्यकता के कारण मुझे मजाक के साथ भी एक समस्या है। test के तहत उम्मीदों को लपेटना उन मामलों के लिए काम करता है जहां एसिंक्रोनस कॉल की कोई आवश्यकता नहीं है। लेकिन चूंकि जेस्ट describe (#2235 ) एक वादा वापस करने को संभाल नहीं सकता है, इसलिए हम उन्हें test के साथ लपेटने के साथ-साथ एसिंक्रोनस कॉल के साथ परीक्षण नहीं बना सकते हैं। और हमारे पास एकाधिक test नेस्टेड नहीं हो सकते हैं।

समस्या का वर्णन करने के लिए यहां एक उदाहरण दिया गया है:

async function getArray() {
  return [0,0,0,0,0,0]
}

describe('Custom messages with async', async () => {
  const array = await getArray();
  array.forEach((item) => {
    test(`test${item}`, () => {
      expect(item).toBe(0)
    });
  });
})

कोई विचार इसे कैसे संभालना है?

ओपी में इस मुद्दे को देखते हुए ("यह अच्छा होगा यदि कुछ मानव पठनीय संदर्भ हों जो इसे तुरंत स्पष्ट कर दें कि कौन सी अपेक्षा विफल रही"), मुझे लगता है कि यह अब हल हो गया है। जेस्ट 22 के अनुसार हम असफल अभिकथन के संदर्भ को प्रिंट करते हैं। क्या अतिरिक्त संदेश अभी भी आवश्यक है? यदि यह _is_ है, तो यह ऊपर या अभिकथन के पक्ष में एक कोड टिप्पणी हो सकती है

Async वर्णन एक और समस्या है (जो अतिरिक्त कोडफ़्रेम द्वारा मदद नहीं की जाएगी)

मुझे लगता है कि मैं async वर्णन का उपयोग नहीं करूँगा और इसके बजाय beforeEach या beforeAll का उपयोग करूँगा

@kentcdodds क्या आप एक उदाहरण प्रदान कर सकते हैं कि इसे beforeEach या beforeAll से कैसे संभालें? यदि आप beforeEach और beforeAll में सभी आवश्यक async कॉल परिणाम बनाने का प्रयास करते हैं तो यह अंत में आपको नेस्टेड test बनाने के लिए मजबूर करेगा जिसकी अनुमति नहीं है।

आह, मुझे याद आया कि आप उस एसिंक कॉल के साथ क्या कर रहे थे। इसके बारे में क्षमा करें 😅 हाँ, आप ऐसा करने के लिए beforeEach या beforeAll नहीं कर सके।

@SimenB , संदर्भ को प्रिंट करना पहले से ही बहुत मदद करता है और कस्टम संदेशों के साथ अधिकांश मुद्दों को हल करता है। इसके लिए धन्यवाद! लेकिन कस्टम संदेशों के लिए स्पष्ट रूप से तर्क के रूप में संभावना होना अच्छा होगा क्योंकि यह लूप के भीतर अपेक्षाओं का उपयोग करने जैसी परिस्थितियों में मदद करता है।

@tojuhaka इसे आजमाएं: https://github.com/negativetwelve/jest-plugins/tree/master/packages/jest-plugin-context

ओपी में इस मुद्दे को देखते हुए ("यह अच्छा होगा यदि कुछ मानव पठनीय संदर्भ हों जो इसे तुरंत स्पष्ट कर दें कि कौन सी अपेक्षा विफल रही"), मुझे लगता है कि यह अब हल हो गया है।

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

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

आप उसके लिए toHaveProperty का उपयोग कर सकते हैं।

test('property', () => {
  expect({foo: 'bar'}).toHaveProperty('baz', 'foobar');
});

अगर आप सिर्फ यह जांचना चाहते हैं कि यह वहां है, तो दूसरा तर्क छोड़ दें। यदि आप केवल यह कहना चाहते हैं कि इसका _some_ मान है, तो आप expect.anything() का उपयोग कर सकते हैं।
toMatchObject एक और विकल्प है।

आप चाहें तो assert का भी इस्तेमाल कर सकते हैं।

test('property', () => {
  const obj = {foo: 'bar'};
  assert.equal(obj.baz, 'foobar', JSON.stringify(obj));
});

पारितोषिक के लिए धन्यवाद। assert.equal(obj.baz, 'foobar', JSON.stringify(obj)); मेरे विशेष मामले में काम करेगा।

@SimenB @mpseidel मुखर क्या है? क्या यह कोई तृतीय पक्ष पुस्तकालय है? मुझे जेस्ट डॉक्स में कुछ भी नहीं मिल रहा है।

@sharikovvladislav assert एक नोड कोर मॉड्यूल है https://nodejs.org/api/assert.html

@mpseidel उफ़! मुझे नहीं पता था। शुक्रिया। यह काम करता हैं।

मैं ढांचे की इस सीमा के आसपास हैक करने के लिए निम्नलिखित कोड खंड का उपयोग कर रहा हूं (टाइपस्क्रिप्ट में लेकिन जेएस के लिए टाइप एनोटेशन को हटा दें)
export const explain = (expectation: () => void, explanation: string) => { try { expectation(); } catch(e) { console.log(explanation) throw e; } }

नमस्ते,
मुझे आश्चर्य है कि अभी तक किसी ने लूप का उल्लेख नहीं किया है। संदेश केवल एक स्ट्रिंग नहीं होगा, बल्कि लूप पुनरावृत्ति के आधार पर एक गतिशील स्ट्रिंग होगा।
jest-plugin-context अच्छा है, इस काम के लिए धन्यवाद, लेकिन यह थोड़ा भारी है और प्रारंभिक मुद्दा अभी भी प्रासंगिक आईएमओ है।
इस परीक्षण को देखें

describe('MyStuff', () => {
    it('should render and contain relevant inputs', () => {
      const wrapper = shallowWrapped(<MyStuff />);
      const expectedKeys = ['love','jest','but','need','details','for','expect'];
      expectedKeys.forEach((key) => {
        expect(wrapper.find({ id: key }).length).toEqual(1);
      });
    });
  });

अपने अपराधी को खोजने का सौभाग्य। अभी मुझे {len:.., key:..} की तरह एक लाइन जोड़नी होगी या किसी ऑब्जेक्ट का परीक्षण करना होगा, यह साफ नहीं है और उपयोगकर्ता के अनुकूल नहीं है।
मुझे लगता है कि यह उपयोग मामला प्रासंगिक है, उदाहरण के लिए फॉर्म और आइटम प्रतिपादन जांच के लिए।
वाक्यविन्यास toEqual(1).context("my message") या toEqual(1, "my message") जितना सरल हो सकता है (हालांकि निश्चित रूप से मुझे पता है कि कार्यान्वयन हमेशा कठिन होता है, और मैं जेस्ट के साथ आपके द्वारा किए गए महान काम का सम्मान करता हूं)।

शायद उसी प्रारूप का उपयोग करें जैसे chai करता है - यानी संदेश को अपेक्षित कॉल के दूसरे तर्क के रूप में जोड़ें:

expect(foo, 'this detail').toEqual(2)

टी

पहले चमेली का इस्तेमाल किया था, इसलिए यह खोजने के लिए यहां आया कि यह समर्थित नहीं है।
हालाँकि afik ये सभी कार्य हैं। क्या हम ऐसा कुछ नहीं कर सकते:

describe('MyStuff', () => {
    describe('should render and contain relevant inputs', () => {
      const wrapper = shallowWrapped(<MyStuff />);
      const expectedKeys = ['love','jest','but','need','details','for','expect'];

      expectedKeys.forEach((key) => {
        it(`contains key "${key}"`, () =>
          expect(wrapper.find({ id: key }).length).toEqual(1)
        )
      })
  });
});

@akkerman अच्छा समाधान। चूंकि वर्णन और यह जादू के ग्लोबल्स हैं जो जेस्ट द्वारा प्रदान किए गए हैं, मुझे यह स्वीकार करना होगा कि वे अस्पष्ट महसूस कर सकते हैं, मुझे यकीन नहीं था कि लूप में t` लिखना काम कर सकता है।

एक और संशोधक का पीछा करने के बारे में क्या?

expect(foo).toEqual(bar).because('reason with %s placeholders')

या शायद एक समारोह

expect(foo).toEqual(bar).explainedBy((result) => `Lorem ipsum ${result}`)

मुझे लगता है कि एक और संशोधक जल्दी से अपठनीय हो जाता है।
टी

2018-04-19 13:47 जीएमटी+02:00 • जियोवानी डी सूजा नोटिफिकेशन @github.com :

एक और संशोधक का पीछा करने के बारे में क्या?

उम्मीद (foo).toEqual(bar).क्योंकि ('% s प्लेसहोल्डर्स के साथ कारण')

या शायद एक समारोह

उम्मीद (foo).toEqual(bar).explainedBy((result) => Lorem ipsum ${result} )

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

--

तारजेई हुसे
मोबिल: 920 63 413

जिस तरह से expect काम फेंकना है, तो वह वैसे भी काम नहीं करेगा।

मुझे लगता है कि या तो expect(something, 'some helpful text on failure').toEqual(somethingElse) या expect.context(something, 'some helpful text on).toEqual(somethingElse) सबसे अच्छे विकल्प हैं, लेकिन मुझे वास्तव में उनमें से कोई भी पसंद नहीं है

क्या इसे फिर से खोला जा सकता है? ऐसा लगता है कि जेस्ट के पास अभी भी परीक्षण के लिए कोई अच्छा समाधान नहीं है कि राज्य कैसे कई इंटरैक्शन में बदलता है, उदाहरण के लिए:

• घटनाओं की एक श्रृंखला के जवाब में एक स्टेटफुल रिएक्ट कंटेनर कैसे बदलता है, इसका परीक्षण करना
• कठपुतली का उपयोग करके कई इंटरैक्शन के दौरान एक वेब पेज कैसे बदलता है, इसका परीक्षण करना

इन दोनों मामलों में क्रियाओं की एक श्रृंखला करने की आवश्यकता होती है, और यह कहते हुए कि प्रत्येक क्रिया के बाद राज्य कैसे बदल गया (या नहीं बदला), इसलिए बहु-अभिकथन परीक्षण कभी-कभी आवश्यक होते हैं। इस तरह की समस्या को beforeEach के साथ हल करना हमेशा संभव नहीं होता है।

मैं ऐसी स्थितियां ढूंढता रहता हूं जहां यह वास्तव में उपयोगी होगा। विशेष रूप से जब मैं @callumlocke के रूप में कई इंटरैक्शन और दावे चला रहा हूं।

अगर हम एक ऐसा एपीआई लेकर आते हैं जिससे लोग नफरत नहीं करते हैं, तो क्या यह ऐसी चीज है जिसे आप आगे बढ़ाने के लिए तैयार हैं? मुझे सच में लगता है कि यह एक मूल्यवान और अधिक उपयोग की जाने वाली विशेषता होगी।

यहां प्रस्तावित समाधानों का सारांश दिया गया है:

expect(api()).toEqual([]) // api without magic provides no items
it('api without magic provides no items', () => expect(api()).toEqual([]))
test('api without magic provides no items', () => expect(api()).toEqual([]))
expect(api()).toHaveNoItems()

expect(api(), 'api without magic provides no items').toEqual([])
expect(api()).because('api without magic provides no items').toEqual([])
since('api without magic provides no items').expect(api()).toEqual([]))
because('api without magic provides no items').expect(api()).toEqual([]))
jest.debug('api without magic provides no items'); expect(api()).toEqual([]))

ध्यान दें कि पिछला .because() संभव नहीं है, इसलिए इसे एक विकल्प के रूप में शामिल नहीं किया गया है।

पहले समूह में सभी चार विकल्प आज समर्थित हैं। व्यक्तिगत रूप से, मुझे लगता है कि पहला विकल्प (टिप्पणी के साथ एक कोड फ्रेम) बहुत अच्छा काम करता है। और उससे भी बेहतर एक कस्टम मिलानकर्ता (विकल्प 4) का उपयोग करना है।

मुझे लगता है कि इस पर आंदोलन करने के लिए हमें क्या समझने की आवश्यकता है: दूसरे समूह में विकल्पों के बारे में पहले के विकल्पों की तुलना में अधिक आकर्षक क्या है? दूसरा समूह क्या जोड़ता है जो हमारे द्वारा प्रदान किए जाने वाले सभी मैचर्स के लिए मुख्य रखरखाव को सही ठहरा सकता है (एसिंक मैचर्स, एसिमेट्रिक मैचर्स, स्पाई मैचर्स, थ्रो मैचर्स, प्रॉमिस मैचर्स और कस्टम मैचर्स में)?

नमस्ते,
आपको मूल रूप से कुछ उपयोग के मामले मिले हैं:

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

पहले समूह के विकल्प मुख्य रूप से पहले उपयोग के मामले के लिए होते हैं। यदि आप प्रस्तावित के अनुसार गतिशील रूप से उत्पन्न अभिकथन की आवश्यकता का सामना करते हैं, तो आप it और test पर कॉल को नेस्ट कर सकते हैं, ताकि एक परीक्षण लूप में नए परीक्षण उत्पन्न कर सके। समस्या यह है कि आप परीक्षण उत्पन्न करते हैं न कि अभिकथन । कल्पना कीजिए कि मैं 1000 तत्वों के सरणी के प्रत्येक तत्व पर कुछ जोर देना चाहता हूं, यह परीक्षण सारांशों को फुला देगा।

चूंकि उन गतिशील उपयोग के मामले अभी भी दुर्लभ हैं, आईएमओ हमें उस समाधान के लिए रहना चाहिए जिसके लिए रखरखाव के लिए न्यूनतम काम की आवश्यकता होती है। मुझे व्यक्तिगत रूप से because/since समाधान पसंद है, क्योंकि यह काफी सरल लगता है। मुझे लगता है कि कार्यान्वयन ज्यादातर expect को try/catch में लपेटेगा जो संदेश को प्रिंट करता है और उसे वापस कर देता है?
jest.debug अजीब लगता है, मेरे लिए डिबगिंग एक संदेश प्रिंट कर रहा है, भले ही परीक्षण वास्तव में पास हो जाएं
"अंतिम तर्क" विकल्प भी अच्छा है, लेकिन मुझे यकीन नहीं है कि क्या यह संभव है क्योंकि expect तर्कों की एक चर संख्या को स्वीकार कर सकता है?

मैं किसी भी विकल्प के साथ ठीक हूँ। मुझे बस फीचर चाहिए। मैं jest.debug एपीआई पर बहुत बड़ा नहीं हूं, लेकिन अगर यह एकमात्र ऐसा है जो समझ में आता है तो मैं इसके साथ ठीक हूं क्योंकि मुझे यह सुविधा चाहिए।

@kentcdodds चार मौजूदा विकल्पों के बारे में क्या?

@ एरिक-ब्यूरल क्या आपने test.each और describe.each को जेस्ट 23 में जोड़ा है (जेस्ट <23 के लिए एक स्टैंडअलोन के रूप में उपलब्ध)?

जैसा मैंने कहा, मुझे वास्तव में परवाह नहीं है कि हम किस विकल्प के साथ जाते हैं। मैं सिर्फ यह चाहता हूं कि सुविधा मौजूद रहे। मुझे लगता है कि अगर मैं वरीयता के क्रम में उन्हें क्रमबद्ध करना चाहता हूं तो यह होगा:

1. expect(api(), 'api without magic provides no items').toEqual([])
2. because('api without magic provides no items').expect(api()).toEqual([]))
3. since('api without magic provides no items').expect(api()).toEqual([]))
4. expect(api()).because('api without magic provides no items').toEqual([])
5. jest.debug('api without magic provides no items'); expect(api()).toEqual([]))

(test|describe).each बहुत अच्छा है, लेकिन उस समस्या का समाधान नहीं करता है जहां आप एक ही परीक्षण में एकाधिक कार्रवाइयां/दावा करना चाहते हैं।

यह सुविधा आज चार विकल्पों के साथ मौजूद है:

expect(api()).toEqual([]) // api without magic provides no items
it('api without magic provides no items', () => expect(api()).toEqual([]))
test('api without magic provides no items', () => expect(api()).toEqual([]))
expect(api()).toHaveNoItems()

इनमें गलत क्या है? प्रस्तावित _new_ समाधान इन मौजूदा समाधानों की तुलना में केवल मामूली रूप से बेहतर प्रतीत होते हैं। हमारे पास जो कुछ है उससे वे क्या लाभ लाते हैं जो रखरखाव लागत को सही ठहराते हैं?

@rickhanlonii अच्छा मुझे test.each के बारे में पता नहीं था, यह वास्तव में एक महान विशेषता है, इसे इंगित करने के लिए धन्यवाद। मुझे लगता है कि यह मेरे तीसरे उपयोग के मामले के लिए समस्या हल करता है, एक सरणी से गतिशील रूप से जेनरेट किया गया परीक्षण।

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

संपादित करें: it या test के साथ किसी अन्य परीक्षण में एक परीक्षण बनाना और परीक्षण के लिए गतिशील रूप से जेनरेट किया गया नाम एक वैध समाधान है लेकिन मुझे वास्तव में एक परीक्षण बनाना पसंद नहीं है जब मेरा मतलब एक दावा बनाना है . मैंने कभी अनुमान नहीं लगाया होगा कि यह संभव था यदि इस सूत्र में समाधान नहीं दिया गया है।

यह पागल है। उम्मीद करने के लिए बस एक दूसरा, वैकल्पिक पैरामीटर जोड़ें ()। हममें से जो इसका उपयोग करना चाहते हैं वे (चुनिंदा) करेंगे, और जो नहीं करेंगे, वे नहीं करेंगे।

मोचा यह हमेशा के लिए कर रहा है ... यह एक कारण है कि मैंने वर्षों पहले जैस्मीन को छोड़ दिया था (दूसरा बेहतर टाइमर मजाक कर रहा था।) अगर मुझे रिएक्ट बैंडवागन में शामिल नहीं होना था, तो मैं जेस्ट या किसी का उपयोग नहीं कर रहा था अन्य जैस्मीन व्युत्पन्न।

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

@mattphillips क्या आपको लगता है कि उपयोगकर्तालैंड में समाधान मौजूद होने की अनुमति देने के लिए यहां जेस्ट-चेन के समान कुछ करना संभव है? उदाहरण के लिए expect . का दूसरा तर्क

ईमानदारी से, अधिकांश जेएस परीक्षण ढांचे में यह कुछ बहुत ही मानक है। जेस्ट में इसे न पाकर बहुत निराशा हुई क्योंकि हम अपने सभी परीक्षण एक कस्टम त्रुटि संदेश के साथ लिखते हैं।

@SimenB क्षमा करें मैंने आज सुबह ही आपका संदेश देखा!

हां यह यूजरलैंड में करने योग्य है, मैंने अभी इसे खटखटाया है और इसे jest-expect-message https://github.com/mattphillips/jest-expect-message के रूप में जारी किया है

प्रतिक्रिया का स्वागत है: मुस्कान:

बढ़िया, इसे करने के लिए धन्यवाद!

@cpojer

मुझे लगता है कि यह बहुत उपयोगी नहीं है इसका कारण यह है कि इंजीनियर परीक्षण लिखने में समय बर्बाद नहीं करना चाहते हैं। हम उनके लिए इसे कठिन बनाने के लिए जो कुछ भी करते हैं, वह केवल बदतर परीक्षणों की ओर ले जाएगा।

दो चीज़ें:

1. उम्मीद करने के लिए वैकल्पिक दूसरा तर्क जोड़ना() डेवलपर्स के लिए शायद ही कुछ कठिन बना रहा है।
2. आखिरी चीज जो डेवलपर्स करना चाहते हैं वह समय बर्बाद करना है जिससे परीक्षण विफल हो गया। अक्सर अपेक्षाएं बनाम प्राप्त यह जांचने का एक अच्छा तरीका है कि क्या कोई शर्त पूरी हुई थी, लेकिन अक्सर यह पर्याप्त संदर्भ नहीं है कि इसके विफल होने का कारण क्या है।

मैंने जेस्ट में आने से पहले मोचा/चाई के साथ-साथ टेप का भी इस्तेमाल किया, और यह वास्तव में एक डील ब्रेकर है। कस्टम संदेश समर्थन को अपेक्षित रूप से प्राप्त करने के लिए हमें क्या करना होगा?

कस्टम मैचर बनाने के लिए हमें अपेक्षा करने के लिए कहना। विस्तार करने के लिए बिल्कुल वैसा ही लगता है जैसा आप अपने पहले तर्क से बचने की कोशिश कर रहे थे: "इंजीनियर परीक्षण लिखने में समय बर्बाद नहीं करना चाहते हैं।"

मुझे यूनिट टेस्ट खोलना और लाइन नंबर देखना आसान लगता है, इसलिए ओपी में उपयोग-मामला मुझे परेशान नहीं करता है।

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

it("Should contain at least one word of every wordType", () => {
  for (const wordType of wordTypes) {
    expect(words.find((word) => word.wordType === wordType)).toBeTruthy();
  }
});

अगर वह विफल हो जाता है तो मुझे नहीं पता कि कौन सा वर्ड टाइप मान विफल हुआ।

मेरा काम-आसपास उस संदेश के साथ बदलना था जिसमें परीक्षा परिणाम होता है, और उम्मीद है कि संदेश में अपेक्षित परीक्षा परिणाम (यानी सत्य) शामिल है। यदि यह विफल हो जाता है तो जेस्ट उस संदेश को प्रिंट करता है जिसमें अतिरिक्त जानकारी होती है।

    expect(`${wordType} ${!!words.find((word) => word.wordType === wordType)}`).toEqual(`${wordType} ${true}`);

जेस्ट इसे प्रिंट करता है ...

expect(received).toEqual(expected)

Difference:

- Expected
+ Received

- 6 true
+ 6 false

... जो मुझे बताता है कि विफल होने पर वर्ड टाइप 6 था।

या अधिक पठनीय रूप से कुछ ऐसा ...

    if (!words.find((word) => word.wordType === wordType)) {
      expect(`Didn't find a word with wordType '${wordType}'`).toEqual(null);
    }

@cwellsx test.each के साथ पैरामीटरयुक्त परीक्षणों की जांच करें इस तरह प्रत्येक शब्द प्रकार एक वर्णनात्मक शीर्षक के साथ एक स्वतंत्र परीक्षण होगा (मूल्य के आधार पर)

यह इस तरह के परीक्षणों में अविश्वसनीय रूप से उपयोगी होगा:

test("compare ArrayBufferCursors", () => {
    const orig: ArrayBufferCursor;
    const test: ArrayBufferCursor;

    expect(test.size).toBe(orig.size);

    while (orig.bytes_left) {
        expect(test.u8()).toBe(orig.u8());
    }
});

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

@rickhanlonii , मैं समझता हूं कि आप मजाक की रखरखाव लागत को कम करना चाहते हैं, लेकिन विकल्प जो आप अपनी टिप्पणी में देते हैं, अन्य सभी परियोजनाओं के यूनिट परीक्षणों के रखरखाव में वृद्धि करते हैं। अगर मैं toEqual का उपयोग करके एक दावे की व्याख्या करना चाहता हूं, जो अन्यथा पूरी तरह से पर्याप्त है, तो क्या आप वास्तव में मुझे एक कस्टम मैचर पेश करने का सुझाव दे रहे हैं ?!

जबकि दोहराव वाले परीक्षणों के मामले हैं, जहां it.each उपयोगी हैं, एक दावे पर एक साधारण टिप्पणी के लिए एक अनावश्यक कोड जोड़ने से यह परीक्षण ढांचे का उपयोग करने के लिए भारी हो जाता है।

यह चर्चा और jest-expect-message उभरना मुझे जैस्मीन में beforeAll मुद्दे की याद दिलाता है...

मैं यहां ओपी के अनुरोध को गलत समझ सकता हूं, लेकिन जिस समस्या को मैं हल करने की कोशिश कर रहा था और मुझे इस मुद्दे पर लाया था, उसे केवल एक साधारण try / catch और रैपर का उपयोग करके हल किया गया था jest.expect । मैं केवल उन वस्तुओं की संपूर्णता को लॉग करना चाहता था जिनकी मुझे उम्मीद थी बनाम जो मुझे प्राप्त हुई थी + कुछ बुनियादी लॉग जो महत्व को समझाते हैं। बेशक, इसे आप जो कुछ भी चाहते हैं उसे करने के लिए बढ़ाया जा सकता है।

इसका सबसे सामान्य संस्करण इस तरह दिख सकता है:

in some test utility file...

const myExpect = (expectFn, errorCallback) => {
  try {
    expectFn();
  } catch (err) {
    errorCallback();
    throw new Error(err);
  }
};

// in the actual test suite...

const context = { hello: "world", results, expected };
myExpect(
    () => expect(results).toEqual(expected),
    () => console.error("[Error] -- context:", JSON.stringify(context))
);

+1
नमस्ते, मुझे यह सुविधा भी बहुत अच्छी लगेगी। यह मेरे जीवन को इतना आसान बना देगा।