खोज…
बुनियादी दावा
अपने सबसे बुनियादी स्तर पर, किसी भी भाषा में यूनिट परीक्षण कुछ ज्ञात या अपेक्षित आउटपुट के खिलाफ दावे प्रदान करता है।
function assert( outcome, description ) {
var passFail = outcome ? 'pass' : 'fail';
console.log(passFail, ': ', description);
return outcome;
};
ऊपर दी गई लोकप्रिय शोध पद्धति हमें सबसे तेज वेब ब्राउजर और एन्टरमास्टर जैसे एनोड.जेएस के किसी भी संस्करण के साथ व्याख्या करने वालों के लिए एक त्वरित और आसान तरीका दिखाती है।
एक अच्छा यूनिट टेस्ट कोड की एक विचारशील इकाई का परीक्षण करने के लिए डिज़ाइन किया गया है; आमतौर पर एक समारोह।
function add(num1, num2) {
return num1 + num2;
}
var result = add(5, 20);
assert( result == 24, 'add(5, 20) should return 25...');
ऊपर के उदाहरण में, फ़ंक्शन add(x, y) या 5 + 20 से रिटर्न वैल्यू स्पष्ट रूप से 25 , इसलिए हमारे 24 दावा विफल होना चाहिए, और एस्टर विधि एक "विफल" लाइन लॉग करेगी।
यदि हम अपने अपेक्षित परिणाम को संशोधित करते हैं, तो परीक्षण सफल होगा और परिणामी आउटपुट कुछ इस तरह दिखाई देगा।
assert( result == 25, 'add(5, 20) should return 25...');
console output:
> pass: should return 25...
यह सरल अभिकथन यह आश्वस्त कर सकता है कि कई अलग-अलग मामलों में, आपका "ऐड" फ़ंक्शन हमेशा अपेक्षित परिणाम लौटाएगा और काम करने के लिए अतिरिक्त रूपरेखा या पुस्तकालयों की आवश्यकता नहीं है।
मुखरता का एक और अधिक कठोर सेट इस तरह दिखेगा (प्रत्येक var result = add(x,y) का उपयोग करते हुए):
assert( result == 0, 'add(0, 0) should return 0...');
assert( result == -1, 'add(0, -1) should return -1...');
assert( result == 1, 'add(0, 1) should return 1...');
और कंसोल आउटपुट यह होगा:
> pass: should return 0...
> pass: should return -1...
> pass: should return 1...
अब हम सुरक्षित रूप से कह सकते हैं कि add(x,y) ... को दो पूर्णांकों का योग लौटाना चाहिए । हम इन्हें कुछ इस तरह से रोल कर सकते हैं:
function test__addsIntegers() {
// expect a number of passed assertions
var passed = 3;
// number of assertions to be reduced and added as Booleans
var assertions = [
assert( add(0, 0) == 0, 'add(0, 0) should return 0...'),
assert( add(0, -1) == -1, 'add(0, -1) should return -1...'),
assert( add(0, 1) == 1, 'add(0, 1) should return 1...')
].reduce(function(previousValue, currentValue){
return previousValue + current;
});
if (assertions === passed) {
console.log("add(x,y)... did return the sum of two integers");
return true;
} else {
console.log("add(x,y)... does not reliably return the sum of two integers");
return false;
}
}
इकाई परीक्षण मोचा, सिनोन, चाय और प्रॉक्सी के साथ वादा करता है
यहां हमारे पास एक साधारण वर्ग का परीक्षण किया जाना है जो एक बाहरी ResponseProcessor के परिणामों के आधार पर एक Promise जो निष्पादित होने में समय लेता है।
सरलता के लिए हम मान लेंगे कि processResponse विधि कभी भी विफल नहीं होगी।
import {processResponse} from '../utils/response_processor';
const ping = () => {
return new Promise((resolve, _reject) => {
const response = processResponse(data);
resolve(response);
});
}
module.exports = ping;
इसका परीक्षण करने के लिए हम निम्नलिखित उपकरणों का लाभ उठा सकते हैं।
मैं अपने package.json फ़ाइल में निम्न test स्क्रिप्ट का उपयोग करता हूं।
"test": "NODE_ENV=test mocha --compilers js:babel-core/register --require ./test/unit/test_helper.js --recursive test/**/*_spec.js"
यह मुझे es6 सिंटैक्स का उपयोग करने की अनुमति देता है। यह एक test_helper संदर्भ test_helper जो जैसा दिखेगा
import chai from 'chai';
import sinon from 'sinon';
import sinonChai from 'sinon-chai';
import chaiAsPromised from 'chai-as-promised';
import sinonStubPromise from 'sinon-stub-promise';
chai.use(sinonChai);
chai.use(chaiAsPromised);
sinonStubPromise(sinon);
Proxyquire हमें बाहरी ResponseProcessor के स्थान पर अपने स्वयं के स्टब को इंजेक्ट करने की अनुमति देता है। फिर हम स्टब के तरीकों पर जासूसी करने के लिए sinon का उपयोग कर सकते हैं। हम एक्सटेंशन का उपयोग करने chai कि chai-as-promised जांचने के लिए कि injects ping() विधि का वादा किया गया है fullfilled , और है कि यह eventually आवश्यक प्रतिक्रिया देता है।
import {expect} from 'chai';
import sinon from 'sinon';
import proxyquire from 'proxyquire';
let formattingStub = {
wrapResponse: () => {}
}
let ping = proxyquire('../../../src/api/ping', {
'../utils/formatting': formattingStub
});
describe('ping', () => {
let wrapResponseSpy, pingResult;
const response = 'some response';
beforeEach(() => {
wrapResponseSpy = sinon.stub(formattingStub, 'wrapResponse').returns(response);
pingResult = ping();
})
afterEach(() => {
formattingStub.wrapResponse.restore();
})
it('returns a fullfilled promise', () => {
expect(pingResult).to.be.fulfilled;
})
it('eventually returns the correct response', () => {
expect(pingResult).to.eventually.equal(response);
})
});
अब इसके बजाय मान लें कि आप ping से प्रतिक्रिया का उपयोग करने वाली किसी चीज़ का परीक्षण करना चाहते हैं।
import {ping} from './ping';
const pingWrapper = () => {
ping.then((response) => {
// do something with the response
});
}
module.exports = pingWrapper;
pingWrapper परीक्षण करने के लिए हम लाभ उठाते हैं
पहले की तरह, Proxyquire हमें बाहरी निर्भरता के स्थान पर अपने स्वयं के स्टब को इंजेक्ट करने की अनुमति देता है, इस मामले में ping विधि जिसे हमने पहले परीक्षण किया था। इसके बाद हम उस ठूंठ के तरीकों की जासूसी करने के लिए sinon का उपयोग कर सकते हैं और sinon-stub-promise का लाभ sinon-stub-promise हमें returnsPromise देने की अनुमति दे सकते हैं। यह वादा तब हल किया जा सकता है या अस्वीकार कर दिया जा सकता है जब हम परीक्षण में चाहते हैं, ताकि रैपर की प्रतिक्रिया का परीक्षण किया जा सके।
import {expect} from 'chai';
import sinon from 'sinon';
import proxyquire from 'proxyquire';
let pingStub = {
ping: () => {}
};
let pingWrapper = proxyquire('../src/pingWrapper', {
'./ping': pingStub
});
describe('pingWrapper', () => {
let pingSpy;
const response = 'some response';
beforeEach(() => {
pingSpy = sinon.stub(pingStub, 'ping').returnsPromise();
pingSpy.resolves(response);
pingWrapper();
});
afterEach(() => {
pingStub.wrapResponse.restore();
});
it('wraps the ping', () => {
expect(pingSpy).to.have.been.calledWith(response);
});
});