fmt - ejemplo de usar ServletUnit para probar JSP''s
taglib jsp ejemplo (2)
No necesita registrar Servlet si va a usar el compilador Jasper predeterminado. Sin embargo, necesitaba Jasper jar y sus dependencias en CLASSPATH. Las dependencias de Maven que necesitaba para obtener un JSP básico para compilar y representar eran:
<dependency>
<groupId>tomcat</groupId>
<artifactId>jasper</artifactId>
<version>3.3.2</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>tomcat</groupId>
<artifactId>jasper-compiler</artifactId>
<version>5.5.23</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>tomcat</groupId>
<artifactId>tomcat-util</artifactId>
<version>5.5.23</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>tomcat</groupId>
<artifactId>core_util</artifactId>
<version>3.3.2</version>
<scope>test</scope>
</dependency>
Estoy atrapado en un proyecto JDK1.4, por lo que es posible que pueda usar versiones más nuevas. Aún no he conseguido el taglib estándar funcionando ...
¿Alguien puede señalarme un ejemplo de cómo usar ServletUnit para probar JSP? ¿Necesito necesito llamar a registerServlet ()? Si es así, ¿qué nombre de clase paso?
Esto es lo que estoy usando ahora para probar el renderizado JSP y verificar formas y reenvíos.
Primeras dependencias de Maven
<!-- Testing JSP -->
<dependency>
<groupId>net.sourceforge.openutils</groupId>
<artifactId>openutils-testing4web</artifactId>
<version>1.2.1</version>
<scope>test</scope>
<exclusions>
<exclusion>
<artifactId>slf4j-log4j12</artifactId>
<groupId>org.slf4j</groupId>
</exclusion>
<exclusion>
<artifactId>spring-core</artifactId>
<groupId>org.springframework</groupId>
</exclusion>
<exclusion>
<artifactId>spring-context</artifactId>
<groupId>org.springframework</groupId>
</exclusion>
<exclusion>
<artifactId>slf4j-api</artifactId>
<groupId>org.slf4j</groupId>
</exclusion>
<exclusion>
<artifactId>jcl-over-slf4j</artifactId>
<groupId>org.slf4j</groupId>
</exclusion>
<exclusion>
<artifactId>jsp-api</artifactId>
<groupId>javax.servlet</groupId>
</exclusion>
<exclusion>
<artifactId>jasper-runtime</artifactId>
<groupId>tomcat</groupId>
</exclusion>
<exclusion>
<artifactId>jasper-compiler</artifactId>
<groupId>tomcat</groupId>
</exclusion>
<exclusion>
<artifactId>jasper-compiler-jdt</artifactId>
<groupId>tomcat</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>catalina</artifactId>
<version>${tomcat.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>servlet-api</artifactId>
<version>${tomcat.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>jasper</artifactId>
<version>${tomcat.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>jasper-el</artifactId>
<version>${tomcat.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>jsp-api</artifactId>
<version>${tomcat.version}</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>${javax.servlet.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>jasper-jdt</artifactId>
<version>6.0.29</version>
<scope>test</scope>
</dependency>
<!-- log configuration -->
tomcat.version es 6.0.39, puede probar la versión moderna de Tomcat, 7 u 8, pero tenga cuidado con las dependencias que a veces se vuelven confusas.
javax.servlet.version es 3.0.1
A continuación he definido una clase de prueba común que se extienden por todas mis pruebas. Tengo una clase de prueba por controlador.
import it.openutils.testing.junit.AbstractDbUnitJunitSpringContextTests;
import org.junit.After;
import org.junit.Before;
import org.junit.runner.RunWith;
import org.springframework.core.io.Resource;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestExecutionListeners;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.DependencyInjectionTestExecutionListener;
import org.springframework.test.context.support.DirtiesContextTestExecutionListener;
import org.springframework.test.context.transaction.TransactionalTestExecutionListener;
import org.springframework.transaction.annotation.Transactional;
import com.meterware.servletunit.ServletRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "/integration/application-database-test.xml", "/integration/mvc-dispatcher-servlet-test.xml" })
@TestExecutionListeners({ DependencyInjectionTestExecutionListener.class, DirtiesContextTestExecutionListener.class, TransactionalTestExecutionListener.class })
public abstract class ControllerIntegrationCommonTest extends AbstractDbUnitJunitSpringContextTests
{
/**
* The Web CLient for JSP rendeting Test
*/
protected ServletRunner servletRunner;
/**
* @throws java.lang.Exception
*/
@Before
public void setUp() throws Exception
{
Resource web = this.applicationContext.getResource("/WEB-INF/web.xml");
if (servletRunner == null)
{
servletRunner = new ServletRunner(web.getFile(),null);
}
}
@After
public void setDown() throws Exception
{
servletRunner.shutDown();
}
}
Se necesita @ContextConfiguration, @TestExecutionListeners si desea ejecutarlo todo desde el contexto de Spring Junit. Si lo elimina, obtendrá una buena java.lang.IllegalStateException: no se pudo cargar ApplicationConext.
Observe aquí que instanciar el ServletRunner usando un Web.xml. Esto es obligatorio por supuesto y muy similar a mi producción. El segundo parámetro, contextPath se establece en Nulo. Para mi prueba, no la necesito Te remito a la API para obtener información más completa.
Una vez que haya configurado eso, haga que la prueba sea fácil. Añado ejemplos:
PostMethodWebRequest webRequest = new PostMethodWebRequest("http://myserver/setup/checkXML",true);
webRequest.setParameter("param1", "11112");
File file = new File("src/test/resources/datasets/myxml.xml");
webRequest.selectFile("fileData",file,"multipart/form-data");
WebResponse webResponse = servletRunner.getResponse(webRequest);
assertNotNull(webResponse);
assertTrue(webResponse.getURL().getPath().contains("checkXML"));
assertNotNull(webResponse.getElementsByTagName("resultCheck"));
log.debug(" ----------------- ");
log.debug(webResponse.getText());
log.debug(" ----------------- ");
webResponse.getFormWithID("resultsForm").getSubmitButtons()[0].click();
En este ejemplo, haré una publicación cargando un archivo. Debe crear PostMethodWebRequest con el parámetro mimeencoded establecido como verdadero. Si no, recibirá algunos mensajes de error divertidos. Para agregar el archivo solo utilicé los métodos. Puedes ver en la API que puedes subir un archivo o un conjunto de.
Este último ejemplo es solo para hacer Obtener solicitud
GetMethodWebRequest webRequest = new GetMethodWebRequest("http://myserver/setup/addarea");
webRequest.setParameter("param", "11");
WebResponse webResponse = servletRunner.getResponse(webRequest);
assertNotNull(webResponse);
assertTrue(webResponse.getURL().getPath().contains("addsomething"));
assertNotNull(webResponse.getElementsByTagName("listofsomething"));
assertNotNull(webResponse.getElementsByTagName("someelement"));
log.debug(" ----------------- ");
log.debug(webResponse.getText());
log.debug(" ----------------- ");
En este ejemplo, hago una solicitud Get a mi controlador. Como en el anterior, envío algunos parámetros y luego obtengo la respuesta. Allí verifico si la URL es lo que esperaba y verifico que el JSP ha renderizado algunos elementos.
Tenga en cuenta que para compilar WebRequest debo usar un formato de URL bien pero no hay problema con el nombre del servidor, la Unidad de servlet no lo usa en absoluto, no necesita definirlo en ningún lugar.
Espero que te ayude. ¡¡Que te diviertas!!