Integrar JUnit con Spring

Integrar JUnit con Spring es bastante simple. Solo debes crear tu test y anotarlo con @RunWith(SpringJUnit4ClassRunner.class).

JUnit invocará la clase de referencia, en este caso ‘SpringJUnit4ClassRunner’.
SpringJUnit4ClassRunner se encargará de levantar el contexto de Spring, en este ejemplo tengo dos contextos, donde el segundo ’sobreescribe’ al primero.

La configuración del contexto puedes pasarla con otra anotación de Spring @ContextConfiguration

Para inyectar un bean de Spring en el test deben marcarlo con @Autowired.

Spring buscará un bean definido con el mismo nombre del atributo y lo inyectará en tu test. Si queres forzar a Spring para que utilice un bean puedes utilizar @Qualifier

import java.util.ArrayList;
 
import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
/**
 * @author gustavo
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "/gp/applicationContext.xml", "/gp/applicationContextTesting.xml" })
public class TestWithSpring {
 
    @BeforeClass
    public static void setup() {
        BasicConfigurator.configure();
        Logger.getRootLogger().setLevel(Level.INFO);
        //... configuracion de inicio
    }
 
    @Autowired
    @Qualifier("_testSpringList")
    private ArrayList _testSpringList; // spring inyectara este atributo
 
    @Test
    public void simpleTest() {
        Assert.assertFalse(this._testSpringList.isEmpty());
        for (Object s : this._testSpringList) {
            System.out.println(s.toString());
        }
    }    
 
    @AfterClass
    public static void endClazz() {
        //... 
    }
 
}

En Spring tengo definido _testSpringList de esta manera:

	<bean id="_testSpringList" class="java.util.ArrayList">
		<constructor-arg>
			<list>
				<value>hi!</value>
				<value>bye!</value>
			</list>
		</constructor-arg>
	</bean>

Mejora la calidad de tu software con testing

Mejorar la calidad de tu software depende también de que hagas buenos test durante su desarrollo.

Es importante tener presente en el ciclo de desarrollo las pruebas y orientarse hacia el testing para evitarse futuros e innecesarios problemas. Los test te ayudarán a encontrar errores, pero ten presente que aunque el test no falle, esto no significa que el software no contenga errores.
Como dijo ‘Dijkstra’ “…El testing prueba la presencia de errores pero no la ausencia de ellos…”

Hay que distinguir dos tipos de errores: los llamados errores de software o bugs y los errores de forma.
Los errores de forma son aquellos en los cuales el software no falla en su código pero si en su funcionalidad, es decir no cumple con lo que se espera de ellos como resultado.

Los frameworks de testing como JUnit, TestNG te ayudarán principalmente con los bugs y otro poco con los errores de funcionalidad, pero estos últimos deben ser subsanados con un buen ciclo de entregas y retroalimentación continuo del software.
Además, estos frameworks te serán de gran utilidad en entornos de aplicación ‘pesados’ donde probar el software significa, por ejemplo, levantar un servidor web.

Otro punto positivo, es que si diseñas buenas suites de pruebas, podrás luego,  ante un cambio por mantenimiento en tu software,  realizar una prueba integral de todos los módulos del mismo verificando que no hayas ‘roto’ alguna otra cosa.
Testear el software es poco divertido (al menos para mí) y apoyarse en un buen framework de testing ayuda a aliviar en parte esa tediosa (pero necesaria) tarea de probar el software. Una vez que tienes hecho el test, lo ejecutas las veces que quieras.

JUnit es un clásico de los test, muy conocido y muy integrado a los principales entornos de desarrollo.
TestNG es otra buena opción para realizar tus pruebas.

Veamos un poco de JUnit con un simple ejemplo:

JUnit

Esta es la consola de JUnit

Anotaciones mas usadas:

@BeforeClass:  se ejecuta una sola vez para todos los test. Util para inicializar variables u otros datos que serán compartidos.
@AfterClass: se ejecuta una sola vez al finalizar los test.
@Before: se ejecuta previo al iniciar cada @Test.
@After: se ejecuta luego de cada @Test
@Test: metodo que será ejecutado como test.

Nuestra clase de test JUnit…
——-

import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;

public class SimpleTestJUnit {

    Calculator calc;

    @Before
    public void setUp() {
        // Before indica que debe ejecutrarse antes de iniciar el test...
        System.out.println("Ejecutando SimpleTest.setUp ...");
        calc = new Calculator();
    }

    @After
    public void after() {
        // After indica que debe ejecutrarse despues del test...
        System.out.println("Ejecutando SimpleTest.after...");
    }

    @Test
    public void testDivision() {
        System.out.println("Ejecutando SimpleTest.testDivision...");
        System.out.println(calc.getDivision(10, 3));
    }

    @Test
    public void testDivisionByZero() {
        // este test se ejecutara con error
        System.out.println("Ejecutando SimpleTest.testDivisionByZero...");
        System.out.println(calc.getDivision(10, 0));
    }

    @Test(expected = ArithmeticException.class)
    public void testDivisionByZeroWithExpectedException() {
        // Este test no dara error. Esperamos la exception ArithmeticException
        System.out.println("Ejecutando SimpleTest.testDivisionByZeroWithExpectedException...");
        System.out.println(calc.getDivision(10, 0));
    }

    @Test
    public void testPrimeNumber() {
        System.out.println("Ejecutando SimpleTest.testPrimeNumber...");
        int i = 10;
        int j = 5;
        System.out.println("Es numero primo: " + calc.isPrimeNumber(i, j));
        Assert.assertTrue(calc.getRest(i, j) == 0);
    }

    @Ignore
    @Test
    public void testIgnore() {
        // NO se ejecutara debido a que tiene la anotacion @Ignore...
        System.out.println("SimpleTest.testIgnore...");
    }

}

———–
Nuestra clase Calculator que usamos para este ejemplo es…
–

public class Calculator {

    public double getDivision(int v1, int v2){
        int i = v1 / v2 ;
        return i;
    }

    public double getRest(int v1, int v2){
        double i = v1 % v2;
        return i;
    }

    public boolean isPrimeNumber(int v1, int v2){
        return getRest(v1, v2) == 0;
    }

}

–
Ahora armaremos un suite para ejecutar varios test’s juntos…
Defines una clase con las dos anotaciones que se muestran, en una de ellas ‘SuiteClasses’ indicarás los test a ejecutar.

import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;

@RunWith(Suite.class)
@SuiteClasses( { SimpleTestJUnit.class, SimpleTestJUnit2.class})
public class AllTests {

    public static void main(String[] args) {
        // esta clase ejecutara los test's definidos en @SuiteClasses
    }

}

——

TestNG

Si conoces JUnit te resultará mas que fácil usarlo y si no, verás que es muy parecido a JUnit
Este framework se integra a Eclipse con su plug-in

Esta es la consola de TestNG (muy similar a la de JUnit)

Haz click aqui para ver un test simple con TestNG …

import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;

public class SimpleTestNG {

    @BeforeTest(dependsOnMethods = "setup")
    public void before() {
        // BeforeTest indica que debe ejecutarrse antes de iniciar los test. 
        // Antes se ejecutara 'setup' debido a que esta indicado con 'dependsOnMethods'
        System.out.println("Ejecutando SimpleTest.before (antes debio ejecutarse setup)...");
    }

    @BeforeTest
    public void setup(){
        System.out.println("Ejecutando SimpleTest.setup...");
    }

    @AfterTest
    public void after() {
        // AfterTest indica que debe ejecutrarse despues. 
        System.out.println("Ejecutando SimpleTest.after...");
    }    

    @Test
    public void test() {
        // este es el test a ejecutarse...
        //... tu logica y llamadas a las clases que hace a la logica de negocio...
        System.out.println("Ejecutando SimpleTest.test...");
    }

    @Test(expectedExceptions={RuntimeException.class})
    public void test2() {
        System.out.println("Ejecutando SimpleTest.test2...");
        //Se espera que este test tire una expcetion 'RuntimeException'
        //Si no ocurre la exception el test sera fallido
        //throw new RuntimeException("Error esperado"); // si se comenta fallara el test 
    }

    @Test(enabled = false)
    public void test3() {
        // NO se ejecutara debido a que 'enabled = false'
        System.out.println("Ejecutando SimpleTest.test3...");
    }

}

En TestNG podemos crear también una suite de test’s.
Este xml ejecutará dos test SimpleTestNG, y SimpleTestNG2.
Solo debes ejecutarlo con el menú de TestNG

<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name="SuiteSimpleTests"    verbose="1" >
  <test name="GroupTest1"   >
    <classes>
      <class name="test.SimpleTestNG"/>
      <class name="test.SimpleTestNG2"/>
    </classes>
  </test>
</suite>

Como vez, los frameworks son bastante simples de utilizar, es solo cuestión de que te hagas el hábito de trabajar pensando y orientandote al testing. Pronto verás los beneficios que te trae para la calidad de tu software.
Espero te haya servido.

Enlaces: JUnit TestNG