प्रोग्राम को कैसे मोचा में टेस्ट छोड़ें?


142

मेरे पास एक कोड है जहां कुछ परीक्षण सीआई के वातावरण में हमेशा विफल रहेंगे। मैं पर्यावरण की स्थिति के आधार पर उन्हें निष्क्रिय करना चाहूंगा।

क्रमिक निष्पादन के दौरान मोचा में परीक्षण को कैसे प्रोग्रामेटिक रूप से छोड़ें?


3
प्रोग्रामेटिक रूप this.skip()से स्किप करने पर नीचे mochajs.org/#inclusive-tests और @ zatziky के उत्तर द्वारा कवर किया गया है । बाकी उत्तर मोचा v3 +
पैट्रिक

1
description.skip ('विवरण', () => {}) / description.only ('विवरण', () => {}) / it.skip ('विवरण', () => {}) / it। केवल ('विवरण', () => {})
Jun711

कोई भी स्वीकृत उत्तर?
पॉल रूनी

जवाबों:


168

आप विवरण के सामने x रखकर या उसके बाद ब्लॉक करके परीक्षण छोड़ सकते हैं .skip

xit('should work', function (done) {});

describe.skip('features', function() {});

आप परीक्षण पर एक एकल परीक्षण भी चला सकते हैं .only। उदाहरण के लिए

describe('feature 1', function() {});
describe.only('feature 2', function() {});
describe('feature 3', function() {});

केवल सुविधा 2 ब्लॉक इस मामले में चलेगा।

प्रोग्राम को टेस्टीली स्किप करने का एक तरीका प्रतीत नहीं होता है, लेकिन आप किसी beforeEachस्टेटमेंट में किसी प्रकार की जांच कर सकते हैं और केवल तभी सेट कर सकते हैं जब झंडा सेट हो गया हो।

beforeEach(function(){
    if (wrongEnvironment){
        runTest = false
    }
}

describe('feature', function(){
    if(runTest){
         it('should work', function(){
            // Test would not run or show up if runTest was false,
         }
    }
}

8
किसी समाधान पर आपका दूसरा प्रयास काम नहीं करेगा, क्योंकि निष्पादन का क्रम वह नहीं है जो आप सोचते हैं। जब beforeEachकॉल निष्पादित होता है, तो मोचा भविष्य में उपयोग के लिए अनाम फ़ंक्शन ("हुक") रिकॉर्ड करता है, जब कॉल निष्पादित होता है, तो मोचा तुरंत उस अनाम फ़ंक्शन को निष्पादित करता है। इसलिए जब तक यह निष्पादित नहीं हो जाता, तब तक हुक नहीं चलेगा। describeif (runTest)beforeEach
लुइस

22
इस उत्तर में 27 उत्थान कैसे होते हैं? सवाल प्रोग्रामिंग स्किपिंग टेस्ट के बारे में पूछता है, इसलिए ".Sip" या ".only" जोड़ना मददगार नहीं है। तब यह स्पष्ट रूप से कहता है कि आप ऐसा नहीं कर सकते हैं कि ओपी क्या करना चाहता है, इस तथ्य के बावजूद कि अन्य उत्तर आपको यह करने का तरीका बताते हैं।
ग्रीम पेरो

3
काम नहीं करेंगे, सवाल का जवाब नहीं, इसके बजाय @ गजस की प्रतिक्रिया देखें
NorTicUs

1
इस जवाब में एक अलग प्रश्न है जो यहाँ नहीं पूछा गया था। मेरे पास यहां कुछ भी बदलने की शक्ति नहीं है। यह देखें ।skip () उत्तर
एंड्रयू मार्टिनेज

3
इस सवाल का जवाब नहीं है
इंगो रेनर

110

प्रोग्रामिंग स्किपिंग परीक्षणों का एक अविभाजित तरीका है:

// test.js

describe('foo', function() {
  before(function() {
    this.skip();
  });

  it('foo', function() {
    // will not run
    console.log('This will not be printed');
  });
});

चल रहा है:

$ mocha test.js


  foo
    - foo


  0 passing (9ms)
  1 pending

इसकी चर्चा https://github.com/mochajs/mocha/issues/1901 में की गई है ।


13
पाठकों को यह जानना पसंद है कि यह पूरे निशान के describeरूप में चिह्नित किया गया है (यानी सभी परीक्षण describeछोड़ दिए गए हैं)।
लुई

मोचा के "लंबित परीक्षण" दस्तावेज: mochajs.org/#pending-tests
lasec0203

description.skip ('विवरण', () => {}) / description.only ('विवरण', () => {}) / it.skip ('विवरण', () => {}) / it। केवल ('विवरण', () => {})
Jun711

मैं नहीं समझता कि इस तरह का जवाब क्यों दिया जाता है। इसकी हैक - और प्रीति नहीं।
चिनोप

2
वास्तविक प्रलेखन mochajs.org/#inclusive-tests , यह किसी भी तरह से एक हैक btw नहीं है, लेकिन रनटाइम सेटिंग्स के आधार पर कुछ परीक्षणों को बाहर करने की सही विधि है। अर्थात यह मूल प्रश्न से पूछे गए उत्तर का सटीक उत्तर देता है। धन्यवाद @xavdid
WowPress.host

41

यह उत्तर ES6 के लिए काम करता है

के बजाय:

describe('your describe block', () => {

तुम्हें चाहिए:

(condition ? describe : describe.skip)('your describe block', () => {

यह सशर्त वर्णन ब्लॉक में सभी परीक्षणों को छोड़ देता है यदि स्थिति झूठी है।

या, इसके बजाय:

it('your it block', () => {

तुम्हें चाहिए:

(condition ? it : it.skip)('your it block', () => {

यह सशर्त एक परीक्षण को छोड़ देता है यदि स्थिति झूठी है।


4
मुझे वह मिलता है जो आप सुझा रहे हैं, लेकिन आपको पहले इस तरह के एक प्रासंगिक विवरण को परिभाषित करने की आवश्यकता है : const contextualDescribe = shouldAvoidTests ? describe.skip : describe फिर आप इसका उपयोग कर सकते हैं: contextualDescribe('your it block', () => {
सेर

3
@ एक लाइन पर आने के लिए, मैंने कुछ इस तरह का इस्तेमाल किया:(condition ? describe : describe.skip)('your describe block', () => {
joshden

यह कैसे करें async? मुझे रेडिस फ्लैग के आधार पर स्किप की स्थिति को देखने की जरूरत है, जो कि एक async ऑपरेशन है (हम फीचर फ्लैग को रेडिस में स्टोर करते हैं)।
पैट्रिक फिनिगन

थोड़ी देर हो चुकी है, लेकिन ive को इस तरह की आवश्यकता पहले भी थी, मुझे लगता है कि मैं एक समारोह में सभी मोचा सामान लपेटता हूं जो कि async कॉलबैक पूरा होने के बाद बुलाया गया था - कठबोली सटीक विवरण याद है
danday74

मैं इस तकनीक का उपयोग करता था, लेकिन अब यह मेरे लिए विफल है। बस लिखने की कोशिश(it)('my test', () => {})
सिर

33

मैं मोचा से रनटाइम स्किपिंग का उपयोग उसी परिदृश्य के लिए करता हूं जैसा आप वर्णन कर रहे हैं। यह डॉक्स से कॉपी पेस्ट है :

it('should only test in the correct environment', function() {
  if (/* check test environment */) return this.skip();

  // make assertions
});

जैसा कि आप देख सकते हैं, यह पर्यावरण के आधार पर परीक्षण को छोड़ देता है। मेरी अपनी हालत है if(process.env.NODE_ENV === 'continuous-integration')


2
माना! क्या शायद जल्दी वापसी करके वन लाइनर बन सकता है? जैसे: if (/* skipTestCondition */) return this.skip();- संपादित करें: काम करता है: D
सिडऑक '’

12

परीक्षण छोड़ें, उपयोग करें describe.skipयाit.skip

describe('Array', function() {
  it.skip('#indexOf', function() {
    // ...
  });
});

उन परीक्षणों को शामिल करने के लिए जिनका आप उपयोग कर सकते हैं describe.onlyयाit.only


describe('Array', function() {
  it.only('#indexOf', function() {
    // ...
  });
});

Https://mochajs.org/#inclusive-tests पर अधिक जानकारी


6

यह निर्भर करता है कि आप प्रोग्राम को टेस्ट कैसे छोड़ना चाहते हैं। अगर किसी भी टेस्ट कोड को चलाने से पहले स्किपिंग की शर्तों को निर्धारित किया जा सकता है, तो आप बस एक शर्त के आधार पर कॉल itया it.skipआवश्यकतानुसार कर सकते हैं। उदाहरण के लिए, यह कुछ परीक्षण छोड़ देगा यदि पर्यावरण चर ONEकिसी भी मान पर सेट है:

var conditions = {
    "condition one": process.env["ONE"] !== undefined
    // There could be more conditions in this table...
};

describe("conditions that can be determined ahead of time", function () {
    function skip_if(condition, name, callback) {
        var fn = conditions[condition] ? it.skip: it;
        fn(name, callback);
    };

    skip_if("condition one", "test one", function () {
        throw new Error("skipped!");
    });

    // async.
    skip_if("condition one", "test one (async)", function (done) {
        throw new Error("skipped!");
    });

    skip_if("condition two", "test two", function () {
        console.log("test two!");
    });

});

यदि आप जिन स्थितियों को जांचना चाहते हैं, वे केवल परीक्षण के समय में निर्धारित किए जा सकते हैं, तो यह थोड़ा अधिक जटिल है। यदि आप परीक्षण एपीआई के कड़ाई से बोलने वाले हिस्से तक कुछ भी नहीं पहुंचना चाहते हैं, तो आप ऐसा कर सकते हैं:

describe("conditions that can be determined at test time", function () {
    var conditions = {};
    function skip_if(condition, name, callback) {
        if (callback.length) {
            it(name, function (done) {
                if (conditions[condition])
                    done();
                else
                    callback(done);
            });
        }
        else {
            it(name, function () {
                if (conditions[condition])
                    return;
                callback();
            });
        }
    };

    before(function () {
        conditions["condition one"] = true;
    });

    skip_if("condition one", "test one", function () {
        throw new Error("skipped!");
    });

    // async.
    skip_if("condition one", "test one (async)", function (done) {
        throw new Error("skipped!");
    });

    skip_if("condition two", "test two", function () {
        console.log("test two!");
    });

});

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

describe("conditions that can be determined at test time", function () {
    var condition_to_test = {}; // A map from condition names to tests.
    function skip_if(condition, name, callback) {
        var test = it(name, callback);
        if (!condition_to_test[condition])
            condition_to_test[condition] = [];
        condition_to_test[condition].push(test);
    };

    before(function () {
        condition_to_test["condition one"].forEach(function (test) {
            test.pending = true; // Skip the test by marking it pending!
        });
    });

    skip_if("condition one", "test one", function () {
        throw new Error("skipped!");
    });

    // async.
    skip_if("condition one", "test one (async)", function (done) {
        throw new Error("skipped!");
    });

    skip_if("condition two", "test two", function () {
        console.log("test two!");
    });

});

3

मुझे यकीन नहीं है कि यह not प्रोग्रामेटिक स्किपिंग ”के रूप में योग्य है, लेकिन हमारे सीआई पर्यावरण के लिए कुछ विशिष्ट परीक्षणों को चुनिंदा रूप से छोड़ने के लिए, मैं मोचा की टैगिंग सुविधा ( https://github.com/mochajs/mocha-wiki/Tagging ) का उपयोग करता हूं । में describe()या it()संदेश, आप @ नो-ci की तरह एक टैग जोड़ सकते हैं। उन परीक्षणों को बाहर करने के लिए, आप अपने पैकेज में एक विशिष्ट "ci लक्ष्य" को परिभाषित कर सकते हैं। आगजनी और उपयोग --grepऔर --invertमापदंडों जैसे:

"scripts": {
  "test": "mocha",
  "test-ci" : "mocha --reporter mocha-junit-reporter --grep @no-ci --invert"
}

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

2

आप मेरे पैकेज mocha- मान का उपयोग कर सकते हैं परीक्षणों को प्रोग्रामेटिक रूप से छोड़ने के लिए, लेकिन केवल परीक्षणों के बाहर से। आप इसे इस तरह उपयोग करते हैं:

assuming(myAssumption).it("does someting nice", () => {});

मोचा संभालेंगे केवल अपने परीक्षण चलेगा जब myAssumptionहै true, अन्यथा यह इसे छोड़ देंगे (का उपयोग कर it.skipएक अच्छा संदेश के साथ)।

यहाँ एक और अधिक विस्तृत उदाहरण दिया गया है:

describe("My Unit", () => {
    /* ...Tests that verify someAssuption is always true... */

    describe("when [someAssumption] holds...", () => {
        let someAssumption;

        beforeAll(() => {
            someAssumption = /* ...calculate assumption... */
        });

        assuming(someAssumption).it("Does something cool", () => {
            /* ...test something cool... */
        });
    });
});

इस तरह इसका उपयोग करके आप कैस्केडिंग विफलताओं से बच सकते हैं। कहो कि परीक्षण "Does something cool"हमेशा विफल हो जाएगा जब someAssumption पकड़ में नहीं आता है - लेकिन यह धारणा पहले से ही ऊपर (में Tests that verify someAssuption is always true") का परीक्षण किया गया था ।

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


यह वास्तव में अच्छा है, दुखद है कि इस परियोजना को छोड़ दिया जाता है ...
विक्टर श्रोडर

@ VictorSchröder खैर, मुझे आभास था कि कोई भी इसका उपयोग नहीं कर रहा है। अगले कुछ हफ्तों में इसमें सुधार हो सकता है, अगर मेरे पास समय होता। क्या आप जीथब पर एक मुद्दा खोल सकते हैं और मुझे बता सकते हैं कि आप क्या देखना चाहते हैं?
डेविड तंज़र

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

1
हालाँकि, इस उत्तर में दूसरा उदाहरण है, एक समस्या है। beforeAllहुक सभी परीक्षणों एकत्र कर रहे हैं इससे पहले कि चलाने के लिए गारंटी नहीं है। वास्तव में, यह केवल बाद में चलने की बहुत संभावना है, लेकिन इस मामले में assuming(someAssumption)पहले से ही प्रारंभिक (अपरिभाषित) मान प्राप्त किया होगा। वांछित प्रभाव को प्राप्त करने के लिए उस भाग को एक फंक्शन में लपेटना आवश्यक है।
विक्टर श्रोडर

2

हम इस प्रकार के रूप में परीक्षण चलाने के लिए एक अच्छा साफ आवरण समारोह लिख सकते हैं:

function ifConditionIt(title, test) {
  // Define your condition here
  return condition ? it(title, test) : it.skip(title, test);
}

यह तब आवश्यक हो सकता है और आपके परीक्षणों में निम्नानुसार उपयोग किया जा सकता है:

ifConditionIt('Should be an awesome test', (done) => {
  // Test things
  done();
});

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

0

कहो कि मैं अपने पैराट्राइज्ड परीक्षण को छोड़ना चाहता था यदि मेरे परीक्षण विवरण में स्ट्रिंग "फू" शामिल था, तो मैं यह करूंगा:

// Skip parametrized test if description contains the string "foo"
(test.description.indexOf("foo") === -1 ? it : it.skip)("should test something", function (done) {
    // Code here
});

// Parametrized tests
describe("testFoo", function () {
        test({
            description: "foo" // This will skip
        });
        test({
            description: "bar" // This will be tested
        });
});

आपके मामले में, मेरा मानना ​​है कि यदि आप पर्यावरण चर की जाँच करना चाहते हैं, तो आप NodeJS का उपयोग कर सकते हैं:

process.env.ENV_VARIABLE

उदाहरण के लिए (चेतावनी: मैंने इस बिट कोड का परीक्षण नहीं किया है!), शायद कुछ इस तरह:

(process.env.NODE_ENV.indexOf("prod") === -1 ? it : it.skip)("should...", function(done) {
    // Code here
});

जहाँ आप ENV_VARIABLE सेट कर सकते हैं, जो भी आप बंद कर रहे हैं, और उस मान का उपयोग करके, परीक्षण छोड़ें या चलाएं। (FYI करें NodeJS 'process.env के लिए प्रलेखन यहाँ है: https://nodejs.org/api/process.html#process_process_env )

मैं इस समाधान के पहले भाग के लिए पूरा श्रेय नहीं लूंगा, मैंने उत्तर पाया और इसका परीक्षण किया और इस संसाधन के माध्यम से एक साधारण स्थिति के आधार पर परीक्षणों को छोड़ने के लिए पूरी तरह से काम किया: https://github.com/mochajs/mocha/issues / 591

उम्मीद है की यह मदद करेगा! :)


0

यह वास्तव में मोचा की विशेषताओं का उपयोग नहीं कर रहा है, बल्कि इसे उस व्यवहार को प्राप्त करने के लिए ट्विक करना है जो मुझे चाहिए था।

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

जब केवल मानक मोचा परीक्षण (प्रोट्रैक्टर नहीं) चल रहा हो, तो इसे वैश्विक से पहले और बाद में प्राप्त किया जा सकता है, इस तरह से परीक्षण के माता-पिता (वर्णन) को 'स्किपसुबेंटेंट' ध्वज संलग्न करके हुक:

    beforeEach(function() {
      if(this.currentTest.parent.skipSubsequent) {
            this.skip();
      }
    }); 


    afterEach(function() {
      if (this.currentTest.state === 'failed') {
        this.currentTest.parent.skipSubsequent = 'true'
      }
    })

जब इसे हटाने वाले के साथ प्रयास किया जाता है और इसे 'इस' का दायरा बदल दिया जाता है और ऊपर वाला कोड काम नहीं करता है। आप 'एरर कॉलिंग ()' और प्रोट्रैक्टर हाल्ट जैसे त्रुटि संदेश के साथ समाप्त होते हैं।

इसके बजाय मैं नीचे दिए गए कोड के साथ समाप्त हुआ। सबसे सुंदर नहीं है, लेकिन यह इस .skip () के साथ शेष परीक्षण कार्यों के कार्यान्वयन की जगह लेता है। यह संभवतया तब काम करना बंद कर देगा जब / बाद में संस्करणों के साथ मोचा के आंतरिक परिवर्तन होते हैं।

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

beforeEach(function() {

    var parentSpec = this.currentTest.parent;

    if (!parentSpec.testcount) {
        parentSpec.testCount = parentSpec.tests.length;
        parentSpec.currentTestIndex = 0;
    } else {
        parentSpec.currentTestIndex = parentSpec.currentTestIndex + 1;
    }

    if (parentSpec.skipSubsequent) {

        parentSpec.skipSubsequent = false;
        var length = parentSpec.tests.length;
        var currentIndex = parentSpec.currentTestIndex;

        for (var i = currentIndex + 1; i < length; i++) {
            parentSpec.tests[i].fn = function() {
                this.skip();
            };
        }
    }
});


afterEach(function() {
    if (this.currentTest.state === 'failed') {
        this.currentTest.parent.skipSubsequent = 'true'
    }
});


-2

जैसा कि @danielstjules ने यहां उत्तर दिया कि टेस्ट छोड़ने का एक तरीका है। इस विषय के @author ने github.com mochajs चर्चा से उत्तर की प्रतिलिपि बनाई है, लेकिन मोचा किस संस्करण में उपलब्ध है, इसकी कोई जानकारी नहीं है।

मैं अपनी परियोजना में मोचा परीक्षण कार्यक्षमता को एकीकृत करने के लिए ग्रंट-मोचा-परीक्षण मॉड्यूल का उपयोग कर रहा हूं। अंतिम (अब के लिए) संस्करण पर कूदते हुए - 0.12.7 इस मोशन के कार्यान्वयन के साथ मुझे मोचा संस्करण 2.4.5 लाएं। ()

तो, मेरे पैकेज में। json

  "devDependencies": {
    "grunt-mocha-test": "^0.12.7",
    ...

और तब

npm install

और यह मुझे इस हुक से खुश करता है:

describe('Feature', function() {

    before(function () {

        if (!Config.isFeaturePresent) {

            console.log('Feature not configured for that env, skipping...');
            this.skip();
        }
    });
...

    it('should return correct response on AB', function (done) {

        if (!Config.isABPresent) {

           return this.skip();
        }

        ...

-2

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

इसके अलावा यह दोहराव को बढ़ाता है। यदि सर्वर और स्थानीय पर अलग-अलग परीक्षण चलते हैं, तो मेरे पास देव और सीआई या इसके विपरीत में पास होने में परीक्षण विफल हो सकते हैं। कोई मजबूर कार्य नहीं है और मेरे पास असफल निर्माण को जल्दी और सही तरीके से ठीक करने का कोई तरीका नहीं है।

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

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.