चाई में उम्मीद()। To.be.true कैसे काम करता है?

Question

expect(true).to.be.true; 

इस कोड में, सभी 'to', 'be', 'true' 'उम्मीद (सत्य)' से ऑब्जेक्ट प्रतिक्रिया का गुण प्रतीत होता है।

ये गुण कैसे काम कर सकते हैं ताकि वे अपवाद उठा सकें?

Answer 1

कोड स्निपेट में true as defined देखेंगे आप स्रोत कोड की जांच कर सकते हैं:

[ 'to', 'be', 'been' 
    , 'is', 'and', 'has', 'have' 
    , 'with', 'that', 'which', 'at' 
    , 'of', 'same', 'but', 'does' ].forEach(function (chain) { 
    Assertion.addProperty(chain); 
}); 

और वहाँ एक utils में addProperty है:
https://github.com/chaijs/chai/blob/master/lib/chai/utils/addProperty.js

इसके साथ आप गुणों को अनगिनत रूप से श्रृंखलाबद्ध कर सकते हैं: .to.be.to.to.to.be.equal()

के एक सरल प्रदर्शन बनाएँ: .true() विधि

const assert = { 
    'true': function (v) { 
    return !!v 
    } 
} 

साथ,

मान लें कि आप एक assert वस्तु है कि और आप श्रृंखला .to असीम करने में सक्षम होना चाहता हूँ। सीधे शब्दों में हमारे गेटर परिभाषित करने के लिए defineProperty का उपयोग करें: तो अब

Object.defineProperty(assert, 'to', { 
    get() { 
    return assert 
    } 
}) 

आप कर सकते हैं

assert.to.to.to.to.true(false) 

काम कर कोड: https://codepen.io/CodinCat/pen/LLzBEX?editors=0012

---

मैं एक और अधिक जटिल उदाहरण यहां जोड़ दिया है: https://codepen.io/CodinCat/pen/dRVjXL?editors=0012

इस उदाहरण में आप देख सकते हैं टी .true संपत्ति में कुछ व्यवहार हैं।

हम आंतरिक __expectObj में expect() से मूल्य और __value संपत्ति की दुकान, और फिर .true की गेटर में उसका सत्यापन करें। तो तुम

expect(false).to.to.to.to.true 

Answer 2

chai Assertion के स्रोत पर नज़र डालें लेकिन टीएल; डॉ यह है कि चाई अपनी जोरदार लाइब्रेरी पर अपनी श्रृंखलाबद्ध विधियों को लागू करता है। हालांकि, नीचे दिए गए कोड में विशेष कीवर्ड सिंटैक्टिक चीनी हैं।

/** 
    * ### Language Chains 
    * 
    * The following are provided as chainable getters to improve the readability 
    * of your assertions. 
    * 
    * **Chains** 
    * 
    * - to 
    * - be 
    * - been 
    * - is 
    * - that 
    * - which 
    * - and 
    * - has 
    * - have 
    * - with 
    * - at 
    * - of 
    * - same 
    * - but 
    * - does 
    * 
    * @name language chains 
    * @namespace BDD 
    * @api public 
    */ 

    [ 'to', 'be', 'been' 
    , 'is', 'and', 'has', 'have' 
    , 'with', 'that', 'which', 'at' 
    , 'of', 'same', 'but', 'does' ].forEach(function (chain) { 
    Assertion.addProperty(chain); 
    }); 

वहाँ क्या यह वास्तव में के लिए लग रहा है से करते हैं, कीवर्ड यह विशेष रूप से परिभाषित करता है: सचमुच वे सिर्फ गुण जोड़ रहे हैं कि और श्रृंखलित जा सकती है, लेकिन कुछ भी सही मायने में परिभाषित किया गया है कर रहे हैं। तो एक उदाहरण कीवर्ड .to.be.true इसके नीचे

/** 
    * ### .true 
    * 
    * Asserts that the target is strictly (`===`) equal to `true`. 
    * 
    *  expect(true).to.be.true; 
    * 
    * Add `.not` earlier in the chain to negate `.true`. However, it's often best 
    * to assert that the target is equal to its expected value, rather than not 
    * equal to `true`. 
    * 
    *  expect(false).to.be.false; // Recommended 
    *  expect(false).to.not.be.true; // Not recommended 
    * 
    *  expect(1).to.equal(1); // Recommended 
    *  expect(1).to.not.be.true; // Not recommended 
    * 
    * A custom error message can be given as the second argument to `expect`. 
    * 
    *  expect(false, 'nooo why fail??').to.be.true; 
    * 
    * @name true 
    * @namespace BDD 
    * @api public 
    */ 

    Assertion.addProperty('true', function() { 
    this.assert(
     true === flag(this, 'object') 
     , 'expected #{this} to be true' 
     , 'expected #{this} to be false' 
     , flag(this, 'negate') ? false : true 
    ); 
    });