Dos Ideas. - Contribuciones del usuario [es]

Spring Security

2012-07-03T14:19:04Z

MaTT: Página creada con 'Spring Security es un framework para la autenticación y control de acceso en una aplicación Java. == Configuración rápida de Spring Security == Configurar Spring Securi…'

[[Spring Security]] es un framework para la autenticación y control de acceso en una aplicación Java.

== Configuración rápida de Spring Security ==
Configurar Spring Security para un sitio web consiste en:
# Agregar las librerias de Spring Security al proyecto.
# Crear un archivo de configuración '''applicationContext-security.xml''' con las definiciones de los accesos y usuarios.
# Configurar el filtro de Spring Security en el archivo '''web.xml'''

=== 1. Configurar las librerias de Spring Security ===
Usando Maven, incluir 3 dependencias:
<code xml>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-web</artifactId>
<version>3.1.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-config</artifactId>
<version>3.1.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-taglibs</artifactId>
<version>3.1.0.RELEASE</version>
</dependency>
</code>

=== 2. Configurar applicationContext-security.xml ===
Crear un archivo '''applicationContext-security.xml''' en la aplicación web. El siguiente archivo tiene una definición de ejemplo agregada.

<code xml>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:sec="http://www.springframework.org/schema/security"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/security
http://www.springframework.org/schema/security/spring-security.xsd">

<sec:http auto-config="true" use-expressions="true">
<sec:remember-me key="contactManagerRememberMeUniqueKey"/>

<sec:intercept-url pattern="/login/**" access="true" />
<sec:intercept-url pattern="/**" access="isAuthenticated()" />
</sec:http>

<sec:global-method-security pre-post-annotations="enabled"/>

<sec:authentication-manager alias="authenticationManager">
<sec:authentication-provider>
<sec:user-service>
<sec:user name="admin" password="admin" authorities="admin" />
</sec:user-service>
</sec:authentication-provider>
</sec:authentication-manager>

</beans>
</code>

=== 3. Configurar el filtro de Spring Security ===
En el archivo '''web.xml''' configurar:
<code xml>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<filter>
<filter-name>springSecurityFilterChain</filter-name>
<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
</filter>

<filter-mapping>
<filter-name>springSecurityFilterChain</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</code>

Con esta configuración puede desplegarse la aplicación y se visualizará el login default de Spring Security.

== Ver también ==
* [http://www.springsource.org/spring-security Página oficial de Spring Security]
* [https://dosideas-aplicaciones-modelo.googlecode.com/svn/dosideas-spring-security-workshop/trunk Proyecto de Ejemplo]

Java

2012-07-03T13:16:34Z

MaTT:

[[Category:Java]]
Java es un lenguaje de programación, aunque también se suele hacer referencia con este nombre a toda una plataforma para el desarrollo de aplicaciones. Hay un buen [http://es.wikipedia.org/wiki/Java_%28Sun%29 resumen de Java en la wikipedia].

Al desarrollar un sistema se suele basar en una [[Arquitectura De Software]] para crear los componentes.

Java se caracteriza por una enorme cantidad de proyectos libres.

== Algunas tecnologías Java ==
=== Frameworks de base===
* [[Spring Framework]]
* [[Terracotta]]
* [[EJB]]
* [[Restlet]]

===Acceso a datos===
* [[Hibernate]]
* [[Apache Lucene]]

===Frameworks de presentación===
* [[Apache Tiles]]
* [[Struts]]
* [[JSF]]
* [[JSTL]]
* [[GWT]]

===Librerías===
* [[Google Guava]]
* [[Jawr]]

===Mensajeria===
* [[JMS]]

===Web Services===
* [[Web Service]]
* [[Web Service Con Spring]]

===Ejecuciones batch y programadas===
* [[Quartz]]
* [[Spring Batch]]

===Seguridad===
* [[Spring Security]]

===Cuestiones generales de Java===
* [[Fechas En Java]]
* [[Numeros En Java]]
* [[Encoding En Java]]
* [[Serializacion De Objetos En Java]]
* [[Log4J]]
* [[SLF4J]]
* [[Cache De Objetos Java]]
* [[Exportacion Hacia Archivos]]

Mock de un WS mediante Spring WS

2012-04-09T14:28:56Z

MaTT: /* Ejemplo */

===Introducción===

En esta página explicaremos de qué forma podemos simular el entorno de un Web Service en memoria, de modo tal de poder realizar un test de componentes contra dicho entorno.

===Requerimientos===

Para mockear un Web Service mediante Spring WS, necesitaremos agregar a nuestro proyecto los siguientes jars:
* jaxb-api-2.0.jar
* jaxb-impl-2.0.3.jar
* xalan-2.7.1.jar (importante que sea esta versión o superior)
* xmlunit-1.1.jar

===Ejemplo===

Básicamente, el código para crear un test contra dicho entorno será como el siguiente:

<code java>
@RunWith(SpringJUnit4ClassRunner.class)

// indicamos a Spring que levante los archivos de configuración que veremos más adelante
@ContextConfiguration("spring-configuration.xml")
public class ClienteIntegracionTest {

// Creamos el request a enviarle al WS
private String request = "<ns2:ClienteRequest xmlns:ns2='http://ejemplo.com.ar/'><ns2:APELLIDO_RAZONSOCIAL>Una razon social</ns2:APELLIDO_RAZONSOCIAL></ns2:ClienteRequest>";

// Creamos el response que nos responderá el WS
private String response = "<ns2:ClienteResponse xmlns:ns2='http://ejemplo.com.ar/'><ns2:ID_CLIENTE>123</ns2:ID_CLIENTE></ns2:ClienteResponse>";

//Inyectamos el WebServiceTemplate
@Autowired
private WebServiceTemplate webServiceTemplate;

// Mockeamos el WebServiceServer
private MockWebServiceServer server;

// Clase nuestra que lo consumirá
@Autowired
private Cliente cliente;

// En el Before levantamos el server pasandole como parámetro al constructor
// el webServiceTemplate
@Before
public void setup() {
server = MockWebServiceServer.createServer(webServiceTemplate);
}

@Test
public void testInvocacionWs() {

// Le damos comportamiento a nuestro WS con el request y el response
// antes configurado
server.expect(RequestMatchers.payload(new StringSource(request))).andRespond(ResponseCreators.withPayload(new StringSource(response)));

cliente.invocarMetodoQueLlamaAlWs();

// Nos aseguramos que el servicio fue invocado
server.verify();
}

}
</code>

Dentro de los archivos de configuración que levante Spring, tendremos que configurarle los siguientes beans:

<code xml>
<bean id="wsTemplate" class="org.springframework.ws.client.core.WebServiceTemplate">

<property name="defaultUri" value="http://localhost:8080/" />
<property name="marshaller" ref="marshaller" />
<property name="unmarshaller" ref="marshaller" />
</bean>

<bean id="marshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">
<property name="classesToBeBound">
<list>

<value>com.dosideas.ejemplo.schemas.ClienteRequest</value>
<value>com.dosideas.ejemplo.schemas.ClienteResponse</value>
</list>
</property>
</bean>
</code>

Finalmente, el método de nuestra clase cliente, deberá contener

<code java>
public void invocarMetodoQueLlamaAlWs() {
...
ClienteRequest clienteRequest = new ClienteRequest();
...
ClienteResponse clienteResponse = (clienteResponse) webServiceTemplate
.marshalSendAndReceive(clienteRequest);
...
}
</code>

===Otra forma de generar un mock===
Spring WS Test project es una libreria que simplifica los test que realizamos utilizando spring-ws.

====Requerimientos====
* spring-ws-test.jar

====Ejemplo====
Básicamente, el código para crear un test será como el siguiente:

<code java>

@RunWith(SpringJUnit4ClassRunner.class)
// indicamos a Spring que levante los archivos de configuración que veremos más adelante
@ContextConfiguration(locations = {"spring-configuration.xml", "spring-ws-responses-mock.xml"})

public class ClienteComponenteTest {

// Clase nuestra que lo consumirá
@Autowired
private Cliente cliente;

@Test
public void testInvocacionWs() {

Collection<Algo> coleccion = cliente.invocarMetodoQueLlamaAlWs(param1);
assertNotNull(coleccion )
}

}
</code>

En nuestra clase de test, debemos agregar al contexto de spring un xml (ej: spring-ws-responses-mock.xml) con la siguiente configuracion:

<code xml>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">


<bean id="messageSender" class="net.javacrumbs.springws.test.MockWebServiceMessageSender"/>


<bean class="net.javacrumbs.springws.test.util.MockMessageSenderInjector"/>


<bean class="net.javacrumbs.springws.test.generator.DefaultResponseGeneratorFactoryBean">
<property name="namespaceMap">
<map>
<entry key="soapenv" value="http://schemas.xmlsoap.org/soap/envelope/"/>
</map>
</property>
<property name="XPathExpressions">
<list>
<value>concat('/com/tma/dosideas/ws/mock/response/',local-name(//soapenv:Body/*[1]),'-response-', //APELLIDO_RAZONSOCIAL, '.xml')</value>
</list>
</property>
</bean>

</beans>
</code>

En la primera parte del xml declaramos un mock message sender que luego inyectamos en nuestro WebServiceTemplate de spring-ws para que las peticiones del template sean atendidas por el mock.

La clase DefaultResponseGeneratorFactoryBean se encarga de buscar en los archivos de un directorio, el xml de response.
Para saber cual xml de response corresponde al request, se utiliza xpath sobre el nombre de los archivos del directorio.

Ejemplo:

Si el request es el siguiente:

<code xml>
<?xml version="1.0" encoding="UTF-8"?>
<ns2:ClienteRequest xmlns:ns2='http://ejemplo.com.ar'>
<ns2:APELLIDO_RAZONSOCIAL>Una razon social</ns2:APELLIDO_RAZONSOCIAL>
</ns2:ClienteRequest>
</code>

En el directorio "/com/tma/dosideas/ws/mock/response/" se buscara el xml con el siguiente nombre: ClienteRequest-response-Una razon social.xml

El response del directorio es:

<code xml>
<?xml version="1.0" encoding="UTF-8"?>
<ns2:ClienteResponse xmlns:ns2='http://ejemplo.com.ar'>
<ns2:ID_CLIENTE>123</ns2:ID_CLIENTE>
</ns2:ClienteResponse>
</code>

====Fuente====
*[http://static.springsource.org/spring-ws/site/reference/html/client.html Spring MVC Test ]
*[http://www.developer.com/java/ent/integration-testing-support-in-spring-ws-2.0.html Otro ejemplo ]
*[http://javacrumbs.net/spring-ws-test/ Spring WS Test ]

Mock de un WS mediante Spring WS

2012-04-09T14:16:54Z

MaTT: /* Ejemplo */

===Introducción===

En esta página explicaremos de qué forma podemos simular el entorno de un Web Service en memoria, de modo tal de poder realizar un test de componentes contra dicho entorno.

===Requerimientos===

Para mockear un Web Service mediante Spring WS, necesitaremos agregar a nuestro proyecto los siguientes jars:
* jaxb-api-2.0.jar
* jaxb-impl-2.0.3.jar
* xalan-2.7.1.jar (importante que sea esta versión o superior)
* xmlunit-1.1.jar

===Ejemplo===

Básicamente, el código para crear un test contra dicho entorno será como el siguiente:

<code java>
@RunWith(SpringJUnit4ClassRunner.class)

// indicamos a Spring que levante los archivos de configuración que veremos más adelante
@ContextConfiguration("spring-configuration.xml")
public class ClienteIntegracionTest {

// Creamos el request a enviarle al WS
private String request = "<ns2:ClienteRequest xmlns:ns2='http://ejemplo.com.ar/'><ns2:APELLIDO_RAZONSOCIAL>Una razon social</ns2:APELLIDO_RAZONSOCIAL></ns2:ClienteRequest>";

// Creamos el response que nos responderá el WS
private String response = "<ns2:ClienteResponse xmlns:ns2='http://ejemplo.com.ar/'><ns2:ID_CLIENTE>123</ns2:ID_CLIENTE></ns2:ClienteResponse>";

//Inyectamos el WebServiceTemplate
@Autowired
private WebServiceTemplate webServiceTemplate;

// Mockeamos el WebServiceServer
private MockWebServiceServer server;

// Clase nuestra que lo consumirá
@Autowired
private Cliente cliente;

// En el Before levantamos el server pasandole como parámetro al constructor
// el webServiceTemplate
@Before
public void setup() {
server = MockWebServiceServer.createServer(webServiceTemplate);
}

@Test
public void testInvocacionWs() {

// Le damos comportamiento a nuestro WS con el request y el response
// antes configurado
server.expect(RequestMatchers.payload(new StringSource(request))).andRespond(ResponseCreators.withPayload(new StringSource(response)));

cliente.invocarMetodoQueLlamaAlWs();

// Nos aseguramos que el servicio fue invocado
server.verify();
}

}
</code>

Dentro de los archivos de configuración que levante Spring, tendremos que configurarle los siguientes beans:

<code xml>
<bean id="wsTemplate" class="org.springframework.ws.client.core.WebServiceTemplate">

<property name="defaultUri" value="http://localhost:8080/" />
<property name="marshaller" ref="marshaller" />
<property name="unmarshaller" ref="marshaller" />
</bean>

<bean id="marshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">
<property name="classesToBeBound">
<list>

<value>com.dosideas.ejemplo.schemas.ClienteRequest</value>
<value>com.dosideas.ejemplo.schemas.ClienteResponse</value>
</list>
</property>
</bean>
</code>

Finalmente, el método de nuestra clase cliente, deberá contener

<code java>
public void invocarMetodoQueLlamaAlWs() {
...
ClienteRequest clienteRequest = new ClienteRequest();
...
ClienteResponse clienteResponse = (clienteResponse) webServiceTemplate
.marshalSendAndReceive(clienteRequest);
...
}
</code>

===Otra forma de generar un mock===
Spring WS Test project es una libreria que simplifica los test que realizamos utilizando spring-ws.

====Requerimientos====
* spring-ws-test.jar

====Ejemplo====
Básicamente, el código para crear un test será como el siguiente:

<code java>

@RunWith(SpringJUnit4ClassRunner.class)
// indicamos a Spring que levante los archivos de configuración que veremos más adelante
@ContextConfiguration(locations = {"spring-configuration.xml", "spring-ws-responses-mock.xml"})

public class ClienteComponenteTest {

// Clase nuestra que lo consumirá
@Autowired
private Cliente cliente;

@Test
public void testInvocacionWs() {

Collection<Algo> coleccion = cliente.invocarMetodoQueLlamaAlWs(param1);
assertNotNull(coleccion )
}

}
</code>

En nuestra clase de test, debemos agregar al contexto de spring un xml (ej: spring-ws-responses-mock.xml) con la siguiente configuracion:

<code xml>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">


<bean id="messageSender" class="net.javacrumbs.springws.test.MockWebServiceMessageSender"/>


<bean class="net.javacrumbs.springws.test.util.MockMessageSenderInjector"/>


<bean class="net.javacrumbs.springws.test.generator.DefaultResponseGeneratorFactoryBean">
<property name="namespaceMap">
<map>
<entry key="soapenv" value="http://schemas.xmlsoap.org/soap/envelope/"/>
</map>
</property>
<property name="XPathExpressions">
<list>
<value>concat('/com/tma/dosideas/ws/mock/response/',local-name(//soapenv:Body/*[1]),'-response-', //APELLIDO_RAZONSOCIAL, '.xml')</value>
</list>
</property>
</bean>

</beans>
</code>

En la primera parte del xml declaramos un mock message sender que luego inyectamos en nuestro WebServiceTemplate de spring-ws para que las peticiones del template sean atendidas por el mock.
La clase DefaultResponseGeneratorFactoryBean se encarga de buscar en los archivos de un directorio, el xml de response para el request que tenga el valor "Una razon social" en el campo APELLIDO_RAZONSOCIAL.

* REQUEST

<code xml>
<?xml version="1.0" encoding="UTF-8"?>
<ns2:ClienteRequest xmlns:ns2='http://ejemplo.com.ar'>
<ns2:APELLIDO_RAZONSOCIAL>Una razon social</ns2:APELLIDO_RAZONSOCIAL>
</ns2:ClienteRequest>
</code>

* RESPONSE con el siguiente formato: operacion-response-APELLIDO_RAZONSOCIAL.xml

<code xml>
<?xml version="1.0" encoding="UTF-8"?>
<ns2:ClienteResponse xmlns:ns2='http://ejemplo.com.ar'>
<ns2:ID_CLIENTE>123</ns2:ID_CLIENTE>
</ns2:ClienteResponse>
</code>

====Fuente====
*[http://static.springsource.org/spring-ws/site/reference/html/client.html Spring MVC Test ]
*[http://www.developer.com/java/ent/integration-testing-support-in-spring-ws-2.0.html Otro ejemplo ]
*[http://javacrumbs.net/spring-ws-test/ Spring WS Test ]

Mock de un WS mediante Spring WS

2012-04-09T14:16:16Z

MaTT: /* Ejemplo */

===Introducción===

En esta página explicaremos de qué forma podemos simular el entorno de un Web Service en memoria, de modo tal de poder realizar un test de componentes contra dicho entorno.

===Requerimientos===

Para mockear un Web Service mediante Spring WS, necesitaremos agregar a nuestro proyecto los siguientes jars:
* jaxb-api-2.0.jar
* jaxb-impl-2.0.3.jar
* xalan-2.7.1.jar (importante que sea esta versión o superior)
* xmlunit-1.1.jar

===Ejemplo===

Básicamente, el código para crear un test contra dicho entorno será como el siguiente:

<code java>
@RunWith(SpringJUnit4ClassRunner.class)

// indicamos a Spring que levante los archivos de configuración que veremos más adelante
@ContextConfiguration("spring-configuration.xml")
public class ClienteIntegracionTest {

// Creamos el request a enviarle al WS
private String request = "<ns2:ClienteRequest xmlns:ns2='http://ejemplo.com.ar/'><ns2:APELLIDO_RAZONSOCIAL>Una razon social</ns2:APELLIDO_RAZONSOCIAL></ns2:ClienteRequest>";

// Creamos el response que nos responderá el WS
private String response = "<ns2:ClienteResponse xmlns:ns2='http://ejemplo.com.ar/'><ns2:ID_CLIENTE>123</ns2:ID_CLIENTE></ns2:ClienteResponse>";

//Inyectamos el WebServiceTemplate
@Autowired
private WebServiceTemplate webServiceTemplate;

// Mockeamos el WebServiceServer
private MockWebServiceServer server;

// Clase nuestra que lo consumirá
@Autowired
private Cliente cliente;

// En el Before levantamos el server pasandole como parámetro al constructor
// el webServiceTemplate
@Before
public void setup() {
server = MockWebServiceServer.createServer(webServiceTemplate);
}

@Test
public void testInvocacionWs() {

// Le damos comportamiento a nuestro WS con el request y el response
// antes configurado
server.expect(RequestMatchers.payload(new StringSource(request))).andRespond(ResponseCreators.withPayload(new StringSource(response)));

cliente.invocarMetodoQueLlamaAlWs();

// Nos aseguramos que el servicio fue invocado
server.verify();
}

}
</code>

Dentro de los archivos de configuración que levante Spring, tendremos que configurarle los siguientes beans:

<code xml>
<bean id="wsTemplate" class="org.springframework.ws.client.core.WebServiceTemplate">

<property name="defaultUri" value="http://localhost:8080/" />
<property name="marshaller" ref="marshaller" />
<property name="unmarshaller" ref="marshaller" />
</bean>

<bean id="marshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">
<property name="classesToBeBound">
<list>

<value>com.dosideas.ejemplo.schemas.ClienteRequest</value>
<value>com.dosideas.ejemplo.schemas.ClienteResponse</value>
</list>
</property>
</bean>
</code>

Finalmente, el método de nuestra clase cliente, deberá contener

<code java>
public void invocarMetodoQueLlamaAlWs() {
...
ClienteRequest clienteRequest = new ClienteRequest();
...
ClienteResponse clienteResponse = (clienteResponse) webServiceTemplate
.marshalSendAndReceive(clienteRequest);
...
}
</code>

===Otra forma de generar un mock===
Spring WS Test project es una libreria que simplifica los test que realizamos utilizando spring-ws.

====Requerimientos====
* spring-ws-test.jar

====Ejemplo====
Básicamente, el código para crear un test será como el siguiente:

<code java>

@RunWith(SpringJUnit4ClassRunner.class)
// indicamos a Spring que levante los archivos de configuración que veremos más adelante
@ContextConfiguration(locations = {"spring-configuration.xml", "spring-ws-responses-mock.xml"})

public class ClienteComponenteTest {

// Clase nuestra que lo consumirá
@Autowired
private Cliente cliente;

@Test
public void testInvocacionWs() {

Collection<Algo> coleccion = cliente.invocarMetodoQueLlamaAlWs(param1);
assertNotNull(coleccion )
}

}
</code>

En nuestra clase de test, debemos agregar al contexto de spring un xml (ej: spring-ws-responses-mock.xml) con la siguiente configuracion:

<code xml>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">


<bean id="messageSender" class="net.javacrumbs.springws.test.MockWebServiceMessageSender"/>


<bean class="net.javacrumbs.springws.test.util.MockMessageSenderInjector"/>


<bean class="net.javacrumbs.springws.test.generator.DefaultResponseGeneratorFactoryBean">
<property name="namespaceMap">
<map>
<entry key="soapenv" value="http://schemas.xmlsoap.org/soap/envelope/"/>
</map>
</property>
<property name="XPathExpressions">
<list>
<value>concat('/com/tma/dosideas/ws/mock/response/',local-name(//soapenv:Body/*[1]),'-response-', //APELLIDO_RAZONSOCIAL, '.xml')</value>
</list>
</property>
</bean>

</beans>
</code>

En la primera parte del xml declaramos un mock message sender que luego inyectamos en nuestro WebServiceTemplate de spring-ws para que las peticiones del template sean atendidas por el mock.
La clase DefaultResponseGeneratorFactoryBean se encarga de buscar en los archivos de un directorio, el xml de response para el request que tenga el valor "Una razon social" en el campo APELLIDO_RAZONSOCIAL.

* REQUEST

<code xml>
<?xml version="1.0" encoding="UTF-8"?>
<ns2:ClienteRequest xmlns:ns2='http://ejemplo.com.ar'>
<ns2:APELLIDO_RAZONSOCIAL>Una razon social</ns2:APELLIDO_RAZONSOCIAL>
</ns2:ClienteRequest>
</code>

* RESPONSE con el siguiente formato: operacion-response-APELLIDO_RAZONSOCIAL.xml

<code xml>
<?xml version="1.0" encoding="UTF-8"?>
<ns2:ClienteResponse xmlns:ns2='http://ejemplo.com.ar'><ns2:ID_CLIENTE>123</ns2:ID_CLIENTE>
</ns2:ClienteResponse>
</code>

====Fuente====
*[http://static.springsource.org/spring-ws/site/reference/html/client.html Spring MVC Test ]
*[http://www.developer.com/java/ent/integration-testing-support-in-spring-ws-2.0.html Otro ejemplo ]
*[http://javacrumbs.net/spring-ws-test/ Spring WS Test ]

Mock de un WS mediante Spring WS

2012-04-09T14:15:45Z

MaTT: /* Ejemplo */

===Introducción===

En esta página explicaremos de qué forma podemos simular el entorno de un Web Service en memoria, de modo tal de poder realizar un test de componentes contra dicho entorno.

===Requerimientos===

Para mockear un Web Service mediante Spring WS, necesitaremos agregar a nuestro proyecto los siguientes jars:
* jaxb-api-2.0.jar
* jaxb-impl-2.0.3.jar
* xalan-2.7.1.jar (importante que sea esta versión o superior)
* xmlunit-1.1.jar

===Ejemplo===

Básicamente, el código para crear un test contra dicho entorno será como el siguiente:

<code java>
@RunWith(SpringJUnit4ClassRunner.class)

// indicamos a Spring que levante los archivos de configuración que veremos más adelante
@ContextConfiguration("spring-configuration.xml")
public class ClienteIntegracionTest {

// Creamos el request a enviarle al WS
private String request = "<ns2:ClienteRequest xmlns:ns2='http://ejemplo.com.ar/'><ns2:APELLIDO_RAZONSOCIAL>Una razon social</ns2:APELLIDO_RAZONSOCIAL></ns2:ClienteRequest>";

// Creamos el response que nos responderá el WS
private String response = "<ns2:ClienteResponse xmlns:ns2='http://ejemplo.com.ar/'><ns2:ID_CLIENTE>123</ns2:ID_CLIENTE></ns2:ClienteResponse>";

//Inyectamos el WebServiceTemplate
@Autowired
private WebServiceTemplate webServiceTemplate;

// Mockeamos el WebServiceServer
private MockWebServiceServer server;

// Clase nuestra que lo consumirá
@Autowired
private Cliente cliente;

// En el Before levantamos el server pasandole como parámetro al constructor
// el webServiceTemplate
@Before
public void setup() {
server = MockWebServiceServer.createServer(webServiceTemplate);
}

@Test
public void testInvocacionWs() {

// Le damos comportamiento a nuestro WS con el request y el response
// antes configurado
server.expect(RequestMatchers.payload(new StringSource(request))).andRespond(ResponseCreators.withPayload(new StringSource(response)));

cliente.invocarMetodoQueLlamaAlWs();

// Nos aseguramos que el servicio fue invocado
server.verify();
}

}
</code>

Dentro de los archivos de configuración que levante Spring, tendremos que configurarle los siguientes beans:

<code xml>
<bean id="wsTemplate" class="org.springframework.ws.client.core.WebServiceTemplate">

<property name="defaultUri" value="http://localhost:8080/" />
<property name="marshaller" ref="marshaller" />
<property name="unmarshaller" ref="marshaller" />
</bean>

<bean id="marshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">
<property name="classesToBeBound">
<list>

<value>com.dosideas.ejemplo.schemas.ClienteRequest</value>
<value>com.dosideas.ejemplo.schemas.ClienteResponse</value>
</list>
</property>
</bean>
</code>

Finalmente, el método de nuestra clase cliente, deberá contener

<code java>
public void invocarMetodoQueLlamaAlWs() {
...
ClienteRequest clienteRequest = new ClienteRequest();
...
ClienteResponse clienteResponse = (clienteResponse) webServiceTemplate
.marshalSendAndReceive(clienteRequest);
...
}
</code>

===Otra forma de generar un mock===
Spring WS Test project es una libreria que simplifica los test que realizamos utilizando spring-ws.

====Requerimientos====
* spring-ws-test.jar

====Ejemplo====
Básicamente, el código para crear un test será como el siguiente:

<code java>

@RunWith(SpringJUnit4ClassRunner.class)
// indicamos a Spring que levante los archivos de configuración que veremos más adelante
@ContextConfiguration(locations = {"spring-configuration.xml", "spring-ws-responses-mock.xml"})

public class ClienteComponenteTest {

// Clase nuestra que lo consumirá
@Autowired
private Cliente cliente;

@Test
public void testInvocacionWs() {

Collection<Algo> coleccion = cliente.invocarMetodoQueLlamaAlWs(param1);
assertNotNull(coleccion )
}

}
</code>

En nuestra clase de test, debemos agregar al contexto de spring un xml (ej: spring-ws-responses-mock.xml )con la siguiente configuracion:

<code xml>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">


<bean id="messageSender" class="net.javacrumbs.springws.test.MockWebServiceMessageSender"/>


<bean class="net.javacrumbs.springws.test.util.MockMessageSenderInjector"/>


<bean class="net.javacrumbs.springws.test.generator.DefaultResponseGeneratorFactoryBean">
<property name="namespaceMap">
<map>
<entry key="soapenv" value="http://schemas.xmlsoap.org/soap/envelope/"/>
</map>
</property>
<property name="XPathExpressions">
<list>
<value>concat('/com/tma/dosideas/ws/mock/response/',local-name(//soapenv:Body/*[1]),'-response-', //APELLIDO_RAZONSOCIAL, '.xml')</value>
</list>
</property>
</bean>

</beans>
</code>

En la primera parte del xml declaramos un mock message sender que luego inyectamos en nuestro WebServiceTemplate de spring-ws para que las peticiones del template sean atendidas por el mock.
La clase DefaultResponseGeneratorFactoryBean se encarga de buscar en los archivos de un directorio, el xml de response para el request que tenga el valor "Una razon social" en el campo APELLIDO_RAZONSOCIAL.

* REQUEST

<code xml>
<?xml version="1.0" encoding="UTF-8"?>
<ns2:ClienteRequest xmlns:ns2='http://ejemplo.com.ar'>
<ns2:APELLIDO_RAZONSOCIAL>Una razon social</ns2:APELLIDO_RAZONSOCIAL>
</ns2:ClienteRequest>
</code>

* RESPONSE con el siguiente formato: operacion-response-APELLIDO_RAZONSOCIAL.xml

<code xml>
<?xml version="1.0" encoding="UTF-8"?>
<ns2:ClienteResponse xmlns:ns2='http://ejemplo.com.ar'><ns2:ID_CLIENTE>123</ns2:ID_CLIENTE>
</ns2:ClienteResponse>
</code>

====Fuente====
*[http://static.springsource.org/spring-ws/site/reference/html/client.html Spring MVC Test ]
*[http://www.developer.com/java/ent/integration-testing-support-in-spring-ws-2.0.html Otro ejemplo ]
*[http://javacrumbs.net/spring-ws-test/ Spring WS Test ]

Mock de un WS mediante Spring WS

2012-04-09T14:14:31Z

MaTT:

===Introducción===

En esta página explicaremos de qué forma podemos simular el entorno de un Web Service en memoria, de modo tal de poder realizar un test de componentes contra dicho entorno.

===Requerimientos===

Para mockear un Web Service mediante Spring WS, necesitaremos agregar a nuestro proyecto los siguientes jars:
* jaxb-api-2.0.jar
* jaxb-impl-2.0.3.jar
* xalan-2.7.1.jar (importante que sea esta versión o superior)
* xmlunit-1.1.jar

===Ejemplo===

Básicamente, el código para crear un test contra dicho entorno será como el siguiente:

<code java>
@RunWith(SpringJUnit4ClassRunner.class)

// indicamos a Spring que levante los archivos de configuración que veremos más adelante
@ContextConfiguration("spring-configuration.xml")
public class ClienteIntegracionTest {

// Creamos el request a enviarle al WS
private String request = "<ns2:ClienteRequest xmlns:ns2='http://ejemplo.com.ar/'><ns2:APELLIDO_RAZONSOCIAL>Una razon social</ns2:APELLIDO_RAZONSOCIAL></ns2:ClienteRequest>";

// Creamos el response que nos responderá el WS
private String response = "<ns2:ClienteResponse xmlns:ns2='http://ejemplo.com.ar/'><ns2:ID_CLIENTE>123</ns2:ID_CLIENTE></ns2:ClienteResponse>";

//Inyectamos el WebServiceTemplate
@Autowired
private WebServiceTemplate webServiceTemplate;

// Mockeamos el WebServiceServer
private MockWebServiceServer server;

// Clase nuestra que lo consumirá
@Autowired
private Cliente cliente;

// En el Before levantamos el server pasandole como parámetro al constructor
// el webServiceTemplate
@Before
public void setup() {
server = MockWebServiceServer.createServer(webServiceTemplate);
}

@Test
public void testInvocacionWs() {

// Le damos comportamiento a nuestro WS con el request y el response
// antes configurado
server.expect(RequestMatchers.payload(new StringSource(request))).andRespond(ResponseCreators.withPayload(new StringSource(response)));

cliente.invocarMetodoQueLlamaAlWs();

// Nos aseguramos que el servicio fue invocado
server.verify();
}

}
</code>

Dentro de los archivos de configuración que levante Spring, tendremos que configurarle los siguientes beans:

<code xml>
<bean id="wsTemplate" class="org.springframework.ws.client.core.WebServiceTemplate">

<property name="defaultUri" value="http://localhost:8080/" />
<property name="marshaller" ref="marshaller" />
<property name="unmarshaller" ref="marshaller" />
</bean>

<bean id="marshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">
<property name="classesToBeBound">
<list>

<value>com.dosideas.ejemplo.schemas.ClienteRequest</value>
<value>com.dosideas.ejemplo.schemas.ClienteResponse</value>
</list>
</property>
</bean>
</code>

Finalmente, el método de nuestra clase cliente, deberá contener

<code java>
public void invocarMetodoQueLlamaAlWs() {
...
ClienteRequest clienteRequest = new ClienteRequest();
...
ClienteResponse clienteResponse = (clienteResponse) webServiceTemplate
.marshalSendAndReceive(clienteRequest);
...
}
</code>

===Otra forma de generar un mock===
Spring WS Test project es una libreria que simplifica los test que realizamos utilizando spring-ws.

====Requerimientos====
* spring-ws-test.jar

====Ejemplo====
Básicamente, el código para crear un test será como el siguiente:

<code java>

@RunWith(SpringJUnit4ClassRunner.class)
// indicamos a Spring que levante los archivos de configuración que veremos más adelante
@ContextConfiguration(locations = {"spring-configuration.xml", "spring-ws-responses-mock.xml"})

public class ClienteComponenteTest {

// Clase nuestra que lo consumirá
@Autowired
private Cliente cliente;

@Test
public void testInvocacionWs() {

Collection<Algo> coleccion = cliente.invocarMetodoQueLlamaAlWs(param1);
assertNotNull(coleccion )
}

}
</code>

En nuestra clase de test, debemos agregar al contexto de spring un xml con la siguiente configuracion:

<code xml>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">


<bean id="messageSender" class="net.javacrumbs.springws.test.MockWebServiceMessageSender"/>


<bean class="net.javacrumbs.springws.test.util.MockMessageSenderInjector"/>


<bean class="net.javacrumbs.springws.test.generator.DefaultResponseGeneratorFactoryBean">
<property name="namespaceMap">
<map>
<entry key="soapenv" value="http://schemas.xmlsoap.org/soap/envelope/"/>
</map>
</property>
<property name="XPathExpressions">
<list>
<value>concat('/com/tma/dosideas/ws/mock/response/',local-name(//soapenv:Body/*[1]),'-response-', //APELLIDO_RAZONSOCIAL, '.xml')</value>
</list>
</property>
</bean>

</beans>
</code>

En la primera parte del xml declaramos un mock message sender que luego inyectamos en nuestro WebServiceTemplate de spring-ws para que las peticiones del template sean atendidas por el mock.
La clase DefaultResponseGeneratorFactoryBean se encarga de buscar en los archivos de un directorio, el xml de response para el request que tenga el valor "Una razon social" en el campo APELLIDO_RAZONSOCIAL.

* REQUEST

<code xml>
<?xml version="1.0" encoding="UTF-8"?>
<ns2:ClienteRequest xmlns:ns2='http://ejemplo.com.ar'>
<ns2:APELLIDO_RAZONSOCIAL>Una razon social</ns2:APELLIDO_RAZONSOCIAL>
</ns2:ClienteRequest>
</code>

* RESPONSE con el siguiente formato: operacion-response-APELLIDO_RAZONSOCIAL.xml

<code xml>
<?xml version="1.0" encoding="UTF-8"?>
<ns2:ClienteResponse xmlns:ns2='http://ejemplo.com.ar'><ns2:ID_CLIENTE>123</ns2:ID_CLIENTE>
</ns2:ClienteResponse>
</code>

====Fuente====
*[http://static.springsource.org/spring-ws/site/reference/html/client.html Spring MVC Test ]
*[http://www.developer.com/java/ent/integration-testing-support-in-spring-ws-2.0.html Otro ejemplo ]
*[http://javacrumbs.net/spring-ws-test/ Spring WS Test ]

Mockito

2011-11-11T13:09:28Z

MaTT: /* Ejemplo de Mockito para mockear appender de log4j */

Mockito es una librería [[Java]] para la creación de [[Mock Object]] muy usados para el testeo unitario en [[Test Driven Development]], basado en [[EasyMock]].

Mockito fue creado con el objetivo de simplificar y solucionar algunos de los temas antes mencionados. EasyMock y Mockito puede hacer exactamente las mismas cosas, pero Mockito tiene un API más natural y práctico de usar.

==Características principales==
# Se pueden crear mocks de interfaces y clases concretas.
# Verificación de invocaciones (cantidad exacta, al menos una vez, órden de invocación, etc.)
# El stack trace se mantiene limpio, ya que los errores ocurren en los assert que se hagan (y no dentro del método bajo prueba, como en EasyMock).
# Un API más clara para crear stubs y verificaciones

==Ejemplo de uso==
<code java>
import static org.mockito.Mockito.*;
.....
//creamos el mock y el stub
ArrayList instance = mock(ArrayList.class);
doReturn("hola mundo").when(instance).get(0);

//ejecutamos la lógica a probar
instance.get(0);

//verificamos que se hayan invocado los métodos
verify(instance).get(0);
</code>

==Más de una invocación a un mismo método==

Algunas veces necesitamos que un método retorne un valor y que en la segunda invocación retorne nulo o una excepción. Para eso, anidamos los retornos:

<code html4strict>

//Retornos para las 2 invocaciones
doReturn("algo").doReturn(null).when(instance).scrollNext();

//ejecutamos la lógica a probar
instance.unMetodoQueUsaScroll();

//verificamos que se haya invocado el mismo método dos veces
verify(instance, times(2)).scrollNext();

</code>

* [http://mockito.googlecode.com/svn/branches/1.5/javadoc/org/mockito/Mockito.html Leer más en Mockito API]

==Ejemplos de Mockito junto a PowerMock==

===Invocación a un método estático===

Para mockear métodos estáticos, según el [http://code.google.com/p/mockito/wiki/FAQ FAQ] de mockito, esto no es posible. Pero nombra 2 framewors que pueden resultarnos útil [http://jmockit.dev.java.net/ JMockit] y [http://code.google.com/p/powermock PowerMock]

<code java>
@RunWith(PowerMockRunner.class)
@PrepareForTest(ClaseConMetodosEstaticos.class)
public class DosIdeasTestCase {
@Test
public void testMetodo_conInvocacionAMetodosEstaticos() {

//PowerMockito mockea los metodos estaticos que se encuentren en la
//clase ClaseConMetodosEstaticos
PowerMockito.mockStatic(ClaseConMetodosEstaticos.class);

//Con mockito determinamos el retorno del metodo estatico
when(ClaseConMetodosEstaticos.firstStaticMethod(param)).thenReturn(value);

// ejecucion
instance.invocarMetodoEstatico();

//Por cada metodo estatico que se quiere verificar se debe invocar
//a PowerMockito.verifyStatic().
PowerMockito.verifyStatic();
ClaseConMetodosEstaticos.secondStaticMethod();
}
}
</code>

===Invocación a un método privado===

<code java>
public class PruebaMetodoPrivado {

public String decirHola(String nombre) {
return decirHolaNombre(nombre);
}

private String decirHolaNombre(String nombre) {
return "Hola "+nombre;
}
}
</code>

<code java>
@RunWith(PowerMockRunner.class)
@PrepareForTest(PruebaMetodoPrivado.class)
public class PruebaMetodoPrivadoTest {

@Spy
PruebaMetodoPrivado metodoPrivado = new PruebaMetodoPrivado();

@Test
public void mockMetodoPrivado() throws Exception {

Assert.assertEquals("Hola Juan", metodoPrivado.decirHola("Juan"));
doReturn("Chau Juan").when(metodoPrivado,"decirHolaNombre","Juan");
Assert.assertEquals("Chau Juan",metodoPrivado.decirHola("Juan"));
verifyPrivate(metodoPrivado,
Mockito.times(2)).invoke("decirHolaNombre","Juan");
}
}

</code>

===Otra manera de invocar a un metodo privado (Bypass encapsulation) ===

Para invocar a un metodo privado se puede usar el metodo de PowerMock '''Whitebox.invokeMethod(..)'''.

<code java>
public class PruebaMetodoPrivado2 {

....

private int sumar(int a, int b) {
return a+b;
}
}
</code>

<code java>
import org.powermock.reflect.Whitebox;

public class PruebaMetodoPrivado2Test {

private PruebaMetodoPrivado2 instance;

@Before
public void setup() throws Exception {
instance = new PruebaMetodoPrivado2();
}

@Test
public void sumar_conParametrosEnteros_retornaSuma() throws Exception {

int respuestaEsperada = 4;

int respuestaObtenida = Whitebox.<Integer> invokeMethod(instance, "sumar", 1, 3);

Assert.assertEquals(respuestaEsperada, respuestaObtenida);
}
}

</code>

===Inicialización de atributos estaticos===

<code java>
public class PruebaInicializacionEstaticos {

private static final String atributo = new String("CHAU");

public String crearObjetoLista() {
return atributo;
}
}
</code>

<code java>
@RunWith(PowerMockRunner.class)
@SuppressStaticInitializationFor("PruebaInicializacionEstaticos")
@PrepareForTest(PruebaInicializacionEstaticos.class)
public class PruebaMetodoPrivadoTest {

PruebaInicializacionEstaticos pruebaInicializacionEstaticos =
new PruebaInicializacionEstaticos();

@Test
public void controlCreacionLista() throws Exception {
Assert.assertNull(pruebaInicializacionEstaticos.retornarAtrinbuto());
String s = "Hola";
Whitebox.setInternalState(pruebaInicializacionEstaticos.class,"atributo", s);
Assert.assertEquals(s, pruebaInicializacionEstaticos.retornarAtrinbuto());
}
}
</code>

===Captura creación de objetos===

<code java>
public class PruebaCreacionObjeto {

public List crearObjetoLista() {
return new ArrayList();
}
}
</code>

<code java>
@RunWith(PowerMockRunner.class)
@PrepareForTest(PruebaCreacionObjeto.class)
public class PruebaMetodoPrivadoTest {

@Spy
PruebaCreacionObjeto pruebaCreacionObjeto = new PruebaCreacionObjeto();

@Test
public void controlCreacionLista() throws Exception {
List list = new ArrayList();
list.add("Hola");
whenNew(ArrayList.class).withNoArguments().thenReturn((ArrayList) list);
List resultado = pruebaCreacionObjeto.crearObjetoLista();
Assert.assertEquals(list, resultado);
verifyNew(ArrayList.class);
}
}
</code>

Para mas ejemplos de Mockito junto a PowerMock ver los [http://code.google.com/p/powermock/wiki/MockitoUsage13 ejemplos] provisto por la documentación de PowerMock.

[http://www.dosideas.com/descargas/category/3-testing.html?download=40 Descargar proyecto NetBeans demo de los ejemplos]

===PowerMockito & Cobertura===
Existe un problema al utilizar PowerMockito con Cobertura (versión 1.8.4), este último no registra la corrida de los test con anotación @PrepareForTest, dando como resultados falta de cobertura.
Para solucionar este inconveniente solo hay que actualizar la versión de Cobertura.

==Ejemplo de Mockito para mockear appender de log4j==

<code java>
//Inicializamos mock.
Appender mockAppender = mock(AppenderSkeleton.class);
//Inicializamos logger de la clase bajo test
Logger log = Logger.getLogger(ClaseATestear.class);
//Agregamos el mock del appender al logger.
log.addAppender(mockAppender);
//Seteamos el nivel de log que nos interesa recuperar.
log.setLevel(Level.DEBUG);
</code>

Para poder obtener los log que se produjeron utilizamos la clase ArgumentCaptor de mockito que nos permite, entre otras cosas, capturar los eventos de log.

<code java>
ArgumentCaptor loggingEventCaptor = ArgumentCaptor.forClass(LoggingEvent.class);
verify(mockAppender, times(1)).doAppend((LoggingEvent) loggingEventCaptor.capture());

loggingEventCaptor.capture());
</code>

Una posible forma de obtener un mensaje particular es iterando la lista de mensajes que nos da la clase capturada.

<code java>
List<LoggingEvent> loggingEvent = (List<LoggingEvent>) loggingEventCaptor.getAllValues();
</code>

== BDDMockito ==
BDDMokcito es una clase alternativa que ofrece [[Mockito]] para crear pruebas al estilo [[Behavior Driven Development]] (BDD) (es decir, con bloques dado / cuando / entonces).

El problema es que el API de Mockito usa la palabra "when" y no se integra bien con los comentarios //given //when //then (según BDD, el stubbing forma parte del área //given, y no del //when).

BDDMockito agrega una clase que tiene alias para los métodos de stub, usando given(Object).

<code java5>
import static org.mockito.BDDMockito.*;

Vendedor vendedor = mock(Vendedor.class);
Negocio negocio = new Negocio(vendedor);

@Test
public void comprarPan() throws Exception {
//given
given(vendedor.buscarPan()).willReturn(new Pan());

//when
Compra compra = negocio.comprarPan();

//then
assertThat(compra, contienePan());
}
</code>

Stubbing con void y excepciones:
<code java5>
//given
willThrow(new RuntimeException("boo")).given(mock).foo();

//when
Result result = sistemaBajoPrueba.ejecutar();

//then
assertEquals(failure, result);
</code>

==Ver también==
* [[EasyMock]]
* [[Captura De Parametros]]
* [[Inyeccion De Mocks De Mockito Con Spring]]
* [[Test de componente para un cliente TCP]]
* [http://www.dosideas.com/descargas/category/3-testing.html?download=11%3Ademo-de-mockito Proyecto de ejemplos con Mockito]
* [http://www.dosideas.com/java/242-mockito-o-basta-de-easymock.html Introducción a Mockito]
* [http://mockito.googlecode.com/svn/branches/1.8.0/javadoc/org/mockito/BDDMockito.html Javadoc de BDDMockito]

[[Category:TDD]]
[[Category:BDD]]
[[Category:JUnit]]

Selenium

2011-10-12T14:14:54Z

MaTT:

[[Selenium]] es una herramienta de [[Software Libre]] para pruebas de aplicaciones Web. Las pruebas de [[Selenium]] se ejecutan directamente en un navegador y facilitan las pruebas de compatibilidad en navegadores, también como pruebas funcionales de aceptación de aplicaciones Web.

La herramienta [[Selenium]] posee un ambiente de desarrollo llamado [[Selenium]] IDE, este facilita el registro de pruebas de aceptación y su depuración.

==Integracion con JUnit 4.x==

Para poder armar el test es necesario incluir los siguientes jars.

*selenium-java-client-driver-tests.jar
*selenium-java-client-driver.jar
*selenium-server-tests.jar
*selenium-server.jar

Se pueden descargar de acá: [http://archiva.openqa.org/repository/releases/org/openqa/selenium/selenium-remote-control/1.0-beta-1/selenium-remote-control-1.0-beta-1-dist.zip Librerías]

<code java>
import org.junit.Before;
import org.junit.Test;
import org.openqa.selenium.server.SeleniumServer;

import com.thoughtworks.selenium.DefaultSelenium;
import com.thoughtworks.selenium.SeleneseTestCase;

public class GoogleWebTest extends SeleneseTestCase {

private DefaultSelenium selenium;
private SeleniumServer seleniumServer;

@Override
@Before
public void setUp(String browser) throws Exception {
// Se instancia el server de selenium por default toma el puerto 4444
seleniumServer = new SeleniumServer();
seleniumServer.start();

// Se configura el acceso a la pagina por medio del server de selenium
// DefaultSelenium("SELENIUM_HOST", PUERTO, "BROWSER", URL_DE_LA_APLICACION);
// En este ejemplo, se utiliza Internet Explorer: "*iehta"
selenium = new DefaultSelenium("localhost", 4444, "*iehta", "http://www.google.com");
selenium.start();
}

/** Al finalizar los tests, detener el server de Selenium
*/
@Override
public void tearDown() throws Exception {
// Se para la conexión con la pagina
selenium.stop();

// Se para la instancia del server de selenium
seleniumServer.stop();
}

/** Testeamos una búsqueda en Google
* Accedemos a Google, realizamos una búsqueda y comprobamos que venga el resultado esperado
*/
@Test
public void testGoogle() throws Exception {
selenium.open("http://www.google.com/webhp");
assertEquals("Google", selenium.getTitle());
selenium.type("q", "Selenium OpenQA");
assertEquals("Selenium OpenQA", selenium.getValue("q"));
selenium.click("btnG");
selenium.waitForPageToLoad("30000");
assertEquals("Selenium OpenQA - Google Search", selenium.getTitle());
}

}
</code>

==Sobre waitForPageToLoad==

Es importante que la página esté cargada antes de hacer las verificaciones sobre el nuevo contenido. Para hacer más sólido el caso de prueba ubica un waitForPageToLoad luego de un click.

Es recomendable que al terminar un caso de prueba ubiques un waitForPageToLoad y así te aseguras que el próximo caso de prueba no falle al comenzar.
ghjgjgj

Yo, good lkooin out! Gonna make it work now.

==Sobre assertTextPresent==

Este comando es útil después de cada comando clickAndWait para confirmar un texto debe estar presente en la página.

==Sobre verifyTrue==

Al realizar [http://www.dosideas.com/java/743-test-secuencial-con-selenium-y-junit.html test secuencial] con [[Selenium]] IDE, y verificar texto en la página, después de convertir el test a código Java -para correrlo con JUnit- queda generado con el comando

<code html4strict>

verifyTrue(selenium.isTextPresent("Algun texto"));

</code>

Este comando no genera fallas en el test en caso que el texto buscado no se encuentre en la página. El comando adecuado para que se genere la falla es

<code html4strict>

assertTrue(selenium.isTextPresent("Algun texto"));

</code>

== Sobre Popups ==

En Selenium, se trabaja con una ventana a la vez. Para trabajar con diferentes ventanas (por ejemplo, un popup) se necesita primero elegir la ventana en cuestión. Y no solo basta con esto, tambien dicha ventana tiene que ser identificada. La forma mas facil de realizar esto es capturar el id de la nueva ventana con Selenium IDE.

Si la ventana se abre con un target="_blank" no se podrá utilizar Selenium para acceder a dicha ventana dado a que el id que se genera es random. Hay un [http://jira.openqa.org/browse/SEL-203 Jira] abierto en Selenium para resolver esto.

== Sobre caracteres especiales ==

Para que hudson tome bien los acentos (y caracteres especiales) en los test de selenium hay que usar unicode.

Los codigos son:

*á -> \u00e1
*é -> \u00e9
*í -> \u00ed
*ó -> \u00f3
*ú -> \u00fa
*Á -> \u00c1
*É -> \u00c9
*Í -> \u00cd
*Ó -> \u00d3
*Ú -> \u00da
*ñ -> \u00f1
*Ñ -> \u00d1

*ü -> \u00FC
*Ü -> \u00DC
*ç -> \u00E7
*Ç -> \u00C7
*¿ -> \u00BF
*¡ -> \u00A1

== Sobre la integración contínua ==

Cuando se usa Selenium en un proceso de integración contínua puede pasar que nos encontremos con tests que fallan porque no se encuentran los elementos esperados. Lo bueno es saber qué se encontró en lugar de lo que se esperaba.

El método selenium.getBody() retorna un String con el texto de la página en la que se encuentra selenium en ese momento, pero lo mejor de todo es que además lo escribe en consola.

Si miramos la salida por consola del test fallido vamos a encontrar la secuencia de los comandos de selenium y en los lugares donde hayamos puesto los getBody() vamos a ver intercalado los textos que mostraba la página en ese momento.

== Selenium 2.0 and WebDriver ==
Tiene muchas características nuevas y mejoras con respecto selenium 1.

La nueva característica principal es la integración de la API WebDriver.
Esto surge a partir de una serie de limitaciones, junto con ofrecer una alternativa, y más simple, interfaz de programación. El objetivo es desarrollar una API orientada a objetos que proporciona apoyo adicional para un mayor número de navegadores con soporte mejorado para los modernos problemas avanzados de pruebas de aplicaciones web.

=== Migrar de Selenium RC a Selenium WebDriver ===

Ventajas:
* El API WebDriver es más orientada a objetos que el original de la API de selenium RC. Esto puede hacer que sea más fácil trabajar con él.

* Mejora de la emulación de las interacciones del usuario. Siempre que sea posible, WebDriver hace uso de eventos nativos con el fin de interactuar con una página web.

* El apoyo de los fabricantes de navegadores. Opera, Mozilla y Google son todos los participantes activos en el desarrollo de WebDriver, y cada uno tiene ingenieros trabajando para mejorar el marco.

El primer paso para empezar a migrar es cambiar como obtener la instancia de selenium. Cuando se utiliza Selenium RC, seria:

<code java>
Selenium selenium = new DefaultSelenium(
"localhost", 4444, "*firefox", "http://www.dosideas.com");
selenium.start();
</code>

Estas lineas hay que cambiarlas por:

<code java>
WebDriver driver = new FirefoxDriver();
Selenium selenium = new WebDriverBackedSelenium(driver, "http://www.dosideas.com");
</code>

=== Como inicializar el driver de Firefox con un perfil particular ===

Cuando se quiere utilizar Firefox para correr los test, es posible que necesitemos que el perfil tenga algunas caracteristicas que no vienen por default.
Esto se realiza de la siguiente manera:

Creamos un nuevo perfil:

<code java>FirefoxProfile profile = new FirefoxProfile();
</code>

Si por ejemplo, nosotros queremos agregarle a la configuracion del perfil para que utilice un proxy deberias poner:

<code java>
profile.setPreference("network.proxy.type", 1);
profile.setPreference("network.proxy.http", "proxy.dosideas.com");
profile.setPreference("network.proxy.http_port", 8080);
profile.setPreference("network.proxy.no_proxies_on", "PC-DOSIDEAS");
</code>

Nota: El atributo network.proxy.no_proxies_on indica que el proxy no se utiliza para esa direccion.

Finalmente, agregamos el nuevo perfil al driver e inicializamos normalmente:

<code java>
WebDriver driver = new FirefoxDriver(profile);
</code>

==Ver también==
*[[Herramientas Para Pruebas De Aceptacion]]
*[http://selenium.openqa.org/ Web oficial de Selenium]
*[http://www.pghcodingdojo.org/index.php/Selenium_RC_Tutorial Selenium RC Tutorial]
*[http://www.dosideas.com/java/743-test-secuencial-con-selenium-y-junit.html Test Secuencial con Selenium y JUnit]
*[http://seleniumhq.org/docs/04_selenese_commands.html#verifying-page-elements Comandos de Verificación de elementos en páginas web]
*[http://wiki.openqa.org/display/SEL/Selenium+Core+FAQ#SeleniumCoreFAQ-HowdoIworkwithapopupwindow%3F Popup con Selenium]
*[[Simplium]]

[[Category:ATDD]]

GlassFish

2010-06-11T19:21:49Z

MaTT: /* Crear un dominio nuevo */

GlassFish es un [[Servidor de Aplicaciones]] para [[Java EE]] libre de código abierto, apoyado por Sun. Usualmente GlassFish es uno de los primeros Servidores de aplicaciones en soportar las últimas novedades de [[Java EE]].

== Librerías cliente ==
Para acceder a EJBs y otros recursos del Application Server, un cliente standalone necesita las siguientes librerias (que se encuentran en el directorio ''lib/'' de GlassFish):
* j2ee.jar
* appserv-rt.jar
* appserv-deployment-client.jar
* appserv-ext.jar

== Breve resumen de uso ==

=== Instalación ===
# Bajar GlassFish (es un jar)
# Copiar el jar al directorio donde se quiera instalar
# Abrir una terminal de texto, ubicarse en el directorio donde copiar el jar, y ejecutar los comandos:
java -Xmx256m -jar filename.jar
cd glassfish
ant -f setup.xml

Reemplazar ''filename.jar'' con el nombre del archivo descargado. Para estos comandos, debe tenerse acceso en el PATH del sistema operativo a una version de Java 1.5 o superior, y al ejecutable de [Ant]. GlassFish ya incluye una versión de Ant (ubicada en el directorio ''lib/ant'')que puede usarse en caso de no tener Ant en el path.

Una vez instalado GlassFish, se puede iniciar o parar su ejecución con un par de comandos. Los comandos de administración de GlassFish se encuentran ubicados en el directorio_de_instalacion/bin

=== Iniciar GlassFish ===

asadmin start-domain

GlassFish inicia, y puede cerrarse la consola donde se ejecutó este comando.

=== Configurar GlassFish (consola de administración) ===

Una vez iniciado, la consola de administración de GlassFish se puede acceder desde:

http://localhost:4848
'''usuario''': admin
'''password''': adminadmin

Desde esta consola pueden administrarse las aplicaciones (deploys/redeploys/undeploys) y configurar los ConnectionPool y DataSource.

=== Acceder a aplicaciones instaladas ===

Por default, GlassFish expone las aplicaciones web en el puerto 8080. Por ejemplo, para acceder a la aplicación web "miAplicacion":

http://localhost:8080/miAplicacion

=== Detener GlassFish ===

asadmin stop-domain

=== Crear un dominio nuevo ===

asadmin create-domain --adminport 4848 domain2

== Integración con CentOS / Fedora y otros Linux ==
[[GlassFish]] se inicia desde la línea de comandos, por lo cual es muy facil integrarlo con los sistemas de servicios que ofrecen las distintas distribuciones de Linux.

Para integrarlo con CentOS / Fedora / RedHat Linux, ubicar el siguiente script en '''/etc/init.d/glassfish'''
<pre>
#!/bin/bash
#
# glassfish Este script se encarga de iniciar y detener el
# servidor de aplicaciones Java GlassFish v3.
#

# Source function library.
. /etc/init.d/functions

prog="GlassFish v3"
asadmin="/usr/local/glassfishv3/bin/asadmin"

# Esta variable la usa GlassFish para determinar el JDK a usar.
# Habra otra manera?
export AS_JAVA=/usr/local/jdk1.6.0_18/

start() {
action $"Starting $prog: " $asadmin start-domain
}
stop() {
action $"Stopping $prog: " $asadmin stop-domain
}
restart() {
action $"Restarting $prog: " $asadmin restart-domain
}

case "$1" in
start)
start
;;
stop)
stop
;;
restart)
restart
;;
*)
echo $"Usage: $0 {start|stop|restart}"
exit 2
esac

exit $?
</pre>

Luego, podemos ejecutar los siguentes comandos desde la consola de Linux para iniciar/detener [[GlassFish]]
service glassfish start
service glassfish stop

== Ver también ==
* [[Servidor de Aplicaciones]]
* [https://glassfish.dev.java.net/ Web oficial de GlassFish]
* [https://glassfish.dev.java.net/downloads/quickstart/index.html GlassFish Quick Start]
* [https://glassfish.dev.java.net/public/downloadsindex.html Descarga de GlassFish ]
* [https://glassfishplugins.dev.java.net/eclipse33/index.html Plugin de Glassfish para Eclipse]

[[Category:GlassFish]]

GlassFish

2010-06-11T19:21:23Z

MaTT: /* Breve resumen de uso */

Debug Remoto De Weblogic

2010-05-06T12:38:27Z

MaTT: /* Configuración para Weblogic 10.x. */

[[Category:WebLogic]]
[[Category:IDE]]
Existe una forma de poder debuguear el [[WebLogic]] desde algún IDE. Esto lo posibilita una característica conocida como [[JPDA]] que las máquinas virtuales de Java (JVM) tienen.

==Configurando el Weblogic==
*Setear la variable para debug:
set DEBUG_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,address=1044,server=y,suspend=n

===Configuración para Weblogic 8.x.===
*Ubicar el dominio en uso. Por ejemplo \bea\user_projects\domain\mydomain.
*Abrir el archivo startWeblogic.cmd para editar.
*Sobre el final del archivo, localizar esta línea:
%JAVA_HOME%\bin\java %JAVA_VM% %MEM_ARGS% %JAVA_OPTIONS%...
*Agregarle la variable %DEBUG_OPTS% de la siguiente forma:
%JAVA_HOME%\bin\java '''%DEBUG_OPTS%''' %JAVA_VM% %MEM_ARGS%...

===Configuración para Weblogic 9.x.===
*Ubicar la carpeta bin del dominio en uso. Por ejemplo \bea\user_projects\domain\mydomain\bin.
*Abrir el archivo startWebLogic.cmd para editar.
*Sobre el final del archivo, localizar las dos lineas que comienzan:
%JAVA_HOME%\bin\java %JAVA_VM%
*Agregarle la variable %DEBUG_OPTS% de la siguiente forma:
%JAVA_HOME%\bin\java '''%DEBUG_OPTS%''' %JAVA_VM% %MEM_ARGS%...

===Configuración para Weblogic 10.x.===
Para iniciar WebLogic Server en modo debug, se necesita modificar el startWebLogic.cmd script. Ejemplo: <WLS-root>\wlserver_10.0\samples\domains\wl_server. <WLS-root> es el directorio en el que se instalo el weblogic.

En el startWebLogic.cmd script, añadir:

set JAVA_OPTIONS=-Xdebug -Xnoagent -Xrunjdwp:transport=dt_socket,address=4000,server=y,suspend=n

El -XDebug parametro habilita el debug.
El -Xnoagent parametro desabilita el default sun.tools.debug agente debug.
El -Xrunjdwp parametro carga el JPDA refencia de la implementacion de JDWP.
Debugging es hablitado en el puerto 4000.
El protocolo JDWP es el protocolo usado en debug con el debugger remoto.

Iniciar el WebLogic Server con el startWebLogic.cmd script.

==Configurando el IDE==

La idea es siempre la misma: conectar el debugger del IDE a la JVM de WebLogic. Esta tarea varia de acuerdo al IDE que se utilice. A continuación las instrucciones para algunos IDE.

En todos los casos, WebLogic tiene que estar levantado para que el IDE pueda conectarse. Para esto, ejecutar el script que se modifico en el paso anterior. Una vez que WebLogic inicie, sigan las instrucciones.

=== [[Eclipse]] ===
#Ir al menú Run -> Debug... (varia el nombre de acuerdo a la versión. se debe acceder a la configuración del debug).
#Seleccionar la opción de la izquierda "Remote Java Application".
#Click en el botón "New".
#En la solapa "Connect" completen los datos:
##Connection Type: Standard (Socket Attach)
##Host: el IP o nombre de su maquina
##Port: 1044
#Click en el botón Debug. Eclipse debería conectarse a WebLogic y quedar listo para debug.

=== [[NetBeans]] ===
#Ir al menú Debug -> Attach Debugger
#Completar los datos del popup que aparece:
##Connector: !SocketAttach
##Transport: dt_socket
##Host: El IP o nombre de su maquina
##Port: 1044
#Click en "Ok". NetBeans se debería conectar a WebLogic y quedar listo para debug.

=== [[JDeveloper]] ===
#Sobre el toolbar, ir al ícono de debug -> Manage Run Configurations...
#Seleccionar la categoría Run/Debug
#Doble-click en la configuración de debug Default (o la que se este usando)
#Seleccionar la opción Launch Settings
#Activar el checkbox "Remote Debugging and Profiling"
#Seleccionar la opción Debugger -> Remote
#Completar los datos:
##Protocol: Attach to JPDA
##Host: el IP o nombre de la maquina
##Port: 1044
#Aceptar las ventanas abiertas. JDeveloper está listo para debug.

Debug Remoto De Weblogic

2010-05-06T12:27:02Z

MaTT: /* Configurando el Weblogic */

[[Category:WebLogic]]
[[Category:IDE]]
Existe una forma de poder debuguear el [[WebLogic]] desde algún IDE. Esto lo posibilita una característica conocida como [[JPDA]] que las máquinas virtuales de Java (JVM) tienen.

==Configurando el Weblogic==
*Setear la variable para debug:
set DEBUG_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,address=1044,server=y,suspend=n

===Configuración para Weblogic 8.x.===
*Ubicar el dominio en uso. Por ejemplo \bea\user_projects\domain\mydomain.
*Abrir el archivo startWeblogic.cmd para editar.
*Sobre el final del archivo, localizar esta línea:
%JAVA_HOME%\bin\java %JAVA_VM% %MEM_ARGS% %JAVA_OPTIONS%...
*Agregarle la variable %DEBUG_OPTS% de la siguiente forma:
%JAVA_HOME%\bin\java '''%DEBUG_OPTS%''' %JAVA_VM% %MEM_ARGS%...

===Configuración para Weblogic 9.x.===
*Ubicar la carpeta bin del dominio en uso. Por ejemplo \bea\user_projects\domain\mydomain\bin.
*Abrir el archivo startWebLogic.cmd para editar.
*Sobre el final del archivo, localizar las dos lineas que comienzan:
%JAVA_HOME%\bin\java %JAVA_VM%
*Agregarle la variable %DEBUG_OPTS% de la siguiente forma:
%JAVA_HOME%\bin\java '''%DEBUG_OPTS%''' %JAVA_VM% %MEM_ARGS%...

===Configuración para Weblogic 10.x.===
Para iniciar WebLogic Server en modo debug, se necesita modificar el startWebLogic.cmd script. Ejemplo: <WLS-root>\wlserver_10.0\samples\domains\wl_server. <WLS-root> es el directorio en el que se instalo el weblogic.

En el startWebLogic.cmd script, añadir:

set JAVA_OPTIONS=-Xdebug
-Xnoagent -Xrunjdwp:transport=dt_socket,address=4000,server=y,suspend=n

El -XDebug parametro habilita el debug.
El -Xnoagent parametro desabilita el default sun.tools.debug agente debug.
El -Xrunjdwp parametro carga el JPDA refencia de la implementacion de JDWP.
Debugging es hablitado en el puerto 4000.
El protocolo JDWP es el protocolo usado en debug con el debugger remoto.

Iniciar el WebLogic Server con el startWebLogic.cmd script.

==Configurando el IDE==

La idea es siempre la misma: conectar el debugger del IDE a la JVM de WebLogic. Esta tarea varia de acuerdo al IDE que se utilice. A continuación las instrucciones para algunos IDE.

En todos los casos, WebLogic tiene que estar levantado para que el IDE pueda conectarse. Para esto, ejecutar el script que se modifico en el paso anterior. Una vez que WebLogic inicie, sigan las instrucciones.

=== [[Eclipse]] ===
#Ir al menú Run -> Debug... (varia el nombre de acuerdo a la versión. se debe acceder a la configuración del debug).
#Seleccionar la opción de la izquierda "Remote Java Application".
#Click en el botón "New".
#En la solapa "Connect" completen los datos:
##Connection Type: Standard (Socket Attach)
##Host: el IP o nombre de su maquina
##Port: 1044
#Click en el botón Debug. Eclipse debería conectarse a WebLogic y quedar listo para debug.

=== [[NetBeans]] ===
#Ir al menú Debug -> Attach Debugger
#Completar los datos del popup que aparece:
##Connector: !SocketAttach
##Transport: dt_socket
##Host: El IP o nombre de su maquina
##Port: 1044
#Click en "Ok". NetBeans se debería conectar a WebLogic y quedar listo para debug.

=== [[JDeveloper]] ===
#Sobre el toolbar, ir al ícono de debug -> Manage Run Configurations...
#Seleccionar la categoría Run/Debug
#Doble-click en la configuración de debug Default (o la que se este usando)
#Seleccionar la opción Launch Settings
#Activar el checkbox "Remote Debugging and Profiling"
#Seleccionar la opción Debugger -> Remote
#Completar los datos:
##Protocol: Attach to JPDA
##Host: el IP o nombre de la maquina
##Port: 1044
#Aceptar las ventanas abiertas. JDeveloper está listo para debug.

Debug Remoto De Weblogic

2010-05-06T12:24:07Z

MaTT: /* Configurando el Weblogic */