Mocha: त्रुटि: रिज़ॉल्यूशन विधि का निरीक्षण किया जाता है।

async कार्यों के साथ done भी टूटते हैं।

जैसा कि त्रुटि में कहा गया है, आप meaning 0 की अर्थ के साथ एक फ़ंक्शन प्रदान करने वाले नहीं हैं (जिसका अर्थ है कि यह done कॉलबैक स्वीकार कर रहा है), _and_ एक वादा वापस करें।

इसे ठीक करने का सबसे आसान तरीका return को छोड़ना होगा, लेकिन जब से आप वादों का उपयोग कर रहे हैं, तो मैं इसके बजाय done कॉलबैक से छुटकारा पाने का सुझाव देता हूं, क्योंकि इससे बहुत सरल निर्माण होगा। :

before(() => Promise.all([]).then(() => Model.insert(...)));

यहाँ दोनों async (अनिवार्य रूप से एक वादा) और done का एक उदाहरण है जो टूट जाता है:

it('fires change event when calling blah.doSomethingThatFiresChange', async function (done) {
  const blah = await getBlah()
  blah.on('change', () => done())
  blah.doSomethingThatFiresChange()
})

@elado यह एक दिलचस्प उपयोग का मामला है, हालांकि मोचा के दृष्टिकोण से यह एक ही स्थिति है - एक फ़ंक्शन जो दोनों done कॉलबैक लेता है और एक वादा वापस करता है। मैं इसे पूरी तरह से वादा-आधारित होने के लिए फिर से लिखूंगा:

it('fires change event when calling blah.doSomethingThatFiresChange', async function () {
  const blah = await getBlah()
  return new Promise(resolve => {
    blah.on('change', resolve)
    blah.doSomethingThatFiresChange()
  })
})

... लेकिन मुझे लगता है कि आप जो प्राप्त कर रहे हैं, वह इस उदाहरण में है कि मोचा _both_ के लिए इंतजार किए जाने से बेहतर होगा कि समाधान का वादा किया जाए और कॉलबैक कहा जाए?

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

... अगर मैं .iten (।) (> = किया ()) तो परीक्षा के समय समाप्त हो जाते हैं।

यह एक बग की तरह लगता है, किसी भी मामले में।

@ScottFreeCode हम्म, हाँ, ऐसा लगता है क्योंकि "ओवरस्पीड" त्रुटि को done कॉलबैक के रूप में प्रदान किए गए फ़ंक्शन में जारी किया जाता है: https://github.com/mochajs.mocha/blob/4944e31ff60105815f4b314996a373/73/7373 runnable.js # L357 -L373

... लेकिन हम निश्चित रूप से यह निर्धारित कर सकते हैं कि फ़ंक्शन के वापस आते ही हमें उस त्रुटि से विफल होना है।

@ScottFreeCode यहां क्या तय है?

मुझे लगता है कि यह "हल करने या अस्वीकार करने के वादे की प्रतीक्षा कर रहा है, फिर 'ओवरस्पीसीफाइड' त्रुटि के साथ अस्वीकार करें?"

यदि हम एक ही परीक्षण में done प्लस के वादे पर विचार करने जा रहे हैं, तो मुझे ऐसा कोई कारण नहीं दिखाई देता है जो परीक्षण फ़ंक्शन के रूप में जल्द ही त्रुटि का पता नहीं लगाता है, जिसमें done रिटर्न प्राप्त होता है वादा, @papandreou ने सुझाव दिया। जब तक हम वादों और done को कुछ मामलों में अनुमति देने का इरादा नहीं रखते हैं, तब तक यह पता लगाने का प्रयास करने के लिए कि मुझे किन बिंदुओं पर त्रुटि का ट्रिगर करना चाहिए, यह बहुत मायने नहीं रखता है।

@ScottFreeCode मैं सहमति में हूं। तो यह

1. समस्या का पता लगाएं; Error तुरंत done() कॉल न करें
2. वादा पूरा होने तक इंतजार करें
3. Error साथ अस्वीकार करें

बोनस प्रश्न: वादे के पूरा होने के परिणाम के साथ क्या करना है?

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

क्या कोई परीक्षण भी वादा पूरा करने या खारिज किए बिना done को समाप्त कर सकता है? यदि हां, तो यह एक और अंतिम मामला है जिसे हमें संभालना होगा।

मेरा झुकाव, फिर से। परीक्षण के परिणाम के साथ क्या करना है, यह है कि अगर यह समय से बाहर (बिना ___ done या हल किए गए / वादे को अस्वीकार किए बिना) हमें बस done के उपयोग की रिपोर्ट प्रतिज्ञा के साथ देनी चाहिए (क्योंकि संयोजन पर भ्रम बहुत अच्छी तरह से हो सकता है कि यह कभी भी एक के लिए क्यों नहीं निकला और इसके बजाय समय समाप्त हो गया), लेकिन अगर यह किसी भी तरह से समाप्त करने का प्रबंधन करता है तो संभवतः परिणाम मान्य है (या कम से कम किसी तरह सार्थक) और हमें रिपोर्ट करना चाहिए दोनों done का संभवतः गलत उपयोग करते हैं और एक साथ वादा करते हैं और यह भी परीक्षण का परिणाम है कि यह कम से कम कुछ मददगार है।

इस समय मैं सबसे अच्छा कर सकता हूं, वैसे भी, लेकिन मुझे और अधिक जानकारी हो सकती है अगर मुझे इस समस्या में खुदाई करने का समय मिल जाए।

खैर, हम इसे चरणों में कर सकते हैं। पहला यह सुनिश्चित करना होगा कि यदि कोई वादा वापस किया जाता है और एक done कॉलबैक दिया जाता है, तो मोचा एक दोस्ताना तरीके से टूट जाएगा।

यह _conceivable_ है कि कोई ऐसा कुछ कर सकता है (Bluebird के साथ):

// to make this work, you need to omit `return`
it('should do something async for sure', function(done) {
  return somethingAsync()
    .then(makeAssertion)
    .asCallback(done);
});

लेकिन यह सिर्फ कुछ है जो आप _could_ करते हैं; मुझे इसके लिए एक उपयोग के मामले का निर्धारण करना बाकी है।

मुझे लगता है कि मैंने खुद को भ्रमित किया है। मुझे यकीन नहीं है कि यहाँ एक बग है।

यह "खराब यूआई" -प्रकार के मुद्दे से अधिक है

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

it("should not time out", function(done) {
  return new Promise(function(resolve, reject) {
    setTimeout(resolve.bind(42), 50)
  })
})

1) समय समाप्त नहीं होना चाहिए:
त्रुटि: 2000 मी का समय समाप्त हो गया। सुनिश्चित करें कि इस परीक्षण में कॉलबैक किया जा रहा है।

मैं किसी भी मामले में पीआर को देखूंगा ...

इच्छुक पार्टियों को # 2413 देखना चाहिए।

@ ब्रायनसिपल

मुझे संस्करण 3 में कई async beforeEach हुक का उपयोग करके एक ही त्रुटि मिलती है:

  beforeEach((cb) => connection.db.collection('users').remove({}, cb));
  beforeEach((cb) => connection.db.collection('accounts').remove({}, cb));
  beforeEach((cb) => connection.db.collection('accounts').insertOne(account1, cb));

क्या उस तरह से अभी भी एसिंक्स हुक का उपयोग करना संभव नहीं है?

मैंने अपने मुद्दे का पता लगा लिया: प्रत्येक हुक के अंदर मेरे तरीके promise लौट रहे हैं (मुझे नहीं पता था कि क्योंकि मैं उन मामलों में वादों का उपयोग नहीं कर रहा था) और जाहिर है मैं cb फ़ंक्शन से भी गुजर रहा हूं। ।

मुझे नहीं लगता कि यह एक अच्छा विचार है। यदि कोई कॉलबैक के लिए अनुरोध करता है तो मुझे लगता है कि उन्होंने अपने इरादे स्पष्ट कर दिए हैं। यहाँ त्रुटि सिर्फ एक झुंझलाहट है। कृपया इसे हटा दें।

यह वास्तव में इरादे की बात नहीं है। # 1320 के विवरण से:

जब कॉलबैक फ़ंक्शन निर्दिष्ट किया जाता है और एक वादा वस्तु होती है
लौटे, रननेबल की रिज़ॉल्यूशन स्थिति अस्पष्ट है।

यह अस्पष्ट नहीं है, कॉलबैक का अनुरोध किया गया था। वह कैसा अस्पष्ट है?

मैं इस बात से सहमत हूं कि @RobertWHurst यहाँ कोई अस्पष्ट नहीं है।

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

हमने कुछ भी करने के लिए किसी को _force_ नहीं किया। हमने एक प्रमुख जारी किया, जिसकी परिभाषा में परिवर्तन होंगे। हमने सेमर नहीं तोड़ा।

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

beforeEach((cb) => connection.db.collection('users').remove({}, cb));
            ^^

^ ^ जो अस्पष्ट नहीं है। यह स्पष्ट है कि लेखक को क्या उम्मीद है। लेखक कॉलबैक का अनुरोध करने के लिए अपने रास्ते से बाहर चला गया है।

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

ड्रामा की मात्रा को डायल करना फायदेमंद हो सकता है। "तुमने मोचा तोड़ दिया" किसी की मदद नहीं कर रहा है। एक सेमर प्रमुख संस्करण वृद्धि स्पष्ट रूप से उन परिवर्तनों को तोड़ने के रूप में परिभाषित की जाती है जिन्हें आपको अपने कोड को समायोजित करने की आवश्यकता हो सकती है। आप अपने परीक्षणों को ठीक करने के लिए बदलाव करने के लिए आपको समय देने के लिए 2.x पर रह सकते हैं। यह एक विकास है, एक टूटना नहीं है

@ मैं अभी भी एक नुकसान में हूँ कि कैसे कॉलबैक का अनुरोध करना अस्पष्ट है। यदि आप कॉलबैक के लिए पूछते हैं, तो आपको इसका उपयोग करने की उम्मीद है। अन्यथा यह एक प्रोग्रामिंग त्रुटि है। यह परीक्षण लेखक द्वारा एक स्पष्ट कार्रवाई है।

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

जैसा कि babel async / प्रतीक्षा से पहले मुझे पता चला है कि नए mocha @ 3 के साथ अच्छी तरह से काम नहीं करता है

it('should fill userName and password', async function (done) {
    const userNameField = global.driver.wait(until.elementLocated({css: '#username'}));
    userNameField.sendKeys('admin');

    const passNameField = global.driver.findElement({css: '#password'});
    passNameField.sendKeys('*******');

    const userNameVal = await userNameField.getAttribute('value');
    const passwordVal = await passNameField.getAttribute('value');

    try {
      assert.equal(userNameVal, 'admin');
      assert.equal(passwordVal, 'changeme');
    } catch (error) {
      done(error);
      return;
    }

    done();
  });

यह कोड mocha @ 2 के साथ अच्छी तरह से काम करता है, लेकिन mocha @ 3 के साथ नहीं है क्योंकि await यह वादा करता है

मुझे लगता है कि यह पीआर यहां प्रासंगिक है => https://github.com/mochajs/mocha/pull/2413
इस त्रुटि के किनारे के मामलों से निपटने के लिए अधिक जटिलता।

@artyomtrityak यह एक महान उदाहरण है जहाँ done अनावश्यक है।

हतोत्साहित करने वालों ने उनके टुकड़े को कहा है। फिर भी, मोचा के रखवाले इस बदलाव को वापस लेने के तर्क (नों) से असहमत हैं। एरण हैमर ने कहा (विरोधाभास), "एक अनुचर के रूप में, आप जो सबसे कठिन काम कर सकते हैं, उनमें से एक है जो उन लोगों को निराश कर रहा है जो अपनी दिशा में काम करना चाहते हैं।"

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

यदि आपको यह परिवर्तन पसंद नहीं है, और आप इसके बारे में रचनात्मक नहीं हो सकते हैं, तो यह OSS है - आप इस परियोजना को कांटा कर सकते हैं और वहां के परिवर्तनों को वापस ला सकते हैं।

@boneskull यह async फ़ंक्शंस में बदल जाता है जो वादे वापस करता है, मुझे अपना टेस्ट केस खत्म करने की ज़रूरत नहीं है जब वादा पूरा हो जाएगा लेकिन परिणामों के आसपास कुछ कस्टम चेक करने की आवश्यकता है। जैसा कि मैंने कहा कि यह कोड mocha @ 2 के साथ पूरी तरह से ठीक काम करता है, लेकिन mocha @ 3 के साथ ऐसा नहीं है। इसलिए मेरी टीम (~ 20ppl) इस वजह से नवीनतम मोचा में नहीं जा सकती है।

वर्तमान में मोचा 2.x बहुत लचीलापन देता है, क्या इस बदलाव का कोई तकनीकी कारण है?

@artyomtrityak यह एक महान उदाहरण है जहाँ किया गया अनावश्यक है।

क्या आप कृपया एक उदाहरण बना सकते हैं कि यह बेबल async/await सिंटैक्स के साथ कैसा दिखना चाहिए और बिना return new Promise ?

@artyomtrityak पूरी तरह से वादों को गले लगाने के बारे में कैसे? तो आप अपने परीक्षण को छोटा कर सकते हैं:

it('should fill userName and password', async function () {
    const userNameField = global.driver.wait(until.elementLocated({css: '#username'}));
    userNameField.sendKeys('admin');

    const passNameField = global.driver.findElement({css: '#password'});
    passNameField.sendKeys('*******');

    const userNameVal = await userNameField.getAttribute('value');
    const passwordVal = await passNameField.getAttribute('value');

    assert.equal(userNameVal, 'admin');
    assert.equal(passwordVal, 'changeme');
  });

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

आप में से अधिकांश (वर्तमान में सक्रिय अनुचर) ने मोचा पर 2014 के मध्य में काम करना शुरू कर दिया था। मोचा पहले से ही स्थापित था जिस बिंदु पर आप लोगों ने योगदान देना शुरू किया था। यह सिर्फ मेरी राय है, लेकिन मुझे नहीं लगता कि मैं यह सोचकर अकेला हूं कि किसी स्थापित पुस्तकालय में ब्रेकिंग परिवर्तन नहीं किया जाना चाहिए जब तक कि यह उचित न हो। हालांकि मैं इस बदलाव के मूल औचित्य की कल्पना कर सकता हूं, लेकिन जब एक अंक निम्नलिखित होता है तो यह अच्छी तरह से खड़ा नहीं होता है। कॉलबैक के लिए पूछना स्पष्ट इरादे का संचार करता है। वादे उतने स्पष्ट नहीं होते हैं क्योंकि उनसे अनुरोध नहीं किया जाता है, उन्हें वापस कर दिया जाता है, जो अप्रत्यक्ष रूप से और दुर्घटनावश हो सकता है (उदाहरण के लिए तृतीय पक्ष पुस्तकालय से लौटाया गया)। इन भिन्नताओं के कारण उपज देने के दो तरीके समान नहीं हैं, और इस प्रकार दोनों का उपयोग करने की कोशिश करना वास्तव में अस्पष्ट नहीं है। कॉलबैक को परीक्षण तर्कों में लिखा जाना चाहिए। आप वादों के साथ ऐसा नहीं कर सकते, और इसलिए कॉलबैक के लिए पूछकर, आपने अपने इरादे स्पष्ट रूप से बताए हैं। आपके समुदाय ने इन चिंताओं को उठाया, और इसके बजाय कि आप लोग गलत व्यवहार को स्वीकार कर रहे हैं, दोगुना हो रहा है। ऐसा लगता है कि आप परीक्षण को इस त्रुटि को लगातार सुनिश्चित करने के लिए async होने पर भी विचार कर रहे हैं। देखें => https://github.com/mochajs/mocha/pull/2413 एक त्रुटि संदेश के लिए एक बड़े बदलाव की तरह लगता है जो एक अप्रत्याशित गलती से बचाता है।

आप लोगों ने @tj के प्रस्थान के बाद से इस पुस्तकालय को बनाए रखने का एक बड़ा काम किया है, क्या आप इस बदलाव के बारे में थोड़ा और सोच सकते हैं। मेरी चिंता यह है कि यह पुस्तकालय से समझौता कर सकता है।

पूरी तरह से @RobertWHurst से सहमत हैं।

done अनुरोध किया गया वादा व्यवहार को ओवरराइड करना चाहिए। इसकी आवश्यकता नहीं होने पर done का अनुरोध करने की संभावना नहीं है, और async फ़ंक्शन में उत्सर्जित घटनाओं के परिदृश्य एक आदर्श उदाहरण हैं।

ऊपर मेरी टिप्पणी से:

it('fires change event when calling blah.doSomethingThatFiresChange', async function (done) {
  const blah = await getBlah()
  blah.on('change', () => done())
  blah.doSomethingThatFiresChange()
})

जैसा कि अधिक लोग ES6 / 7 + async / await लिए आगे बढ़ते हैं, यह मोचा का उपयोग करते समय एक आम गेटा बन जाएगा।

कृपया इस बदलाव पर पुनर्विचार करें।

@RobertWHurst आप तर्क देते हैं कि done कॉलबैक को परिभाषित करना स्पष्ट इरादा है। क्या एक return बयान एक स्पष्ट इरादा नहीं है? दोनों आपके द्वारा आपके कोड में परिभाषित किए गए हैं। हम कैसे तय कर सकते हैं कि आपके कोड का एक हिस्सा जानबूझकर और दूसरा नहीं है? यदि आप () => foo से पहले किसी दुनिया की कल्पना करते हैं तो कोई भी रिटर्न स्टेटमेंट हमेशा स्पष्ट होता है। एकमात्र कारण यह है कि अब आप सभी हथियार उठा रहे हैं, क्योंकि आपने निहित रिटर्न स्टेटमेंट का उपयोग करना शुरू कर दिया है, जिसके लिए मैं केवल सोच सकता हूं कि यह सौंदर्यवादी कारण हैं।

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

वर्तमान व्यवहार बहुत स्पष्ट है कि केवल एक अनपेक्षित टाइमआउट की तुलना में क्या गलत है

@Munter तस्वीर में async कार्यों के साथ, मुझे लगता है कि खोजे गए पैमाने पर रिटर्न किए गए वादे कम हैं क्योंकि यह बनाया गया है और स्वचालित रूप से वापस आ गया है, चाहे आप await उपयोग करें या नहीं:

it('should work with a async function that could have been sync', async function () {
  assert.ok(true);
});

it('should work with a legitimately async function', async function () {
  assert.equal(await getBlah(), 'blah');
});

it('should work with a fully spelled-out Promise-based test', function () {
  return getBlah().then(function (blah) {
    assert.equal(blah, 'blah');
  });
});

और फिर विवादास्पद है:

it('should foo', async function (done) {
  assert.equal('foo', 'foo');
  done();
});

यह उस किशोरी-वेनी async लिए दुर्घटना से डराने के लिए भी आसान है, इसलिए हमें नए प्रकार के गोच के रूप में (कम से कम) पहले उदाहरण के बारे में सोचना चाहिए, जैसा कि

यहाँ पर थोड़ी बातचीत के बाद => https://github.com/mochajs/mocha/pull/1320, मुझे समस्या के वैकल्पिक समाधान के लिए एक विचार आया। मैंने यहाँ पर आपकी समीक्षा करने के लिए एक पीआर जोड़ा है => https://github.com/mochajs/mocha/poc/654

:बियर:

आप तर्क देते हैं कि किसी किए गए कॉलबैक को परिभाषित करना स्पष्ट इरादा है। क्या रिटर्न स्टेटमेंट एक स्पष्ट इरादा नहीं है?

@ मूनर उस कॉफ़िशस्क्रिप्ट और es6 एरो फंक्शन एक्सप्रेशन्स को नहीं भूलते हैं, _implicitly_, ताकि आप कुछ ऐसा कर सकें

it 'should foo', (done) -> request('/foo').end (err, res, body) -> done()

और सोचें कि आप सुरक्षित हैं। लेकिन इस मुद्दे का मतलब है कि आपको उस अच्छे वन-लाइनर को कुछ इस तरह बदलना होगा

it 'should foo', (done) ->
  request('/foo').end (err, res, body) -> done()
  return

यह वास्तव में प्रत्येक और मेकोनो में हमारे समग्र कोडबेस के साथ हमारी समस्या है। इस पर विचार करो:

it 'should foo', (done) ->
  obj =
    run: ->
      done()
      @
    then: -> "what the hell, i'm not a promise"
  obj.run()

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

सभी को प्रणाम,
निम्नलिखित कोड के साथ इस मुद्दे में भाग गया;

describe('Page', ->
  describe('/GET home', ->
    it('it SHOULD return the homepage', (done) ->
      chai.request(app).get('/').end((err, res) ->
        res.should.have.status(200)
        res.text.should.be.a('string')
        done()
      )
    )
  )
)

यह वादा श्रृंखला का सम्मान करके और कॉलबैक done() को छोड़ कर हल किया गया।

describe('Page', ->
  describe('/GET home', ->
    it('it SHOULD return the homepage', ->
      chai.request(app).get('/').then((res) ->
        res.should.have.status(200)
        res.text.should.be.a('string')
      )
    )
  )
)

मुझे आशा है कि यह दूसरों की मदद करता है, जो एक समान त्रुटि में भाग लेते हैं: मुस्कान:

PS : दिल: मोचा btw: +1:

EDIT @Munter की टिप्पणी के आधार पर catch() निकालें।

@karlbateman धन्यवाद हालांकि आपको उस अंतिम .catch नहीं है। अस्वीकार किए गए वादे को मोचा द्वारा एक त्रुटि के रूप में गिना जाता है

@ मैं देख रहा हूँ, धन्यवाद: स्माइली:

इसके बारे में थोड़ा और सोचने पर मुझे वास्तव में वादे और कॉलबैक दोनों की प्रतीक्षा करने का व्यवहार पसंद है। क्या इसे लागू करने के साथ कोई प्रगति हुई थी?

@ light24bulbs प्रतिक्रिया के लिए धन्यवाद! नहीं, afaik किसी ने भी इस पर काम करना शुरू नहीं किया क्योंकि यह सिर्फ एक विचार है जिसे मैंने प्रतिक्रियाओं को देखने के लिए वहां फेंक दिया। मैं अभी जाँच कर रहा था कि क्या विचार पर कोई अतिरिक्त प्रतिक्रिया हुई है, किसी भी मामले में यह काम नहीं करता है, आदि।

क्या बाबेल का उपयोग करते समय इसके लिए कोई समाधान है?

क्या बाबेल का उपयोग करते समय इसके लिए कोई समाधान है?

मैं दो बार लपेटता हूं:

it("should work", done => {
  (async () => {
    await something;
    done();
  })();
});

@SaschaNaz धन्यवाद, यह

6 महीने बाद, यह मुद्दा अभी भी सभी आधुनिक जेएस परीक्षणों को ब्रेक कर रहा है ...
शर्म की बात है

@benfavre उत्साहजनक शब्दों के लिए धन्यवाद, जो निश्चित रूप से स्वयंसेवकों को अपने बच्चों के साथ खेलने के बजाय उनके खाली समय में आपके द्वारा निर्दिष्ट किसी भी समाधान को लागू करने की जिम्मेदारी लेने के लिए प्रेरित करेंगे।

@ मंटर को कोई चिंता नहीं है कि मैं एक विशेष मुद्दे की पहचान करने में मदद कर सकता हूं जिसका सामना मुझे एक नए उपयोगकर्ता के रूप में करना पड़ा।
@ शशनाज ने सुझाव दिया कि दो बार लपेटने से कोई

=> विशेष रूप से वादे का उपयोग करना चाहिए जैसा कि इसे करना चाहिए।

अगली बार जब मुझे लगता है कि मुझे मोर्टार की तरह सिर्फ "+1" चाहिए तो मुझे मुफ्त में अपमान नहीं करना चाहिए।
मेरे संदेश में कुछ भी अपमानजनक नहीं था, मेरे कथन का सही अर्थ है।

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

नया साल मुबारक हो और बच्चों के साथ खेलने में मज़ा आए।

सर्द...

चर्चा done कॉलबैक और " Promise " दोनों पर ध्यान देने में विकसित हुई: https://github.com/mochajs/mocha/issues/2509

समापन। # 2509 देखें

मामले में कुछ निकाय अभी भी संघर्ष कर रहे हैं ...

क्या बाबेल का उपयोग करते समय इसके लिए कोई समाधान है?

अब # 2509 में उल्लिखित वादे के लिए निर्मित हैंडलर के साथ, हमें wrapping twice hack का उपयोग करने की आवश्यकता नहीं है:

it("should work", done => {
  (async () => {
    await something;
    done();
  })();
});

इसके बदले में, हम बस इस के साथ जा सकते हैं:

it("should work", async () => {
  await something;
});

अधिक विस्तार के लिए इस पोस्ट की जाँच करें

@ लो-टी.पी.
1.) यह कोड तब काम करता है जब इसकी कोलाहल के साथ संकलित किया जाता है?

it("should work", async () => {
  await something;
});

@ सेरकनसीपही

• हां, अब async/await सिंटैक्स का उपयोग करने के लिए, हमें बेबल की मदद चाहिए।

यकीन नहीं होता कि मुझे कुछ याद आ रहा है ... लेकिन मैंने अपने प्रोमिस के साथ किसी भी रिटर्न स्टेटमेंट का उपयोग न करके और बस () किया गया भरोसा करके इस समस्या को हल किया।

यहाँ मेरे लिए एक उदाहरण काम कर रहा है

  describe('STRIPE CHARGES: Get Charges', () => {
    it('should list customer charges', async () => {
      const charges = await Stripe.getChargesList(customerObj);
      charges.data[0].should.have.property('id');
      charges.data[0].amount.should.have.property('id');
    });
  });

मैं chai.assert के साथ mocha 4 का उपयोग कर रहा हूं।

सबसे पहले मैंने ऐसा किया () कॉलबैक का उपयोग करने की कोशिश की।

it('should throw an error', async function(done) {
  try {
    result = await something('value that causes something() to throw an Error');
    done('failed');
  } catch (e) {
    done();
  }
});

इसके साथ असफल रहा

Error: Resolution method is overspecified. Specify a callback *or* return a Promise; not both."

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

यदि ऐसा है, तो कॉल करने के लिए मैं निम्नलिखित परीक्षा पास कैसे करूं जब किसी चीज़ का इंतजार करने के लिए () एक त्रुटि फेंकता है और यही मैं होने की उम्मीद करूंगा?

it('should throw an error', async function() {
  try {
    result = await something('value that causes something() to throw an Error');
  } catch (e) {
    // how to indicate that this should happen, if I can't call done() to tell mocha?
  }
});

कृपया कोई मुझे इस विशिष्ट मामले को समझने में मदद कर सकता है? क्या मुझे अभिकथन पुस्तकालय का उपयोग करना चाहिए या क्या मुझे ऊपर दिए गए कोड में कुछ अतिरिक्त चाहिए?

बहुत धन्यवाद।

निम्न स्तर और त्रुटि-प्रवण समाधान:

it('should throw an error', async function() {
  try {
    result = await something('value that causes something() to throw an Error');
    throw new Error('Promise unexpectedly fulfilled');
  } catch (e) {
    // Optionally assert something about e...
  }
});

मैं सप्ताह के किसी भी दिन एक पुस्तकालय का उपयोग करता हूँ:

const expect = require('unexpected');
it('should throw an error', async function () {
    await expect(something(), 'to be rejected with', 'the error message');
});

या चाई + चाई-जैसा-वादा:

const chai = require('chai');
chai.use(require('chai-as-promised'));
const expect = chai.expect;

it('should throw an error', async function () {
    await expect(something()).to.be.rejectedWith('argh');
});

हाय दोस्तों, यह एक asyncawait के साथ अच्छी तरह से काम करता है (बस omit 'किया ()')

describe('New order from landing', function() {
    describe('check new client function', function () {
        it("must check db and return that random client is new", async function () {
            var result = await handler.checkClient(reqNewClient.body)
                expect(result).to.have.property('newclient').equal(true)
            })
    })
})

परिणाम:

लैंडिंग से नया आदेश
नए ग्राहक समारोह की जाँच करें
√ db की जाँच करनी चाहिए और यह जानना चाहिए कि यादृच्छिक ग्राहक नया है
1 पासिंग (9 एमएस)

@kolykhalov धन्यवाद यह मेरे लिए काम किया

मेरे मामले में, मैं एक कोशिश / पकड़ में async ब्लॉक लपेट दिया

it('It should activate a user.', async() => {
        return new Promise((resolve, reject) => {
            try {
                // Get the last activation token from the DB
                let sql = 'select * from activation_tokens order by created_at desc limit 1';
                let res = await DB.query(sql);
                let {token} = res[0];

                server
                    .post('/auth/activate')
                    .send({token})
                    .set('Content-Type', 'application/x-www-form-urlencoded')
                    .expect('Content-Type', /json/)
                    .expect(200)
                    .end((err, res) => {
                        res.body.data.should.contain.keys('message');
                        res.body.data.message.should.equal("Activated");
                        resolve();
                    });
            } catch (e) {
                console.error(e);
            }
        });
    });

कमजोरियों से बचने के लिए अपग्रेड किया गया। अब मुझे 99 परीक्षणों को फिर से लिखना है। एफएमएल

तो बस यह स्पष्ट करने के लिए कि समस्या क्या है, जैसा कि कुछ कह रहे हैं कि आपको done और async का उपयोग करने की आवश्यकता नहीं है, यहाँ एक उदाहरण है जहाँ आप दोनों का उपयोग करना चाहते हैं।

it('should error on fn', async function(done) {
  try {
    await fn();
  } catch (e) {
    // assert some things here
    done()
  }
});

done का उपयोग नहीं करने पर यदि कोई त्रुटि नहीं हुई तो परीक्षण को पास होने दिया जाएगा। कुछ ने expect(await fn).to.throw('blah') जैसी चीजों का उपयोग करने का सुझाव दिया है, लेकिन कभी-कभी आपको एक-लाइनर में फिट होने की तुलना में अधिक गुणों की जांच करने की आवश्यकता होती है।

मुझे यह त्रुटि मिल रही थी लेकिन मैं गलती से एक वादा (सुपरर्ट) लौटा रहा था

it('Should do something', (done) => {
       return supertest(server)
           .get(`/api/endpoint`)
           .set('somekey', 'somevalue')
           .expect(200)
           .then(() => { done(); })
           .catch(done);
});

'रिटर्न' क्लॉज को हटाने से समस्या हल हो गई

किसी और के लिए जो इस से पागल हो गया था ...

यह काम:

it("should work", async () => {
  await something;
});

यह नहीं करता:

it("should work", async (done) => {
  await something;
});

आपको पैरामीटर के रूप में done निकालना होगा।

@tamoyal , yeah - as elado वापस 3 अगस्त 2016 को

एसिंक्स / वेट का उपयोग करना निहित Promise का रिटर्न देता है। done कॉलबैक का उपयोग करना है
सीपीएस- आधारित एसेन्ड, जैसा कि यहां दिखाया गया
यह दस्तावेज है और मोचा-3.0 रिलीज के बाद से मानक व्यवहार है।

मुझे यह त्रुटि मिल रही थी लेकिन मैं गलती से एक वादा (सुपरर्ट) लौटा रहा था

it('should do something', (done) => {
       return supertest(server)
           .get(`/api/endpoint`)
           .set('somekey', 'somevalue')
           .expect(200)
           .then(() => { done(); })
           .catch(done);
});

'रिटर्न' क्लॉज को हटाने से समस्या हल हो गई

@victorsferreira , ऐसा लगता है कि समाधान होना चाहिए था ...

it('should do something', () => {
  return supertest(server)
    .get(`/api/endpoint`)
    .set('somekey', 'somevalue')
    .expect(200);
});

@tamoyal Yep कि मुझे क्या

@mienaikoe , यह सटीक परिदृश्य स्पष्ट रूप से प्रलेखित है , आप जानते हैं ...

@plroebuck दो बातें:

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

2) प्रलेखन में दोष है:

Mocha v3.0.0 और नए में, एक वादा लौटाया और किया () ...

यह कॉल किए जाने के बारे में नहीं है, यह एक पैरामीटर के रूप में done के बारे में है। आप इसका उपयोग करते हैं या नहीं।

@mienaikoe

1. Mocha it के दूसरे पैरामीटर को देखने के लिए जाँचता है कि क्या फ़ंक्शन मौजूद है, और (यदि ऐसा है) तो यह निर्धारित करने के लिए कि उपयोगकर्ता ने कॉलबैक जोड़ा है। यह मुश्किल से आत्मनिरीक्षण के रूप में योग्य है, और सामान्यतः जावास्क्रिप्ट में उपयोग किया जाता है।
2. यदि आपको लगता है कि यह अस्पष्ट है, तो दस्तावेज़ को सही करने के लिए PR भेजें।

एक परम के रूप में किया गया निष्कासन मेरे लिए काम कर गया!

इससे पहले:

(काम करता है!)

@QauseenMZ , आपके "पहले" और "बाद" कोड के बीच कोई अंतर नहीं देखता है।

तुम भी अपना वादा नहीं लौटा रहे हो। यह निम्नलिखित की तरह अधिक नहीं होना चाहिए?

  it('should receive successful RPC response', async () => {
    return await getResponse(unitData)
      .then((res) => {
        expect(res).to.have.status(200);
      });
  });

पुनश्च। आपका नोड कॉलबैक तर्क आदेश समाप्त हो गया है ... error _always_ पहले जाता है।

@plroebuck उल्लेख करने के लिए धन्यवाद! मैंने अभी संपादित किया है।

मैं वादा नहीं संभाल रहा हूं क्योंकि getResponse फ़ंक्शन कॉलबैक लौटा रहा है। यह मुझे काम करने का एकमात्र तरीका था। getResponse फ़ंक्शन निम्नानुसार है:

यहां कॉलबैक getResponse फ़ंक्शन के वापस आने के कारण त्रुटि दूसरा पैरामीटर है। कृपया मुझे इसके बारे में अपने विचार बताएं। धन्यवाद!

कुछ भाग थोड़े अतार्किक लगते हैं। सिर्फ स्पष्टता के लिए, आप किस request पैकेज का उपयोग कर रहे हैं?
आपको options ऑब्जेक्ट (आपको unitData ) की आवश्यकता क्यों होगी?

• obj कहाँ से आता है?
• क्यों आप एक के लिए होता है res.body.error एक साथ res.statusCode === 200 ?

पुनश्च। कृपया कोड की छवियों के बजाय केवल कोड पेस्ट करें ...

किसी और के लिए जो इस से पागल हो गया था ...

यह काम:

it("should work", async () => {
  await something;
});

यह नहीं करता:

it("should work", async (done) => {
  await something;
});

आपको पैरामीटर के रूप में done निकालना होगा।

@tamoyal आपने मेरी जान बचाई <3

यह टूट जाता है और एक ही त्रुटि के परिणामस्वरूप होता है:

it('Location Querying Works', async () => {
    await WeatherComponent.pullLocationData();
    Vue.nextTick(()=>{
      expect(WeatherComponent.$el.textContent).contain("Spain")
    })
  })

इस समस्या का तेज़ समाधान देने के लिए, अपने पूरे परीक्षण को एक वादा में लपेटें, और resolve क्योंकि आप done ।

इसे चालू करें:

it.only("Works with the database", async (done) => {
    let browser = await puppeteer.launch();
    let query = db.collection('lists').where('ownerId', '==', 'UJIXXwynaCj8oeuWfYa8');
    let ct = 0;
    query.onSnapshot(async querySnapshot => {
        if (ct === 0) {
            await addAPurpose(browser, session, sessionSig); // A function with a bunch of Puppeteer code.
            ct++
        } else {
            expect(querySnapshot.size).to.equal(1);
            expect(querySnapshot.docs[0].get().title).to.equal("Understand Mocha");
            done();
        }
        console.log(`Received query snapshot of size ${querySnapshot.size}`);
    }, err => {
        console.log(`Encountered error: ${err}`);
    });
});

इस मामले में:

it.only("Works with the database", async () => {
    const onSnap = new Promise(async (res, rej) => {
        let browser = await puppeteer.launch();
        let query = db.collection('lists').where('ownerId', '==', 'UJIo1gGMueoubgfWfYa8');
        let ct = 0;
        let unsubscribe = query.onSnapshot(async querySnapshot => {
            if (ct === 0) {
                await addAPurpose(browser, session, sessionSig);
                ct++
            } else {
                expect(querySnapshot.size).to.equal(1);
                expect(querySnapshot.docs[0].data().title).to.equal("Evolution");
                // done(); 
                unsubscribe();
                res();
            }
            console.log(`Received query snapshot of size ${querySnapshot.size}`);
        }, err => {
            console.log(`Encountered error: ${err}`);
            rej()
        });
    });
    return onSnap;
});

और यह काम करता है जैसे आप चाहते हैं।

done को निकालने की आवश्यकता ने मुझे आश्चर्यचकित कर दिया, क्योंकि परीक्षण तब तक चला जब तक बुलाया नहीं गया था। यह स्पष्ट करने के लिए कि किया गया async के साथ उपयोग नहीं किया जाना चाहिए, async फ़ंक्शन विफल होना चाहिए _immediately_ यदि किया गया है तो पास किया गया। मोचा द्वारा परीक्षण शुरू करना चाहिए:

1. यह देखते हुए कि फ़ंक्शन async है, और
2. done तर्क का पता लगाना।

यदि वे दोनों मौजूद हैं, तो यह मेरे परीक्षणों को done तक चलने देने के बजाय फेंक देना चाहिए और फिर मुझे ब्लू-बॉल करना चाहिए। फिर त्रुटि को यह सुझाव देना चाहिए कि आप अपने कोड को किसी अन्य वादे में लपेटते हैं, और संकल्प का उपयोग करें जैसा कि आप done ।

मुझे पता है कि आप function.prototype.name === "AsyncFunction" उपयोग कर सकते हैं। तो फिर यह है

if (function.prototype.name === "AsyncFunction && arg1.name === "done") {
  throw new Error("Can't use done with an async function")
}

इसे लागू करने के लिए।

मैं इस पर लगभग SOL था। मुझे async कोड निष्पादित करने की आवश्यकता है और इसकी उम्मीद है कि कोड निष्पादित (कभी भी) समाप्त नहीं होगा, इसलिए मुझे इसका उपयोग करना होगा। कष्टप्रद हैक-ए-राउंड को एक आत्म-आक्रमण वाले async फ़ंक्शन में मेरे async परीक्षण कोड को लपेटना था, लेकिन it func को सिंक फ़ंक्श के रूप में छोड़ दें।

उपाय:

it("It shouldn't be like this", function (done) {
    ( async function(){
        var life = require('InfiniteLife');
        var asyncRes = await life.someCoolstuff();
        assert(asyncRes);
        setTimeout( function(){
            done();
        },letsCallItQuitsNow);
    })();
});

ब्रेकिंग के साथ async फ़ंक्शंस का एक उदाहरण।

it('If the credentials exists in the system it should return the token generated against it.', async (done) => {
        let aObj = await admin.createAdmin();
        chai.request(server)
        .post("/authenticate")
        .set("Content-Type", "application/x-www-form-urlencoded")
        .send({username: aObj.login,password:aObj.password})
        .end((err, res) => {
            res.should.have.status(200);
            res.body.should.be.a("string");
            done();
        });
    });

सफलता का मामला

it('If the credentials exists in the system it should return the token generated against it.', async () => {
        let adminObj = await admin.createAdmin();
        chai.request(server)
        .post("/auth/login")
        .set("Content-Type", "application/x-www-form-urlencoded")
        .send({username: adminObj.login,password:adminObj.password})
        .end((err, res) => {
            res.should.have.status(200);
            res.body.should.be.a("string");
            // done();
        });
    });

@ Haisum92

आपको अपने परीक्षण में न तो done और न ही async है। चाय http एक वादा वापस करता है। यदि आप एक वादा वापस करते हैं तो मोचा के परीक्षण async कोड के साथ काम करते हैं।

it('If the credentials exists in the system it should return the token generated against it.', () => {
  let adminObj = await admin.createAdmin();
  return chai.request(server)
    .post("/auth/login")
    .set("Content-Type", "application/x-www-form-urlencoded")
    .send({username: adminObj.login,password:adminObj.password})
    .end((err, res) => {
      res.should.have.status(200);
      res.body.should.be.a("string");
    });
});

@ नैटजिमर

आपके पोस्ट किए गए समाधान के परीक्षण के समय के लिए है अगर यह बहुत लंबा लगता है। मोचा में पहले से ही यह कार्यक्षमता है।

it("It should be liek this", async function () {
  this.timeout(letsCallItQuitsNow);

  var life = require('InfiniteLife');
  var asyncRes = await life.someCoolstuff();
  assert(asyncRes);
});

आपका उदाहरण भी परीक्षण को विफल करने के लिए प्रतीत नहीं होता है यदि टाइमआउट पार हो गया है, तो इसके सही होने के आधार पर सावधान रहें

`एक्सप्रेस / जेएस, और फायरबेस क्लाउड फ़ंक्शन का उपयोग करके, एपीआई त्रुटि प्रतिक्रियाओं की जांच करें, फिर एक टोकन प्राप्त करें और फिर से प्रयास करें। सुनिश्चित करें कि यदि आप एक्सप्रेस का उपयोग करते हैं, तो .json और नहीं। Send, मोच के साथ लकड़हारा कीड़े भी काम करता है, इसलिए सादे कंसोल का उपयोग करें।
सुनिश्चित करें कि आप async का उपयोग करते हैं और पूरी तरह से उत्सर्जन करते हैं

  process.env.NODE_ENV='TESTING';
  const { FIREBASE_UID } = require('dotenv').config()?.parsed;
  const { red, green, white } = require('chalk');
  const chai = require('chai');
  const chaiHttp = require('chai-http');
  const server = require('../lib/api').API;
  const should = chai.should();
  const expect = chai.expect;
  chai.use(chaiHttp);
  const test = chai.request(server).keepOpen();

  const shouldPrint = (details, status) => {
      return white(`details: ${details}, status: ${status}`);
  };

describe('Authorization Middleware Error Check for bad token', () => {

    it(shouldPrint('Bad Request', red(400)), async () => {
        try {
            const res = await test.get('/').send()
            res.should.have.status(400);
            res.should.have.json
            const { details, status } = JSON.parse(res.text)
            expect(details).to.equal('Bad request')
            expect(status).to.equal(400)
        } catch (error) { 
            throw error 
        }
    })


    it(shouldPrint('Unauthorized', red(401)), async () => {
        try {
            const res = await test.get('/').set('Authorization', 'Bearer bad123token').send()
            res.should.exist
            res.should.have.status(401);
            res.should.have.json
            const { details, status } = JSON.parse(res.text)
            expect(details).to.equal('Unauthorized')
            expect(status).to.equal(401) 
        } catch (error) {
            throw error
        }
    })

})

 describe('Get token and ping', () => {
    let adminToken

    it(shouldPrint( 'Create custom jwt for testing', green(200)), async () => {
        try {
            const res = await test.get(`/createToken/${FIREBASE_UID}`).send()
            res.should.exist
            res.should.have.status(200);
            res.should.have.json
            adminToken = (JSON.parse(res.text)).token
        } catch (error) {
            throw error
        }
    })

    it(shouldPrint('PING', green(200)), async () => {
        try {
            const res = await test.get('/')
                .set('x-tenorders-testing', 'true')
                .set('Authorization', `Bearer ${adminToken}`).send()

            res.should.exist
            res.should.have.status(200);
            res.should.have.json
            const { details, status } = JSON.parse(res.text)
            expect(details).to.equal('PING')
            expect(status).to.equal(200)
        } catch (error) {
            throw error
        }   
    })

})
`