2009-07-08 9 views
9

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

  1. आप इस डेटा को व्यवस्थित/बनाए रखते हैं?
  2. आप इसे अपने यूनिट परीक्षण (किसी भी स्वचालन उपकरण) पर कैसे लागू करते हैं?
  3. क्या आपको वास्तव में परीक्षण डेटा की आवश्यकता है या आपको लगता है कि यह बेकार है?

मेरे वर्तमान समाधान:

मैं मास्टर डेटा और नमूना डेटा जहां पूर्व से उपलब्ध हो जाएगा के बीच अंतर है जब सिस्टम उत्पादन (पहली बार के लिए स्थापित) में चला जाता है और बाद सामान्य परीक्षण मामले हैं जिन्हें मुझे चलाने के लिए आवश्यक है (और विकास के दौरान खेलने के लिए)।

मैं इसे एक्सेल फ़ाइल में संग्रहीत करता हूं (क्योंकि यह बनाए रखना इतना आसान है) जहां प्रत्येक वर्कशीट में एक विशिष्ट इकाई होती है (जैसे उपयोगकर्ता, ग्राहक इत्यादि) और मास्टर या नमूना ध्वजांकित किया जाता है।

2 परीक्षण मामलों जो मैं (याद आती है) आवश्यक डेटा आयात करने के लिए उपयोग किया है:

  1. InitForDevelopment (बनाएं स्कीमा, आयात मास्टर डेटा, आयात नमूना डेटा)
  2. InitForProduction (स्कीमा, आयात मास्टर बनाएं डेटा)

उत्तर

12

मैं भंडार पैटर्न का उपयोग करें और एक डमी भंडार है कि प्रश्न में इकाई परीक्षण द्वारा instantiated रहा है, यह डेटा का एक ज्ञात सेट है कि एक उदाहरण है कि दोनों के भीतर और विभिन्न क्षेत्रों के लिए सीमा से बाहर हैं शामिल हैं प्रदान करता है।

इसका मतलब है कि मैं टेस्ट यूनिट से परीक्षण इकाई या रनटाइम पर उत्पादन भंडार (निर्भरता इंजेक्शन (कैसल) के माध्यम से तत्काल भंडार की आपूर्ति करके अपरिवर्तित मेरे कोड का परीक्षण कर सकता हूं।

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

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

मेरे वर्तमान परियोजना में मैं इस प्रकार एक अंतरफलक है:

namespace myProject.Abstract 
{ 
    public interface ISeriesRepository 
    { 
     IQueryable<Series> Series { get; } 
    } 
} 

यह दोनों मेरे लाइव डाटा भंडार (एसक्यूएल को LINQ का उपयोग) के रूप में कार्यान्वित किया जाता है और यह भी इस तरह एक नकली भंडार:

namespace myProject.Tests.Respository 
{ 
    class FakeRepository : ISeriesRepository 
    { 
     private static IQueryable<Series> fakeSeries = new List<Series> { 
      new Series { id = 1, name = "Series1", openingDate = new DateTime(2001,1,1) }, 
      new Series { id = 2, name = "Series2", openingDate = new DateTime(2002,1,30), 
      ... 
      new Series { id = 10, name = "Series10", openingDate = new DateTime(2001,5,5) 
     }.AsQueryable(); 

     public IQueryable<Series> Series 
     { 
      get { return fakeSeries; } 
     } 
    } 
} 

फिर डेटा का उपभोग करने वाला वर्ग कन्स्ट्रक्टर को रिपोजिटरी संदर्भ पास करने के लिए तत्काल है:

namespace myProject 
{ 
    public class SeriesProcessor 
    { 
     private ISeriesRepository seriesRepository; 

     public void SeriesProcessor(ISeriesRepository seriesRepository) 
     { 
      this.seriesRepository = seriesRepository; 
     } 

     public IQueryable<Series> GetCurrentSeries() 
     { 
      return from s in seriesRepository.Series 
        where s.openingDate.Date <= DateTime.Now.Date 
        select s; 
     } 
    } 
} 

तब मेरे परीक्षण में मैं इसे इस प्रकार से संपर्क कर सकता:

namespace myProject.Tests 
{ 
    [TestClass] 
    public class SeriesTests 
    { 
     [TestMethod] 
     public void Meaningful_Test_Name() 
     { 
      // Arrange 
      SeriesProcessor processor = new SeriesProcessor(new FakeRepository()); 

      // Act 
      IQueryable<Series> currentSeries = processor.GetCurrentSeries(); 

      // Assert 
      Assert.AreEqual(currentSeries.Count(), 10); 
     } 

    } 
} 

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

+0

एक दिलचस्प दृष्टिकोण की तरह लगता है, लेकिन किसी भी तरह से मैं इसे पूरी तरह से समझ नहीं पा रहा हूं। क्या आपके पास इस दृष्टिकोण के लिए वेब पर कोई संदर्भ है? – Michal

1

हमारी कंपनी में हम इन समस्याओं को सप्ताह और महीने के बाद से समय की एक गुच्छा पर चर्चा करते हैं।

इकाई परीक्षण के दिशानिर्देश का पालन करें:

प्रत्येक परीक्षा atomar होना चाहिए और एक दूसरे से संबंधित (कोई डेटा साझा), यानी, प्रत्येक tust होना चाहिए शुरुआत में वहाँ स्वयं के डेटा है की अनुमति नहीं है और अंत में डेटा साफ़ करें।

आउट उत्पाद इतना जटिल (5 साल का विकास, डेटाबेस में 100 से अधिक टेबल) है, जो स्वीकार्य तरीके से इसे बनाए रखना लगभग असंभव है।

हमने डेटाबेस स्क्रिप्ट्स को आजमाया, जो टेस्ट से पहले/बाद में डेटा बनाता है और हटा देता है (स्वचालित तरीके हैं जो इसे कॉल करते हैं)।

मैं कहूंगा कि आप एक्सेल फ़ाइलों के साथ एक अच्छे तरीके से हैं। मुझ से

विचार यह एक छोटे अच्छी तरह से बनाने के लिए:

  • आप "NDBUnit" के लिए अपने सॉफ़्टवेयर गूगल के पीछे एक डेटाबेस है। यह इकाई परीक्षणों के लिए डेटाबेस में डेटा डालने और हटाने के लिए एक ढांचा है।
  • यदि आपके पास कोई डेटाबेस नहीं है तो एक्सएमएल एक्सेल जैसे सिस्टम पर थोड़ा अधिक लचीला है।
1

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

मुझे लगता है कि मॉक ऑब्जेक्ट्स का उपयोग करके एक विशिष्ट ठोस कार्यान्वयन आप वास्तविक डेटा की मात्रा को कम कर सकते हैं जिसे आप उपयोग करने के लिए आवश्यक हैं, क्योंकि आप उनके द्वारा पास किए गए डेटा को संसाधित नहीं करते हैं। वे ठीक उसी तरह प्रदर्शन करते हैं जैसे आप उन्हें चाहते हैं।

मुझे अभी भी यकीन है कि आपको शायद कई उदाहरणों में डमी डेटा की आवश्यकता है, अगर आप पहले से ही उपयोग कर रहे हैं या नकली ढांचे के बारे में जानते हैं।

1

बस स्पष्ट होने के लिए, आपको यूनिट परीक्षण (अन्य मॉड्यूल पर कोई अंतर्निहित निर्भरता वाले मॉड्यूल का परीक्षण करें) और ऐप परीक्षण (एप्लिकेशन के परीक्षण भाग) के बीच अंतर करने की आवश्यकता है।

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

उत्तरार्द्ध के लिए, वही मॉकिंग फ्रेमवर्क उपयोगी है, साथ ही परीक्षण डेटा सेट बनाने की क्षमता (जिसे प्रत्येक परीक्षण के लिए रीसेट किया जा सकता है)। परीक्षण के लिए लोड किया जाने वाला डेटा किसी ऑफ़लाइन स्टोरेज में रह सकता है जिसे आप लोड कर सकते हैं - सिबबेस डीबी डेटा, एक्सएमएल के लिए बीसीपी फाइलें, जो भी आपकी कल्पना को गुदगुदी करती है। हम दोनों बीसीपी और एक्सएमएल का उपयोग करते हैं।

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

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