Jak spouštět JUnit testy pomocí Antu

JUnit je framework, který slouží v Javě k jednotkovému testování. V tomto článku se nebudu zabývat filozofií testování, zmíním zde jen způsob, jak jednoduše integrovat testy do vašeho build procesu takovým způsobem, abyste v případě vzniku chyby věděli, že k chybě došlo.

Co k tomu budeme potřebovat? Především Ant a JUnit knihovnu.

Kód, který budeme testovat

Uvedeme si jen takovou jednoduchou třídu:

public class SimpleClass {
	public int getSum(int a, int b) {
		return a + b;
	}
}

Jednoduchý JUnit test

Nejdříve si napíšeme jednoduchý test – uvedu zde pouze ilustrační příklad, který otestuje naší třídu. Tady máme náš test:

import static org.junit.Assert.*;
import org.junit.*;
 
public class SimpleTest {
 
	static int number1;
	static int number2;
	static int number3;
 
	@BeforeClass
	public static void init() {
		// Tato metoda se zavolá jednou - na začátku testování
		number1 = 5;
		number2 = 3;
		number3 = 8;
	}
 
	@Before
	public void setUp() {
		// Tato metoda se zavolá před každým testem
	}
 
	@AfterClass
	public static void delete() {
		// Tato metoda se zavolá po skončení posledního testu
	}
 
	@After
	public void clear() {
		// Tato metoda se zavolá po skončení každého testu
	}
 
	@Test
	public void firstTest() {
		SimpleClass simpleClass = new SimpleClass();
 
		assertTrue( number3 == simpleClass.getSum(number1, number2) );
	}
}

Všimněte si, že název testovací třídy obsahuje řetězec Test. Proč tomu tak je vysvětlím později.

Ant

Nyní máme napsaný jednoduchý test. Aby nám testy k něčemu byly, měly by se spouštět co nejčastěji. Myslím si, že nejvhodnější chvíle na spuštění JUnit testu je doba těsně před vytvořením výsledného spustitelného balíku. To zaručí, že pokud vytvoříme nějaký spustitelný balík (jar soubor), bude vše potřebné řádně otestováno. Ideální je nastavit to tak, aby při selhání jakéhokoliv testu nebyl tento balík ani vytvořen.

Vytvoříme si proto build.xml soubor:

< ?xml version="1.0" encoding="UTF-8"?>
<project name="SimpleProject" default="createJar" basedir="../">
	<property name="mainclass" value="SimpleClass"/>
	<property name="srcdir" value="./src"/>
	<property name="bindir" value="./bin"/>
	<property name="junit" value="./lib/junit-4.5.jar"/>
	<property name="junit-report-dir" value="./report"/>
 
	<target name="compile">
		<javac srcdir="${srcdir}" destdir="${bindir}" >
		</javac>
	</target>
 
	<target name="createJar" depends="compile,JUnitTests">
		<jar destfile="Simple.jar">
			<fileset dir="${bindir}"/>
			<manifest>
				<attribute name="Main-Class" value="${mainclass}"/>
			</manifest>
		</jar>
	</target>
 
	<target name="JUnitTests" depends="compile">
		<mkdir dir="${junit-report-dir}"/>
		<junit haltonfailure="yes">
			<formatter type="plain"/>
	   		<classpath>
	   			<pathelement location="${junit}" />
	   			<pathelement location="${bindir}" />
	   	  	</classpath>
			<batchtest fork="yes" todir="${junit-report-dir}">
		    	<fileset dir="${srcdir}">
		      		<include name="**/*Test*.java"/>
		    	</fileset>
		  	</batchtest>
		</junit>
	</target>
</project>

Jak to funguje?

Default target pro Ant je createJar, který je závislý na targetu compile a JUnitTests. To znamená, že se nejdříve zkompilují zdrojové kódy, potom se spustí testy a nakonec se vytvoří jar soubor.

Elementu junit můžete nastavit attribut halfonfailture, který pokud je nastaven na yes přeruší buildování v případě, že některý test neproběhne v pořádku. To se nám hodí – pokud testování selže, nevytvoří se jar soubor.

Do elementu classpath uvedeme cestu k JUnit knihovně (tu musíte stáhnout z této stránky) a také ke zkopilovaným třídám.

Samotné testování zařídí element batchtest, který je určen k hromadnému testování. V mém případě jsem si jej nastavil tak, aby otestoval všechny soubory, které mají v názvu řetězec Test. Díky tomu se otestuje i náš SimpleTest.

Pokud vše proběhne v pořádku, můžeme se na výsledky testu podívat do souborů uložených v adresáři report. V případě vzniku chyby můžete v těchto souborech najít podrobnější informace o chybě.

Krátké shrnutí na závěr

Pokud budete psát JUnit testy důsledně, máte díky tomuto postupu velkou šanci na odhalení chyby hned, jak se objeví. Díky integraci do build procesu si nemusíte spouštění testů nijak hlídat. Samozřejmě vím, že JUnit testy nikdy nepokryjí 100% kódu, takže i přes tuto snahu může nějaká chyba proklouznout. Nicméně tyto testy neslouží k odstranění rizika vzniku chyby – JUnit testy pouze zmenší šanci, že se taková chyba objeví.

Všechen přiložený kód jsem otestoval, nicméně je možné, že jsem někde mohl udělat chybu. Pokud tedy najdete nějakou chybu, nebo nesrovnalost, prosím dejte mi vědět v komentáři pod článkem.

Příspěvek byl publikován v rubrice Programování. Můžete si uložit jeho odkaz mezi své oblíbené záložky.

Napsat komentář

Vaše emailová adresa nebude zveřejněna. Vyžadované informace jsou označeny *