2012-06-13 26 views
5

¿Cuál es la mejor práctica para probar un servicio de Grails que depende de otro servicio? El mixin predeterminado TestFor inyectar correctamente el servicio que se está probando, por ejemplo:Grails pruebas de integración con servicios múltiples

@TestFor(TopService) 
class TopServiceTests { 
    @Test 
    void testMethod() { 
     service.method() 
    } 
} 

pero si mi instancia de Topservice (servicio) se basa en otro servicio, como InnerService:

class TopService { 
    def innerService 
} 

innerService no será disponible, la inyección de dependencia no parece llenar esta variable. ¿Cómo debo proceder?

+0

Pruebe extiende 'GroovyTestCase' en su prueba. –

Respuesta

8

Las pruebas de integración no deben usar la anotación @TestFor, deben extend GroovyTestCase. Las anotaciones de prueba son solo para pruebas unitarias (y tendrán un mal comportamiento cuando se utilicen en pruebas de integración, especialmente las anotaciones @Mock). Estás viendo uno de esos malos comportamientos ahora.

Si extiende GroovyTestCase continuación, puede simplemente tener

def topService 

En la parte superior de la prueba y se obtendrá inyectados con todas sus dependencias inyectar.

Para un caso de prueba unitaria, solo querría agregar nuevas instancias de servicios asociados a su servicio en un método setUp. Al igual que:

@TestFor(TopService) 
class TopServiceTests { 
    @Before public void setUp() { 
     service.otherService = new OtherService() 
    } 
    ... 
+0

¡Gracias! Finalmente lo entendí con tu explicación;) Me equivoqué un poco con los comentarios de http://stackoverflow.com/questions/2272677/dependency-injection-in-grails-integration-tests "Las pruebas de integración no deberían extender GrailsUnitTestCase" . No estoy seguro de entender por completo las diferencias entre GroovyTestCase y GrailsUnitTestCase ... – Wavyx

+1

La mayor diferencia (que termina mordiendo a las personas) es que el caso de prueba de unidad hace mucho más en la forma de burlarse y jugar con el metaClass en setUp y tearDown. La burla es algo que las pruebas de integración no necesitan ya que ya han inyectado cosas reales. También significa que cuando finalicen las pruebas de integración, es malo que se ejecute la prueba unitaria tearDown, ya que puede eliminar los cambios en la metaClass (como los métodos GORM dinámicos) que se supone que existen y que las pruebas de integración posteriores esperan. –

1

Tengo un CustomerRegistrationServiceTest y mi CustomerRegistrationService depende del PasswordService.

mi CustomerRegistrationService simplemente autowires que como normal:

class CustomerRegistrationService { 
    def passwordService 

En mi CustomerRegistrationServiceTest tengo:

@TestFor(CustomerRegistrationService) 
@Mock(Customer) 
class CustomerRegistrationServiceTests extends GrailsUnitTestMixin { 

    void setUp() { 
     mockService(PasswordService) 
    } 

Así que cuando pruebo la CustomerRegistrationService, es capaz de acceder al PasswordService

+1

Gracias. De hecho, burlarse parece ser el camino a seguir, pero más para una unidad de prueba en mi humilde opinión. Para las pruebas de integración, prefiero probar el entorno en toda regla. – Wavyx

Cuestiones relacionadas