मैं एमएसटीएक्स्ट/एक्सयूनीट फ्रेमवर्क के साथ संदर्भ/विनिर्देश शैली इकाई परीक्षण कैसे लिखूं?

Question

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

बस क्या मैं हासिल करने के लिए कोशिश कर रहा हूँ समझाने के लिए है, तो यहां मैं एक MSpec परीक्षण

[Subject(typeof(Calculator))]  
public class when_I_add_two_numbers : with_calculator 
{ 
    Establish context =() => this.Calculator = new Calculator(); 
    Because I_add_2_and_4 =() => this.Calculator.Add(2).Add(4); 
    It should_display_6 =() => this.Calculator.Result.ShouldEqual(6); 
} 

public class with_calculator 
{ 
    protected static Calculator; 
} 

MSTest साथ

तो मैं (इस तरह की परीक्षा लिखने के लिए हालांकि आप देख सकते हैं यह जीता कोशिश करेगा लिखने करेंगे 'टी काम करते हैं क्योंकि मैं 2 में TestInitialize विशेषताओं रख दिया है, लेकिन आप मुझे क्या करना कोशिश कर रहा हूँ मिल ..)

[TestClass] 
public class when_I_add_two_numbers : with_calculator 
{ 
    [TestInitialize] 
    public void GivenIHaveACalculator() 
    { 
     this.Calculator = new Calculator(); 
    } 

    [TestInitialize] 
    public void WhenIAdd2And4() 
    { 
     this.Calculator.Add(2).Add(4); 
    } 

    [TestMethod] 
    public void ThenItShouldDisplay6() 
    { 
     this.Calculator.Result.ShouldEqual(6); 
    } 
} 

public class with_calculator 
{ 
    protected Calculator Calculator {get;set;} 
} 

किसी MSTest के साथ इस तरह से परीक्षण लिखने के लिए कुछ और अधिक सुरुचिपूर्ण सुझाव के साथ आ सकते हैं ?

Answer 1

क्या आप इस बारे में सोचते हैं:

[TestClass] 
public class when_i_add_two_numbers : with_calculator 
{ 
    public override void When() 
    { 
     this.calc.Add(2, 4); 
    } 

    [TestMethod] 
    public void ThenItShouldDisplay6() 
    { 
     Assert.AreEqual(6, this.calc.Result); 
    } 

    [TestMethod] 
    public void ThenTheCalculatorShouldNotBeNull() 
    { 
     Assert.IsNotNull(this.calc); 
    } 
} 

public abstract class with_calculator : SpecificationContext 
{ 
    protected Calculator calc; 

    public override void Given() 
    { 
     this.calc = new Calculator(); 
    } 
} 

public abstract class SpecificationContext 
{ 
    [TestInitialize] 
    public void Init() 
    { 
     this.Given(); 
     this.When(); 
    } 

    public virtual void Given(){} 
    public virtual void When(){} 
} 

public class Calculator 
{ 
    public int Result { get; private set; } 
    public void Add(int p, int p_2) 
    { 
     this.Result = p + p_2; 
    } 
} 

Answer 2

Mark Nijhof अपने Fohjin.DDD github repository में NUnit के साथ देखते हुए-जब-तब शैली परीक्षण कर की an example है।

यहाँ उदाहरण से एक अंश ऊपर संदर्भित है:

public class When_registering_an_domain_event : BaseTestFixture<PreProcessor> 
{ 
    /* ... */ 

    protected override void When() 
    { 
     SubjectUnderTest.RegisterForPreProcessing<ClientMovedEvent>(); 
     SubjectUnderTest.Process(); 
    } 

    [Then] 
    public void Then_the_event_processors_for_client_moved_event_will_be_registered() 
    { 
     IEnumerable<EventProcessor> eventProcessors; 
     EventProcessorCache.TryGetEventProcessorsFor(typeof(ClientMovedEvent), out eventProcessors); 
     eventProcessors.Count().WillBe(1); 
    } 
} 

और तुम base class implementation में देखते हुए देख सकते हैं:

[Given] 
public void Setup() 
{ 
    CaughtException = new NoExceptionWasThrownException(); 
    Given(); 

    try 
    { 
     When(); 
    } 
    catch (Exception exception) 
    { 
     CaughtException = exception; 
    } 
    finally 
    { 
     Finally(); 
    } 
} 

Answer 3

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

निम्नलिखित एक NUnit को देखते हुए परीक्षण का एक उदाहरण है:

[Story(AsA = "car manufacturer", 
     IWant = "a factory that makes the right cars", 
     SoThat = "I can make money")] 
public class when_building_a_toyota : Specification 
{ 
    static CarFactory _factory; 
    static Car _car; 

    given a_car_factory =() => 
           { 
            _factory = new CarFactory(); 
           }; 

    when building_a_toyota =() => _car = _factory.Make(CarType.Toyota); 

    [then] 
    public void it_should_create_a_car() 
    { 
     _car.ShouldNotBeNull(); 
    } 

    [then] 
    public void it_should_be_the_right_type_of_car() 
    { 
     _car.Type.ShouldEqual(CarType.Toyota); 
    } 
} 

मैं अपना सर्वश्रेष्ठ करने की कोशिश की Dan North's Introducting BDD ब्लॉग से अवधारणाओं को सही रहने के लिए, और इस तरह के रूप में, सब कुछ का उपयोग किया जाता दी, जब, तो विनिर्देश की शैली। जिस तरह से इसे कार्यान्वित किया जाता है, वह आपको कई गिफ्ट और यहां तक ​​कि एकाधिक होने की अनुमति देता है, और क्रम में निष्पादित किया जाना चाहिए (अभी भी इसमें जांच कर रहा है)।

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

हालांकि, मुझे लगता है कि भुगतान, रिपोर्टिंग में है। परीक्षण धावक, परिदृश्य आपके द्वारा बनाया गया से भर जाता है ताकि एक नज़र में आप क्या प्रत्येक परीक्षा वास्तव में कोड में गोता बिना कर रहा है के बारे में जानकारी प्राप्त कर सकते हैं: टी -4 का उपयोग कर

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

असफल परीक्षण रंग लाल होंगे और अपवाद विवरण देखने के लिए क्लिक किया जा सकता है।

यह बहुत अधिक है। मैं इसे कई परियोजनाओं में उपयोग कर रहा हूं जिन पर मैं काम कर रहा हूं, इसलिए यह अभी भी सक्रिय रूप से विकसित हो रहा है, लेकिन मैं कोर को बहुत स्थिर के रूप में वर्णित करता हूं। मैं विरासत की बजाय संरचना द्वारा संदर्भ साझा करने का एक तरीका देख रहा हूं, इसलिए यह संभवतः पाइक के नीचे आने वाले अगले परिवर्तनों में से एक होगा। आलोचना लाओ। :)

Answer 4

आप इस तरह NUnit.Specifications इस्तेमाल कर सकते हैं और लिखने परीक्षण:

using NUnit.Specifications; 
using Should; 

public class OrderSpecs 
{ 
    [Component] 
    public class when_a_customer_places_an_order : ContextSpecification 
    { 
     static OrderService _orderService; 
     static bool _results; 
     static Order _order; 

     Establish context =() => 
     { 
      _orderService = new OrderService(); 
      _order = new Order(); 
     }; 

     Because of =() => _results = _orderService.PlaceOrder(_order); 

     It should_successfully_place_the_order =() => _results.ShouldBeTrue(); 
    } 
} 

Answer 5

MSTestEnhancer आप मदद कर सकते हैं, और आप के माध्यम से पैकेज मिल सकता है।

---

यहाँ नमूना कोड है:

[TestClass] 
public class TheTestedClassTest 
{ 
    [ContractTestCase] 
    public void TheTestedMethod() 
    { 
     "When Xxx happens, results in Yyy.".Test(() => 
     { 
      // Write test case code here... 
     }); 

     "When Zzz happens, results in Www.".Test(() => 
     { 
      // Write test case code here... 
     }); 
    } 
} 

और जब आप अपने परीक्षा परिणाम देखते हैं, तो आप इस नीचे मिलेगा:

मैं के लिए एक पोस्ट में लिखा है इसके बारे में अधिक जानकारी प्रस्तुत करें। अधिक जानकारी के लिए Introducing MSTestEnhancer to make unit test result easy to read - walterlv देखें।