JUnit - Extensões

A seguir estão as extensões JUnit -

Cactus
JWebUnit
XMLUnit
MockObject

Cacto

Cactus é uma estrutura de teste simples para teste de unidade de código java do lado do servidor (Servlets, EJBs, Tag Libs, Filtros). A intenção do Cactus é reduzir o custo de escrever testes para código do lado do servidor. Ele usa JUnit e o estende. Cactus implementa uma estratégia dentro do contêiner que executa os testes dentro de um contêiner.

O ecossistema de cactos é feito de vários componentes -

Cactus Frameworké o coração do Cactus. É o mecanismo que fornece a API para escrever testes Cactus.
Cactus Integration Modules são front-ends e frameworks que fornecem maneiras fáceis de usar o Cactus Framework (scripts Ant, plug-in Eclipse e plug-in Maven).

O código a seguir demonstra como o Cactus pode ser usado.

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 é uma estrutura de teste baseada em Java para aplicativos da web. Ele envolve as estruturas de teste existentes, como HtmlUnit e Selenium, com uma interface de teste simples e unificada para testar a exatidão de seus aplicativos da web.

JWebUnit fornece uma API Java de alto nível para navegar em um aplicativo da web combinada com um conjunto de asserções para verificar a exatidão do aplicativo. Isso inclui navegação por meio de links, entrada e envio de formulário, validação de conteúdo de tabela e outros recursos típicos de aplicativos da Web de negócios.

Os métodos de navegação simples e asserções prontas para uso permitem a criação de testes mais rápida do que usar apenas JUnit ou HtmlUnit. E se você quiser mudar de HtmlUnit para outros plug-ins como Selenium (disponível em breve), não há necessidade de reescrever seus testes.

Aqui está um código de amostra.

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 fornece uma única classe de extensão JUnit, XMLTestCase, e um conjunto de classes de suporte que permitem que asserções sejam feitas sobre -

As diferenças entre duas partes do XML (por meio das classes Diff e DetailedDiff).
A validade de uma parte do XML (via classe Validator).
O resultado da transformação de um pedaço de XML usando XSLT (via classe Transform).
A avaliação de uma expressão XPath em um pedaço de XML (por meio de classes que implementam a interface XpathEngine).
Nós individuais em um fragmento de XML que são expostos pelo DOM Traversal (via classe NodeTest).

Vamos supor que temos duas peças de XML que desejamos comparar e afirmar que são iguais. Poderíamos escrever uma classe de teste simples 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

Em um teste de unidade, os objetos fictícios podem simular o comportamento de objetos reais complexos (não fictícios) e, portanto, são úteis quando um objeto real é impraticável ou impossível de ser incorporado em um teste de unidade.

O estilo de codificação comum para teste com objetos fictícios é -

Crie instâncias de objetos fictícios.
Defina o estado e as expectativas nos objetos fictícios.
Chame o código de domínio com objetos fictícios como parâmetros.
Verifique a consistência nos objetos fictícios.

A seguir está um exemplo 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();
   }
}