Selenium mit Maven

+ andere TechDocs
+ SeleniumHQ
+ HtmlUnit und HttpUnit
+ Maven
+


Mit Selenium können Sie über automatisierte Integrationstests Webanwendungen über einen Webbrowser testen. Dies hat den Vorteil, dass JavaScript und Ajax leichter und realitätsnäher getestet werden. Allerdings gibt es auch einen Nachteil: Da die Installation eines Webbrowsers vorausgesetzt wird, ist die Ausführung auf beliebigen PCs nicht mehr so einfach zu gewährleisten und die Ausführung in Continuous-Integration-Systemen könnte unsicherer sein. Falls Sie nur einfache HTML-Anwendungen ohne DHTML, JavaScript und Ajax testen wollen, sind HtmlUnit und HttpUnit besser geeignet.

Der folgende Text beschreibt weder die Möglichkeiten von Selenium noch von Maven. Stattdessen werden einige mögliche Maven-Konfigurationen für Selenium-Tests gezeigt.



Inhalt

  1. Einfacher Selenium-Test für die Google-Webseite
  2. Selenium-Java-Integrationstest für die Google-Webseite
  3. Selenium-HTML-Integrationstest für die Google-Webseite
  4. Testskriptaufzeichnung mit Selenium IDE
  5. Selenium-Integrationstest für eigene Webanwendung mit dem Jetty-Plug-in
  6. Selenium-Integrationstest für eigene Webanwendung mit dem Cargo-Plug-in
  7. Selenium-Integrationstest mit Cargo für Tomcat- und JBoss-Zipdateien
  8. Links auf weiterführende Informationen


Einfacher Selenium-Test für die Google-Webseite

Dieses Beispiel zeigt eine sehr minimalistische Version eines Selenium-Tests, um das Prinzip zu verdeutlichen. In späteren Beispielen folgen Verbesserungen.

Sie können dieses und die meisten der folgenden Programmierbeispiele wahlweise downloaden oder, wie im Folgenden beschrieben wird, schrittweise ausführen.

  1. Infos zum "Web Application Testing System" Selenium finden Sie unter http://seleniumhq.org.
  2. Falls Sie das "Build Management System" Maven noch nicht kennen: Sehen Sie sich die Einführung unter maven.htm an.
  3. Installieren Sie Maven wie beschrieben unter maven.htm#Installation.
  4. Legen Sie in Ihrem Projekte-Workspace-Verzeichnis (z.B. \MeinWorkspace) das neue Projekt SeleniumGoogleSimple an:

    cd \MeinWorkspace

    md SeleniumGoogleSimple

    cd SeleniumGoogleSimple

    md src\test\java\seleniumtest

  5. Erzeugen Sie im SeleniumGoogleSimple-Projektverzeichnis die Maven-Projektkonfiguration: pom.xml

    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <groupId>de.meinefirma.meinprojekt</groupId>
      <artifactId>SeleniumGoogleSimple</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>jar</packaging>
      <name>SeleniumGoogleSimple</name>
      <build>
        <plugins>
          <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>selenium-maven-plugin</artifactId>
            <version>2.3</version>
            <executions>
              <execution>
                <phase>test-compile</phase>
                <goals>
                  <goal>start-server</goal>
                </goals>
                <configuration>
                  <background>true</background>
                </configuration>
              </execution>
            </executions>
          </plugin>
        </plugins>
      </build>
      <dependencies>
        <dependency>
          <groupId>org.seleniumhq.selenium</groupId>
          <artifactId>selenium-java</artifactId>
          <version>2.24.1</version>
          <scope>test</scope>
        </dependency>
        <dependency>
          <groupId>org.seleniumhq.selenium</groupId>
          <artifactId>selenium-server</artifactId>
          <version>2.24.1</version>
          <scope>test</scope>
        </dependency>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.10</version>
          <scope>test</scope>
        </dependency>
      </dependencies>
    </project>
    

    Sehen Sie sich die Doku zum Selenium-Maven-Plugin und zum start-server-Goal an.

  6. Erzeugen Sie im src\test\java\seleniumtest-Verzeichnis die Testklasse: GoogleSeleniumTest.java

    package seleniumtest;
    
    import com.thoughtworks.selenium.*;
    import junit.framework.TestCase;
    
    public class GoogleSeleniumTest extends TestCase
    {
       private Selenium selenium;
    
       public void setUp()
       {
          // Bitte anpassen, falls nicht Firefox verwendet werden soll:
          selenium = new DefaultSelenium( "localhost", 4444, "*firefox", "http://www.google.de" );
          selenium.start();
          selenium.setSpeed( "500" );
       }
    
       public void tearDown()
       {
          selenium.stop();
       }
    
       public void testGoogle()
       {
          selenium.open( "" );
          selenium.waitForPageToLoad( "33000" );
          selenium.type( "q", "seleniumhq.org" );
          selenium.click( "btnG" );
          selenium.waitForCondition( "selenium.isTextPresent( 'seleniumhq.org' )", "22000" );
          assertTrue( selenium.isTextPresent( "seleniumhq.org" ) );
       }
    }
    

    In setUp() wird Selenium gestartet und in testGoogle() wird die Google-Webseite geöffnet, im Eingabefeld etwas eingetragen, der Such-Button betätigt und kontrolliert, ob ein bestimmter Text in der Ergebnisseite enthalten ist. Das "selenium.setSpeed( "500" )"-Kommando dient nur zur Verlangsamung des Tests, damit der Ablauf besser beobachtet werden kann. Sehen Sie sich die vielfältigen Möglichkeiten an, welche die Selenium-Klasse bietet.

    Falls Sie nicht Mozilla Firefox installiert haben, müssen Sie in der setUp()-Methode beim DefaultSelenium-Konstruktor einen anderen Browser vorgeben (für den Microsoft Internet Explorer z.B. *iexplore oder besser *iexploreproxy, siehe hierzu die Selenium-RC-Doku) (die anschließend folgenden Beispiele zeigen, wie dies per Kommandozeile umschaltbar gemacht werden kann).

  7. Die Projektstruktur sieht jetzt so aus (überprüfen Sie es mit tree /F):

    [\MeinWorkspace\SeleniumGoogleSimple]
     |- [src]
     |   '- [test]
     |       '- [java]
     |           '- [seleniumtest]
     |               '- GoogleSeleniumTest.java
     '- pom.xml
    
  8. Schließen Sie den Webbrowser und führen Sie den Test aus:

    cd \MeinWorkspace\SeleniumGoogleSimple

    mvn test

    Sie können im Webbrowser den Verlauf des Tests verfolgen und erhalten im Kommandozeilenfenster:

    Launching Selenium Server
    ...
    INFO  [org.openqa.jetty.http.HttpServer] Version Jetty/5.1.x
    ...
    Selenium Server started
    ...
    -------------------------------------------------------
     T E S T S
    -------------------------------------------------------
    Running seleniumtest.GoogleSeleniumTest
    ...
    INFO - Command request: getNewBrowserSession[*firefox, http://www.google.de, ] ...
    ...
    INFO - Launching Firefox...
    ...
    INFO - Got result: OK,true ...
    ...
    INFO - Killing Firefox...
    ...
    Results :
    Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
    [INFO] ------------------------------------------------------------------------
    [INFO] BUILD SUCCESS
    [INFO] ------------------------------------------------------------------------
    
  9. Falls Sie eine der beiden folgenden Fehlermeldung erhalten:

    BUILD ERROR Failed to resolve artifact. Missing: org.seleniumhq.selenium:selenium-server:jar:2.24.1
    BUILD ERROR Failed to resolve artifact. Missing: org.seleniumhq.selenium.server:selenium-server:jar:standalone:1.0.2

    Prüfen Sie, ob Ihr Virenscanner den Download von selenium-server-1.0.2-standalone.jar bzw. selenium-server-2.24.1.jar geblockt hat, weil er die darin enthaltene Datei "hudsuckr.exe" für zu gefährlich hält. In diesem Fall müssen Sie die Datei manuell downloaden oder im Virenscanner hierfür eine Ausnahme konfigurieren oder den Virenscanner kurzeitig temporär deaktivieren.

  10. Falls Sie folgende Fehlermeldung erhalten:

    Failed to start new browser session: Firefox could not be found in the path!
    Please add the directory containing ''firefox.exe'' to your PATH environment variable

    Dann erweitern Sie (vorübergehend) die PATH-Umgebungsvariable, zum Beispiel für den 32-bit-Firefox unter 64-bit-Windows:

    set PATH=%PATH%;C:\Program Files (x86)\Mozilla Firefox

    mvn test

  11. Wenn Sie sich in einem Proxy-geschützten Firmennetz befinden, kann der Test fehlschlagen. Sehen Sie sich in diesem Fall die weiter unten beschriebenen Selenium-Tests an, welche von einer eigenen Webanwendung erzeugte Webseiten testet (was ja auch der typischere Fall für Selenium-Tests ist).



Selenium-Java-Integrationstest für die Google-Webseite

Wir wollen für das letzte Beispiel kleine Verbesserungen durchführen:

Führen Sie folgende Schritte durch:

  1. Installieren Sie Maven wie beschrieben unter maven.htm#Installation.
  2. Legen Sie ein neues Projekt an:

    cd \MeinWorkspace

    md SeleniumGoogleJavaIntegrTest

    cd SeleniumGoogleJavaIntegrTest

    md src\test\java\integrationtest

  3. Erzeugen Sie im Projektverzeichnis die die Maven-Projektkonfiguration: pom.xml

    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <groupId>de.meinefirma.meinprojekt</groupId>
      <artifactId>SeleniumGoogleJavaIntegrTest</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>jar</packaging>
      <name>SeleniumGoogleJavaIntegrTest</name>
      <build>
        <plugins>
          <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>selenium-maven-plugin</artifactId>
            <version>2.3</version>
            <executions>
              <execution>
                <phase>pre-integration-test</phase>
                <goals>
                  <goal>start-server</goal>
                </goals>
                <configuration>
                  <background>true</background>
                </configuration>
              </execution>
            </executions>
          </plugin>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>2.12</version>
            <configuration>
              <skip>true</skip>
              <systemPropertyVariables>
                <browser>firefox</browser>
              </systemPropertyVariables>
            </configuration>
            <executions>
              <execution>
                <phase>integration-test</phase>
                <goals>
                  <goal>test</goal>
                </goals>
                <configuration>
                  <skip>false</skip>
                </configuration>
              </execution>
            </executions>
          </plugin>
        </plugins>
      </build>
      <dependencies>
        <dependency>
          <groupId>org.seleniumhq.selenium</groupId>
          <artifactId>selenium-java</artifactId>
          <version>2.24.1</version>
          <scope>test</scope>
        </dependency>
        <dependency>
          <groupId>org.seleniumhq.selenium</groupId>
          <artifactId>selenium-server</artifactId>
          <version>2.24.1</version>
          <scope>test</scope>
        </dependency>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.10</version>
          <scope>test</scope>
        </dependency>
      </dependencies>
    </project>
    

    Sehen Sie sich die Doku zum Surefire-Plugin, zum Selenium-Plugin und zum start-server-Goal an.

  4. Erzeugen Sie im src\test\java\integrationtest-Verzeichnis die Testklasse: GoogleSeleniumTest.java

    package integrationtest;
    
    import org.junit.*;
    import com.thoughtworks.selenium.*;
    
    public class GoogleSeleniumTest
    {
       private static Selenium selenium;
    
       @BeforeClass
       public static void startSelenium()
       {
          String browser = System.getProperty( "browser" );
          selenium = new DefaultSelenium( "localhost", 4444, "*" + browser, "http://www.google.de" );
          selenium.start();
          selenium.setSpeed( "500" );
       }
    
       @AfterClass
       public static void stopSelenium()
       {
          selenium.stop();
       }
    
       @Test
       public void testGoogle()
       {
          selenium.open( "" );
          selenium.waitForPageToLoad( "33000" );
          selenium.type( "q", "seleniumhq.org" );
          selenium.click( "btnG" );
          selenium.waitForCondition( "selenium.isTextPresent( 'seleniumhq.org' )", "22000" );
          Assert.assertTrue( selenium.isTextPresent( "seleniumhq.org" ) );
       }
    }
    

    Der Test startet Selenium in startSelenium(). In testGoogle() wird wieder die Google-Webseite geöffnet, im Eingabefeld etwas eingetragen, der Such-Button betätigt und kontrolliert, ob ein bestimmter Text in der Ergebnisseite enthalten ist.

    Bitte beachten Sie, dass der Webbrowser diesmal nicht fest programmiert ist, sondern als browser-Parameter übergeben wird.

  5. Die Projektstruktur sieht jetzt so aus (überprüfen Sie es mit tree /F):

    [\MeinWorkspace\SeleniumGoogleJavaIntegrTest]
     |- [src]
     |   '- [test]
     |       '- [java]
     |           '- [integrationtest]
     |               '- GoogleSeleniumTest.java
     '- pom.xml
    
  6. Schließen Sie den Webbrowser und starten Sie den Selenium-Integrationstest:

    cd \MeinWorkspace\SeleniumGoogleJavaIntegrTest

    mvn verify

    Falls Sie Mozilla Firefox installiert haben, können Sie wieder den Verlauf des Tests im Webbrowser verfolgen und erhalten wieder im Kommandozeilenfenster:

    Launching Selenium Server
    ...
    INFO - Launching Firefox...
    ...
    Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
    [INFO] BUILD SUCCESS
    

    Dasselbe Ergebnis erhalten Sie, wenn Sie Firefox explizit angeben:

    mvn verify -Dbrowser=firefox

  7. Starten Sie den Test mit fehlerhaftem Browserparameter:

    mvn verify -Dbrowser=?

    Sie erhalten eine Fehlermeldung und unter "Supported browsers" eine Liste der unterstützten Browser.

  8. Falls Sie unter Windows arbeiten: Führen Sie den Integrationstest für den Microsoft Internet Explorer aus:

    mvn verify -Dbrowser=iexploreproxy

    Falls Sie über einen Proxy-Server ins Internet gelangen, sollten Sie sich vor diesem Aufruf die Proxy-Einstellungen merken, weil es vorkommen kann, dass diese Einstellungen bei dem Test verloren gehen und anschließend wiederhergestellt werden müssen. Sie finden die Proxy-Einstellungen unter:
    Start | Systemsteuerung | Netzwerk und Internet | Internetoptionen | Reiter Verbindungen | LAN-Einstellungen.
    Oder alternativ im Microsoft Internet Explorer unter:
    Extras | Internetoptionen | Reiter Verbindungen | LAN-Einstellungen.

    Falls es zu Problemen kommt, testen Sie die verschiedenen "Run Modes" iexplore und iexploreproxy. Eventuell müssen Sie auch Sicherheits- und Pop-up-Blocker-Einstellungen ändern. Sehen Sie sich auch die Selenium-RC-Doku an.

  9. Auch hier gilt wieder: Wenn Sie sich in einem Proxy-geschützten Firmennetz befinden, kann der Test fehlschlagen. Sehen Sie sich in diesem Fall die weiter unten beschriebenen Selenium-Tests an, welche von einer eigenen Webanwendung erzeugte Webseiten testet.



Selenium-HTML-Integrationstest für die Google-Webseite

Bei den bisherigen Beispielen war der Testablauf als Java-Sourcecode formuliert. In diesem Beispiel wird der Testablauf stattdessen in HTML-Tabellen definiert (in etwa vergleichbar mit dem Fit-ActionFixture).

  1. Installieren Sie Maven wie beschrieben unter maven.htm#Installation.
  2. Legen Sie ein neues Projekt an:

    cd \MeinWorkspace

    md SeleniumGoogleHtmlIntegrTest

    cd SeleniumGoogleHtmlIntegrTest

    md src\test\selenium

  3. Erzeugen Sie im Projektverzeichnis die die Maven-Projektkonfiguration: pom.xml

    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <groupId>de.meinefirma.meinprojekt</groupId>
      <artifactId>SeleniumGoogleHtmlIntegrTest</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>jar</packaging>
      <name>SeleniumGoogleHtmlIntegrTest</name>
      <properties>
        <browser>firefox</browser>
      </properties>
      <build>
        <plugins>
          <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>selenium-maven-plugin</artifactId>
            <version>2.3</version>
            <configuration>
              <browser>*${browser}</browser>
              <suite>src/test/selenium/suite.html</suite>
              <startURL>http://www.google.de</startURL>
            </configuration>
            <executions>
              <execution>
                <phase>integration-test</phase>
                <goals>
                  <goal>selenese</goal>
                </goals>
                <configuration>
                  <background>true</background>
                </configuration>
              </execution>
            </executions>
          </plugin>
        </plugins>
      </build>
    </project>
    

    Sehen Sie sich die Doku zum Selenium-Maven-Plugin und zum selenese-Goal an.

  4. Erzeugen Sie im src\test\selenium-Verzeichnis folgende HTML-Dateien:

    suite.html

    <html>
      <head><title>SeleniumGoogleHtmlIntegrTest</title></head>
      <body>
        <table>
          <tr><td><b>SeleniumGoogleHtmlIntegrTest</b></td></tr>
          <tr><td><a href="./GoogleTest1.html">GoogleTest1</a></td></tr>
          <tr><td><a href="./GoogleTest2.html">GoogleTest2</a></td></tr>
        </table>
      </body>
    </html>
    

    GoogleTest1.html

    <html>
      <head><title>GoogleTest1</title></head>
      <body>
        <table cellpadding="2" cellspacing="0" border="1">
          <tr><td rowspan="1" colspan="3">GoogleTest1</td></tr>
          <tr><td>setSpeed         </td><td>1000          </td><td></td></tr>
          <tr><td>open             </td><td>              </td><td></td></tr>
          <tr><td>type             </td><td>q             </td><td>seleniumhq.org</td></tr>
          <tr><td>click            </td><td>btnG          </td><td></td></tr>
          <tr><td>verifyTextPresent</td><td>seleniumhq.org</td><td></td></tr>
        </table>
      </body>
    </html>
    

    GoogleTest2.html

    <html>
      <head><title>GoogleTest2</title></head>
      <body>
        <table cellpadding="2" cellspacing="0" border="1">
          <tr><td rowspan="1" colspan="3">GoogleTest2</td></tr>
          <tr><td>setSpeed         </td><td>1000             </td><td></td></tr>
          <tr><td>open             </td><td>                 </td><td></td></tr>
          <tr><td>type             </td><td>q                </td><td>selenium-maven-plugin selenese</td></tr>
          <tr><td>click            </td><td>btnG             </td><td></td></tr>
          <tr><td>assertTextPresent</td><td>mojo.codehaus.org</td><td></td></tr>
        </table>
      </body>
    </html>
    

    suite.html fasst die Selenium-Tests zu einer Selenium-Suite zusammen.
    Die beiden GoogleTest*.html-Dateien enthalten die Testbeschreibungen: Diesmal nicht als Java-Code, sondern als HTML-Tabelle.
    Die Tests öffnen die Google-Webseite, tragen im Eingabefeld etwas ein, betätigen den Such-Button und kontrollieren, ob ein bestimmter Text in der Ergebnisseite enthalten ist. Das "setSpeed 1000"-Kommando dient nur zur Verlangsamung des Tests, damit der Ablauf besser beobachtet werden kann. Sehen Sie sich die vielfältigen Selenium Commands an.

  5. Die Projektstruktur sieht jetzt so aus (überprüfen Sie es mit tree /F):

    [\MeinWorkspace\SeleniumGoogleHtmlIntegrTest]
     |- [src]
     |   '- [test]
     |       '- [selenium]
     |           |- GoogleTest1.html
     |           |- GoogleTest2.html
     |           '- suite.html
     '- pom.xml
    
  6. Starten Sie den Selenium-Integrationstest:

    cd \MeinWorkspace\SeleniumGoogleHtmlIntegrTest

    mvn verify

    Sie erhalten in target\results-firefox-suite.html:

    Test suite results

    SeleniumGoogleHtmlIntegrTest
    GoogleTest1
    GoogleTest2

    GoogleTest1
    setSpeed 1000  
    open    
    type q seleniumhq.org
    clickAndWait btnG  
    verifyTextPresentseleniumhq.org 

    GoogleTest2
    setSpeed 1000  
    open    
    type q selenium-maven-plugin selenese
    clickAndWait btnG  
    assertTextPresentmojo.codehaus.org 
  7. Im Fehlerfall würden Sie beispielsweise erhalten:

    ...

    GoogleTest2
    setSpeed 1000  
    open    
    type q selenium-maven-plugin selenese
    clickAndWait XXXX Element XXXX not found
    assertTextPresentmojo.codehaus.org 


Testskriptaufzeichnung mit Selenium IDE

In den letzten Beispielen wurden die Testskripte manuell erstellt, entweder als Java-Sourcecode oder als HTML-Tabelle. Meistens ist es einfacher, stattdessen die Testskripte ähnlich wie bei einem Makrorekorder "aufzunehmen". Dies ist sehr komfortabel mit Selenium IDE möglich.

  1. Selenium IDE setzt Mozilla Firefox voraus. Die erstellten Skripte können mit beliebigen Browsern abgespielt werden.

  2. Installieren Sie das Firefox-Plug-in Selenium IDE (z.B. selenium-ide-1.2.0.xpi) von http://seleniumhq.org/download/ in Firefox.

  3. Starten Sie Firefox. Starten Sie Selenium IDE in Firefox über "Extras" | "Selenium IDE". Selenium IDE startet in einem Extrafenster.

  4. Öfnen Sie im ursprünglichen Firefox-Fenster eine beliebige Webseite. Tragen Sie Texte in Eingabefelder ein und klicken Sie auf Buttons und Links. Im Selenium-IDE-Fenster erscheinen alle Kommandos.

  5. Um dem Testskript Überprüfungen hinzuzufügen, klicken Sie auf der Webseite mit der rechten Maustaste auf Elemente oder markieren Textbereiche und klicken darauf mit der rechten Maustaste. Es erscheint ein Kontextmenü. Darin finden Sie im unteren Bereich die zum jeweiligen Element passenden üblichen Kommandos (z.B. assert... und verify...). Ganz unten finden Sie "Show All Available Commands". Wählen Sie ein Kommando aus, damit es dem Testskript im Selenium-IDE-Fenster hinzugefügt wird.

  6. Wenn Sie fertig sind, klicken Sie im Selenium-IDE-Fenster oben rechts auf den roten Button "Click to Stop Recording".

  7. Klicken Sie im Selenium-IDE-Fenster oben auf einen der beiden grünen dreieckigen Abspiel-Buttons "Play test suite/case", um das Skript ablaufen zu lassen. Wenn Sie kurz nach dem Start auf den gelben "Pause"-Button klicken, können Sie das Skript über den blauen Pfeil-Button "Step" auch in Einzelschritten durchlaufen.

  8. Unter dem Tabulatorreiter "Source" können Sie sich das Testskript als HTML-Source ansehen.

  9. Speichern Sie im Selenium-IDE-Fenster das Testskript über "Datei" | "Export Test Case As...". Sie können im HTML-Format, als Java-Sourcecode ("JUnit") und in anderen Formaten speichern.

  10. Die gespeicherten Fragmente können Sie nach kleinen Anpassungen leicht in die obigen Programmierbeispiele einfügen.

Selenium IDE



Selenium-Integrationstest für eigene Webanwendung mit dem Jetty-Plug-in

In den bisherigen Beispielen wurde immer eine Remote-Webanwendung getestet, die nicht vom eigenen Projektmodul erzeugt wurde, und die bereits aktiv ist. Das muss nicht unbedingt eine entfernte Webanwendung (wie z.B. Google) sein, sondern kann auch eine auf dem lokalen PC laufende sein.

In den folgenden Beispielen ist die Webanwendung Teil desselben Maven-Projektmoduls und kann innerhalb des Integrationstests automatisch erzeugt, deployt und getestet werden, inklusive Hoch- und Runterfahren eines geeigneten Testservers.

  1. Öffnen Sie ein Kommandozeilenfenster, wechseln Sie in Ihr Projekte-Workspace-Verzeichnis (z.B. \MeinWorkspace) und erzeugen Sie eine Webapp-Projektstruktur:

    cd \MeinWorkspace

    mvn archetype:generate -DinteractiveMode=false -DarchetypeArtifactId=maven-archetype-webapp -DgroupId=de.meinefirma.meinprojekt -DartifactId=SeleniumJetty

    cd SeleniumJetty

    md src\main\java\de\meinefirma\meinprojekt

    md src\test\java\de\meinefirma\meinprojekt

    md src\test\java\integrationtest

    rd src\main\resources

    tree /F

    Sie erhalten:

    [\MeinWorkspace\SeleniumJetty]
     |- [src]
     |   |- [main]
     |   |   |- [java]
     |   |   |   '- [de]
     |   |   |       '- [meinefirma]
     |   |   |           '- [meinprojekt]
     |   |   '- [webapp]
     |   |       |- [WEB-INF]
     |   |       |   '- web.xml
     |   |       '- index.jsp
     |   '- [test]
     |       '- [java]
     |           |- [de]
     |           |   '- [meinefirma]
     |           |       '- [meinprojekt]
     |           '- [integrationtest]
     '- pom.xml
    
  2. Ersetzen Sie im Projektverzeichnis den Inhalt der pom.xml durch:

    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <groupId>de.meinefirma.meinprojekt</groupId>
      <artifactId>SeleniumJetty</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>war</packaging>
      <name>SeleniumJetty: Webapp mit Selenium-Integrationstest</name>
      <properties>
        <browser>firefox</browser>
        <selenium.port>4455</selenium.port>
        <servlet.port>8080</servlet.port>
        <appsrv.url>http://localhost:${servlet.port}</appsrv.url>
        <contextpath>${project.artifactId}</contextpath>
      </properties>
      <build>
        <finalName>${project.artifactId}</finalName>
        <plugins>
          <plugin>
            <groupId>org.mortbay.jetty</groupId>
            <artifactId>maven-jetty-plugin</artifactId>
            <version>6.1.26</version>
            <configuration>
              <scanIntervalSeconds>10</scanIntervalSeconds>
              <stopPort>9999</stopPort>
              <stopKey>geheim</stopKey>
            </configuration>
            <executions>
              <execution>
                <id>start-jetty</id>
                <phase>pre-integration-test</phase>
                <goals>
                  <goal>run</goal>
                </goals>
                <configuration>
                  <scanIntervalSeconds>0</scanIntervalSeconds>
                  <daemon>true</daemon>
                </configuration>
              </execution>
              <execution>
                <id>stop-jetty</id>
                <phase>post-integration-test</phase>
                <goals>
                  <goal>stop</goal>
                </goals>
              </execution>
            </executions>
          </plugin>
          <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>selenium-maven-plugin</artifactId>
            <version>2.3</version>
            <executions>
              <execution>
                <id>start-selenium</id>
                <phase>pre-integration-test</phase>
                <goals>
                  <goal>start-server</goal>
                </goals>
                <configuration>
                  <background>true</background>
                  <logOutput>true</logOutput>
                  <multiWindow>true</multiWindow>
                </configuration>
              </execution>
              <execution>
                <id>stop-selenium</id>
                <phase>post-integration-test</phase>
                <goals>
                  <goal>stop-server</goal>
                </goals>
              </execution>
            </executions>
            <configuration>
              <port>${selenium.port}</port>
            </configuration>
          </plugin>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>2.12</version>
            <configuration>
              <systemPropertyVariables>
                <browser>${browser}</browser>
                <seleniumPort>${selenium.port}</seleniumPort>
                <appsrvUrl>${appsrv.url}</appsrvUrl>
                <contextPath>${contextpath}</contextPath>
              </systemPropertyVariables>
              <excludes>
                <exclude>**/integrationtest/*Test.java</exclude>
              </excludes>
            </configuration>
            <executions>
              <execution>
                <id>integration-tests</id>
                <phase>integration-test</phase>
                <goals>
                  <goal>test</goal>
                </goals>
                <configuration>
                  <skip>false</skip>
                  <excludes>
                    <exclude>none</exclude>
                  </excludes>
                  <includes>
                    <include>**/integrationtest/*Test.java</include>
                  </includes>
                </configuration>
              </execution>
            </executions>
          </plugin>
        </plugins>
      </build>
      <dependencies>
        <dependency>
          <groupId>org.seleniumhq.selenium</groupId>
          <artifactId>selenium-java</artifactId>
          <version>2.24.1</version>
          <scope>test</scope>
        </dependency>
        <dependency>
          <groupId>org.seleniumhq.selenium</groupId>
          <artifactId>selenium-server</artifactId>
          <version>2.24.1</version>
          <scope>test</scope>
        </dependency>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.10</version>
          <scope>test</scope>
        </dependency>
      </dependencies>
    </project>
    

    Erläuterungen zu den Konfigurationsoptionen des Jetty-Plugins finden Sie unter http://jetty.mortbay.org/jetty/maven-plugin/run-mojo.html (sehen Sie sich insbesondere scanIntervalSeconds und daemon an).

    Erläuterungen zu den Optionen des Surefire-Test-Plugins finden Sie unter http://maven.apache.org/plugins/maven-surefire-plugin/ und maven-surefire-plugin/howto.html.

  3. Ersetzen Sie im src\main\webapp-Verzeichnis den Inhalt der index.jsp durch:

    <html>
    <head><title>Startseite</title></head>
    <body>
    <h2>Startseite</h2>
    <p><a name="BerechnungsFormular" href="BerechnungsFormular.jsp">Berechnungsformular</a></p>
    </body>
    </html>
    
  4. Fügen Sie im src\main\webapp-Verzeichnis folgende BerechnungsFormular.jsp hinzu:

    <%@ page import="de.meinefirma.meinprojekt.MeineBean" %>
    <html>
    <head><title>Webseite mit Berechnungsformular</title></head>
    <body>
    <h2>Webseite mit Berechnungsformular</h2>
    <% String wert1 = request.getParameter( "wert1" );
       String wert2 = request.getParameter( "wert2" );
       if( wert1 == null ) wert1 = "";
       if( wert2 == null ) wert2 = "";
       String ergebnis = (new MeineBean()).berechne( wert1, wert2 ); %>
    <form name="meinFormular" method="post"><pre>
    Wert1 <input type="text" name="wert1" value='<%= wert1 %>' size=10 maxlength=10><br>
    Wert2 <input type="text" name="wert2" value='<%= wert2 %>' size=10 maxlength=10><br>
          <input type="submit" name="berechne" value="berechne"> <input type="text" name="ergebnis" value='<%= ergebnis %>' size=10 readonly><br>
    </pre></form>
    </body>
    </html>
    
  5. Erstellen Sie im src\main\java\de\meinefirma\meinprojekt-Verzeichnis eine JavaBean: MeineBean.java

    package de.meinefirma.meinprojekt;
    
    public class MeineBean
    {
       public String berechne( String d1, String d2 )
       {
          try {
             return "" + (Double.parseDouble( d1 ) + Double.parseDouble( d2 ));
          } catch( Exception ex ) {
             return "";
          }
       }
    }
    
  6. Erstellen Sie im src\test\java\de\meinefirma\meinprojekt-Verzeichnis einen Komponenten-JUnit-Test: MeineBeanTest.java

    package de.meinefirma.meinprojekt;
    
    import org.junit.*;
    
    public class MeineBeanTest
    {
       @Test
       public void testMeineBean()
       {
          MeineBean meineBean = new MeineBean();
          Assert.assertEquals( "3.0", meineBean.berechne( "1", "2" ) );
       }
    }
    
  7. Erstellen Sie im src\test\java\integrationtest-Verzeichnis einen Selenium-Integrationstest: SeleniumIntegrTest.java

    package integrationtest;
    
    import org.junit.*;
    import com.thoughtworks.selenium.*;
    
    public class SeleniumIntegrTest
    {
       private Selenium selenium;
       private String   contextPath;
    
       @Before
       public void startSelenium()
       {
          int seleniumPort = Integer.parseInt( System.getProperty( "seleniumPort" ) );
          String browser   = System.getProperty( "browser" );
          String appsrvUrl = System.getProperty( "appsrvUrl" );
          contextPath      = System.getProperty( "contextPath" );
          selenium         = new DefaultSelenium( "localhost", seleniumPort, "*" + browser, appsrvUrl );
          selenium.start();
          selenium.setSpeed( "500" );
       }
    
       @After
       public void stopSelenium()
       {
          selenium.stop();
       }
    
       @Test
       public void test()
       {
          selenium.open( contextPath );
          selenium.waitForPageToLoad( "33000" );
          Assert.assertTrue( selenium.isTextPresent( "Startseite" ) );
          selenium.click( "link=Berechnungsformular" );
          selenium.waitForPageToLoad( "33000" );
          Assert.assertTrue( selenium.isTextPresent( "Webseite mit Berechnungsformular" ) );
          selenium.type( "wert1", "49.7" );
          selenium.type( "wert2", "-7.7" );
          selenium.click( "berechne" );
          selenium.waitForPageToLoad( "33000" );
          Assert.assertEquals( "42.0", selenium.getValue( "name=ergebnis" ) );
       }
    }
    
  8. Die Projektstruktur sieht jetzt so aus (überprüfen Sie es mit tree /F):

    [\MeinWorkspace\SeleniumJetty]
     |- [src]
     |   |- [main]
     |   |   |- [java]
     |   |   |   '- [de]
     |   |   |       '- [meinefirma]
     |   |   |           '- [meinprojekt]
     |   |   |               '- MeineBean.java
     |   |   '- [webapp]
     |   |       |- [WEB-INF]
     |   |       |   '- web.xml
     |   |       |- BerechnungsFormular.jsp
     |   |       '- index.jsp
     |   '- [test]
     |       '- [java]
     |           |- [de]
     |           |   '- [meinefirma]
     |           |       '- [meinprojekt]
     |           |           '- MeineBeanTest.java
     |           '- [integrationtest]
     |               '- SeleniumIntegrTest.java
     '- pom.xml
    
  9. Manueller Test im Webbrowser:

    cd \MeinWorkspace\SeleniumJetty

    mvn jetty:run

    Warten Sie bis "Started Jetty Server" erscheint und rufen Sie dann im Webbrowser auf:

    http://localhost:8080/SeleniumJetty

    Klicken Sie auf den Berechnungsformular-Link, tragen Sie auf der folgenden Webseite zwei Zahlen ein und betätigen Sie "berechne": Sie erhalten die Summe.

    Beenden Sie Jetty mit "Strg + C".

  10. Manueller Aufruf des JUnit-Komponententests:

    cd \MeinWorkspace\SeleniumJetty

    mvn test -Dtest=de.meinefirma.meinprojekt.MeineBeanTest

  11. Manueller Aufruf des Selenium-Integrationstests:

    Starten Sie Jetty mit der Webanwendung, den Selenium-Server und den Integrationstest (es werden zwei zusätzliche Kommandozeilenfenster geöffnet):

    cd \MeinWorkspace\SeleniumJetty

    start cmd /C mvn jetty:run

    start cmd /C mvn selenium:start-server

    mvn test -Dtest=integrationtest.SeleniumIntegrTest

    Beenden Sie den Jetty-Server und den Selenium-Server jeweils mit "Strg + C".

  12. Automatisierter Integrationstest:

    Der wichtigste Trick in diesem Beispiel ist die vollständig automatisierte Ausführung der Integrationstests inklusive automatischem Start des Jetty-Servers in einem zusätzlichen Hintergrund-Thread (über <daemon>true</daemon>), Ausführung der Integrationstests und anschließend der automatischen Beendigung von Jetty mit folgendem Kommando:

    mvn clean verify

    Oder, falls Sie mit einem anderen Webbrowser als Mozilla Firefox testen wollen, zum Beispiel mit Microsoft Internet Explorer:

    mvn clean verify -Dbrowser=iexploreproxy

    Sie erhalten zwei Testphasen, zuerst default-test und dann integration-tests:

    ...
    [INFO] --- maven-surefire-plugin:2.12:test (default-test) @ SeleniumJetty ---
    ...
    -------------------------------------------------------
     T E S T S
    -------------------------------------------------------
    ...
    Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
    ...
    ...
    [INFO] Starting jetty 6.1.26 ...
    ...
    [INFO] Started Jetty Server
    ...
    Launching Selenium Server
    ...
    Selenium Server started
    ...
    [INFO] --- maven-surefire-plugin:2.12:test (integration-tests) @ SeleniumJetty ---
    ...
    -------------------------------------------------------
     T E S T S
    -------------------------------------------------------
    ...
    Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
    ...
    [INFO] ------------------------------------------------------------------------
    [INFO] BUILD SUCCESS
    [INFO] ------------------------------------------------------------------------
    


Selenium-Integrationstest für eigene Webanwendung mit dem Cargo-Plug-in

Das folgende Beispiel verwendet statt des nur für Jetty geeigneten Jetty-Maven-Plugins das universellere Cargo-Maven-Plugin. Doku hierzu finden Sie unter http://cargo.codehaus.org/Maven2+plugin und http://cargo.codehaus.org/Maven2+Plugin+Reference+Guide.

Dieses Beispiel verwendet wieder Jetty. Das sich anschließende Beispiel ist für andere Application Server geeignet.

  1. Dieses Beispiel setzt die Durchführung des letzten Beispiels ("SeleniumJetty") voraus.

  2. Erzeugen Sie eine Kopie des letzten Beispiels ("SeleniumJetty"):

    cd \MeinWorkspace

    xcopy SeleniumJetty SeleniumCargo\ /S

    cd SeleniumCargo

  3. Ersetzen Sie im neuen SeleniumCargo-Verzeichnis in der pom.xml an zwei Stellen SeleniumJetty durch SeleniumCargo.

  4. Entfernen Sie im neuen SeleniumCargo-Verzeichnis in der pom.xml den
    "<plugin>...maven-jetty-plugin...</plugin>"-Block.
    Ersetzen Sie ihn durch:

          <plugin>
            <groupId>org.codehaus.cargo</groupId>
            <artifactId>cargo-maven2-plugin</artifactId>
            <version>1.2.2</version>
            <configuration>
              <wait>false</wait>
              <container>
                <containerId>jetty6x</containerId>
                <type>embedded</type>
              </container>
            </configuration>
            <executions>
              <execution>
                <id>start-container</id>
                <phase>pre-integration-test</phase>
                <goals>
                  <goal>start</goal>
                  <goal>deploy</goal>
                </goals>
              </execution>
              <execution>
                <id>stop-container</id>
                <phase>post-integration-test</phase>
                <goals>
                  <goal>stop</goal>
                </goals>
              </execution>
            </executions>
          </plugin>
    
  5. Führen Sie den Selenium-Integrationstest aus:

    cd \MeinWorkspace\SeleniumCargo

    mvn clean verify

    Oder mit Internet Explorer statt Firefox:

    mvn clean verify -Dbrowser=iexploreproxy

    Sie erhalten wieder zwei Testphasen, zuerst default-test und dann integration-tests:

    ...
    [INFO] --- maven-surefire-plugin:2.12:test (default-test) @ SeleniumCargo ---
    ...
    -------------------------------------------------------
     T E S T S
    -------------------------------------------------------
    ...
    Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
    ...
    ...
    [INFO] [beddedLocalContainer] Jetty 6.x Embedded starting...
    ...
    [INFO] [beddedLocalContainer] Jetty 6.x Embedded started on port [8080]
    ...
    Launching Selenium Server
    ...
    Selenium Server started
    ...
    [INFO] --- maven-surefire-plugin:2.12:test (integration-tests) @ SeleniumCargo ---
    ...
    -------------------------------------------------------
     T E S T S
    -------------------------------------------------------
    ...
    Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
    ...
    [INFO] ------------------------------------------------------------------------
    [INFO] BUILD SUCCESS
    [INFO] ------------------------------------------------------------------------
    
  6. Sehen Sie sich auch das Cargo-Beispiel unter Automatisierter Integrationstest mit Cargo für WebLogic, JBoss und Tomcat an.



Selenium-Integrationstest mit Cargo für Tomcat- und JBoss-Zipdateien

Dieses Beispiel bietet folgende Erweiterungen:

Führen Sie folgende Schritte durch:

  1. Dieses Beispiel setzt die Durchführung des vorletzten Beispiels ("SeleniumJetty") voraus.

  2. Erzeugen Sie eine Kopie des vorletzten Beispiels ("SeleniumJetty"):

    cd \MeinWorkspace

    xcopy SeleniumJetty SeleniumCargoZipped\ /S

    cd SeleniumCargoZipped

  3. Ersetzen Sie im neuen SeleniumCargoZipped-Verzeichnis in der pom.xml an zwei Stellen SeleniumJetty durch SeleniumCargoZipped.

  4. Achten Sie darauf, dass in der pom.xml in der Zeile "<selenium.port>4455</selenium.port>" als Selenium-Port nicht 4444 eingesetzt ist, sondern zum Beispiel 4455 (4444 benötigt JBoss).

  5. Entfernen Sie im neuen SeleniumCargoZipped-Verzeichnis in der pom.xml den
    "<plugin>...maven-jetty-plugin...</plugin>"-Block.
    Ersetzen Sie ihn durch:

          <plugin>
            <groupId>org.codehaus.cargo</groupId>
            <artifactId>cargo-maven2-plugin</artifactId>
            <version>1.2.2</version>
            <configuration>
              <wait>false</wait>
              <container>
                <containerId>${cargo.containerId}</containerId>
                <zipUrlInstaller>
                  <url>${zipUrlInstaller.url}</url>
                  <downloadDir>${project.build.directory}/appsrvInstallDir</downloadDir>
                  <extractDir>${project.build.directory}/appsrvInstallDir</extractDir>
                </zipUrlInstaller>
                <output>${project.build.directory}/${cargo.containerId}.log</output>
                <log>${project.build.directory}/cargo.log</log>
              </container>
              <configuration>
                <home>${project.build.directory}/${cargo.containerId}/container</home>
                <properties>
                  <cargo.logging>high</cargo.logging>
                  <cargo.servlet.port>${servlet.port}</cargo.servlet.port>
                </properties>
              </configuration>
            </configuration>
            <executions>
              <execution>
                <id>start-container</id>
                <phase>pre-integration-test</phase>
                <goals>
                  <goal>start</goal>
                  <goal>deploy</goal>
                </goals>
              </execution>
              <execution>
                <id>stop-container</id>
                <phase>post-integration-test</phase>
                <goals>
                  <goal>stop</goal>
                </goals>
              </execution>
            </executions>
          </plugin>
    
  6. Fügen Sie in der pom.xml am Ende vor </project> hinzu:

      <profiles>
        <profile>
          <id>tomcat7x</id>
          <activation>
            <activeByDefault>true</activeByDefault>
          </activation>
          <properties>
            <cargo.containerId>tomcat7x</cargo.containerId>
            <zipUrlInstaller.url>http://www.apache.org/dist/tomcat/tomcat-7/v7.0.21/bin/apache-tomcat-7.0.21.zip</zipUrlInstaller.url>
          </properties>
        </profile>
        <profile>
          <id>jboss7x</id>
          <properties>
            <cargo.containerId>jboss7x</cargo.containerId>
            <zipUrlInstaller.url>http://download.jboss.org/jbossas/7.0/jboss-as-7.0.0.Final/jboss-as-7.0.0.Final.zip</zipUrlInstaller.url>
          </properties>
        </profile>
      </profiles>
    
  7. Führen Sie den Selenium-Integrationstest für Tomcat aus (bitte beachten: der erste Aufruf kann wegen des Downloads etwas dauern):

    cd \MeinWorkspace\SeleniumCargoZipped

    mvn verify

    Oder mit Internet Explorer statt Firefox:

    mvn verify -Dbrowser=iexploreproxy

    Sie erhalten wieder die beiden Testphasen default-test und integration-tests sowie als Ergebnis BUILD SUCCESS.

  8. Führen Sie den Selenium-Integrationstest für JBoss aus (bitte beachten: der erste Aufruf kann wegen des großen Downloads etwas länger dauern):

    cd \MeinWorkspace\SeleniumCargoZipped

    mvn verify -Pjboss7x

    Oder mit Internet Explorer statt Firefox:

    mvn verify -Pjboss7x -Dbrowser=iexploreproxy

    Sie erhalten wieder die beiden Testphasen default-test und integration-tests sowie als Ergebnis BUILD SUCCESS.

  9. In der pom.xml können Sie in den beiden <profile>-Sektionen bei <zipUrlInstaller.url> statt der beiden Internet-URLs

            <zipUrlInstaller.url>http://...</zipUrlInstaller.url>
    

    auch Pfade in Ihrem Dateisystem angeben, für Tomcat zum Beispiel so:

            <zipUrlInstaller.url>file:///C:\_Pfad-zur-Tomcat-Zipdatei_\apache-tomcat-6.0.32.zip</zipUrlInstaller.url>
    

    So können Sie am einfachsten vermeiden, dass nach einem mvn clean ein erneuter Download übers Internet erforderlich wird. Alternativ könnten Sie auch in der cargo-<plugin>-Sektion bei

                <zipUrlInstaller>
                  ...
                  <downloadDir>${project.build.directory}/appsrvInstallDir</downloadDir>
                  <extractDir>${project.build.directory}/appsrvInstallDir</extractDir>
                </zipUrlInstaller>
    

    ein Verzeichnis außerhalb des target-Verzeichnisses angeben (z.B.: ${basedir}/target-appsrvInstallDir).

  10. Falls Sie die Fehlermeldung "Failed to download ... Caused by: java.net.ConnectException: Connection timed out: connect" erhalten (z.B. weil Sie sich in einem Proxy-geschützten Firmennetz befinden), dann sollten Sie die Zipdateien separat downloaden, im Dateisystem speichern und bei <zipUrlInstaller.url> statt der Internet-URLs Dateipfade eintragen (<zipUrlInstaller.url>file://...</zipUrlInstaller.url>).

  11. Wie Sie nicht nur einige Properties mit Profilen umschalten können (wie in diesem Beispiel), sondern viele weitere Cargo-Plugin-Eigenschaften, zeigt das Beispiel unter http://cargo.codehaus.org/Maven2+Plugin+Tips#Maven2PluginTips-tip1.

  12. Sehen Sie sich auch das Cargo-Beispiel unter Automatisierter Integrationstest mit Cargo für WebLogic, JBoss und Tomcat an.



Links auf weiterführende Informationen





Weitere Themen: andere TechDocs | maven.apache.org
© 2011 Torsten Horn, Aachen