JUnit - Extensiones

Las siguientes son las extensiones de JUnit:

Cactus
JWebUnit
XMLUnit
MockObject

Cactus

Cactus es un marco de prueba simple para pruebas unitarias de código java del lado del servidor (Servlets, EJB, Tag Libs, Filtros). La intención de Cactus es reducir el costo de escribir pruebas para el código del lado del servidor. Utiliza JUnit y lo amplía. Cactus implementa una estrategia en el contenedor que ejecuta las pruebas dentro de un contenedor.

El ecosistema de cactus está formado por varios componentes:

Cactus Frameworkes el corazón de Cactus. Es el motor que proporciona la API para escribir pruebas de Cactus.
Cactus Integration Modules son interfaces y frameworks que proporcionan formas sencillas de utilizar Cactus Framework (scripts Ant, plugin Eclipse y plugin Maven).

El siguiente código demuestra cómo se puede utilizar Cactus.

import org.apache.cactus.*;
import junit.framework.*;

public class TestSampleServlet extends ServletTestCase {
   @Test
   public void testServlet() {
      // Initialize class to test
      SampleServlet servlet = new SampleServlet();

      // Set a variable in session as the doSomething()
      // method that we are testing 
      session.setAttribute("name", "value");

      // Call the method to test, passing an 
      // HttpServletRequest object (for example)
      String result = servlet.doSomething(request);

      // Perform verification that test was successful
      assertEquals("something", result);
      assertEquals("otherValue", session.getAttribute("otherName"));
   }
}

JWebUnit

JWebUnit es un marco de prueba basado en Java para aplicaciones web. Envuelve los marcos de prueba existentes, como HtmlUnit y Selenium, con una interfaz de prueba unificada y simple para probar la exactitud de sus aplicaciones web.

JWebUnit proporciona una API de Java de alto nivel para navegar por una aplicación web combinada con un conjunto de afirmaciones para verificar la exactitud de la aplicación. Esto incluye navegación a través de enlaces, ingreso y envío de formularios, validación del contenido de la tabla y otras características típicas de aplicaciones web comerciales.

Los métodos de navegación simples y las aserciones listas para usar permiten una creación de pruebas más rápida que usar solo JUnit o HtmlUnit. Y si desea cambiar de HtmlUnit a otros complementos como Selenium (disponible pronto), no es necesario que vuelva a escribir sus pruebas.

Aquí hay un código de muestra.

import junit.framework.TestCase;
import net.sourceforge.jwebunit.WebTester;

public class ExampleWebTestCase extends TestCase {
   private WebTester tester;
   
   public ExampleWebTestCase(String name) {
      super(name);
      tester = new WebTester();
   }
	
   //set base url
   public void setUp() throws Exception {
      getTestContext().setBaseUrl("http://myserver:8080/myapp");
   }
	
   // test base info
   @Test
   public void testInfoPage() {
      beginAt("/info.html");
   }
}

XMLUnit

XMLUnit proporciona una única clase de extensión JUnit, XMLTestCase, y un conjunto de clases de soporte que permiten hacer afirmaciones sobre:

Las diferencias entre dos piezas de XML (a través de las clases Diff y DetailDiff).
La validez de una pieza de XML (a través de la clase Validator).
El resultado de transformar un fragmento de XML utilizando XSLT (a través de la clase Transform).
La evaluación de una expresión XPath en una pieza de XML (a través de clases que implementan la interfaz XpathEngine).
Nodos individuales en una pieza de XML que son expuestos por DOM Traversal (a través de la clase NodeTest).

Supongamos que tenemos dos piezas de XML que deseamos comparar y afirmar que son iguales. Podríamos escribir una clase de prueba simple como esta:

import org.custommonkey.xmlunit.XMLTestCase;

public class MyXMLTestCase extends XMLTestCase {

   // this test method compare two pieces of the XML
   @Test
   public void testForXMLEquality() throws Exception {
      String myControlXML = "<msg><uuid>0x00435A8C</uuid></msg>";
      String myTestXML = "<msg><localId>2376</localId></msg>";
      assertXMLEqual("Comparing test xml to control xml", myControlXML, myTestXML);
   }
}

MockObject

En una prueba unitaria, los objetos simulados pueden simular el comportamiento de objetos complejos, reales (no simulados) y, por lo tanto, son útiles cuando un objeto real no es práctico o es imposible de incorporar a una prueba unitaria.

El estilo de codificación común para probar con objetos simulados es:

Crea instancias de objetos simulados.
Establezca el estado y las expectativas en los objetos simulados.
Invocar código de dominio con objetos simulados como parámetros.
Verifique la coherencia en los objetos simulados.

A continuación se muestra un ejemplo de MockObject usando Jmock.

import org.jmock.Mockery;
import org.jmock.Expectations;

class PubTest extends TestCase {
   Mockery context = new Mockery();
   public void testSubReceivesMessage() {
      // set up
      final Sub sub = context.mock(Sub.class);

      Pub pub = new Pub();
      pub.add(sub);
    
      final String message = "message";
      
      // expectations
      context.checking(new Expectations() {
         oneOf (sub).receive(message);
      });

      // execute
      pub.publish(message);
      
      // verify
      context.assertIsSatisfied();
   }
}

↰ Previous page Next page ↱