Schneller Starten mit Forge

Authors: Paul Bakker, Lincoln Baxter, III Translators: Markus Eisele, Bennet Schulz Language:
Last Update:Jan 13, 2016

Dieser Guide macht Dich vertraut mit dem Arquillian Plugin für JBoss Forge. Nach dem Lesen bist Du in der Lage:

  • Das Arquillian Plugin Deiner Forge Installation hinzuzufügen.
  • Das Plugin zu verwenden, um die Arquiliian Infrastrukur zu einem Maven-basierten Java Projekt hinzuzufügen.
  • Eine Komponente und die zugehörigen Arquillian Tests zu generieren.
  • Die Arquillian Tests auf verschiedenen Containern ohne manuelle Konfiguration auszuführen.

Du wirst viele gleiche Schritte ausführen, welche bereits in dem Getting Started guide beschrieben sind. Einziger Unterschied: Du läßt Forge die dreckige Arbeit machen. Dieser Guide ist so geschrieben, dass Du ihn schnell lesen und noch schneller und produktiver mit Arquillian starten kannst.

Annahmen

Dieser Guide setzt voraus, dass Du JBoss Forge installiert hast. Forge zu installieren ist ein relativ einfacher Vorgang. Vergleiche auch die “Getting Started Guides” oder die offizielle Forge Dokumentation . Dort findest Du auch die Downloads und Installationsanweisungen. Darüber hinaus benötigst Du ein Java Development Kit (JDK) 1.6 oder neuer auf Deinem Rechner.

Erstelle ein neues Projekt

Bevor es mit Arquillian losgeht, brauchen wir ein neues Projekt. Wenn Du bisher noch keins erstellt hast, verwende die nachfolgenden Forge Kommandos und erstelle ein einfaches Java EE 6 Projekt mit Java Persistence API (JPA) Unterstützung.

$ new-project --named arquillian-demo --topLevelPackage demo
? Use [/Users/paul/arquillian-demo] as project directory? [Y/n]
***SUCCESS*** Created project [arquillian-demo] in new working directory [/Users/paul/arquillian-demo]
Wrote /Users/paul/arquillian-demo
Wrote /Users/paul/arquillian-demo/pom.xml
Wrote /Users/paul/arquillian-demo/src/main/java
Wrote /Users/paul/arquillian-demo/src/test/java
Wrote /Users/paul/arquillian-demo/src/main/resources
Wrote /Users/paul/arquillian-demo/src/test/resources
Wrote /Users/paul/arquillian-demo/src/main/resources/META-INF/forge.xml

Damit ist das neue Projekt erstellt. Als nächstes brauchen wir ein wenig Code zum testen. Wir verwenden Forge um ein neues CDI Bean zu erstellen.

Dafür muss zuerst CDI im Projekt bereitgestellt werden. Das erfolgt mit dem “beans” Plugin.

$ beans setup
***SUCCESS*** Installed [forge.spec.cdi] successfully.
 ? Do you want to install CDI APIs? [y/N]

Wrote /Users/paul/arquillian-demo/src/main/resources/META-INF/beans.xml

Jetzt wird ein Bean erstellt:

$ beans new-bean --type demo.MySimpleBean --scoped DEPENDENT
Picked up type <JavaResource>: demo.MySimpleBean
Wrote /Users/paul/arquillian-demo/src/main/java/demo/MySimpleBean.java

Damit ist das Projekt Setup fertig. Jetzt ist es Zeit für das Testen!

Erste Schritte

Arquillian zu installieren ist einfach, wie Du bereits im general getting started guide gesehen hast. Einfach nur eine Menge Copy&Paste Arbeit um neue Container in der pom.xml hinzuzufügen. Forge erledigt das viel schneller einfacher, und das nur mit einem einzelnen Kommando!

Dazu wird erst das Arquillian Plugin installiert:

$ forge install-plugin arquillian

Als nächstes erfolgt die Konfiguration von Arquillian und einem Java EE Container. Starten wir mit JBoss AS7.

$ arquillian setup --container JBOSS_AS_7_MANAGED

Forge fragt Dich welche Versionen von JUnit, Arquillian und JBoss AS 7 Du verwenden möchtest. Verwende die letzten finalen Versionen von allen dreien. Forge kann Dir sogar den JBoss AS 7 herunterladen, wenn Du ihn noch nicht haben solltest.

Das war es auch schon. Arquillian ist fertig konfiguriert. Wenn Du magst, kannst Du in die pom.xml schauen und die Abhängigkeiten und das Maven Profil anschauen, welches angelegt wurde. Forge hat auch die arquillian.xml im Verzeichnis src/test/resources angelegt.

Einen Test Schreiben

Jetzt schreiben wir einen Test. Auch hierbei kann Forge Dir beim Start helfen.

$ arquillian create-test --class demo.MySimpleBean.java
Picked up type <JavaResource>: demo.MySimpleBeanTest
Wrote /Users/paul/arquillian-demo/src/test/java/demo/MySimpleBeanTest.java

Ein neue Testklasse mit einem Deployment Artefakt und einer test Methode wurden dem Projekt hinzugefügt. Die zu testende Klasse wird per CDI injeziert und beweist damit automatisch, dass der Test wirklich im Container läuft. Wenn Deine IDE keine Imports findet, vergewissere Dich, dass das notwendige Maven Profil (welches weiter oben angelegt wurde) auch verwendet wird. Der Test kann aus der IDE, direkt über Maven oder auch über Forge ausgeführt werden.

$ build --profile arq-jbossas-7-managed

Glückwunsch! Deine erste green bar mit Arquillian und Forge!

Jetzt testen wir ein wenig JPA Code.

Persistenz Testen

Bevor wir Tests schreiben können, welche die Java Persistence API (JPA) verwenden, muss diese zuerst via Forge konfiguriert werden. Dann erstellen wir ein Entity und ein einfaches Data Access Object (DAO). Beide Klassen werden dann auch getestet.

$ persistence setup --provider HIBERNATE --container JBOSS_AS7
***SUCCESS*** Installed [forge.spec.jpa] successfully.
***INFO*** Setting transaction-type="JTA"
***INFO*** Using example data source [java:jboss/datasources/ExampleDS]
Warning:  The encoding 'UTF-8' is not supported by the Java runtime.
 ? The JPA provider [HIBERNATE], also supplies extended APIs. Install these as well? [y/N]  [false] 
Wrote /Users/paul/arquillian-demo/pom.xml
Wrote /Users/paul/arquillian-demo/src/main/resources/META-INF/persistence.xml

Jetzt erstellen wir das Entity:

$ entity --named Language --package demo.entities
Created @Entity [demo.entities.Language]
Picked up type <JavaResource>: demo.entities.Language
Wrote /Users/paul/arquillian-demo/src/main/java/demo/entities/Language.java

Das Entity erhält jetzt ein paar Felder.

$ field string --named name
Added field to demo.entities.Language: @Column private String name;
Wrote /Users/paul/arquillian-demo/src/main/java/demo/entities/Language.java

Die erzeugte Datei muss dann noch in das Projekt kopiert werden.

src/main/java/demo/dao/LanguageDao.java
package demo.dao;

import demo.entities.Language;
import javax.annotation.PostConstruct;
import javax.ejb.Singleton;
import javax.ejb.Startup;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import java.util.List;

@Singleton
@Startup
public class LanguageDao {
    @PersistenceContext
    EntityManager em;

    public List<Language> listLanguages() {
        return em.createQuery("select l from Language l").getResultList();
    }

    @PostConstruct
    public void insertTestData() {
        Language java = new Language();
        java.setName("Java");
        em.persist(java);

        Language ruby = new Language();
        ruby.setName("Ruby");
        em.persist(ruby);

        Language groovy = new Language();
        groovy.setName("Groovy");
        em.persist(groovy);
    }
}

Jetzt ist es Zeit, die Testklasse zu erzeugen. Wenn Du den ersten Teil dieses Guides erfolgreich durchgearbeitet hast, dann kommt das folgende Kommando bekannt vor:

$ arquillian create-test --class demo.dao.LanguageDao.java --enableJPA
Picked up type <JavaResource>: demo.dao.LanguageDemoTest
Wrote /Users/paul/arquillian-demo/src/test/java/demo/dao/LanguageDemoTest.java

Auch dieses erstellt einen neuen Test, fügt dem Deployment Artefakt aber auch eine persistence.xml hinzu. Öffne jetzt den Test in Deiner IDE und füge das neue Language entity zum Artefakt hinzu.

Jetzt fehlt nur noch eine Test Assertion:

src/test/java/demo/dao/LanguageDaoTest.java
@Test
public void testListLanguages() {
	Assert.assertEquals(3, languagedao.listLanguages().size());
}

Glückwunsch! Eine weitere green bar mit Arquillian!

Füge weitere Container hinzu

Weitere Container hinzuzufügen ist genauso einfach. Das Setup-Kommando wird einfach erneut ausgeführt. Beispielsweise für den GlassFish:

$ arquillian setup --container GLASSFISH_3_1_REMOTE

Ein Wechsel zwischen den Containern ist durch die Wahl eines anderen Maven Profils möglich. Hier am Beispiel mit Forge:

$ build test --profile glassfish-remote-3

Exportiere das Deployment Paket

Für Debugging und Fehlersuche kann es nützlich sein, dass Deployment als Datei zu exportieren. Auch das geht mit Forge:

Navigiere zu einem Arquillian Test:

$ cd src/test/java/demo/MySimpleBeanTest.java

Anschließen wird das Deployment folgendermaßen exportiert:

$ arquillian export

Das exportierte Archiv liegt dann im target Verzeichnis des Maven Projektes.

Share the Knowledge

Find this guide useful?

There’s a lot more about Arquillian to cover. If you’re ready to learn more, check out the other available guides.

Feedback

Find a bug in the guide? Something missing? You can fix it by forking this website, making the correction and sending a pull request. If you’re just plain stuck, feel free to ask a question in the user discussion forum.

Recent Changelog

  • Jan 13, 2016: Fix typos in the german getting started guide by Bennet Schulz
  • Apr 19, 2012: Remove redundant metadata (internal change) by Dan Allen
  • Apr 11, 2012: Initial german translation by Markus Eisele

See full history »