स्पेल के साथ परीक्षण Grails - कौन सा मॉकिंग फ्रेमवर्क का चयन करें?

Question

मेरे पास अधिक सामान्य प्रश्न है। स्पॉक का उपयोग करते समय Grails 2.x में मॉकिंग के लिए मुझे किस ढांचे या कार्यान्वयन का उपयोग करना चाहिए?

मुझे कई मॉकिंग शैली पता है: लीवरेज ग्रोवी मेटा क्लास, ग्रेल्स मॉकफोर(), ग्रोवी मॉक(), ग्रोवी क्लोजर स्टाइल इत्यादि। उनमें से प्रत्येक के अपने फायदे और नुकसान हैं। लेकिन मुझे समझ में नहीं आता है कि कुछ मजाकिया शैली कुछ अवसरों में काम करती है जिन्हें मैं निर्धारित नहीं कर सकता (यानी mockFor() कुछ कार्यान्वयन के लिए काम करता है, न कि दूसरों के लिए)।

वर्तमान में मेरे पास सेवा विधि मॉकिंग के दो समान कार्यान्वयन हैं।

यह एक काम करता है:

@TestFor(MyController) 
@Mock([MyDevice]) 
class MyControllerSpec extends ControllerSpec { 

void "test st."() { 
     def myService = mockFor(MyService) 
     myService.demand.myMethod() { def st -> 
     return "test" 
     } 
     controller.myService = myService.createMock() 
} 
} 

हालांकि, इस कार्यान्वयन काम नहीं करता:

@TestFor(MyController) 
@Mock([MyDevice]) 
class MyControllerSpec extends ControllerSpec { 

void "test st."() { 
     def yourService = mockFor(YourService) 
     yourService.demand.yourMethod() { def st -> 
     return "test" 
     } 
     controller.yourService = yourService.createMock() 
} 
} 

सेवा कार्यान्वयन और नियंत्रक से फोन कर काफी समान है। तो Grails में मज़ाक करने का सबसे अच्छा अभ्यास क्या है? या क्या Grails के लिए कोई अच्छा मजाकिया ढांचा है जो मेरे समय को नकल करने के बारे में पता लगाएगा?

किसी भी सलाह के लिए धन्यवाद! :-)

Mateo

Answer 1

आप, परीक्षण के लिए स्पॉक ढांचे का उपयोग कर रहे हैं तो ढांचे से ही दिए गए विकल्पों और शैलियों का लाभ उठाने की कोशिश करो।

स्पॉक ढांचा एक बीडीडी [व्यवहार डिजाइन विकास] प्राप्त करने में मदद करता है। व्यवहार से मेरा मतलब था, आप विकास चक्र में व्यवसाय स्वीकृति परिदृश्य को कसकर जोड़ सकते हैं।

@TestFor(MyController) 
class MyControllerSpec extends ControllerSpec { 

    void "test service method in called once and only once"(){ 
     //Defines the behavior of setup 
     setup: "Only one invocation of service method" 
      def myService = Mock(MyService){ 
       //Make sure serviceMethod is called only once from the controller 
       //Beauty of Spock is that you can test the cardinality of 
       //method invocations. 
       1 * serviceMethod() >> "Hello" 
      } 
      controller.myService = myService 

      //The above process can be followed 
      //for stubbing/mocking 'YourService' and 
      //then injecting it to controller like 
      //controller.yourService = yourService 

     //Defines the behavior of action 
     when: "controller action is called" 
      controller.myAction() 

     //Defines the behavior of expected results 
     then: "Expect the stubbed service method output" 
      controller.response.contentAsString == "Hello" 
    } 
} 

//Controller 
def myAction() { 
    render myService.serviceMethod() 
} 

ऊपर दिखने वाला हैं, तो आप प्रत्येक चरण में व्यवहार को परिभाषित:

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

स्पॉक ढांचे का प्रभावी ढंग से उपयोग करने के तरीके के बारे में अधिक जानकारी के लिए, स्पॉक फ्रेमवर्क docs पर जाएं।