Mocha: नेस्टेड सुइट्स/संदर्भों में `पहले प्रत्येक` और `आफ्टरएच` चल रहे हैं

जिज्ञासु लोगों के लिए, यह मेरे उपयोग के मामले का समाधान है:

// Before anything else is run
before(function () {
  // Iterate over all of the test suites/contexts
  this.test.parent.suites.forEach(function bindCleanup (suite) {
    // Attach an afterAll listener that performs the cleanup
    suite.afterAll(function cleanupContext () {
      var key;
      for (key in this) {
        delete this[key];
      }
    });
  });
});

+1

afterEach प्रत्येक Runnable उदाहरण के बाद चलता है; आपके मामले में, एक it() ब्लॉक। यदि आप नेस्टेड व्यवहार नहीं चाहते हैं, तो अपने परीक्षणों को नेस्ट न करें। इस व्यवहार को बदलना मेज पर नहीं है।

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

साथ ही, this 90% समय पर कुछ भी डालना आवश्यक नहीं है।

describe('A banana', function () {
  var banana;

  before(function () {
    banana = new Banana();
  });

  describe('when peeled', function () {
    var peeledBanana;

    beforeEach(function () {
      // I'm assuming peel() has no side-effects since it returns a new object.
      peeledBanana = banana.peel();
    });

    it('is white', function () {
      assert.strictEqual(peeledBanana.color, 'white');
    });

    it('is soft', function () {
      assert.strictEqual(peeledBanana.hardness, 'soft');
    });
  });
});

क्या इसके () स्तर के बजाय वर्णन () स्तर में हुक विधियों को चलाने का कोई तरीका है? यह कुछ परिदृश्यों में उपयोगी हो सकता है।

@RathaKM उपयोग का मामला क्या है?

सुनिश्चित नहीं है कि यह एक अच्छा उदाहरण है, लेकिन क्या इसके लिए निम्नलिखित एक अच्छा उपयोग मामला होगा? @RathaKM सही करने के लिए स्वतंत्र महसूस करें।

describe('A banana', function () {
  var banana;

  beforeEach(function () {
    banana = new Banana();
  });

  describe('when peeled', function () {
    var peeledBanana;

    before(function () {
      // Lets assume peel() HAS side-effects and doesn't return a new object.
      banana.peel();
      peeledBanana = banana;
    });

    it('is white', function () {
      assert.strictEqual(peeledBanana.color, 'white');
    });

    it('is soft', function () {
      assert.strictEqual(peeledBanana.hardness, 'soft');
    });
  });

  describe('when set on FIRE', function () {
    var flamingBanana;

    before(function () {
      // Same assumption as above
      banana.setOnFire();
      flamingBanana = banana
    });

    it('is hot', function () {
      assert.isAbove(flamingBanana.temperature, 9000);
    });
  });
});

@cpoonolly : आपकी टिप्पणियों के लिए धन्यवाद और इसे वापस लाएं। :) आपका उदाहरण वह है जो तार्किक रूप से वर्णन स्तर (पहले से) में काम करने की अपेक्षा करता है। लेकिन, यह प्रत्येक विवरण के भीतर 'पहले ()' के साथ हासिल किया जा सकता है।

मैं जिस मुद्दे का सामना कर रहा था वह नीचे दिए गए उदाहरण में दिया गया है।

var testData = [{country: 'NIL'}],
dataDriven = require('data-driven'),
assert = require('assert');

describe('@Testing_For_Describe_Level_Hook_Method_To_Update_TestData@', function () {

    describe('<strong i="8">@Updated</strong> testData for US@', function () {
        before(function (done) {
            testData = [{country: 'US'}];
            done();
        });
        dataDriven(testData, function () {
            it('expecting updated testData for US', function (ctx, done) {
                assert.equal(ctx.country, 'US');
                done();
            });
        });
    });

    describe('<strong i="9">@Updated</strong> testData for UK@', function () {
        before(function (done) {
            testData = [{country: 'UK'}];
            done();
        });
        dataDriven(testData, function () {
            it('expecting updated testData for UK', function (ctx, done) {
                assert.equal(ctx.country, 'UK');
                done();
            });
        });
    });
});

यहां, परीक्षण सूट विफल हो जाएगा। हम _testData_ को 'पहले ()' हुक विधि के भीतर अपडेट करते हैं जिसे '_it_' ब्लॉक से ठीक पहले कहा जाएगा। लेकिन, हम _dataDriven()_ के भीतर _testData_ वेरिएबल का उपयोग करते हैं जिसे '_it_' ब्लॉक को निष्पादित करने से पहले निष्पादित किया जाएगा।

इसलिए, हमें यहां _'it'_ ब्लॉक निष्पादन शुरू होने से पहले वेरिएबल को अपडेट करने के लिए एक जगह की आवश्यकता है। हो सकता है कि हमें 'डिस्क्राइब' ब्लॉक (डिस्क्राइब लेवल हुक मेथड) से ठीक पहले _before()_ हुक मेथड एक्जीक्यूशन की जरूरत हो।

आशा है, अब मामला स्पष्ट हो गया है।

क्‍या इस पर कोई अतिरिक्‍त चर्चा हुई है?

ऐसा कुछ प्राप्त करना क्यों संभव नहीं है?

describe('Create Article', () => {
  beforeEach(() => console.log('CLEAN DB'))

  context('When Article is valid', () => {
    before(() => console.log("INSERTING VALID ARTICLE"))

    it('should not fail')
    it('should have some properties')    
    it('should send an email')  
  })

  context('When Article is not valid', () => {
    before(() => console.log("INSERTING NOT VALID ARTICLE"))

    it('should fail')
    it('should not send an email')  
  })
})

• प्रत्येक context ब्लॉक से पहले DB को साफ करें।
• सभी it ब्लॉक से पहले परिदृश्य सेट करें

क्या यह कानूनी उपयोग का मामला नहीं है?

@ marqu3z मैं आपके उपयोग के मामले का पालन करने की कोशिश कर रहा हूं। यह वैध है। ऐसा लगता है कि समस्या यह है: पहले वाला हुक पहले के हुक से पहले चलता है? लेकिन आपको पहले वाले हुक के बाद चलाने के लिए पहले हुक की आवश्यकता है?

(क्या आप वास्तव में प्रत्येक टेस्ट केस के लिए डीबी को साफ करना चाहते हैं? ऐसा लगता है कि केवल आपका पहला टेस्ट केस ही सफल होगा, अन्य के पास कोई डेटा नहीं होगा। लेकिन मुझे लगता है कि आप प्रत्येक टेस्ट केस के लिए डीबी को साफ करना चाहते हैं)।

मोचा दिए गए आपके उपयोग के मामले को हल करने के मेरे दो प्रयास यहां दिए गए हैं:

(1) पहले का उपयोग करें, लेकिन एक बूलियन फ्लिप करें, इसलिए पहले वाला केवल एक बार चलता है (यह थोड़े बेकार है)

describe('Create Article', () => {
  beforeEach(() => console.log('CLEAN DB'))

  context('When Article is valid', () => {
    let flip = true;
    beforeEach(() => flip && (flip = false; console.log('INSERTING VALID ARTICLE')))

    it('should not fail')
    it('should have some properties')    
    it('should send an email')  
  })

  context('When Article is not valid', () => {
   let flip = true;
    beforeEach(() => flip && (flip = false; console.log('INSERTING NOT VALID ARTICLE')))

    it('should fail')
    it('should not send an email')  
  })
})

(2) ऐसा करने का दूसरा तरीका - यह ज्यादा बेहतर नहीं है!

describe('Create Article', () => {

  let cleanDB = function(fn){
    return function(done){
        actuallyCleanDB(function(err){
            if(err) return done(err);
            fn(done);
       });
    }
  };

  context('When Article is valid', () => {
    before(() => console.log('INSERTING VALID ARTICLE'))
    it('should not fail', cleanDB(function(done){})
    it('should have some properties', cleanDB(function(done){}))    
    it('should send an email', cleanDB(function(done){})) 
  })

  context('When Article is not valid', () => {
    before(() => console.log('INSERTING NOT VALID ARTICLE')))
    it('should fail', cleanDB(function(done){}))
    it('should not send an email',cleanDB(function(done){}))  
  })
})

कृपया मुझे बताएं कि क्या मैं आपकी समस्या को समझता हूं, और मैं समाधान के बारे में सोचने के लिए और चक्र बिताऊंगा। मेरा कोई भी समाधान बहुत अच्छा नहीं है, लेकिन मैं केवल यह सुनिश्चित करना चाहता हूं कि मैं आपकी समस्या को समझूं।

@RathaKM

क्या आप अपने it() परीक्षण मामलों को अतुल्यकालिक रूप से पंजीकृत कर रहे हैं? यदि ऐसा है तो इसकी अनुमति नहीं है। आपको describe/after/afterEach/before/beforeEach सभी समकालिक रूप से पंजीकृत करना होगा।

// event loop tick X
 dataDriven(testData, function () {
     // it() must be called in the same event loop tick as X above
        it('expecting updated testData for UK', function (ctx, done) {
            assert.equal(ctx.country, 'UK');
            done();
       });
  });

भी, ctx कहाँ से आ रहा है? हो सकता है कि मैं नवीनतम मोचा सुविधाओं पर अप-टू-डेट नहीं हूं, लेकिन मैंने कभी नहीं देखा

it(foo, function(ctx, done){
   // where is ctx coming from?
});

मैं ठीक उसी परिदृश्य में हूं @ marqu3z वर्णित है। describe स्तर beforeEach लिए समर्थन देखना पसंद करेंगे

इस सामान्य परिदृश्य वाले सभी लोगों के लिए मैंने यह सहायक फ़ंक्शन बनाया है जो वर्तमान ब्लॉक में सभी सुइट्स पर पुनरावृत्त करता है और उनमें से प्रत्येक के लिए beforeAll हुक जोड़ता है:

function beforeEachSuite (fn) {
  before(function () {
    let suites = this.test.parent.suites || []
    suites.forEach(s => {
      s.beforeAll(fn)
      let hook = s._beforeAll.pop()
      s._beforeAll.unshift(hook)
    })
  })
}

यह लगभग एक साल पहले मेरे द्वारा वर्णित उपयोग के मामले को अनलॉक करता है:

describe('Create Article', () => {
  beforeEachSuite(() => console.log('CLEAN DB'))

  context('When Article is valid', () => {
    before(() => console.log("INSERTING VALID ARTICLE"))

    it('should not fail')
    it('should have some properties')    
    it('should send an email')  
  })

  context('When Article is not valid', () => {
    before(() => console.log("INSERTING NOT VALID ARTICLE"))

    it('should fail')
    it('should not send an email')  
  })
})

अभी भी यह नहीं मिलता है कि इस उपयोग के मामले को उपयोगी या वैध क्यों नहीं माना जाता है।
हो सकता है कि इस समाधान को beforeEachSuite और afterEachSuite पीआर में बदला जा सके

हाँ कृपया हमें इसकी आवश्यकता है।

https://github.com/mochajs/mocha/issues/911#issuecomment -316736991 जैसे कई उपयोग के मामले हैं

+1

+1

मैं इस धागे पर कुछ इसी तरह की तलाश में ठोकर खाई। तो इस पोस्ट पर ठोकर खाने वाले किसी और के लिए ...

मैंने उस दृष्टिकोण को अनुकूलित किया है जिसे @marqu3z ने अपने स्वयं के एनपीएम पैकेज में उल्लिखित किया है: mocha-suite-hooks ।

इसलिए यदि आप स्वयं को ऐसी स्थिति में पाते हैं जहां before पर्याप्त नहीं है, और beforeEach बहुत अधिक है, तो beforeSuite आज़माएं।

पैकेज अभी भी बहुत कच्चा है, इसलिए किसी भी प्रतिक्रिया की बहुत सराहना की जाएगी!