Mocha: this.timeout() ES6 के तीर कार्यों का उपयोग करते समय विफल रहता है

यह फ़ंक्शन को परीक्षण संदर्भ से बांधता है, जो तीर फ़ंक्शंस का उपयोग करते समय नहीं किया जा सकता है। http://mochajs.org/ से

उसके लिए माफ़ करना!

धन्यवाद।

इतने सारे "जादू" क्यों, अंत में, समस्याएं पैदा करते हैं? यह क्यों नहीं ?:

var mocha = require('mocha');

mocha.describe('foo', (suite) => {
  suite.timeout(100);

  suite.it('must love bar', () => ... );  
});

कोई ग्लोबल्स नहीं, कोई समस्याग्रस्त जादू नहीं ... लेकिन सिर्फ जावास्क्रिप्ट।

आप जो प्रस्तावित कर रहे हैं वह एक बड़ा ब्रेकिंग परिवर्तन है और कुछ ऐसा है जिस पर https://github.com/mochajs/mocha/issues/1969#issuecomment-160925915 में चर्चा की जा रही है एक पुनर्लेखन उन प्रकार के अर्थशास्त्र को पेश कर सकता है :)

जानकर अच्छा लगा। धन्यवाद।

@ibc ठीक है, यह

var mocha = require('mocha');

mocha.describe('foo', (suite) => {
  suite.timeout(100);

  suite.it('must love bar', (suite) => ... );  
});

लेकिन क्या दो अलग-अलग सुइट तर्क एक ही प्रकार के हैं? शायद नहीं, तो फिर आपके पास अलग-अलग प्रकारों को प्रतिबिंबित करने के लिए अलग-अलग चर नाम हैं जैसे कि

var mocha = require('mocha');

mocha.describe('foo', (suite) => {
  suite.timeout(100);

  suite.it('must love bar', (test) => ... );  
});

वैसे भी, तीर ऑपरेटर का उपयोग उन कार्यों में नहीं किया जा सकता है जो संदर्भों की अपेक्षा करते हैं।

मैं #1969 के लिए BDD UI को तोड़ने की कल्पना नहीं करता - बल्ले से ठीक, वैसे भी - हालांकि मुझे राजी किया जा सकता है। यह मेरी आशा थी कि हम मौजूदा एपीआई को बनाए रखेंगे, और बीडीडी यूआई युक्त एक अलग पैकेज पेश करेंगे। मोचा बीडीडी यूआई के एक संस्करण के साथ शिप करेगा जो मौजूदा एपीआई का उपयोग करता है, लेकिन उसके बाद हम लैम्बडास का उपयोग करके बीडीडी यूआई पैकेज का एक नया संस्करण जारी कर सकते हैं - उपयोगकर्ता चुन सकते हैं कि उस पैकेज में स्पष्ट रूप से अपग्रेड करना है या नहीं।

शायद describe या suite रैपर के लिए वैकल्पिक ES6 सिंटैक्स इस समस्या को हल कर सकता है:

describe({ feature: 'create stuff' , do () {
    it('abc', () => {
    }); 
}})

यह कम से कम सुइट स्तर पर बाध्यकारी की अनुमति देगा।

इस पर किसी भी अद्यतन? मेरे पर यह है

mocha = require('mocha');

mocha.describe('test', (suite) => {

suite.timeout(500);

suite.it('test', (done)=>
          )
    }
)

और TypeError प्राप्त करना: अपरिभाषित की संपत्ति 'टाइमआउट' नहीं पढ़ सकता

@mroien यह मोचा बग नहीं है। तीर सिंटैक्स function लिए 1:1 प्रतिस्थापन नहीं है। कृपया इसकी सीमाओं के बारे में पढ़ें

क्या इससे कुछ आया? मुझे प्रस्तावित समाधान पसंद है, यदि केवल तीर कार्यों के मेरे प्यार के लिए और 'इस' से घृणा करने के लिए जब इसकी आवश्यकता नहीं है

चूंकि टाइमआउट केवल done साथ प्रासंगिक है, क्यों न केवल टाइमआउट फ़ंक्शन को किए गए फ़ंक्शन में संलग्न करें।

it('makes sense', done => {
    done.timeout(100);
});

@nomilous यह अभी भी काम नहीं करता है। मुझे इसी तरह की समस्या हुई है। मेरे मामले के लिए जो काम करता है वह setTimeout को it ब्लॉक के अंदर कॉल कर रहा है। जैसे

it('description', done => {
     const func = () => {
          // assertions
     };
     setTimeout(func, 10000);
});

@nomilous तुल्यकालिक या वादा वापस करने वाले मामलों में टाइमआउट भी हो सकता है।

@ andela-engmkwalusimbi यह काम नहीं करना चाहिए। जैसा कि @boneskull ने लिखा है :

@mroien यह मोचा बग नहीं है। एरो सिंटैक्स फ़ंक्शन के लिए 1:1 प्रतिस्थापन नहीं है। कृपया इसकी सीमाओं के बारे में पढ़ें

हर कोई अभी भी इस बारे में सोच रहा है, सुनिश्चित करें कि आप समझते हैं कि एक तीर फ़ंक्शन का क्या अर्थ है, फिर यहां वापस आएं और पढ़ें (वहां बहुत सारे संसाधन हैं जो इसे मेरी तुलना में कहीं बेहतर समझा सकते हैं)।

इस मामले में यह तीर कार्य करने का एकमात्र तरीका यह है कि यदि हम bdd एपीआई को context ऑब्जेक्ट पास करने के लिए this का लाभ उठाने के बजाय प्रत्येक रननेबल (हुक, परीक्षण) कॉलबैक में बदलते हैं। बुरा विचार नहीं है, लेकिन यह एक विनाशकारी परिवर्तन का भूकंप है, ऐसा कभी नहीं होगा। इसके अलावा:

it('should do something', function (done) {
  this.timeout(9000);
  // stuff
  done();
});

यह इस तरह दिखेगा:

it('should do something', (context, done) => {
  context.timeout(9000);
  done();
});

यह अस्तित्व में हर एसिंक मोचा परीक्षण को तोड़ देगा, भले ही यह पीछे की ओर संगत हो अन्यथा:

it('should do something', function (context, done) {
  // context is unused, but 'done' is now the second parameter
  this.timeout(9000);
  done();
});

हम एक वैकल्पिक bdd कार्यान्वयन प्रदान कर सकते हैं जो ऐसा करता है, हालांकि--यह सिर्फ डिफ़ॉल्ट नहीं होगा।

मेरे पास "यह मुद्दा कहां है" के बारे में सबसे गहन स्पष्टीकरण के बारे में है। :मुस्कुराओ:

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

it('should do something', function ({ context, done }) { ...

हम एक वैकल्पिक बीडीडी कार्यान्वयन प्रदान कर सकते हैं जो ऐसा करता है, हालांकि - यह सिर्फ डिफ़ॉल्ट नहीं होगा।

@boneskull एक नया bdd-es6 इंटरफ़ेस बहुत अच्छा होगा :)

हालांकि मुझे एरो फ़ंक्शंस से प्यार है जो वास्तव में उपयोगी हैं जैसे .filter(i => i.val) जैसे ऐरे फ़ंक्शंस, सामान्य फ़ंक्शंस का उपयोग करने में समस्या क्या है? मुझे लगता है कि इसका वर्णन करना काफी उपयोगी है और यह विश्व स्तर पर है इसलिए मुझे हर बार उनकी आवश्यकता नहीं है। इसके अलावा this जादू कब से है, केवल इसलिए कि आप (तीर) कार्यों को नहीं समझते हैं? मैं निश्चित रूप से हर बार एक चर प्रदान नहीं करना चाहता जब मैं वादे वापस कर सकता हूं, अन्यथा मैं बहुत समय पहले एवा जैसे कुछ पर स्विच कर लेता। मोचा की सादगी के बारे में मुझे लगता है कि #1969 में वर्णित सामान्य/तीर कार्यों में कोई बड़ा बदलाव नहीं होना चाहिए। और कृपया मुझे यह न बताएं कि तीर फ़ंक्शन टाइप करने के लिए तेज़ हैं क्योंकि आपका संपादक एकल f को function () {\n\t\n} ।

मैं अस्पष्ट हूं, क्या before() कॉल को टाइमआउट करने का कोई समाधान है जो तीर फ़ंक्शंस का उपयोग करता है?

    before( async function () {
      data = await provider.getData();
      console.log(data);
      this.timeout(30*1000);
    });

कोई प्रभाव नहीं है। अभी भी यहाँ 4 सेकंड का समय समाप्त हो रहा है। मेरे टेस्ट सूट में यह एकमात्र धीमी चीज है। मैं समस्या को हल करने के लिए mocha.opts में 30s तक टाइमआउट डाल सकता हूं, लेकिन मुझे वास्तव में 30 के बाद टाइमआउट के लिए सभी परीक्षणों की आवश्यकता नहीं है, केवल एक एपीआई कॉल जब 4s उनमें से 99% के लिए ठीक है।

इस बीच मैंने इसे कैसे हल किया (ध्यान दें कि पहले describe() वसा तीर सिंटैक्स के बजाय function उपयोग करता है:

describe('Search API', function () {
    this.timeout(30*1000);

    context('search', () => {
        let data;

        before( async () => {
          data = await provider.getSearch();
        });

        it('returns results', () => {
          expect(data).to.exist;
          expect(data.results).to.be.instanceOf(Array);
          expect(data.results.length).to.be.above(0);
        });
    })
});

@chovy await provider.getData() में टाइमआउट होने के बाद आप टाइमआउट सेट कर रहे हैं।
इसके बजाय इसका उपयोग करने का प्रयास करें:

before(async function () {
  this.timeout(30*1000); // set timeout first, then run the function
  data = await provider.getData();
  console.log(data);
});

मैं अस्पष्ट हूं, क्या पहले() कॉल को टाइमआउट करने का कोई समाधान है जो तीर फ़ंक्शंस का उपयोग करता है?

बस इस पर स्पष्ट होने के लिए: वर्तमान में मोचा के timeout को तीर फ़ंक्शन का उपयोग करके कॉल करने का कोई तरीका नहीं है। विकल्पों की कोई भी चर्चा (हालांकि मेधावी) संभावित नए (या कम से कम संशोधित) इंटरफेस के बारे में चर्चा है।

कुछ समय के लिए मेरे दिमाग में कुछ ऐसा करने में सक्षम था:

it('...', (done) => {
  ...
  done()
})

तथा

it('...', (t) => {
  t.timeout(500)
  t.tag('integration', 'api')
  ...
  t.done()
})

एक ही डिफ़ॉल्ट इंटरफ़ेस का उपयोग करना।

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

तो इस कार्यान्वयन में, आपको पारंपरिक done फ़ंक्शन पैरामीटर के रूप में मिलता है, लेकिन उस done फ़ंक्शन ऑब्जेक्ट के गुणों के रूप में जोड़े गए उपयोगिता कार्यों के साथ।

this.timeout() का उपयोग करने से बीता हुआ समय रिपोर्ट में गायब हो जाता है।

@dasilvacontin पता नहीं हमने पहले ऐसा क्यों नहीं सोचा। यह एक उत्कृष्ट विचार है।

@dasilvacontin ओह, मुझे याद है। क्योंकि आपको इसे कॉल करना होगा। आप शायद नहीं चाहते।

क्षमा करें, क्या आप "इसे कॉल करना है", @boneskull पर विस्तार से बता सकते हैं? क्या आप उन समस्याओं के बारे में बात कर रहे हैं जहां मोचा सोचेंगे कि परीक्षण एसिंक है?

२९ जनवरी २०१७ को ०५:५४ बजे, क्रिस्टोफर हिलर नोटिफिकेशन @github.com ने लिखा:

@dasilvacontin ओह, मुझे याद है। क्योंकि आपको इसे कॉल करना होगा। आप शायद नहीं चाहते।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें, या थ्रेड को म्यूट करें।

साथ ही, आप 't' का उपयोग करते समय एसिंक्स परीक्षण करने के अपने इरादे की घोषणा कैसे करते हैं?

टेप में आपको हमेशा 't.done' (उनके API में 't.end') को कॉल करना होता है, या अपेक्षित मात्रा में दावे ('t.plan') सेट करना होता है।

क्या विकल्पों के साथ इसमें () तीसरा तर्क जोड़ना संभव होगा? वह एपीआई नहीं तोड़ेगा।

it ('accepts lambda', (done)=>{ doWork();  done(); }, {timeout:60000});

@बोनस्कुल

क्या होगा यदि संदर्भ को पहले रखने के बजाय, यह एक वैकल्पिक दूसरा था?

इसके अलावा:

it('should do something', function (done) {
  this.timeout(9000);
  // stuff
  done();
});

यह इस तरह दिखेगा:

it('should do something', (done, context) => {
  context.timeout(9000);
  done();
});

it('should do something', function (done, context) {
  // context is unused, but 'done' is now the second parameter
  this.timeout(9000);
  done();
});

हम एक वैकल्पिक बीडीडी कार्यान्वयन प्रदान कर सकते हैं जो ऐसा करता है, हालांकि - यह सिर्फ डिफ़ॉल्ट नहीं होगा।

मेरे पास "यह मुद्दा कहां है" के बारे में सबसे गहन स्पष्टीकरण के बारे में है। मैं

या अगर संदर्भ को कुछ परिभाषित परम होना चाहिए

it('should do something', function (done, override) {
  // context is unused, but 'done' is now the second parameter
  override.timeout(9000);
  done();
});

लेकिन मैं एक गैर-डिफ़ॉल्ट इंटरफ़ेस भी लूंगा :)

done आवश्यकता वाले किसी भी समाधान का नकारात्मक पक्ष यह है कि आपको done का उपयोग करना होगा, भले ही वादा वापस करना आसान हो। खुद के लिए बात हो रही है, मैं मैं नहीं बल्कि बाहर टाइप करेंगे पता function और return से .then(()=>{done()}, done) !

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

@ScottFreeCode मैं निश्चित रूप से done बारे में सहमत हूं, मैं इसका उपयोग करना पसंद नहीं करता, मैं केवल संदर्भ को पहले बनाम अंतिम और हड्डियों के द्वारा प्रदान किए गए उपरोक्त उदाहरण का उपयोग करने की आवश्यकता के बारे में टिप्पणी कर रहा था।

मुझे संदर्भ में पारित करने या ईएस 6 निष्पादन के लिए मोचा पर कुछ स्विच सेट करने का विकल्प पसंद आएगा।

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

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

परीक्षण घोषणा में नीचे परिभाषित निम्नलिखित when फ़ंक्शन को जोड़कर: it('does something', when(() => someFunctionReturningAPromise, customTimeout)) मोचा टाइमआउट को एरो फ़ंक्शंस को छोड़े बिना सेट किया जा सकता है।

इसी तरह, और क्योंकि हम केवल वादों के साथ काम कर रहे हैं, हम परीक्षण के लिए पहले पैरामीटर को फिर से ले सकते हैं और किए गए कॉलबैक के बजाय संदर्भ में पास कर सकते हैं: it('can access the mocha test context', when(testContext => someFunctionThatNeedsContext(testContext))

const when = (lambda, timeout) =>
  function() { // return a plain function for mocha to bind this to
    this.timeout(timeout || this.timeout() || 1000)
    return lambda(this)
  }

उदाहरण के लिए कुछ परीक्षण मामले:

const delay = timeout =>
  new Promise((resolve, reject) => setTimeout(resolve, timeout))

const deject = timeout => // similar to above, but a delayed reject
  new Promise((resolve, reject) => setTimeout(reject, timeout))

describe('mocha testing', () => {
  context('with only arrow functions', () => {
    context('tests that do not time out', () => {
      it('passes fast', when(() => delay(10), 100))
      it('does not usually time out', when(() => delay(2000), 2010))
    })
    context('tests that will time out', () => { // these should fail if the 'when' function works properly
      it('times out fast', when(() => delay(1000), 10)) // will fail in 10ms
      it('times out', when(() => delay(1000), 1000)) // will fail in about 1000ms
    })
    context('tests that will reject', () => { // this shows the when function works as expected when a test rejects
      it('fails fast', when(() => deject(10), 100))
    })
  })
})

@ astitt-Ripple हाँ, या आप बस function () {} लिखते हैं ... Wtf?

ठीक है लुका, बीमार काटने। :-)

एरो फंक्शन के साथ अंतर यह है कि रिटर्न को छोड़ा जा सकता है। एक में
es6 प्रकार सेटअप, यह पहले से ही वादे के लिए एक सामान्य पैटर्न हो सकता है 'फिर'
जंजीर।

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

यदि कोडबेस में अधिकांश कोड पहले से ही वायदे से तीर कार्य करता है। तो
और/या एक कार्यात्मक प्रोग्रामिंग शैली, फ़ंक्शन रिटर्न जोड़ना देख सकते हैं
असंगत। सुझाए गए 'कब' फॉर्म इसके बजाय उन लोगों के लिए उपलब्ध है जो
पारंपरिक फ़ंक्शन की तुलना में तीर और अधिक कार्यात्मक शैली पसंद करते हैं
कॉलबैक या फ़ंक्शन रिटर्न शैलियाँ। यह अधिक संक्षिप्त है, और इसके साथ फिट बैठता है
संदर्भ का वर्णन करें यह dsl हम सभी सहमत हैं कि हम परीक्षण लिखना पसंद करते हैं, इसमें शामिल हैं
वादे को पूरा करें async प्रोग्रामिंग एब्स्ट्रैक्शन जावास्क्रिप्ट हैंडल तो
कुंआ। इसके अलावा यह फ़ंक्शन + रिटर्न से छोटा है, यहां तक ​​​​कि हमारे दोस्त घुंघराले के बिना भी:
कब (() => ...)

शायद यह इस परियोजना की पसंदीदा शैली नहीं है, मैं इसे समझता हूं, और
मैं इसे परियोजना में बदलाव के रूप में प्रस्तावित नहीं कर रहा हूं। शायद यह सम
निंदनीय जैसा कि आपके wtf का तात्पर्य है। कोई बात नहीं। मोचा के साथ काम करना है
प्री-एफपी फ्रेंडली जे.एस. पश्च संगतता एक प्रथम श्रेणी की चिंता है। उस
भी समझ में आता है।

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

धन्यवाद।

यदि कोडबेस में अधिकांश कोड पहले से ही है ... कार्यात्मक प्रोग्रामिंग शैली ...

...फिर व्यवहार सेट करने के लिए this.mutatingMethod(currentConfiguration) का उपयोग करना, विशेष रूप से एक फ़ंक्शन (या बल्कि सबरूटीन) जो पहले से ही निष्पादित किया जा रहा है, return (जो सिर्फ सिंटैक्स है) लिखने की तुलना में अधिक असंगत है। , और असंगत उपस्थिति वास्तव में असंगति का परिचय देने के बजाय उस वास्तविकता को और अधिक स्पष्ट कर देगी।

(मुझे गलत मत समझो, मैं जेएस में कार्यात्मक प्रोग्रामिंग विचारों की लोकप्रियता में वृद्धि से काफी खुश हूं, लेकिन function / return बनाम => का सिंटैक्स है कार्यात्मक प्रोग्रामिंग के लिए वास्तव में आवश्यक नहीं है, बस उस प्रतिमान में क्लीनर दिखने की बात है, जबकि शुद्धता और घोषणात्मक बनाम अनिवार्य जैसी अन्य अवधारणाएं वास्तव में आवश्यक हैं। एक परीक्षण धावक होना साफ-सुथरा होगा, जो इसके बजाय, अधिक कार्यात्मक था इसका व्यवहार / अर्थशास्त्र , जिस बिंदु पर तीर कार्यों पर स्विच करना शायद छोटा होगा ...)

मैं आपसे सहमत हूं कि यह टाइमआउट पारस्परिक है और कार्यात्मक प्रोग्रामिंग प्रतिमान से टूटता है। बेशक यह पूरी तरह से असंगत है। वर्तमान में, क्या इस समय की तुलना में प्रति परीक्षण एक कस्टम टाइमआउट घोषित करने का कोई अन्य तरीका है?

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

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

कृपया मुझे भी गलत न समझें। मुझे नहीं लगता कि कार्यात्मक प्रोग्रामिंग कभी भी ट्यूरिंग मशीन व्युत्पन्न अनिवार्य/म्यूटेशनल प्रोग्रामिंग को पूरी तरह से बदल देगी या कभी भी पूरी तरह से बदल देगी। उदाहरण के लिए, लगभग हर मामले में, जेएस रनटाइम में कोड, कार्यात्मक या नहीं, अंततः उस अधिक पारंपरिक अनिवार्य शैली (शायद सी ++, लेकिन जरूरी नहीं) में लिखे गए प्रोग्राम द्वारा व्याख्या की जाती है, एक ऑपरेटिंग सिस्टम पर चल रहा है जो उत्परिवर्तनीय के आसपास भी लिखा जाता है और अनिवार्य विचार (शायद सी)। मेमोरी एक निश्चित संसाधन है, अपरिवर्तनीय डेटा संरचनाएं एक झूठ हैं जो रनटाइम हमें बताता है। वह मौलिक रूप से अनिवार्य मॉडल कंप्यूटिंग में डिफ़ॉल्ट है, और यहां रहने के लिए है। लेकिन इसका मतलब यह नहीं है कि कार्यात्मक प्रोग्रामिंग इसके शीर्ष पर सह-अस्तित्व में नहीं है। और यदि ऐसा है, तो यह अनिवार्य है कि एफपी कोड को समय-समय पर अंतर्निहित मॉडल तक नीचे गिराना पड़े। मुझे नहीं लगता कि इसका मतलब यह होना चाहिए कि हम अपने हाथों को फेंक दें और इसके सभी सिंटैक्स कहें, और केवल फ़ंक्शन/रिटर्न का उपयोग करें।

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

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

वैसे भी। मैं अपने सुझाए गए सहायक फ़ंक्शन का उपयोग करूंगा, और अन्य लोग भी अब इसका उपयोग करने के लिए स्वतंत्र हैं। मैं आपके परीक्षण-धावक समाधान की प्रतीक्षा कर रहा हूं, लेकिन इस बीच, मुझे नहीं पता कि यह विशेष रूप से उत्पादक होने जा रहा है कि हम एक-दूसरे को अपने स्वयं के विचारों को समझाने की कोशिश करते रहें कि वाक्यविन्यास क्या महत्वपूर्ण है या नहीं, जैसे कि वहाँ एक तरीका है। मुझे तीर पसंद हैं, और आपको कार्य पसंद हैं। मैंने ऐसा कोई ठोस तर्क नहीं देखा जो मेरे विचार को बदल दे। मैं एक के लिए खुला हूं, लेकिन घुटने के झटके से बेहतर सोचा जाना चाहिए जैसे: "बस फ़ंक्शन का उपयोग करें, wtf" या "आप अभी भी अधिक वर्बोज़ _syntax_ के साथ fp कर सकते हैं"।

समस्या को दूसरे तरीके से हल करें, और फिर किसी को भी when का उपयोग करने की आवश्यकता नहीं है। निफ ने कहा। :-)

मुझे नहीं लगता कि इसका मतलब यह होना चाहिए कि हम अपने हाथों को फेंक दें और इसके सभी सिंटैक्स कहें, और केवल फ़ंक्शन/रिटर्न का उपयोग करें।

मुझे तीर पसंद हैं, और आपको कार्य पसंद हैं।

... यह घुटने के झटके से अधिक सोचा जाना बेहतर था जैसे: ... "आप अभी भी अधिक वर्बोज़ सिंटैक्स के साथ fp कर सकते हैं"।

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

मुझे पूरा यकीन है कि this पूरी तरह से पैरामीटर के साथ बदलने के लिए मोचा के शीर्ष पर एक वैकल्पिक इंटरफ़ेस बनाना संभव है। मैं केवल यह स्पष्ट करना चाहता हूं कि यदि आप लिखित परीक्षाओं में एफपी जाना चाहते हैं तो आपको मोचा के this को तीर कार्यों में पास करने के तरीके के साथ आने के अलावा और कुछ करना होगा। हालाँकि, मैं उस तरह की चुनौती के लिए बहुत उत्साहित हूँ। ;^)

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

वर्तमान में, क्या इस समय की तुलना में प्रति परीक्षण एक कस्टम टाइमआउट घोषित करने का कोई अन्य तरीका है?

दुर्भाग्य से, मुझे पूरा यकीन है कि ऐसा नहीं है; मेरे सिर के ऊपर से it लिए एक अतिरिक्त पैरामीटर स्वीकार करने का सुझाव जो कॉन्फ़िगरेशन सेटिंग्स का एक कुंजी-मूल्य मानचित्र (जेएस ऑब्जेक्ट के रूप में) होगा, मोचा में एक सभ्य भविष्य के समाधान की तरह लगता है, अगर कोई चाहता है इसे लागू करने का प्रयास करें।

वर्तमान में, क्या इस समय की तुलना में प्रति परीक्षण एक कस्टम टाइमआउट घोषित करने का कोई अन्य तरीका है?

दुर्भाग्य से, मुझे पूरा यकीन है कि ऐसा नहीं है;

इस विवरण की पुष्टि करने के लिए धन्यवाद। यह उस बिंदु को मजबूत करता है जो मैं बना रहा था।

मेरे सिर के ऊपर से एक अतिरिक्त पैरामीटर को स्वीकार करने का सुझाव जो कॉन्फ़िगरेशन सेटिंग्स का एक कुंजी-मूल्य मानचित्र (जेएस ऑब्जेक्ट के रूप में) होगा, मोचा में एक सभ्य भविष्य के समाधान की तरह लगता है, अगर कोई इसे लागू करने का प्रयास करना चाहता है।

अधिक सामान्य समाधान के लिए +1।

हालांकि मैं जो बता सकता हूं, वह अभी भी एक पैरामीटर को पारित करने के लिए व्यावहारिक लगता है। this को done कॉलबैक के साथ संयोजित करें (इसलिए this एक फ़ंक्शन बन जाता है)। फिर मोचा ने प्रत्येक परीक्षण को एक वादे के साथ लपेटा है (ठीक है, दो वास्तव में, एक टाइमआउट को संभालने के लिए, और एक वास्तव में परीक्षण चलाने के लिए), पैरामीटर गणना की परवाह किए बिना (आज यह कैसे काम करता है)। यह तब जाँच कर सकता था कि समारोह का परिणाम एक वादा था या नहीं। यदि नहीं, तो परीक्षण को अंतिम रूप देने के लिए सिंक्रोनस फ़ंक्शन के वापस आने के बाद done पर कॉल करें। यदि फ़ंक्शन का परिणाम इसके बजाय एक वादा है, तो इसके हल होने (या अस्वीकार करने) की प्रतीक्षा करें। यदि टाइमआउट होता है, तो परीक्षण बंद कर दें (पहले जैसा ही)। उस मामले में जहां एक परीक्षण done पर कॉल करने और एक वादा वापस करने का प्रबंधन करता है। या तो किया गया संकल्प से पहले कहा जाता है, इस मामले में मोचा को वादे की प्रतीक्षा करनी चाहिए और फिर अस्पष्ट पूर्णता अनुक्रम होने के लिए परीक्षण में विफल होना चाहिए। या किया गया संकल्प के कुछ समय बाद कहा जाता है, जिस स्थिति में किसी तरह परीक्षण को पूर्वव्यापी रूप से विफल होना चाहिए - या समस्या ने किसी अन्य उचित तरीके से संकेत दिया। क्षमा करें, यह बहुत व्यापक स्ट्रोक है, लेकिन यह मेरे बाहरी व्यक्ति की समझ है कि मोचा क्या करने की कोशिश कर रहा है और इसमें चल रही विचित्रताएं हैं। अन्य कौन से विचार इसे एक व्यावहारिक समाधान होने से रोक सकते हैं?

यदि आप लिखित परीक्षा में एफपी जाना चाहते हैं तो आपको मोचा को तीर कार्यों में पास करने के तरीके के साथ आने के अलावा और भी कुछ करना होगा

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

उस ने कहा, मैं जानना चाहता हूं कि आप आने वाली बाधाओं के रूप में और क्या देखते हैं जो विशेष रूप से मोचा के साथ करना है (जैसा कि सामान्य रूप से एफपी में लेखन परीक्षण का मतलब हो सकता है)।

हालांकि, मैंने जो कहा, वह इसके बिल्कुल विपरीत है

मुझे खेद है अगर मैंने गलत व्यवहार किया या गलत समझा। मैंने जो कुछ लिखा है, उसके लिए, मुझे यकीन नहीं है कि मैं उत्तरों के आधार पर, जैसा कि इरादा था, वैसा ही हो रहा था। जो दुर्भाग्यपूर्ण है, क्योंकि मुझे लगता है कि अगर हम इसके लिए नीचे उतर गए, तो हम शायद _theory_ में एफपी _शोल्ड_ की तरह दिखने पर काफी करीबी समझौते पर आ जाएंगे। हालांकि ऐसा लगता है, हम इस बात से असहमत हैं कि कम से कम कुछ उपयोगकर्ताओं/उपयोग-मामलों के लिए, आज मोचा की वर्तमान में उपलब्ध रिलीज में _practice_ में एक व्यावहारिक कमी कैसी दिख सकती है। इसलिए मुझे पूरी तरह से यकीन नहीं है कि आपके द्वारा प्रस्तावित प्रस्तावित ऐड-ऑन फ़ंक्शन के साथ प्रमुख मुद्दा क्या है।

(उद्धृत और क्रम में उत्तर दिया, लेकिन यकीनन अधिक महत्वपूर्ण सामान बाद में पहले की बजाय है।)

हालांकि मैं जो बता सकता हूं, वह अभी भी एक पैरामीटर को पारित करने के लिए व्यावहारिक लगता है। इसे किए गए कॉलबैक के साथ संयोजित करें (ताकि यह एक फ़ंक्शन बन जाए)। फिर... कौन से अन्य विचार इसे एक व्यावहारिक समाधान होने से रोक सकते हैं?

यदि हम पीछे की ओर संगतता तोड़ते हैं, तो ऐसे सरल डिज़ाइन हैं जिन पर हम स्विच कर सकते हैं।

यदि हम पश्चगामी संगतता रखते हैं, तो इन दोनों परीक्षणों को पास करने की आवश्यकता है न कि समय समाप्त होने पर:

it("runs immediately", () => {
  // call functions and assert whatever
})
it("runs asynchronously", doneWithSomeOtherName => {
  setTimeout(() => {
    // call functions and assert whatever
    doneWithSomeOtherName()
  }, 100)
})

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

it("looks just like an asynchronous test with a different name for `done`, but never tells Mocha it's done", context => {
  context.configureByMutation("some value")
  // call functions and assert whatever
})

लेकिन साथ ही, वहां उत्परिवर्तन पर ध्यान दें। इस पर और नीचे।

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

:+1:!

उस ने कहा, मैं जानना चाहता हूं कि आप आने वाली बाधाओं के रूप में और क्या देखते हैं जो विशेष रूप से मोचा के साथ करना है (जैसा कि सामान्य रूप से एफपी में लेखन परीक्षण का मतलब हो सकता है)।

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

it("imperatively sets the timeout multiple times", function(done) {
  this.timeout(5000)
  var context = this
  setTimeout(function() {
    context.timeout(1000)
    setTimeout(done, 500)
  }, 4000)
})

...लेकिन आपको नहीं करना है। गैर-कार्यात्मक भाषाओं में कार्यात्मक रूप से प्रोग्रामिंग के इतने सारे तत्वों के साथ: अनिवार्य सामग्री का दुरुपयोग न करें।

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

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

मुझे शायद इस स्पर्शरेखा पर इतनी दूर भी नहीं जाना चाहिए था; समाधान से संबंधित नीचे देखें। मैं

इसलिए मुझे पूरी तरह से यकीन नहीं है कि आपके द्वारा प्रस्तावित प्रस्तावित ऐड-ऑन फ़ंक्शन के साथ प्रमुख मुद्दा क्या है।

(यहां भी महत्वपूर्ण हिस्सा :) वैसे मुझे वह बिट पसंद है जहां यह एक विधि कॉल के बजाय पैरामीटर के रूप में timeout लेता है, वास्तव में! यदि आप मोचा की बाकी कॉन्फ़िगरेशन विधियों को सामान्य बनाने के तरीके के साथ आ सकते हैं (उनमें से बहुत सारे हैं - और कुछ सिंक्रोनस परीक्षणों पर लागू होते हैं यदि मुझे सही याद है, इसलिए हम केवल उसी तरीके को क्यों नहीं जोड़ सकते हैं properties done और लोगों को एसिंक्रोनस परीक्षण लिखने देते हैं जो done माध्यम से कॉन्फ़िगरेशन को कॉल कर सकते हैं, लेकिन मैं पचाता हूं), तो मैं निश्चित रूप से इसे देखना चाहता हूं। कम से कम हम इसे एक सिफारिश बनाना चाहते हैं, और हम तीसरे पैरामीटर (या ऐसा कुछ, शायद it.configured या it(...).configured(...) पारित होने पर कार्यान्वयन को it में अपनाने में सक्षम हो सकते हैं। it(...).configured(...) अगर हम अधिक संख्या में पैरामीटर नहीं चाहते हैं ...) - जो मुझे लगता है कि एक पिछड़ा-संगत समाधान होगा जो अंतर्निहित उत्परिवर्तन/अनिवार्य मामले से निपटता है और तीर फ़ंक्शन समर्थन प्राप्त करता है "दाएं रास्ता" (जो मैं बहस कर रहा हूं वह वैसे भी है): क्योंकि यह नए व्यवहार के अनुकूल है। मुझे लगता है कि वर्कअराउंड में this बाद जाने के बजाय मुझे जो कहना चाहिए था, वह है: आइए इसके पैरामीटर भाग का विस्तार करें!

मैं कसम खाता हूँ मैंने कहीं पढ़ा है आप ऐसा कुछ कर सकते हैं:

describe('a slow thing', () => {
 // test code...
}).timeout(5000);

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

@ थॉम-निक यह काम करता है! मुझे लगता है कि यह समझ में आता है क्योंकि मोचा के सभी कार्य इसका संदर्भ देते हैं

return this;

तीर फ़ंक्शन फॉर्म को सामान्य फ़ंक्शन के साथ बदलते समय यह मेरे साथ काम करता है

समारोह() { ..... }

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

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

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

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

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

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

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

तो शायद मैं इस तरह के परीक्षणों का एक गुच्छा लिखता हूं, और सब कुछ _seems_ काम कर रहा है:

it('does something', function() {
  testProcedureFunction('something','1')
})

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

परीक्षण निश्चित रूप से वापसी के साथ इस तरह दिखना चाहिए:

it('does something', function() {
  return testProcedureFunction('something','1')
})

अब मुझे पता है कि यह परीक्षण ज्यादातर मामलों में एक लाइन होने वाला है। वास्तव में, प्रत्येक केस एक लाइन होगा, सिवाय इसके कि जब इनपुट ऐसे हों कि एक बड़े टाइमआउट की आवश्यकता हो। अब शास्त्रीय जेएस फ़ंक्शन और तीरों के बीच अंतर के बीच, तीर फ़ंक्शंस का एक विशेष पहलू है जो यहां उपयोगी है: ब्रेसिज़ को छोड़े जाने पर एक सिंगल स्टेटमेंट एरो फ़ंक्शन में एक निहित रिटर्न होता है। यदि function {...} लिखने के बजाय, एक परीक्षण => ... का उपयोग करता है, तो मैं उन मामलों को तीर और घुंघराले ब्रेसिज़ की कमी के लिए आसानी से स्कैन कर सकता हूं, और जल्दी से अनुमान लगा सकता हूं कि उनके पास यह लापता return नहीं हो सकता है

इस तरह:

it('does something', () => testProcedureFunction('something','1'))

अब क्या होगा यदि इनमें से किसी एक मामले में दूसरों की तुलना में अधिक समय लगता है! हम निश्चित रूप से इस तरह टाइमआउट सेट कर सकते हैं:

it('does something slow', function() {
  this.timeout(10000)
  return testProcedureFunction('somethingSlow','2')
})

या शायद कोई गलती करेगा और इसे पहले करेगा (जो निश्चित रूप से काम नहीं करता है):

it('does something slow', () => {
  this.timeout(10000)
  return testProcedureFunction('somethingSlow','2')
})

लेकिन अब हम वापस आ गए हैं जहां हमने शुरू किया था, कोडबेस में दोहराने के लिए एक पैटर्न पका हुआ है, जो लापता रिटर्न बग के लिए अतिसंवेदनशील है (या तो भविष्य में मैं, या अगला व्यक्ति एक सुविधा जोड़ने के लिए - बिंदु यह है, यह एक आसान है गलती करने पर, यह किसी का ध्यान नहीं जा सकता है, और इसे ट्रैक करना कठिन हो सकता है)। when फ़ंक्शन इसे हल करता है, और हमें लगातार फिर से तीरों का उपयोग करने देता है:

it('does something slow', when(() => testProcedureFunction('somethingSlow','2'), 10000))

(ध्यान दें, मैं काम करने के लिए ऊपर .timeout(5000) डॉट-चेनिंग सुझाव प्राप्त करने में सक्षम नहीं था, हो सकता है कि मोचा के संस्करण के कारण मुझे उपयोग करने की आवश्यकता हो, मुझे अब और याद नहीं है, वह एक देगा प्रयत्न!)
(नोट 2, ध्यान दें कि when का उपयोग this पैरामीटर उत्थापन चाल का उपयोग नहीं कर रहा है - यह वास्तव में केवल एक विचार के बाद था)।

हो सकता है कि ऐसे लिंटर हों जो लापता रिटर्न-फॉर-वादे बग को ध्वजांकित कर सकते हैं (या शायद अधिक वास्तविक रूप से, प्रत्येक फ़ंक्शन के लिए rhs के साथ रिटर्न स्टेटमेंट लागू करना)। हालांकि उस समय यह एक विकल्प नहीं था, साथ ही मुझे लगता है कि तीर वाक्यविन्यास छोटा हो जाता है और मुझे इसे (व्यक्तिपरक रूप से/व्यक्तिगत रूप से) पढ़ने और काम करने में आसान लगता है, जिसने मेरे लिए function से तराजू को दूर कर दिया .

इसलिए यह अब आपके पास है।

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

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

https://hacks.mozilla.org/2015/06/es6-in-depth-arrow-functions/

@ थॉम-निक यह it पर काम करता है, लेकिन describe ।

describe('my test suite', () => {

  it('test case 1', () => {
    // ...
  }).timeout('10s');  // Works on `it`. This test case doesn't timeout

  it('test case 2', () => {
    // ...
  });  // This test case timeouts.

}).timeout('10s');  // Doesn't work on `describe`. Tests are already created when runs to here.

@ थॉम-निक, आप सामान्य फ़ंक्शन फॉर्म का उपयोग कर सकते हैं

describe('my test suite', function() {
this.timeout(n);

...
}

इसके बारे में शिकायत करने वाला कोई भी व्यक्ति तीर के कार्यों को नहीं समझता है।

एरो फ़ंक्शंस कोई नई फैंसी ES6 चीज़ नहीं है जो क्लासिक function () {} को बदलने वाली है। एरो फ़ंक्शंस का एकमात्र उद्देश्य यह है कि इसे अपने माता-पिता से this विरासत में मिला है, जहां क्लासिक function () का अपना this ।

हां, पूर्ण ES6 सिंटैक्स का उपयोग करते समय भी, आपको अभी भी function () का उपयोग करना चाहिए यदि आप अपने फ़ंक्शन के सही संदर्भ में this का उपयोग करना चाहते हैं। आप जो करने की कोशिश कर रहे हैं उसके आधार पर आपको अपने ES6 एप्लिकेशन में function () और () => दोनों का उपयोग करना चाहिए।

this.timeout() it('....', () => { ... }) साथ काम नहीं करता है क्योंकि कॉलबैक this को पैरेंट describe() फ़ंक्शन से इनहेरिट कर रहा है, जिसमें this.timeout() नहीं है उस स्तर पर समझो।

क्या लैम्ब्डा फ़ंक्शन आपको कॉल में घोषित किए बिना फ़ंक्शन को स्वचालित रूप से एक तर्क भेजने की अनुमति नहीं देते हैं?

(परम) => एक समारोह
... तब (एक समारोह)

फ़ंक्शन () {} 'इस' के लिए बाध्य हो सकता है लेकिन () => 'लॉक इन' है

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

मैं यहां तक ​​​​कहूंगा कि कभी भी फ़ंक्शन() का उपयोग न करें जब तक कि आप 'यह' इसे लागू करते समय 'यह' के अलावा कुछ और न हों।

@ फ्लेमेंको ...

क्या लैम्ब्डा फ़ंक्शन आपको कॉल में घोषित किए बिना फ़ंक्शन को स्वचालित रूप से एक तर्क भेजने की अनुमति नहीं देते हैं?

मुझे यकीन नहीं है कि मैं _बिल्कुल_ समझता हूं कि आप इसे कैसे रख रहे हैं।
जहाँ तक "फ़ंक्शन में तर्क भेजना" है, वसा तीर एक अपवाद के साथ नियमित कार्यों की तरह ही काम करते हैं: यदि आपके पास बिल्कुल 1 तर्क है, तो आप कोष्ठक छोड़ सकते हैं।

() => console.log("hi"); //zero arguments requires empty parenthesis
a => console.log(a); //you can optionally leave the parenthesis off for 1 argument
(a,b) => console.log(`${a} ${b}`); //2..n arguments requires parenthesis

आपको जो मिल रहा है, वह यह है कि जब तक आपका फ़ंक्शन एकल अभिव्यक्ति है, तब तक मोटे तीर आपको घुंघराले ब्रेसिज़ और return कीवर्ड को छोड़ कर _return_ एक मान की अनुमति देते हैं।
तो अगर आपके पास...

setTimeout(function(a,b) { doSomething(); return calculateSomething(a,b); }, 5000);

... और आप इसे एक फैट एरो फंक्शन में बदलना चाहते थे, आप कर्ली ब्रेसेस और रिटर्न कीवर्ड को हिला नहीं पाएंगे क्योंकि फंक्शन बॉडी में कई स्टेटमेंट हैं। आप इसे इस तरह करेंगे ...

setTimeout((a,b) => { doSomething(); return calculateSomething(a,b); }, 5000);

यदि, बल्कि आपने शुरुआत की है...

setTimeout(function(a,b) { return calculateSomething(a,b); }, 5000);

... तो आप एक ऐसे फ़ंक्शन से निपट रहे हैं जो इतना आसान है कि यह केवल एक अभिव्यक्ति देता है और आप इसका उपयोग कर सकते हैं ...

setTimeout((a,b) => calculateSomething(a,b), 5000);

इसे पढ़ना बहुत आसान हो गया!
मैंने इसके बारे में codefoster.com/levelup-arrays पर कुछ और लिखा।

जावास्क्रिप्ट में कई अलग-अलग कोडिंग शैलियाँ हैं - OOP से FP तक, सख्त टाइप-सेफ्टी से लेकर मिक्सिन/डक-टाइपिंग तक। इसके अलावा, उन शैलियों में से प्रत्येक में उन्नत पैटर्न हैं (यानी ओओपी शिविर में निर्भरता इंजेक्शन, एफपी शिविर में करी/मोनाड)।

यदि आपकी कोडिंग शैली एफपी के करीब है जहां this का उपयोग नहीं किया जाता है और बॉयलरप्लेट को कम करने के लिए तीर फ़ंक्शन का उपयोग किया जाता है, तो this को संरक्षित करना किसी भी उन्नत परीक्षण के लिए एक अतिरिक्त ओवरहेड है (उदाहरण के लिए पैरामीटरयुक्त परीक्षण, बनाना डीएसएल)।

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

मुझे एक वैकल्पिक bdd इंटरफ़ेस का विचार पसंद है जो this उपयोग नहीं करता है और इसके बजाय describe , it पैरामीटर के रूप में संदर्भ वस्तु सामान्य रूप से पास करता है

लेकिन इसे लागू करना इतना आसान नहीं है, IIRC। हालांकि एक प्रयास देखने के लिए अच्छा होगा।

मुझे पता है कि यह गंभीर साइड-इफेक्ट्स भूमि में हो रहा है, लेकिन क्या आप इस तरह से किए गए या संदर्भ पैरामीटर से निपट नहीं सकते?

it("runs immediately", () => {
  // call functions and assert whatever
})

it("runs asynchronously", doneOrContext => {
  setTimeout(() => {
    // call functions and assert whatever
    doneOrContext();
  }, 100)
})



md5-b1fe6f00c87a2916712cf6a4df16e142



it("runs immediately using the parameter as a context", doneOrContext => {
  doneOrContext.configureByMutation("some value");
  // As well as changing config, also flags to Mocha that this test is treating the
  // parameter as a context object and is therefore not async.
  // Call functions and assert whatever
})



md5-b1fe6f00c87a2916712cf6a4df16e142



it("runs asynchronously using the parameter as a context", doneOrContext => {
  doneOrContext.configureByMutation("some value");
  doneOrContext.setAsync(); // Flags to Mocha that even though the parameter has been used as
  // a context object, the test is in fact asynchronous.
  setTimeout(() => {
    // call functions and assert whatever
    doneOrContext();
    // or doneOrContext.done()
  }, 100)
})

मैंने नीचे दी गई स्क्रिप्ट का उपयोग किया लेकिन मुझे वही टाइमआउट त्रुटि से अधिक हो गया।

माइस्क्रिप्ट:

वर्णन करें ("getBillingDetail", async फ़ंक्शन (){
यह। समयबाह्य (55000);
it.only ("चेक दिया गया वैध जॉबनाम", async फ़ंक्शन (किया गया) {
यह। समयबाह्य (55000);
वर परिणाम = प्रतीक्षा url.getBillingDetail('12254785565647858');
कंसोल.लॉग (परिणाम);
जोर दें। बराबर (परिणाम, सत्य);
});
});

त्रुटि: 55000ms का समय समाप्त हो गया। एसिंक्स परीक्षण और हुक के लिए, सुनिश्चित करें कि "किया ()" कहा जाता है; यदि कोई वादा लौटा रहा है, तो सुनिश्चित करें कि वह हल हो गया है।

किसी async फ़ंक्शन के लिए किया गया कॉलबैक पास न करें

मैंने एक प्रोटोटाइप समाधान बनाया है जो पीछे की ओर संगत है। अभी के लिए यह एक अलग मॉड्यूल है, लेकिन कार्यक्षमता को आसानी से mocha उचित में विलय किया जा सकता है।

https://github.com/papercuptech/mocha-lambda

तेज तरीका

require('mocha-lambda')
// now a global '_tst' can be used where 'this' was before

describe('suite', () => {
  beforeEach(() => {
    _tst.answer = 42
  })

  it('provides "this" as "_tst"', function() {
    assert(this === _tst)
  })

  it('works', () => {
    assert(_tst.answer === 42)
    _tst.skip()
  })
})

स्पष्ट नामकरण के लिए (और टाइपस्क्रिप्ट के साथ काम करता है)

// if you were previously explicitly importing api (describe, it, etc.) from 'mocha',
// you will have to change to importing from 'mocha-lambda', until (or if) this
// gets merged into mocha proper
import ctx, {describe as d, it as i} from 'mocha-lambda'

d('suite', () => {
  // ctx() is a function that returns "this" as appropriate
  i('works using ctx()', () => {
    ctx().skip()
  })
})

import {Context} from 'mocha'
// ctx() can also rename global
ctx('t')
declare var t: Context
d('suite', () => {
  // ctx() is a function that returns "this" as appropriate
  i('works using renamed global', () => {
    t.skip()
  })
})

@papercuptech लिंक 404 नहीं मिला है।

वूप्स .. निजी रेपो था। अब सार्वजनिक

npm i mocha-lambda . भी कर सकते हैं

@aleung @linesh-simplicity, इसे #3485 . से हटा दिया गया है

धन्यवाद।

इतने सारे "जादू" क्यों, अंत में, समस्याएं पैदा करते हैं? यह क्यों नहीं ?:

var mocha = require('mocha');

mocha.describe('foo', (suite) => {
  suite.timeout(100);

  suite.it('must love bar', () => ... );  
});

कोई ग्लोबल्स नहीं, कोई समस्याग्रस्त जादू नहीं ... लेकिन सिर्फ जावास्क्रिप्ट।

@ थॉम-निक उत्तर देखें, साफ करें और चाल चली

मैं कसम खाता हूँ मैंने कहीं पढ़ा है आप ऐसा कुछ कर सकते हैं:

describe('a slow thing', () => {
 // test code...
}).timeout(5000);

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

@ थॉम-निक समाधान ने मेरे लिए काम किया, धन्यवाद!