Untersuchung der Graillen mit Spock - Welches Versprühungsgerüst wählen?

Question

Ich habe allgemeinere Frage. Welchen Rahmen oder welche Implementierung sollte ich in Grails 2.x verwenden, wenn ich Spock benutze?

Ich kenne Tonnen von Spott Stil: Hebel Groovy MetaClass, Grails MockFor(), Groovy Mock(), Groovy Schließung Stil, etc. Jeder von ihnen hat seine eigenen Vor- und Nachteile. Aber was ich nicht verstehe, ist, dass ein spöttischer Stil bei bestimmten Gelegenheiten funktioniert, die ich nicht bestimmen kann (d. H. MockFor() funktioniert für bestimmte Implementierungen und nicht für die anderen).

Derzeit habe ich zwei ähnliche Implementierung von Service-Methode spöttisch.

Dies funktioniert:

@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() 
} 
} 

Die Service-Implementierung und von der Steuerung Aufruf ist ganz ähnlich:

@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() 
} 
} 

jedoch diese Umsetzung nicht funktioniert. Was ist also die beste Methode, sich in Grails zu verspotten? Oder gibt es irgendeinen GUTEN Spottrahmen für Grails, der mir die Zeit sparen würde, herauszufinden, wie man spotten kann?

Danke für jede Beratung! :-)

Mateo

Answer 1

Wenn Sie spock Rahmen für den Test verwenden, dann versuchen Sie die Optionen und Stile von Rahmen selbst vorgesehen zu nutzen.

Spock Framework hilft bei der Erreichung einer BDD [Behavioral Design Development]. Durch das Verhalten, das ich meinte, können Sie das Geschäftsakzeptanzszenario eng an den Entwicklungszyklus koppeln.

habe ich versucht, Ihren Testfall geschrieben in Spock zu bekommen, da es als neu geschrieben werden kann:

@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() 
} 

Wenn Sie oben sehen, definieren Sie das Verhalten in jedem Schritt. Aus Unternehmenssicht wird dieses Verhalten von BA oder den Stakeholdern gesteuert. Auf diese Weise erfüllen Sie ATDD/BDD (Acceptance Test Driven Dev/Behavior Test Driven Dev) und eventuell eine TDD (Test Driven Dev) für Ihr Projekt.

Weitere Informationen zur effektiven Verwendung von spock framework finden Sie unter spock framework docs.