Jest: टेस्ट अगर वस्तु, सरणी या स्ट्रिंग।

को निर्मित 3 मई 2017 · 29टिप्पणियाँ · स्रोत: facebook/jest

क्या यह जांचने का कोई तरीका है कि कोई घटक ऑब्जेक्ट, सरणी या स्ट्रिंग है या नहीं? यह चाय के 'चाहिए.बी.ए' के समान होगा।

स्रोत

nithrm

👍38 😕2

सबसे उपयोगी टिप्पणी

जो लोग इसे चाहते हैं उनके लिए एक सरल toBeType एक्सटेंशन

expect.extend({
    toBeType(received, argument) {
        const initialType = typeof received;
        const type = initialType === "object" ? Array.isArray(received) ? "array" : initialType : initialType;
        return type === argument ? {
            message: () => `expected ${received} to be type ${argument}`,
            pass: true
        } : {
            message: () => `expected ${received} to be type ${argument}`,
            pass: false
        };
    }
});

describe("testing extended expect", () => {
    it("tests normal types correctly", () => {
        expect("").toBeType("string");
        expect({}).toBeType("object");
        expect(1).toBeType("number");
    });
    it("tests array types correctly", () => {
        expect([]).toBeType("array");
    });
    it("works with promises", () => {
        expect(Promise.resolve([])).resolves.toBeType("array");
    });
});

लागू करने के लिए बहुत आसान है। वास्तव में कोर टीबीएच में होना चाहिए।

नोट - यदि आप उस विस्तार को अपनी सेटअप फ़ाइलों में डाल रहे हैं तो आप इसे setupTestFrameworkScriptFile नहीं setupFiles (जैसा कि विस्तार केवल पूर्व में उपलब्ध है)

abritinthebay 6 अक्तू॰ 2017

👍104 🎉22 ❤17 🚀7 👎2

सभी 29 टिप्पणियाँ

नहीं, वहाँ नहीं है। आपको सभी उपलब्ध मिलानकर्ताओं की सूची यहां मिलेगी: https://facebook.github.io/jest/docs/en/expect.html

आप उसके लिए lodash जैसे सादे जावास्क्रिप्ट या सहायक पुस्तकालय का भी उपयोग कर सकते हैं:

test('name', () => {
  // array
  expect(Array.isArray(['value'])).toBe(true);
  // string
  expect(typeof 'value').toBe('string');
  // object
  expect({value: 'value'}).toBeTruthy();
  expect(typeof {value: 'value'}).toBe('object');
})

thymikee 3 मई 2017

👍121 👎102 😕2

मामूली बिंदु - यह वादे के परिणामों में मदद नहीं करता है।

expect(somePromise).resolves.toBe(...) इस बिंदु पर प्रकार की जांच करने का कोई तरीका नहीं है। आप परवाह नहीं है तो क्या सामग्री हैं, लेकिन यह एक स्ट्रिंग है सिर्फ इतना है कि। मुझे उम्मीद थी कि expects.stringContaining("") एक काम हो जाएगा लेकिन वह भी काम नहीं करता है।

abritinthebay 1 अग॰ 2017

👍14 👀1

@abritinthebay मैं ठीक उसी स्थिति में हूं और Google में यह पहला परिणाम है, शायद इसे फिर से खोला जाना चाहिए?

franciscop 25 सित॰ 2017

निश्चित रूप से इस पर थोड़ा और विचार किया जाना चाहिए। मेरा समाधान श्रृंखला में जोड़ना था ताकि typeof भाग हो। उदाहरण:

expect(somePromise.then(data => typeof data)).resolves.toBe("object");

यह काम करता है, लेकिन यह बिल्कुल साफ नहीं है।

abritinthebay 25 सित॰ 2017

👍6

@thymikee चीजों की जांच करना एक सामान्य पर्याप्त उपयोग मामला (सार्वभौमिक) है कि परीक्षण ढांचे के लिए वास्तव में कोई बहाना नहीं है जिसमें उनकी कमी है। आपके विकल्प अस्वीकार्य हैं क्योंकि हम जो परीक्षण कर रहे हैं उसके सभी संदर्भ खो देते हैं।

यह expect(Array.isArray(['value'])).toBe(false); विफल रहता है

expect(received).toBe(expected)
    Expected value to be (using ===):
      false
    Received:
      true.

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

abramz 6 अक्तू॰ 2017

👍46 ❤8 👎2

फिर expect.extend साथ अपने खुद के मैचर्स बनाएं और एक npm मॉड्यूल के रूप में प्रकाशित करें। यदि यह लोकप्रिय हो जाता है, तो हम इसे अंततः जेस्ट कोर में विलय कर सकते हैं;)

thymikee 6 अक्तू॰ 2017

👎112 😕14 😄14 👍10 👀4

जो लोग इसे चाहते हैं उनके लिए एक सरल toBeType एक्सटेंशन

expect.extend({
    toBeType(received, argument) {
        const initialType = typeof received;
        const type = initialType === "object" ? Array.isArray(received) ? "array" : initialType : initialType;
        return type === argument ? {
            message: () => `expected ${received} to be type ${argument}`,
            pass: true
        } : {
            message: () => `expected ${received} to be type ${argument}`,
            pass: false
        };
    }
});

describe("testing extended expect", () => {
    it("tests normal types correctly", () => {
        expect("").toBeType("string");
        expect({}).toBeType("object");
        expect(1).toBeType("number");
    });
    it("tests array types correctly", () => {
        expect([]).toBeType("array");
    });
    it("works with promises", () => {
        expect(Promise.resolve([])).resolves.toBeType("array");
    });
});

लागू करने के लिए बहुत आसान है। वास्तव में कोर टीबीएच में होना चाहिए।

abritinthebay 6 अक्तू॰ 2017

👍104 🎉22 ❤17 🚀7 👎2

धन्यवाद @abritinthebay

abramz 6 अक्तू॰ 2017

तो अगर लोग इसे चाहते हैं तो मैंने इसे एनपीएम मॉड्यूल में लपेट लिया:

https://www.npmjs.com/package/jest-tobetype

abritinthebay 6 अक्तू॰ 2017

👍55 ❤34 🎉4

describe("assertion framework", ()=> {
 it("should check primitive types", () => {
   expect(expect.toBeA).toBeA("function")
  })
})

विफल: उम्मीद (...)। toBeA एक फ़ंक्शन नहीं हैलेखन त्रुटि: उम्मीद (...)। toBeA एक समारोह नहीं है

alex-dixon 12 अक्तू॰ 2017

https://github.com/jest-community/jest-extended सभी प्रकार के मैचर्स हैं जो आप चाहते हैं (मुझे लगता है)।

SimenB 29 मार्च 2018

👍21 🎉16 ❤9

मैं अपने परीक्षणों में toBeInstanceOf का उपयोग कर रहा हूं:

expect($wrapper.vm.countries).toBeInstanceOf(Array);

ecoker 13 अग॰ 2018

👍53 🎉9

उम्मीद के साथ अपने खुद के मैचर्स बनाएं और फिर एनपीएम मॉड्यूल के रूप में प्रकाशित करें। यदि यह लोकप्रिय हो जाता है, तो हम इसे अंततः जेस्ट कोर में विलय कर सकते हैं;)

हाँ, और जब आप उस पर हों, तब आप अपना स्वयं का मज़ाक ढांचा लिख सकते हैं।

यह सिर्फ GitHub पर आपको मिलने वाले सबसे खराब उत्तरों में से एक हो सकता है।

vitaly-t 26 अग॰ 2018

👎3

तो @abritinthebay ने वही किया जो @thymikee द्वारा अनुरोध किया गया था (जो मानक पुल अनुरोध से कहीं अधिक था)।

अब जब उस बहादुर आत्मा ने सारा काम कर लिया है, तो हममें से बाकी लोगों को आखिरकार यह मैचर कब मिल सकता है (बिना दूसरी लाइब्रेरी स्थापित किए)? क्या अनुरक्षक अभी भी इस विचार को आगे बढ़ा रहे हैं कि यह जेस्ट में नहीं है, या यह सिर्फ उनके रडार से गिर गया है?

machineghost 27 अक्तू॰ 2018

👍14 ❤5

हम इसे कोर में बनाने के साथ बहुत सख्त हैं और आम तौर पर चीनी मैचर्स नहीं जोड़ते हैं। जेस्ट कोर एक काफी बड़ा आर्किटेक्चर है और हम जो भी मैचर जोड़ते हैं वह रखरखाव लागत को बढ़ाता है

चीनी के लिए, हम आम तौर पर https://github.com/jest-community/jest-extended . की सलाह देते हैं

rickhanlonii 2 दिस॰ 2018

👎8 👍2 😕1

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

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

.to.be.an.instanceOf यह नहीं होने वाला है कि कितने उपयोगकर्ता प्रकारों की जांच करने के लिए सोचते हैं, इसलिए उन उपयोगकर्ताओं के लिए, भले ही आप इसे चीनी के रूप में देखते हैं, आप प्रभावी रूप से उन्हें अतिरिक्त पुस्तकालय के बिना जेस्ट में प्रकारों की जांच करने की क्षमता से वंचित कर रहे हैं।

machineghost 2 दिस॰ 2018

👍8 😄1

हाँ मैं सुनता हूँ। स्पष्ट होने के लिए, "चीनी" से मेरा मतलब वाक्य रचना है जो चीजों को पढ़ने या व्यक्त करने में आसान बनाने के लिए डिज़ाइन किया गया है । चीनी, परिभाषा के अनुसार, एक ऐसी विशेषता का रूपांतर है जो पहले से मौजूद है

इस मामले में, हमारे पास है:

// Supported
expect(typeof foo).toBe('string');

// Proposed Sugar
expect(foo).toBeType('string');

तो ऐसा नहीं है कि हम जाँच प्रकारों का समर्थन नहीं करते हैं। हम कर। हम पहले विकल्प का समर्थन करते हैं। यह विकल्प कोर toBe मैचर का उपयोग करता है, जिसमें हमने बग्स को ठीक करने और संदेश को ट्वीक करने में बहुत समय बिताया है, ताकि उपयोगकर्ताओं को एक अच्छा अनुभव हो

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

rickhanlonii 2 दिस॰ 2018

👍16 😕4 👎2

पूरी तरह से निष्पक्ष होने के लिए - अधिकांश मैचर्स किसी न किसी स्तर पर "चीनी" होते हैं। मेरा मतलब है toBeGreaterThanOrEqual expect(foo >= bar).toBe(true); लिए सिर्फ चीनी है

मैचर्स वास्तव में बूलियन स्टेटमेंट्स के आसपास _लगभग सभी_ चीनी हैं;)

(मैं इसे खोदने के लिए नहीं कहता, केवल यह इंगित करने के लिए कि यह... एक बहुत धुंधली रेखा है)

abritinthebay 5 दिस॰ 2018

👍20 😄5

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

हमारी बात सुनें या न सुनें, फिर से अनुरक्षक के रूप में आपके पास बहुत सी अन्य चिंताएँ हैं। लेकिन मुझे नहीं लगता कि सही प्रतिक्रिया यह है कि "आपका सिर्फ स्वाभाविक रूप से अनावश्यक चीनी है" (यह मैं आपको अपने मुंह में शब्द डालने की कोशिश नहीं कर रहा हूं) जब यह निहित नहीं है: यह 100% आपकी कॉल है चाहे जेस्ट सभी प्रकार की जांच कर सकते हैं या बॉक्स से बाहर नहीं।

machineghost 9 दिस॰ 2018

👍6 ❤1 😕1

इसके बारे में क्या मुश्किल नहीं है: पी?

expect(Array.isArray(['your', 'array'])).toBe(true);

expect(typeof something === "object").toBe(true); 
// - or -
expect(something instanceof Object).toBe(true);

expect(typeof something === "string").toBe(true);

nahumzs 18 जन॰ 2019

@nahumzs जबकि यह काम करता है, समस्या यह है कि असफल होने पर आपके परीक्षण आउटपुट पर, यह 'अपेक्षित झूठा सच होने की उम्मीद' कहेगा, जो बहुत उपयोगी नहीं है;)

tdmalone 21 जन॰ 2019

❤7 👍5

मुझे लगता है कि यह जाने का रास्ता है :)

describe('type check', () => {
    test('should be type string', () => {
        expect(typeof '').toBe('string')
    })

    test('should be type number', () => {
        expect(typeof 10).toBe('number')
    })

    test('should be type boolean', () => {
        expect(typeof true).toBe('boolean')
    })

    test('should be type undefined', () => {
        expect(typeof undefined).toBe('undefined')
    })

    test('should be type object', () => {
        expect(typeof { foo: 'bar' }).toBe('object')
    })

    test('should be type function', () => {
        expect(typeof function() {}).toBe('function')
    })

    test('should be type null', () => {
        expect(typeof null).toBe('object')
    })
})

amiteshore 19 फ़र॰ 2019

👍24 👎16 😕9 👀7 🎉5 😄4 ❤4 🚀3

मैंने @abritinthebay द्वारा प्रदान किए गए कार्यान्वयन को दोबारा प्रतिक्रिया दी। मेरे लिए काम करना थोड़ा सहज लगता है।

```जावास्क्रिप्ट
उम्मीद.विस्तार({
/ ** @परम { } प्राप्त हुआ
* @परम {स्ट्रिंग | स्ट्रिंग []} तर्क
* @ वापसी {{पास: बूलियन, संदेश: (फ़ंक्शन (): स्ट्रिंग)}}
*/
toBeType (प्राप्त, तर्क) {
const isCorrectType = arg => {
कॉन्स्ट प्राप्त टाइप = टाइपऑफ प्राप्त;

        const checkForSingle = arg => {
            const type = receivedType === 'object'
                ? Array.isArray(received)
                    ? 'array'
                    : receivedType
                : receivedType;

            return type === arg;
        };

        const checkForArr = arg => {
            const reducer = (prev, curr) => prev || isCorrectType(curr).isCorrect;

            return arg.reduce(reducer, false);
        };

        return {
            receivedType,
            isCorrect: Array.isArray(arg)
                ? checkForArr(arg)
                : checkForSingle(arg)
        };
    };

    const {isCorrect, receivedType} = isCorrectType(arg);

    return {
        pass: isCorrect,
        message: () => {
            const toBe = Array.isArray(arg)
                ? arg.join(`' or '`)
                : arg;

            return `Expected '${received}' of '${receivedType}' type to be of '${toBe}' type(s)`;
        }
    };
}

});

balovbohdan 29 अग॰ 2019

आपको मेरा मॉड्यूल (ऊपर लिंक) देखना चाहिए। यह उससे थोड़ा अधिक करता है। लेकिन अगर यह आपके लिए काम करता है: इसका इस्तेमाल करें!

abritinthebay 29 अग॰ 2019

👍2

मुझे लगता है कि यह जाने का रास्ता है :)

describe('type check', () => {
    test('should be type string', () => {
        expect(typeof '').toBe('string')
    })

    test('should be type number', () => {
        expect(typeof 10).toBe('number')
    })

    test('should be type boolean', () => {
        expect(typeof true).toBe('boolean')
    })

    test('should be type undefined', () => {
        expect(typeof undefined).toBe('undefined')
    })

    test('should be type object', () => {
        expect(typeof { foo: 'bar' }).toBe('object')
    })

    test('should be type function', () => {
        expect(typeof function() {}).toBe('function')
    })

    test('should be type null', () => {
        expect(typeof null).toBe('object')
    })
})

यह भविष्य के लिए एक आकर्षण के साथ-साथ अधिक पठनीय और रखरखाव योग्य काम करता है।

ahtashamabbasse 26 फ़र॰ 2020

मुझे लगता है कि यह जाने का रास्ता है :)

describe('type check', () => {
    test('should be type string', () => {
        expect(typeof '').toBe('string')
    })

    test('should be type number', () => {
        expect(typeof 10).toBe('number')
    })

    test('should be type boolean', () => {
        expect(typeof true).toBe('boolean')
    })

    test('should be type undefined', () => {
        expect(typeof undefined).toBe('undefined')
    })

    test('should be type object', () => {
        expect(typeof { foo: 'bar' }).toBe('object')
    })

    test('should be type function', () => {
        expect(typeof function() {}).toBe('function')
    })

    test('should be type null', () => {
        expect(typeof null).toBe('object')
    })
})

    test('should be type object', () => {
        expect(typeof { foo: 'bar' }).toBe('object')
        // passes
        expect(typeof ['foo', 'bar']).toBe('object')
        // passes
        expect(typeof null).toBe('object')
    })

मैं

Billy- 20 मार्च 2020

👍2

यही कारण है कि मैं ऊपर अपने ऐडऑन का सुझाव देता हूं: इसका ख्याल रखता है।

इंस्टेंसऑफ थोड़ा बेहतर है लेकिन इसी तरह के मुद्दों से ग्रस्त है।

इससे लिंक करें:

https://www.npmjs.com/package/jest-tobetype

abritinthebay 20 मार्च 2020

👍1

समाधान के लिए धन्यवाद @abritinthebay

Temirtator 1 जून 2020

एक और समाधान:

expect('example').toEqual(expect.any(String));
expect(123).toEqual(expect.any(String));

दूसरा वाला असफल होगा:

    Expected: Any<String>
    Received: 123

tfoxy 9 नव॰ 2020

👍1

क्या यह पृष्ठ उपयोगी था?

0 / 5 - 0 रेटिंग्स

Jest: टेस्ट अगर वस्तु, सरणी या स्ट्रिंग।

सबसे उपयोगी टिप्पणी

सभी 29 टिप्पणियाँ

संबंधित मुद्दों