Prueba De Integracion Dummy con Ant

En diferentes oportunidades nos surge la necesidad de realizar pruebas de Integración contra servidores o servicios que no están disponibles por X motivo.

Este es un ejemplo de solución para un servicio que consume un Conector, el cuál le pega a una plataforma que no está disponible. Utilizando una clase Mock y un poco de ant, podemos generar un distribuible que nos sirva para probar el servicio de manera Mock.

Contexto

Supongamos que tenemos un servicio que estamos exponiendo, que internamente se comunica con un conector mediante una librería cliente. Lo hace mediante este Dao

@Repository public class ConectorDaoImpl implements ConectorDao {

   /**
    * Conector delegate.
    */
   @Autowired
   private ConnectorRemoteBusiness conector;

   /**
    * @{@inheritDoc}.
    */
   @Override
   public void llamarAConector(String parametro)  {
       // código... 
   }

}

Ahora supongamos que para nuestros test de componentes nos generemos una implementación mock del cliente del conector, para manejar datos dummy para nuestras pruebas:

public class ConnectorRemoteBusinessMock implements ConnectorRemoteBusiness {

   @Override
   public String invocarConector(String parametro) throws RemoteException {
       String respuesta = null;

       switch (parametro) {
           case 1: respuesta = "Respuesa1" break;
           case 2: respuesta = "Respuesa2" break;
           case 3: respuesta = "Respuesa3" break;
           default: respuesta = "default"; break;
       }
       return respuesta;
   }
  

}

Y en los test de componentes, configuramos Spring para que al Dao se le inyecte la implementación Mock.

Ahora, supongamos que nuestro servidor sigue caído, y necesitamos generar un distribuible que utilice este Dao con la inyección del delegate mock. Podemos tunear las tareas ant para realizar dicha acción. Ahora vamos a ver como.

Generando el Distribuible Mock

La estructura del proyecto es la siguiente en este ejemplo:

/src/java/com...    Código del empaquetado

/test/com/....       Paquete de la clase Mock 

/test/componentes/com... Código de los test de componentes. 

Vamos a generar una tarea ant a la cual llamaremos "dist-mock" que tendrá por salida un war con un Dao que utiliza una interface Mock del Cliente del conector. Para esto necesitamos copiar no solo la clase mock, sino el archivo de Spring para inyectarle este mock al dao. Y luego limpiar la clase mock de nuestro src. Veamos el código ant en un build.xml: 

   <target name="dist-mock">
       <echo>Dist Mock</echo>
       <property name="esMock" value="true" />
       <property name="claseMock"
           value="./test/componente/com/.../ConnectorRemoteBusinessMock.java" />
       <property name="directorioDestino"
           value="./src/java/com/.../ejb" />
       <property name="ejb-xml-mock"
           value="./test/componente/spring-ejb-Componente.xml" />
       <ant target="dist" inheritall="true" />
   </target>

   <target name="-pre-compile" if="esMock">
       <echo>Pre compile Mock</echo>
       <copy file="${claseMock}" todir="${directorioDestino}" />
   </target>

   <target name="-post-compile" if="esMock">
       <echo>Post compile Mock</echo>
       <copy file="${ejb-xml-mock}" todir="${build.classes.dir}" />
       <move file="${build.classes.dir}/spring-ejb-Componente.xml"
           tofile="${build.classes.dir}/spring-ejb.xml" />
   </target>

   <target name="-post-dist" if="esMock">
       <echo>Post dist Mock</echo>
       <delete dir="./src/java/com/tm" />
   </target>

Ahora expliquemos un poco cada parte del ant. 

1. Primero, ejecutando la tarea dist-mock estamos diciendo explicitamente que queremos un distribuible mock. Esto es recomendado, ya que de sobrescribir la tarea dist, podemos olvidarnos y migrar cosas dummy. En la tarea dist-mock se setea en true una variable "esMock". Despues nos guardamos un par de propiedades por simplicidad del código, y llamamos a la tarea dist. 
2. En el pre-compile estamos ubicados antes de que ant compile las clases. Este es el momento en donde copiamos la clase mock a nuestro src.
3. En el post-compile, las clases ya estan compiladas, y llevamos nuestro archivo de componentes de spring a donde quedaron las clases compiladas, y lo renombramos para pisar el archivo spring de src
4. Luego, en el post-dist, antes de terminar, limpiamos el src y borramos la clase mock que copiamos

Con esto tenemos un distribuible mock para hacer nuestras pruebas de "pseudo integración", que pueden servirnos para avanzar con un desarrollo. Igual recuerden, que hasta no integrar nuestro código con los servicios reales, no deberíamos dar como terminado el mismo! Cuando antes fallemos en nuestro desarrollo, mas tiempo tendremos de resolver nuestros problemas.