A diferencia de muchas plataformas, Java adolece de una falta de bibliotecas de stub de conexión. Si has estado en este mundo durante mucho tiempo, entonces probablemente deberías estar familiarizado con WireMock, Betamax o incluso Spock. Muchos desarrolladores en las pruebas usan Mockito para describir el comportamiento de los objetos, DataJpaTest con una base de datos h2 local, pruebas de Cucumber. Hoy conocerá una alternativa liviana que lo ayudará a lidiar con varios problemas que puede encontrar al usar estos enfoques. En particular, anyStub intenta resolver los siguientes problemas:

• simplificar la configuración del entorno de prueba
• automatizar la recopilación de datos para pruebas
• manténgase en la prueba de su aplicación y evite probar para otra cosa

¿Qué es anyStub y cómo funciona?

AnyStub ajusta las llamadas de función, tratando de encontrar las llamadas coincidentes que ya se han grabado. Pueden suceder dos cosas con esto:

• si hay una llamada coincidente, anyStub restaurará el resultado registrado asociado con esa llamada y lo devolverá
• si no hay una llamada coincidente y se permite el acceso al sistema externo, anyStub hará esta llamada, registrará este resultado y lo devolverá

Fuera de la caja, anyStub proporciona envoltorios para el cliente http de Apache HttpClient para crear apéndices para solicitudes http y varias interfaces de javax.sql. * Para conexiones de base de datos. También se le proporciona una API para crear apéndices para otras conexiones.

AnyStub es una biblioteca de clases simple y no requiere una configuración especial de su entorno. Esta biblioteca está diseñada para trabajar con aplicaciones de arranque por resorte y obtendrá el máximo beneficio al seguir esta ruta. Puede usarlo fuera de Spring, en aplicaciones Java simples, pero definitivamente tendrá que hacer un trabajo adicional. La siguiente descripción se centra en probar aplicaciones de arranque por resorte.

Veamos las pruebas de integración. Esta es la forma más emocionante y completa de probar su sistema. De hecho, spring-boot y JUnit hacen casi todo por ti cuando escribes anotaciones mágicas:

@RunWith(SpringRunner.class) @SpringBootTest 

En la actualidad, las pruebas de integración se subestiman y se utilizan de forma limitada, y algunos desarrolladores las evitan. Esto se debe principalmente a la larga preparación y mantenimiento de las pruebas o la necesidad de una configuración especial del entorno en los servidores de compilación.

Con anyStub, no tiene que paralizar el contexto de primavera. En cambio, mantener el contexto cercano a la configuración de producción es simple y directo.

En este ejemplo, veremos cómo conectar anyStub a un Consuming a RESTful Web Service del manual de Pivotal.

Conectar una biblioteca a través de pom.xml

  <dependency> <groupId>org.anystub</groupId> <artifactId>anystub</artifactId> <version>0.2.27</version> <scope>test</scope> </dependency> 

El siguiente paso es modificar el contexto de primavera.

 package hello; import org.anystub.http.StubHttpClient; import org.apache.http.client.HttpClient; import org.apache.http.impl.client.HttpClientBuilder; import org.springframework.boot.web.client.RestTemplateBuilder; import org.springframework.boot.web.client.RestTemplateCustomizer; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.http.client.HttpComponentsClientHttpRequestFactory; import org.springframework.web.client.RestTemplate; @Configuration public class TestConfiguration { @Bean public RestTemplateBuilder builder() { RestTemplateCustomizer restTemplateCustomizer = new RestTemplateCustomizer() { @Override public void customize(RestTemplate restTemplate) { HttpClient real = HttpClientBuilder.create().build(); StubHttpClient stubHttpClient = new StubHttpClient(real); HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(); requestFactory.setHttpClient(stubHttpClient); restTemplate.setRequestFactory(requestFactory); } }; return new RestTemplateBuilder(restTemplateCustomizer); } } 

Esta modificación no cambia las relaciones de componentes en la aplicación, sino que solo reemplaza la implementación de una única interfaz. Esto nos envía al Principio de sustitución de Barbara Lisk . Si el diseño de su aplicación no lo viola, esta sustitución no violará la funcionalidad.

Todo esta listo. Este proyecto ya incluye una prueba.

 @RunWith(SpringRunner.class) @SpringBootTest public class ApplicationTest { @Autowired private RestTemplate restTemplate; @Test public void contextLoads() { assertThat(restTemplate).isNotNull(); } } 

Esta prueba está vacía, pero ya está ejecutando el contexto de la aplicación. La diversión comienza aquí . Como dijimos anteriormente, el contexto de la aplicación en la prueba coincide con el contexto de trabajo en el que se crea CommandLineRunner en el que se ejecuta la solicitud http al sistema externo.

 @SpringBootApplication public class Application { private static final Logger log = LoggerFactory.getLogger(Application.class); public static void main(String args[]) { SpringApplication.run(Application.class); } @Bean public RestTemplate restTemplate(RestTemplateBuilder builder) { return builder.build(); } @Bean public CommandLineRunner run(RestTemplate restTemplate) throws Exception { return args -> { Quote quote = restTemplate.getForObject( "https://gturnquist-quoters.cfapps.io/api/random", Quote.class); log.info(quote.toString()); }; } } 

Esto es suficiente para demostrar el funcionamiento de la biblioteca. Después de comenzar las pruebas por primera vez, encontrará el nuevo complete/src/test/resources/anystub/stub.yml .

 request0: exception: [] keys: [GET, HTTP/1.1, 'https://gturnquist-quoters.cfapps.io/api/random'] values: [HTTP/1.1, '200', OK, 'Content-Type: application/json;charset=UTF-8', 'Date: Thu, 25 Apr 2019 23:04:49 GMT', 'X-Vcap-Request-Id: 5ffce9f3-d972-4e95-6b5c-f88f9b0ae29b', 'Content-Length: 177', 'Connection: keep-alive', '{"type":"success","value":{"id":3,"quote":"Spring has come quite a ways in addressing developer enjoyment and ease of use since the last time I built an application using it."}}'] 

Que paso spring-boot ha incorporado RestTemplateBuilder desde la configuración de prueba a la aplicación. Esto llevó a la aplicación a trabajar a través de la implementación del código auxiliar del cliente http. StubHttpClient interceptó la solicitud, no encontró el archivo apéndice, ejecutó la solicitud, guardó el resultado en un archivo y devolvió el resultado recuperado del archivo.

A partir de ahora, puede ejecutar esta prueba sin conexión a Internet y esta solicitud será exitosa. restTemplate.getForObject() devolverá el mismo resultado. Puede confiar en este hecho en sus futuras pruebas.

Puede encontrar todos los cambios descritos en GitHub .

De hecho, todavía no hemos creado una sola prueba. Antes de escribir pruebas, veamos cómo funciona con las bases de datos.

En este ejemplo, agregaremos una prueba de integración para acceder a datos relacionales usando JDBC con Spring del tutorial fundamental.

La configuración de prueba para este caso se ve así:

 package hello; import org.anystub.jdbc.StubDataSource; import org.h2.jdbcx.JdbcDataSource; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import javax.sql.DataSource; @Configuration public class TestConfiguration { @Bean public DataSource dataSource() { JdbcDataSource ds = new JdbcDataSource(); ds.setURL("jdbc:h2:./test"); return new StubDataSource(ds); } } 

Aquí, se crea un origen de datos regular a una base de datos externa y se envuelve con una implementación de código auxiliar: la clase StubDataSource. Spring-boot lo incorpora en contexto. También necesitamos crear al menos una prueba para ejecutar el contexto de primavera en la prueba.

 package hello; import org.anystub.AnyStubId; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.test.context.junit4.SpringRunner; import static org.junit.Assert.*; @RunWith(SpringRunner.class) @SpringBootTest public class ApplicationTest { @Test @AnyStubId public void test() { } } 

Esto es nuevamente una prueba vacía: su única tarea es ejecutar el contexto de la aplicación. Aquí vemos una anotación muy importante @AnystubId , pero aún no estará involucrada.

Después de la primera ejecución, encontrará un nuevo src/test/resources/anystub/stub.yml que incluye todas las llamadas a la base de datos. Te sorprenderá cómo funciona la primavera detrás de escena con bases de datos. Tenga en cuenta que las nuevas ejecuciones de la prueba no conducirán a un acceso real a la base de datos. Si elimina test.mv.db, no aparecerá después de repetidas ejecuciones de las pruebas. El conjunto completo de cambios se puede ver en GitHub .

Para resumir. con anyStub:

• no necesita configurar específicamente un entorno de prueba
• las pruebas se realizan con datos reales
• la primera ejecución de las pruebas prueba sus suposiciones y guarda los datos de la prueba, las siguientes verifican que el sistema no se haya degradado

Probablemente tenga preguntas: ¿cómo cubre esto los casos en que la base de datos aún no existe, qué hacer con las pruebas negativas y el manejo de excepciones? Volveremos a esto, pero primero, nos ocuparemos de escribir pruebas simples.

Ahora estamos experimentando con Consumir un servicio web RESTful . Este proyecto no contiene componentes que se puedan probar. A continuación se crean dos clases, que deben representar dos capas de un diseño de arquitectura.

 package hello; import org.springframework.stereotype.Component; import org.springframework.web.client.RestTemplate; @Component public class DataProvider { private final RestTemplate restTemplate; public DataProvider(RestTemplate restTemplate) { this.restTemplate = restTemplate; } Quote provideData() { return restTemplate.getForObject( "https://gturnquist-quoters.cfapps.io/api/random", Quote.class); } } 

DataProvider proporciona acceso a datos en volátil sistema externo

 package hello; import org.springframework.stereotype.Component; @Component public class DataProcessor { private final DataProvider dataProvider; public DataProcessor(DataProvider dataProvider) { this.dataProvider = dataProvider; } int processData() { return dataProvider.provideData().getValue().getQuote().length(); } } 

DataProcessor procesará datos de un sistema externo.

Tenemos la intención de probar el DataProcessor . Es necesario probar la corrección del algoritmo de procesamiento y proteger el sistema de la degradación de futuros cambios.

Para lograr estos objetivos, puede considerar crear un objeto simulado DataProvider con un conjunto de datos y pasarlo al constructor DataProcessor en las pruebas. Otra forma podría ser descomponer el DataProcessor para resaltar el procesamiento de la clase Quote. Entonces, tal clase es fácil de probar usando pruebas unitarias (seguramente, este es el método recomendado en libros respetados sobre código limpio). Intentemos evitar los cambios de código y la invención de los datos de prueba y simplemente escriba una prueba.

 @RunWith(SpringRunner.class) @SpringBootTest public class DataProcessorTest { @Autowired private DataProcessor dataProcessor; @Test @AnyStubId(filename = "stub") public void processDataTest() { assertEquals(131, dataProcessor.processData()); } } 

Es hora de hablar sobre la anotación @AnystubId. Esta anotación ayuda a administrar y controlar archivos de código auxiliar en las pruebas. Se puede usar con una clase de prueba o su método. Esta anotación configura un archivo apéndice individual para el área correspondiente. Si cualquier área está cubierta simultáneamente por anotaciones de nivel de clase y método, la anotación de método tiene prioridad. Esta anotación tiene el parámetro de nombre de archivo, que define el nombre del archivo apéndice. la extensión ".yml" se agrega automáticamente si se omite. Al ejecutar esta prueba, no encontrará un nuevo archivo. El src/test/resources/anystub/stub.yml ya se creó anteriormente y esta prueba lo reutilizará. Obtuvimos el número 131 de este código analizando el resultado de la consulta.

  @Test @AnyStubId public void processDataTest2() { assertEquals(131, dataProcessor.processData()); Base base = getStub(); assertEquals(1, base.times("GET")); assertTrue(base.history().findFirst().get().matchEx_to(null, null, ".*gturnquist-quoters.cfapps.io.*")); } 

En esta prueba, la anotación @AnyStubId aparece sin el parámetro de nombre de archivo. En este caso, src/test/resources/anystubprocessDataTest2.yml . El nombre del archivo se crea a partir del nombre de la función (clase) + ".yml". Una vez que anyStub crea un nuevo archivo para esta prueba, debe realizar una llamada real al sistema. Y es nuestra suerte que la nueva cita tenga la misma longitud. Las dos últimas comprobaciones muestran cómo probar el comportamiento de la aplicación. Está disponible para usted: seleccionando consultas por parámetros o partes de parámetros y contando el número de consultas. Hay varias variaciones de los tiempos y las funciones de coincidencia que se pueden encontrar en la documentación .

  @Test @AnyStubId(requestMode = RequestMode.rmTrack) public void processDataTest3() { assertEquals(79, dataProcessor.processData()); assertEquals(79, dataProcessor.processData()); assertEquals(168, dataProcessor.processData()); assertEquals(79, dataProcessor.processData()); Base base = getStub(); assertEquals(4, base.times("GET")); } 

En esta prueba, @AnyStubId aparece con el nuevo parámetro requestMode. Le permite administrar permisos para archivos stub. Hay dos aspectos a controlar: búsqueda de archivos y permiso para llamar a un sistema externo.

RequestMode.rmTrack establece las siguientes reglas: si el archivo acaba de crearse, todas las solicitudes se envían al sistema externo y se escriben en el archivo con las respuestas, independientemente de si hay una solicitud idéntica en el archivo (se permiten duplicados en el archivo). Si antes de ejecutar las pruebas existe el archivo apéndice, las solicitudes al sistema externo están prohibidas. Las llamadas se esperan exactamente en la misma secuencia. Si la siguiente solicitud no coincide con la solicitud en el archivo, se genera una excepción.

RequestMode.rmNew este modo está activado por defecto. Cada solicitud se busca en el archivo apéndice. Si se encuentra una solicitud coincidente: el resultado correspondiente se restaura desde el archivo, la solicitud al sistema externo se pospone. Si no se encuentra la solicitud, se solicita el sistema externo, el resultado se guarda en un archivo. Solicitudes duplicadas en el archivo: no se producen.

RequestMode.rmNone Cada solicitud se busca en un archivo RequestMode.rmNone . Si se encuentra una consulta coincidente, su resultado se restaura desde el archivo. Si la prueba genera una solicitud que no está en el archivo, se genera una excepción.

RequestMode.rmAll antes de la primera solicitud, se borra el archivo RequestMode.rmAll . Todas las solicitudes se escriben en el archivo (se permiten duplicados en el archivo). Puede usar este modo si desea ver cómo funciona la conexión.

RequestMode.rmPassThrough todas las solicitudes se envían directamente al sistema externo, sin pasar por el código auxiliar de implementación.

Estos cambios están disponibles en GitHub.

Que mas

Vimos cómo anyStub guarda las respuestas. Si se produce una excepción al acceder a un sistema externo, anyStub lo guardará y lo reproducirá en solicitudes posteriores.

A menudo, las clases de nivel superior generan excepciones, mientras que las clases de conexión reciben una respuesta válida (probablemente con un código de error). En este caso, anyStub es responsable de reproducir la respuesta con el código de error, y las clases de nivel superior también arrojarán excepciones para sus pruebas.

Agregue archivos de resguardo al repositorio.

No tenga miedo de eliminar y sobrescribir archivos de código auxiliar.

Administre archivos stub con prudencia. Puede reutilizar un archivo en varias pruebas o proporcionar un archivo individual para cada prueba. Aproveche esta oportunidad para sus necesidades. Pero, por lo general, usar un solo archivo con diferentes modos de acceso es una mala idea.

Estas son todas las características principales de anyStub.