बीडीडी का उपयोग कर परीक्षण

परिचय

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

TDD और BDD

मैं यहां आईटी उद्योग के प्रकाशकों के लेखों और प्रस्तुतियों का उल्लेख नहीं करूंगा। मुझे टीडीडी के बारे में ट्विटर का एक वाक्यांश याद है जो मेरे दिमाग में अटका हुआ है, और जो मेरी राय में स्पष्ट रूप से और संक्षेप में टीडीडी दृष्टिकोण की विशेषता है। दुर्भाग्य से, मैं इसे शब्दशः नहीं दे सकता, लेकिन इसका अर्थ निम्न है: "यदि आप टीडीडी का पालन करते हैं, तो आप 100% सुनिश्चित हो सकते हैं कि कोड की प्रत्येक पंक्ति गिर परीक्षण (ओं) के लिए धन्यवाद लिखी गई थी"। मैंने टीडीडी और बीडीडी के पेशेवरों और विपक्षों के बारे में बहुत बहस देखी और सुना है, लेकिन क) आपको परीक्षण लिखने की आवश्यकता है ख) यदि कोड को गिराए गए परीक्षण के लिए धन्यवाद लिखा गया था, तो आप इस कोड पर भरोसा कर सकते हैं और सिस्टम के व्यवहार को खराब करने के डर के बिना इसे (रिफ्लेक्टर) आसानी से बदल सकते हैं। ।
अब बी.डी.डी. यह घटना बाद में दिखाई दी और तथाकथित मोकेस्ट के लिए " मोक्स आर स्टब्स" लेख में फाउलर ने दावा किया। दूसरी ओर, इस दृष्टिकोण को एगेल पार्टी के लोगों द्वारा सक्रिय रूप से बढ़ावा दिया जाता है, डेवलपर्स, उपयोगकर्ताओं और सिस्टम विश्लेषकों के बीच की दूरी को कम करता है। यह एक्ज़ीक्यूटेबल व्यूअर्स प्राप्त करके प्राप्त किया जाता है, दूसरे शब्दों में, उपयोगकर्ता का वर्णन करने वाली लिपियों को एक निष्पादन योग्य परीक्षण में अनुवादित किया जाता है। BDD चौखटे यह अच्छी तरह से करते हैं।
अब चलिए तुलना करते हैं।
सभी उदाहरण समान परिदृश्य का वर्णन करते हैं। मैं समस्या के वर्णन को छोड़ दूंगा, एक समाधान जिसे परीक्षण के साथ कवर करने की आवश्यकता है, क्योंकि लिपियों को स्वयं स्पष्ट रूप से इसका वर्णन करना चाहिए।
लेख के लेखक उनके लिए सहानुभूति के बढ़ते क्रम में बीडीडी कार्यान्वयन का हवाला देते हैं।

Easyb

यह ढांचा ग्रूवी में लिखा गया है। सभी बीडीडी कार्यान्वयन की तरह, यह दिए गए-जब-तब संकेतन का समर्थन करता है। आसानी से निरंतर एकीकरण (CI) में एकीकृत होता है।
यहाँ एक उदाहरण स्क्रिप्ट है:
description "This story is about sqrt optimisation algorithm"
narrative "this shows sqrt optimisation", {
as a "java developer"
i want "to know how sqrt optimisation works"
so that "that I can pass google interview"
}

before "init input and expected result",{
}

where "complete scenarios data",{
input = [[5, 10, -3, 17, 12, 1, -2, 13, -12], [5, 8, 13, 5, 21, 6, 3, 7, -2, 4, 8, 12]]
leftIndex = [2,3]
rightIndex = [5,10]
expectedSumm = [27,51]
}

scenario "find summ within two indexes #leftIndex and #rightIndex of the array #input",{
given "An Sqrt algorithm implementation",{
alg = new SqrtDecompositionSum(input.toArray(new int[0]))
}

when "calc sum between two indexes", {
actualSum = alg.calcSummBetween(leftIndex, rightIndex)
}

then "summ should be equal expected #expectedSumm", {
actualSum.shouldBe expectedSumm
}
}

यहां परीक्षा परिणाम कैसा दिखता है:


यहां ईजीब की पहली कमजोरी "चढ़ती है" है। तथ्य यह है कि यह स्पष्ट नहीं है कि 2 परिदृश्य कहां से आए, जबकि यह वर्णित है 1. यदि आप स्क्रिप्ट के किस भाग को करीब से देखते हैं, तो आप देख सकते हैं कि इनपुट और अपेक्षित मानों के 2 सेट तैयार किए जा रहे हैं। दुर्भाग्य से, जहां प्रोजेक्ट साइट पर भी निर्माण का दस्तावेज नहीं है, कम से कम मुझे वहां नहीं मिला।
नीचे एक गिरी हुई परीक्षण लिपि का उदाहरण दिया गया है


जैसा कि आप देख सकते हैं कि परिणाम काफी पठनीय है। लाइन पर ध्यान दें actualSum.shouldBe expectedSumm । यह चीनी है, जो वास्तविक परिणाम के साथ अपेक्षित की जांच के लिए आसान प्रदान करता है।
IDE से स्क्रिप्ट चलाने के लिए, आपको एक ईजीबी प्लगइन इंस्टॉल करना होगा।
दूसरी कमी जो मैं नोट कर सकता हूं, वह यह है कि पिछली बार 2010 में ईजीबी को अपडेट किया गया था, जो कि मेरी राय में काफी समय से है।
विवरण के लिए , परियोजना वेबसाइट देखें।

स्पॉक

स्पॉक , जैसे ईज़ीबी ग्रूवी से आता है। Groovy / Grails Developers इसे इस्तेमाल करना पसंद करते हैं। हमारी स्क्रिप्ट इस तरह दिखाई देगी:
class SqrtSumAlgSpecTest extends Specification {
Algorithm alg
def "Sqrt sums scenarios"(){
when:
alg = new SqrtDecompositionSum(input.toArray(new int[0]))
then:
outputSumm == alg.calcSummBetween(leftIndex, rightIndex)
where:
input | leftIndex | rightIndex | outputSumm
[5, 10, -3, 17, 12, 1, -2, 13, -12] |2 |5 |27
[5, 8, 13, 5, 21, 6, 3, 7, -2, 4, 8, 12] |3 |10 |52
}
}


मैं स्पॉक को पसंद करता हूं जहां क्लॉज है। स्पॉक स्पेसिफिकेशन बनाने के लिए, आपको spock.lang.Specification से विरासत में मिली ग्रूवी क्लास बनाने की आवश्यकता है।
निम्नलिखित एक गिरा परीक्षण मामले का एक उदाहरण है:


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

ककड़ी

मैं हाल ही में ककड़ी से मिला, और जितना मैंने इसके साथ प्रयोग किया, उतना ही मुझे यह पसंद आया। पहले दो के विपरीत, ककड़ी रूबी से आती है। जावा और C # के लिए एक कार्यान्वयन है।
ककड़ी स्क्रिप्ट में दो फाइलें होती हैं: स्क्रिप्ट ही, और जावा, सी #, रूबी में इसका कार्यान्वयन। यह हमें स्क्रिप्ट को कार्यान्वयन से अलग करने की अनुमति देता है, जो स्क्रिप्ट को अंग्रेजी में बिल्कुल सामान्य कहानी बनाता है, हम एक उदाहरण देते हैं

Feature: Sqrt Sums Algorithm Feature
In order to ensure that my algorithm works
As a Developer
I want to run a quick Cuke4Duke test

Scenario Outline: Sqrt Sums Alg Scenario
Given The input array <input array>
When The calc sum between <Left index>, <Right index>
Then The summ is <output summ>.

Examples:
|input array |Left index |Right index|output summ|
|5, 10, -3, 17, 12, 1, -2, 13, -12 |2 |5 |27 |
|5, 8, 13, 5, 21, 6, 3, 7, -2, 4, 8, 12 |3 |10 |52


वैसे, ककड़ी में लिपियों को विशेषताएं कहा जाता है।
और यहाँ कार्यान्वयन है

public class SqrtsumsalgFeature {
private Algorithm alg;
private int result;

@Given ("^The input array ([\\d\\s\\-\\,]*)$")
public void theInputArray(String input) {
String[] split = input.split(",");
int[] arrayInput = new int[split.length];
for (int i = 0; i < arrayInput.length; i++) {
arrayInput[i] = Integer.valueOf(split[i].trim());
}
alg = new SqrtDecompositionSum(arrayInput);
}

@When ("^The calc sum between ([\\d]*), ([\\d]*)$")
public void theCalcSumBetween(int L, int R) {
result = alg.calcSummBetween(L, R);

}

@Then ("^The summ is ([\\d]*).$")
public void theSummIs(int expectedResult) {
Assert.assertThat(result, is(expectedResult));
}
}


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

नीचे एक पारित ककड़ी परीक्षण का एक उदाहरण है



यहाँ एक गिरी हुई विशेषता का एक उदाहरण है



मुझे इसके कार्यान्वयन से स्क्रिप्ट को अलग करना पसंद है। स्क्रिप्ट के साथ कार्यान्वयन को भ्रमित करने के लिए नियमित अभिव्यक्ति का उपयोग किसी को भ्रमित कर सकता है, लेकिन वे स्क्रिप्ट लेखक से छिपे हुए हैं, और अधिकांश डेवलपर्स उनसे परिचित हैं, इसलिए मैं इसे दोषों के लिए नहीं कहूंगा। Cuke4duke के बारे में जानकारी के लिए - जावा के लिए एक कार्यान्वयन, कृपया यहाँ जाएँ ।

परिणाम

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