Durch die Augen des Anwenders

Automatisches Testen von Webanwendungen mit Selenium und Watij

Markus Stäuble

Damit Qualitätssicherung (QS) mehr als ein Wort auf der Marketingbroschüre ist, muss die Technik auch die notwendigen Mittel besitzen, um diese große Hülle mit Leben füllen zu können. Bei QS sollte dementsprechend der Blick über den Tellerrand reiner Unittests von Klassen geworfen werden. Für den Bereich der Webanwendungen sind dabei Frameworks wie HttpUnit und HtmlUnit bekannt. Dieser Artikel beleuchtet hingegen die eher unbekannten Open Source-Juwelen Selenium und Watij.

Der erste Schritt in die richtige Richtung zur Qualitätssicherung ist die Entwicklung eines Bewusstseins dafür, dass eine gut funktionierende Testautomatik zu einer vorhersehbaren und beherrschbaren Realisierung von Softwareprojekten gehört. Bei der mannigfaltigen Anzahl von Werkzeugen, die am Markt vorhanden sind, sollte man sich vorher im Klaren sein, welche Ansprüche und Erwartungen an eine Testautomatik gestellt werden. Erst dann ist es an der Zeit, eine Toolauswahl zu treffen.

Der Einstieg in den Test von Anwendungen beginnt bereits bei der Entwicklung von Unittests z.B. mit JUnit oder TestNG. Nach der ersten Freude über die grünen Balken und nachdem auch die ersten Tränen über rote Balken getrocknet sind, muss die berechtigte Frage nach dem Weiter gestellt werden. Denn über kurz oder lang kommt man zu der Erkenntnis, dass Unittests vor allem für eine Sache gut sind, nämlich das Testen von isolierter Businesslogik.

Bei Webanwendungen ist ein wichtiger Bestandteil das so genannte „Face to Customer“ (die Benutzeroberfläche). Für stabile Releases ist es notwendig, die Benutzeroberfläche so zu testen, wie diese vom Anwender des Systems verwendet wird. Und da es hierfür einige Varianten gibt, die sicherlich nicht bei jedem Build getestet werden können, ist hier eine gute Testautomation (am besten in den Build-Prozess integriert) notwendig. Zusätzlich muss bei Webanwendungen vor allem darauf geachtet werden, dass unterschiedlichste Browser vom Anwender verwendet werden können. Dieser Aspekt sollte von einem Testframework abgedeckt werden. D.h., die Tests sollten mit unterschiedlichen Browsern getestet werden können.

Das Ziel dieses Artikels ist einerseits, eine Übersicht über die beiden genannten Frameworks zu geben, aber andererseits auch deren zweifellos vorhandene Unterschiede in der Verwendung aufzuzeigen. Um dies nachvollziehbar zu machen, wird eine kleine Webanwendung, die auch im Quellcode heruntergeladen werden kann, als Beispiel herangezogen. Die Testanwendung und der darauf aufbauende Test haben als Schwerpunkt das Testen von HTML-Tabellen. Denn diese kommen sehr häufig in Anwendungen vor und sind somit von besonderem Interesse für das Testen von Webanwendungen.

Testanwendung

Um die Tests mit den beiden Werkzeugen nachvollziehbar darstellen zu können, wird eine einfache HTML-Seite innerhalb einer sonst leeren Webanwendung verwendet. Die Seite enthält eine einfache Tabelle mit 4 Spalten und 5 Zeilen (Siehe Abb. 1).

Die erste Zeile ist dabei der Tabellenkopf. Für den Tabellenkopf wurde auch das speziell dafür vorgesehene Tag th verwendet. Die nachfolgenden drei Tabellenzeilen sind gleich aufgebaut. Die vierte Spalte (Anzahl) enthält jeweils eine rationale Zahl mit dem Punkt als Dezimaltrenner. In der letzten Zeile wird die Summe der Werte aus der vierten Spalte (Anzahl) angegeben.

Abb. 1: Testseite im Firefox
Selenium – der Browser wird zur IDE

Der Ursprung von Selenium liegt in einem Testframework der Firma ThoughtWorks . Für die Automatisierung von Tests verwendet Selenium JavaScript und IFrames innerhalb des betreffenden Browsers.

Abb. 2: Selenium-Oberfläche: 1. Laden der Testsuite; 2. Darstellung der Tests; 3. Steuerung der Tests; 4. Anwendungsbereich

Aufgrund dieser Funktionsweise ist Selenium nicht auf einen Browser und ein Betriebssystem beschränkt, sondern unterstützt viele Browser auf den unterschiedlichsten Plattformen. D.h., mit Selenium ist es möglich, die Applikation auf unterschiedlichen Browsern zu testen. Dies macht den Einsatz von Selenium so verführerisch.

Grundsätzlich werden von Selenium die nachfolgenden Plattformen unterstützt.

Tabelle 1: Selenium-Plattform
Betriebssystem Browser
Linux
  • Firefox 0.8 bis 1.5
  • Konquerer
  • Mozilla Suite 1.6+, 1.7+
Mac OS X
  • Camino 1.0a1
  • Firefox 0.8 bis 1.5
  • Mozilla Suite 1.6+, 1.7+
  • Safari 1.3+
  • Seamonkey 1.0
Windows
  • Firefox 0.8 bis 1.5
  • Internet Explorer 6.0
  • Mozilla Suite 1.6+, 1.7+
  • Opera 8
  • Seamonkey 1.0
Welches Selenium ist für wen geeignet?

Bei der ersten Berührung mit Selenium fällt auf, dass es nicht nur eine Selenium-Plattform gibt, sondern dass mehrere Ausprägungen existieren:

  • Selenium Core
  • Selenium Core HTA (HTML-Application)
  • Selenium IDE
  • Selenium RC (Remote Control)

Die nachfolgende Matrix kann eine Entscheidungshilfe dafür sein, welche Ausprägung von Selenium ausgewählt werden soll.

Tabelle 2: Selenium kompakt
Selenium Core Selenium Core HTA Selenium IDE Selenium RC
Browser-Unterstützung Alle aus Tab. 1 Internet Explorer Firefox Firefox 1.5.0.4,
IE 6.0,
Opera 8.5.4 auf Windows
Installation innerhalb des SUT notwendig X
Unterstützung von HTTPS/SSL X X X
Unterstützung von Multi-Domains X X
Java erforderlich X
Persistierung der Ergebnisse X X X
Programmgesteuerte Definition der Tests Selenese Selenese Selenese Java, .NET, Perl, Python,
Ruby, Selenese

Um die Matrix besser verstehen zu können, werden einzelne Aspekte im Folgenden kurz erläutert.

Tabelle 3: Erläuterung der Selenium-Matrix
Browser-Unterstützung Die bei Selenium RC aufgeführten Browser werden nach der Übersicht von Selenium definitiv unterstützt. Bei anderen, von Selenium grundsätzlich unterstützten Browsern, kann nicht die vollständige Funktionalität garantiert werden.
Installation innerhalb des SUT notwendig Da Selenium auf JavaScript basiert, ist es für Selenium Core aufgrund von Cross-Site Scripting (XSS) notwendig, dass Selenium mit der Anwendung (SUT: System Under Test), d.h. auf dem gleichen Application Server, installiert wird.
Unterstützung von Multi-Domains Multi-Domains bedeutet in diesem Zusammenhang, dass ein Test auf einer Domain startet, aber auch Seiten auf anderen Domains aufruft.
Java erforderlich Für Selenium RC existiert zusätzlich eine Serverkomponente, um Tests auch von einem anderen Rechner zu treiben. Dieser Server ist in Java implementiert, daher erfordert diese Komponente ein installiertes JRE.
Persistierung der Ergebnisse Ergebnisse der Tests können abgespeichert werden.
Programmgesteuerte Definition der Tests Sprache, in der die Tests definiert werden können. Selenese ist dabei die Sprache, die von Selenium mitgeliefert wird. Das Prinzip von Selenese ist, dass der Test als HTML-Tabelle definiert wird.

Der Unterschied zwischen Selenium Core und Selenium Core HTA besteht in der Ausführung der Tests. Bei der Verwendung von HTA fallen die Sicherheitsbeschränkungen (Stichwort: Cross-Site Scripting) weg, wodurch eine Multi-Domain-Unterstützung gegeben ist.

Selenium.install
Bevor eigene Tests mit Selenium durchgeführt werden, soll kurz auf einige wichtige Aspekte innerhalb der Installation der unterschiedlichen Ausprägungen von Selenium eingegangen werden.

Selenium Core (HTA)
Nach dem Download des Archivs (Version 0.8.0 zum Zeitpunkt des Artikel) sollte dies zunächst in ein Verzeichnis entpackt werden. Danach hat die Installation das in Abbildung 3 dargestellte Aussehen.

Prinzipiell gibt es zwei Varianten, um Tests mit Selenium Core auszuführen: Die erste Variante besteht darin, das Verzeichnis core auf dem gleichen Applicationserver wie die zu testende Anwendung zu installieren. Danach können die Tests über /core/TestRunner.html gestartet werden. Die zweite Variante ist es, Selenium als HTA-Applikation zu starten. Für diesen Zweck steht im Verzeichnis core die Datei TestRunner.hta zur Verfügung. Diese Variante funktioniert allerdings nur im Internet Explorer (Tabelle 2).

Selenium IDE
Diese Ausprägung von Selenium ist als Plug-in für Firefox installiert. Für die Installation muss lediglich die xpi-Datei auf Selenium IDE installiert werden. In Abbildung 4 ist die IDE abgebildet. Mithilfe der Capture-Replay-Fähigkeit der IDE ist es möglich, Tests aufzuzeichnen. Zusätzlich können über das Kontextmenü Prüfungen, beispielsweise über das Vorhandensein eines bestimmten Textes, definiert werden.

Selenium RC
Selenium RC besteht aus einem einzelnen Archiv. Nach dem Entpacken des Archivs entsteht für die Version 0.8.1 das nachfolgend abgebildete Verzeichnislayout (siehe Abbildung 5).

Selenium RC besteht aus einer Serverkomponente, die Funktionsweise wird in Abbildung 6 dargestellt.

Die Serverkomponente befindet sich im Verzeichnis server. Der Server kann über das Kommando java -jar selenium-server.jar gestartet werden. Um Tests in Java zu realisieren, muss das Archiv selenium-java-client-driver.jar im Verzeichnis java für Tests eingebunden sein. Die Dokumentation befindet sich im Verzeichnis doc, der Quellcode im Verzeichnis source.

Abb. 3: Verzeichnislayout einer Selenium Core (HTA) 0.8.0-Distribution

Abb. 4: Selenium IDE

Abb. 5: Verzeichnislayout einer Selenium RC 0.8.1-Distribution

Abb. 6: Funktionsweise Selenium RC
Selenium – Die Praxis

Nun ist es an der Zeit, den bereits zu Beginn der Anwendung beschriebenen Testfall in einen Testfall für Selenium zu gießen. Als Implementierungssprache für den Test wurde Java gewählt. In Listing 2 (Quellcode befindet sich im Verzeichnis selenium des Beispielarchivs) ist der Test abgebildet. Ein Kernpunkt bei der Arbeit mit Selenium ist XPath, hierüber können alle Elemente in einem HTML-Dokument angesprochen werden.

Selenese in a nutshell

Neben der Möglichkeit, die Tests für Selenium in unterschiedlichen Programmiersprachen wie Java, .NET, Perl, Python und Ruby zu definieren, hat Selenium einen eigenen Dialekt namens Selenese. Es handelt sich hierbei nicht um eine eigene proprietäre Sprache, sondern einfach um HTML. Aus diesem Grund ist dieser Dialekt eine reizvolle Alternative.

Im Prinzip besteht die Definition eines Selenese-Tests im Schreiben einer HTML-Tabelle. Die Tabelle besteht dabei aus den drei Spalten Kommando, Ziel und Wert.

Eine Übersicht über alle Kommandos kann der Selenium Referenz entnommen werden. Alle Zeilen, die weniger als drei Spalten enthalten, werden von Selenium ignoriert und können als Kommentar verwendet werden. Denn auch Tests bedürfen einer gewissen Grunddokumentation. Listing 1 enthält einen einfachen Test der anhand von Google getestet wurde.

Listing 1
---------------------------------------------------------------------------------------------------------------------------------------
Ein einfacher Test in Selenese
open /search?hl=de&q=selenium&btnG=Google-Suche&meta=
verifyTextPresent Selenium IDE

Der Test selbst wurde hierbei mit der Selenium IDE aufgezeichnet und als HTML exportiert.

Listing 2
---------------------------------------------------------------------------------------------------------------------------------------
package de.javamagazin.selenium;

import java.text.NumberFormat;
import java.text.ParseException;
import java.util.Locale;

import com.thoughtworks.selenium.DefaultSelenium;
import com.thoughtworks.selenium.Selenium;

import junit.framework.TestCase;

/**
 * @author Markus Stäuble
 */
public class TableTest extends TestCase {
     
     /***************************************************************************
      * Private Konstanten
      **************************************************************************/
     
     private final static String SELENIUM_SERVER_HOST = "localhost";
     private final static int SELENIUM_SERVER_PORT = 4444;

     private final static String FIREFOX_LOCATION = "D:/Programme/Mozilla Firefox/firefox.exe";
     private final static String START_URL = "http://localhost:8080";
     
     private Selenium sel;
    
     /**
      * Selenium wird gestartet.
      */
     public void setUp() {
        sel = new DefaultSelenium(TableTest.SELENIUM_SERVER_HOST,
            TableTest.SELENIUM_SERVER_PORT, "*firefox "+FIREFOX_LOCATION, START_URL);
        sel.start();
    }
     
     /**
      * Zugriff auf die Seite
      *
      */
    public void testTableAccess() {
          //Seite oeffnen
          sel.open("http://localhost:8080/webtable/table-id.html");
          //Warten bis Seite geladen ist
          sel.waitForPageToLoad("5000");

          //Ueberpruefung ob die erste Zeile existiert
          assertTrue(sel.isElementPresent("//table[@id='first.table']//tr[1]"));
          assertTrue(sel.isElementPresent("//table[@id='first.table']//tr[1]//th[4]"));
          assertFalse(sel.isElementPresent("//table[@id='first.table']//tr[1]//th[5]"));
          
          
          //Pruefung des Tabellenkopfes
          assertEquals("Id",sel.getTable("first.table.0.0"));
          assertEquals("Name",sel.getTable("first.table.0.1"));
          assertEquals("Vorname",sel.getTable("first.table.0.2"));
          assertEquals("Anzahl",sel.getTable("first.table.0.3"));
          
          //Ueberpruefung der Tabellenzeilen
          assertTrue(sel.isElementPresent("//table[@id='first.table']//tr[5]"));
          assertFalse(sel.isElementPresent("//table[@id='first.table']//tr[6]"));
          
          double sum = 0;
          NumberFormat nf = NumberFormat.getInstance(Locale.ENGLISH);
          for (int i = 1; i 

Wie in Listing 2 zu sehen ist, stehen die einzelnen HTML-Elemente nicht als Objekte zur Verfügung, es kann nur auf deren Inhalt zugriffen werden. D.h., es gibt für eine Tabelle kein spezielles Tabellenobjekt, sondern es kann nur auf den Wert der Zellen zugegriffen werden.

Selenium RC – Testdrive

Von Selenium RC existiert eine Variante, die für einen schnellen Test verwendet werden kann: Der interaktive Modus des Servers wird mit java -jar selenium-server.jar -interactive gestartet. Nun können Kommandos an den Selenium-Server direkt abgesetzt werden.

Das nachfolgende Listing zeigt eine beispielhafte Session im interaktiven Modus des Servers.

Listing 3
---------------------------------------------------------------------------------------------------------------------------------------
cmd=getNewBrowserSession&1=*iexplore&2=http://www.google.de
---> Requesting http://localhost:4444/selenium-server/driver?cmd=getNewBrowserSession&1=*iexplore&2=http://www.google.de
queryString = cmd=getNewBrowserSession&1=*iexplore&2=http://www.google.de
Backing up registry settings...
Modifying registry settings...
Launching Internet Explorer...
01.10.2006 20:12:10 org.mortbay.util.Container start
INFO: Started HttpContext[/,/]
Got result: OK,1159726328667
cmd=open&1=http://www.google.de/webhp&sessionId=1159726328667
---> Requesting http://localhost:4444/selenium-server/driver?cmd=open&1=http://www.google.de/webhp&sessionId=1159726328667
queryString = cmd=open&1=http://www.google.de/webhp&sessionId=1159726328667
Got result: OK
cmd=type&1=q&2=javamagazin&sessionId=1159726328667
---> Requesting http://localhost:4444/selenium-server/driver?cmd=type&1=q&2=javamagazin&sessionId=1159726328667
queryString = cmd=type&1=q&2=javamagazin&sessionId=1159726328667
Got result: OK
cmd=click&1=btnG&sessionId=1159726328667
---> Requesting http://localhost:4444/selenium-server/driver?cmd=click&1=btnG&sessionId=1159726328667
queryString = cmd=click&1=btnG&sessionId=1159726328667
Got result: OK

Nach der ersten Eingabe wird vom Server eine SessionId zurückgeliefert. Diese ist bei weiteren Eingaben mitzuführen. Das macht diesen Modus leider etwas unbequem, aber ansonsten kann hier sehr einfach und schnell ein Kommando gegen den Selenium-Server abgesetzt werden.

Neben der Variante des interaktiven Modus besteht die Möglichkeit, die Selenium IDE für einen Testlauf zu verwenden. Durch die Möglichkeit des Capture Replay können schnell Tests aufgezeichnet werden. Diese Tests können nicht nur als Selenese, sondern auch in jede von Selenium RC unterstützte Programmiersprache exportiert werden.

Wer hilft, wenn Selenium nicht funktioniert?

Da Selenium stark auf JavaScript basiert, kann es vorkommen, dass ein Test einmal nicht funktioniert. In diesem Fall hilft nur der Debugger. Im Internet Explorer ist dies der MS Script Debugger und im Firefox der Debugger Venkman.

Watij – von Ruby gelernt

Der Ursprung von Watij (gesprochen wattage) liegt in dem Ruby-Testframework Watir (gesprochen water). Das grundsätzliche Prinzip liegt darin, dass der Internet Explorer ferngesteuert wird. Somit wird gleich die erste Einschränkung deutlich, nämlich Microsoft Windows und der Internet Explorer.

Watij.install
Um Tests mit Watij auszuführen, muss zunächst eine aktuelle Version (3.1.0 zum Zeitpunkt des Artikels) des Frameworks heruntergeladen werden. Nach dem Download steht ein ZIP-Archiv zur Verfügung. Dieses wird nun in ein Verzeichnis entpackt, z.B. watij-3.1.0. Nach dem Entpacken sollte das Verzeichnis wie in Abbildung 7 dargestellt werden.

Watij.dir
Im Verzeichnis docs ist die Javadoc-basierte API-Dokumentation enthalten. Das Verzeichnis lib enthält alle benötigten Zusatzbibliotheken, die für funktionierende Tests mit Watij benötigt werden. In dem Verzeichnis res sind HTML-Dateien und Bilder zu finden, die für eine Ausführung der mitgelieferten Beispiele verwendet werden. Das Verzeichnis src enthält einerseits die Java-Quellen von Watij (Unterverzeichnis java) und andererseits die Unit-Tests (Unterverzeichnis java-test). Diese Unit-Tests können auch als gute Referenz herangezogen werden. Im Basisverzeichnis von Watij sind noch folgende Dateien enthalten:

  • .bshrc
  • jniwrap.dll
  • launchWatijBeanShell.bat
  • watij.jar

Die Datei .bshrc definiert dabei die Konfiguration für die mitgelieferte BeanShell. Um die BeanShell zu starten, muss einfach die Datei launchWaitjBeanShell.bat gestartet werden. Das Archiv waitj.jar enthält das zugrunde liegende API von Watij.
Da Watij zur Ausführung der Tests mit einem Internet Explorer arbeitet, wird zur Integration die Datei jniwrap.dll mit ausgeliefert. Die Dokumentation von Watij empfiehlt zwar, diese Datei nach WINDOWSSystem32 zu kopieren, davon ist jedoch eher abzuraten, denn dadurch können ungewollte Konflikte (Stichwort DLL Hell) für andere Programme entstehen. Aus diesem Grund ist anzuraten, den java.library.path zu erweitern. Leider reicht es nicht, diese Variable einfach auf das Verzeichnis mit der jniwrap.dll zu setzen, sondern der Pfad muss erweitert werden.

(Siehe Listing 4)

Durch diesen Ansatz ist es möglich, Watij ohne Nachwirkungen auszutesten.

Abb. 7: Verzeichnislayout einer Watij 3.1.0-Distribution
Listing 4
-------------------------------------------------------------------------------------------------------------------------------------
//Pfad zur Watij Installation
static final String WATIJ_INSTALL_DIR = "D:/Development/JavaTools/watij-3.1.0";
//java.library.path um Pfad zu jniwrap.dll erweitern
static {
     System.setProperty("java.library.path", System.getProperty("java.library.path")+";"+WATIJ_INSTALL_DIR);
}
Watij – die Praxis

Nun ist es an der Zeit, den Test, der bereits mit Selenium realisiert wurde, auch mit Watij auszuführen. Dies wurde in Listing 5 gemacht. Der Quellcode ist im Verzeichnis watij des Beispielarchivs enthalten.

Listing 5
--------------------------------------------------------------------------------------------------------------------------------------
package de.javamagazin.watij;

import static watij.finders.SymbolFactory.id;

import java.text.NumberFormat;
import java.util.Locale;

import junit.framework.TestCase;
import watij.elements.HtmlElements;
import watij.elements.Table;
import watij.elements.TableRow;
import watij.elements.TableRows;
import watij.finders.Finder;
import watij.finders.TagFinder;
import watij.runtime.ie.IE;

/**
 * @author Markus Stäuble
 */
public class TableTest extends TestCase {

     //Pfad zur Watij Installation
     static final String WATIJ_INSTALL_DIR = "D:/Development/JavaTools/watij-3.1.0";
     //java.library.path um Pfad zu jniwrap.dll erweitern
     static {
          System.setProperty("java.library.path", System.getProperty("java.library.path")+";"+WATIJ_INSTALL_DIR);
     }
          
     /**
      * Zugriff auf die Seite
      *
      */
     public void testTableAccess() {          
          IE ie = new IE();
          // Aufruf der Seite
          try {
               ie.start("http://localhost:8080/webtable/table-id.html");
          
          // Erste Tabelle ermitteln, Zugriff ueber Id
          Table table = ie.table(id, "first.table");
          assertNotNull(table);
          // Zeilenzahl ueberpruefen
          assertEquals(5, table.rowCount());

          // Zugriff auf Header der Tabelle ueber TagFinder
          TableRow row = null;
          row = table.row(0);
          assertNotNull(row);
          assertEquals(4, row.columnCount());

          HtmlElements elements = row.htmlElements(new Finder[] { new TagFinder(
                    "th") });
          assertNotNull(elements);
          assertEquals(4, elements.length());

          assertEquals("Id", elements.get(0).innerText());
          assertEquals("Name", elements.get(1).innerText());
          assertEquals("Vorname", elements.get(2).innerText());
          assertEquals("Anzahl", elements.get(3).innerText());

          TableRows rows = table.rows();
          double sum = 0;
          NumberFormat nf = NumberFormat.getInstance(Locale.ENGLISH);

          for (int i = 1; i 
Watij – nur probieren

Um schnell einen Test mit Watij zu probieren, existiert eine Kopplung zu BeanShell. Über die Datei launchWatijBeanShell.bat im Hauptverzeichnis der Watij-Distribution wird die vorkonfigurierte BeanShell (siehe nachfolgende Abbildung) gestartet.

Abb. 8: Gestartete BeanShell

Die Zeilen aus Listing 6 starten einen Internet Explorer, rufen Google auf und suchen dort nach dem Schlagwort „javamagazin“.

Listing 6
---------------------------------------------------------------------------------------------------------------------------------------
IE ie = new IE();
ie.start("www.google.de");
ie.textField(name, "q").set("javamagazin");
ie.button("Google-Suche").click();
Wer die Wahl hat, hat die Qual

Nachdem nun die grundsätzliche Funktionalität der beiden Frameworks aufgezeigt wurde, stellt sich die Frage, welches Werkzeug das bessere ist. Ein besser oder schlechter gibt es bei diesen beiden Werkzeugen eigentlich nicht. Will man testen, ob Webanwendungen in mehreren Browsern laufen, ist nur Selenium als Test geeignet. Geht es jedoch darum, die Anwendung in einem Browser mit automatischen Tests zu treiben, kann man schon ins Überlegen kommen. Aus der Sicht eines Programmierers ist Watij wohl die elegantere Variante, falls die Tests in Java definiert werden. Denn Watij bietet für die HTML-Elemente der Seite auch Objekte, z.B. eine Tabelle. Dies gibt es in Selenium nicht. Bei Selenium ist XPath ein Kernelement.

Das heißt, für den schnellen Test zwischendurch auf einem Entwicklerarbeitsplatz ist Watij klar vorzuziehen. Für den Aufbau größerer Automatisierungsstrecken ist dagegen Selenium zu empfehlen, da dieses Werkzeug dafür vorbereitet ist, die Tests auch von einem entfernten Rechner zu steuern (Stichwort: Selenium RC). Wer statt Java lieber Ruby vorzieht, sollte sich Watir anschauen, dieses ist das Ruby-Vorbild für watij.

Alternativen – der Markt bietet noch mehr

Zum Abschluss dieses Artikels soll noch ein wenig der Blick durch das Fernglas geboten werden, um zu zeigen, dass noch einige andere nennenswerte Frameworks für den Bereich des Testens von Webanwendungen existieren. Für Leser, die Ant zugeneigt sind, sei das Framework Canoo Webtest ans Herz gelegt. Ein sehr interessantes neues Projekt im Umfeld von automatischen Webtests könnte Floyd werden. Davon gibt es leider noch keine Releases, es kann bisher nur die Idee auf der Website nachgelesen werden.

Markus Stäuble ist Java-Chefentwickler bei einem großen Medienunternehmen. Schwerpunkt in der täglichen Arbeit ist die Architektur von Java EE-Anwendungen und die Qualitätssicherung in den Java-Projekten. Kontakt: markus.staeuble[at]web.de

Geschrieben von
Markus Stäuble
Kommentare

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.