JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
factory.getInInterceptors().add(new LoggingInInterceptor());
factory.getOutInterceptors().add(new LoggingOutInterceptor());
factory.setServiceClass(MyService.class);
factory.setAddress("http://localhost/ws");
MyService client = (MyService) factory.create();

var v = "<span style='color:"+myColor+"'>"+singleton.myText()+"</span><span id='"+entityId+"'>"+Text+"</span>";

podemos poner:

var v = "<span style='color:{0}'> {1} </span> <span id='{2}'>{3}</span>".format(myColor,singleton.myText(),entityId,Text);

más lindo no?

// Replaces {0},{1},{n} with the arguments.
String.prototype.format = function() {
	var i = 0;
	var string = (typeof (this) == "function" && !(i++)) ? arguments[0] : this;
	while(i < arguments.length) {
		string = string.replaceAll('\\{' + i + '\\}', arguments[i]);
                i++;
        }
	return string;
}

Estas dependencias suelen remplazarse por objetos que simulan ser los reales compartiendo la misma interfaz. Claro que es solo una fachada, su implementación dista mucho de ser la real, pero nos proporcionan un comportamiento determinista y controlado contra el que probar nuestros componentes. EasyMocks es un framework que permite crear estos objetos de forma muy sencilla indicando cual es la interfaz que deben cumplir y cual es el comportamiento que esperamos.

Creando el Mock

Lo primero que necesitamos es decirle al framework cual va a ser la interfaz que queremos implementar en nuestro “mock”. Supongamos que necesitamos testear una clase Cliente que necesita los favores de una clase que implemente Servicio. Lo que vamos a hacer es un “mock” que simule ser una implementacion real de Servicio pero solo la vamos a usar para llevar a cabo el test.

El metodo estatico createMock de la clase EasyMock toma una Interface como parametro (tambien puede ser una clase) y nos devuelve un objeto que la implementa.

Servicio servicioMock = EasyMock.createMock(Servicio.class)

Its Alive!!

Genial, ¿Ya podemos pasarle la referencia servicioMock al Cliente y testear a gusto?… bueno… no tan easy.

A continuacion vamos a hacer que ese servicioMock implemente la operacion sumarDiez que, a partir de un parametro int numero devuelve ese numero incrementado en 10. No va a ser la implementacion real, solo a ’simular’ que esta haciendo algo realmente mediante el metodo EasyMock.expect.

EasyMock.expect(servicioMock.sumarDiez(5)).andReturn(15);

Acabamos de decirle a nuestro servicioMock que cuando alguien invoque al metodo sumarDiez con el numero 5 como parametro el debe devolver 15. No hay implementacion real, solo se pretende estar realizando la operacion. Ademas nuestro mock no sabe que hacer si alguien le pasa el numero 6 como parametro, y nos lo hara saber con una hermosa excepción.

Easymock.replay(servicioMock);

Esto pone al mock en ‘test mode’ indicando que ya podemos usarlo para nuestro test.

Still alive… and well?

Ahora sí podemos meter el servicioMock en nuestro test y admirar a EasyMock en toda su gloria

Ojo que lo que estamos testeando es el comportamiento de Cliente y no de Servicio! es decir que invocarAlMetodoSumarDiezDeServicio() este delegando correctamente e invocando a Servicio.

Cliente cliente = new Cliente();
cliente.setServicio(servicioMock);
int esultado = cliente.invocarAlMetodoSumarDiezDeServicio(10);
assertEquals(15,resultado);

Las posibilidades que tiene Easymock son ilimitadas y podemos simular comportamientos extremadamente complejos. Pueden encontrar mas informacion sobre todo el potencial de EasyMock en su página oficial.

En Eclipse hay una forma de poder usar el ‘run on server’ (alt+shift+X,R) directamente desde nuestro proyecto Maven y consiste en incorporar el Plugin que da soporte a Eclipse Web Tools Platform al pom.xml del proyecto.

Receta:

1- Crear el proyecto de maven como normalmente lo hariamos. Por ejemplo con un archetype de myfaces

   $ mvn archetype:create -DgroupId=ar.com.mgaravaglia -DartifactId=testWebApp -DarchetypeGroupId=org.apache.myfaces.build -DarchetypeArtifactId=myfaces-archetype-helloworld

2- Modificar el archivo pom.xml creado agregando la referencia al plugin maven-eclipse-plugin en el elemento build

maven-eclipse-plugin

2.0
true
true
true
true
[artifactId]-[version]
${basedir}/src/main/resources/META-INF/MANIFEST.MF

3- Generar el proyecto de eclipse desde maven.

$ mvn eclipse:clean; mvn eclipse:eclipse

4- Una vez dentro de eclipse importar el proyecto como un maven project.

5- Ejecutar y Debuggear a gusto en el tomcat instalado en eclipse usando el ‘Run on Server’

1- Agregar los siguientes parametros a la JVM del Tomcat

-Dcom.sun.management.jmxremote.port=7000
-Dcom.sun.management.jmxremote.ssl=false
-Dcom.sun.management.jmxremote.authenticate=false

2- No tiene que haber inconsistencias en los hostname de la maquina. Es bastante comun que tirar el comando ‘hostname’ devuelvo algo totalmente distinto a lo que dice el /etc/hosts y el RMI es algo susceptible a esto. Ejemplo que funciona correctamente:

#hostname
maquina.dominio.com

#cat /etc/hosts
127.0.0.1 localhost.localdomain localhost
10.1.3.24 maquina.dominio.com

Ahora al conectarnos via jconsole, jvisualvm o cualquier otro agente JMX a 10.1.3.24:7000 no deberiamos tener problemas

List frutas = new ArrayList(){{ add("Manzana");add("Naranja");add("Pera");}};

Muy util para saber en que momento hay que empezar a refactorear.

JSE6 incorpora out-of-the-box el engine Rhino asi que tenemos la posibilidad de ejecutar código JavaScript en nuestras aplicaciónes haciendo poco y nada.

 ScriptEngineManager scm = new ScriptEngineManager();
ScriptEngine jsEngine = scm.getEngineByName("JavaScript");

Uhm… listo! estamos listos para interpretar javascript. Por un proceso de discovering (siguiendo la linea de los *Manager de Java) el ScriptEngineManager sabe que hacer cuando le pedimos un Engine de “JavaScript” y nos devuelve una instancia de ScriptEngine.

String script = "var sum = 0; var obj = new Array(1,1,2,3,5,13);"
+ "for each (var item in obj) { sum += item; }"
+ "print(sum);";
jsEngine.eval(script); // 25

el metodo eval del ScriptEngine interpreta el String que le pasamos como parametro y en la consola terminariamos con un “25″. However, el scripting en Java es mucho más inteligente, el metodo eval devuelve un Object que contiene el valor del ultimo statement del script. El mapeo del valor que ‘retorna’ el script contra los tipos de datos de Java es especifico del Engine por lo que nos vamos a encontrar con comportamientos diferentes segun el lenguaje (y el engine) que interpretemos.

 String script = "var sum = 0; var obj = new Array(1,1,2,3,5,13);"
+ "for each (var item in obj) { sum += item; }"
+ "sum;";
Double d = (Double) jsEngine.eval(script);
 System.out.println( d +1 ); //26!!!

Con esta feature de JSE6 es inevitable pensar en dar un paso más en la parametrización de nuestros sistemas  ya no solo parametrizando valores y constantes sino también la logica de determinados procesos a traves de scripts simples en JS, Phyton, Ruby, Groovy, Jaskell o lo que sea. Otra ventaja en el uso de de esta API esta en incorporar lenguajes que nos eliminan el ciclo de code-compile-deploy-test pero sin alejarnos de la plataforma Java.