streamalism.org

1. Oversikt

Arquillian er et test-rammeverk for container-agnostisk integrasjon for Jakarta EE. Bruk av Arquillian minimerer byrden ved administrering av containere, distribusjoner, initialisering av rammeverk og så videre.

Vi kan fokusere på å skrive faktiske tester og ikke på å starte testmiljøet.

2. Kjernekonsepter

2.1. Implementeringsarkiv

Det er en enkel måte å teste applikasjonen vår når du kjører inne i en container.

For det første, ShrinkWrap klasse gir en API for å opprette distribuerbar *.krukke,*.krig, og *.øre filer.

Deretter tillater Arquillian oss å konfigurere distribusjonen av testen ved hjelp av @Utplassering kommentar - på en metode som returnerer en ShrinkWrap gjenstand.

2.2. Beholdere

Arquillian skiller ut tre forskjellige typer containere:

• Fjerntestet med en ekstern protokoll som JMX
• Administrert - eksterne containere, men deres livssyklus administreres av Arquillian
• Innebygd - lokale containere der tester utføres ved hjelp av lokale protokoller

Vi kan også klassifisere containere etter deres evner:

• Jakarta EE-applikasjoner distribuert på en applikasjonsserver som Glassfish eller JBoss
• Servletcontainere utplassert på Tomcat eller Jetty
• Frittstående containere
• OSGI-containere

Den undersøker kjøretiden og velger automatisk den tilgjengelige beholderen.

2.3. Testberikelse

Arquillian beriker tester ved å levere f.eks. avhengighetsinjeksjonen slik at vi enkelt kan skrive testene våre.

Vi kan injisere avhengigheter ved hjelp av @Injiser, injisere ressurser med @Ressurs, EJB øktbønner ved hjelp av @EJB, etc.

2.4. Flere testløpere

Vi kan opprette flere distribusjoner ved hjelp av kommentaren:

@Deployment (name = "myname" order = 1)

Der navnet er navnet på distribusjonsfilen og ordreparameteren er utførelsesrekkefølgen for distribusjonen, slik at vi nå kan kjøre tester på flere distribusjoner samtidig ved å bruke kommentaren:

@Test @OperateOnDeployment ("mitt navn")

Før-testen utføres på mitt navn distribusjonsbeholder ved hjelp av ordren definert i @Utplassering kommentar.

2.5. Arquillian Extensions

Arquillian tilbyr flere utvidelser i tilfelle testbehovene våre ikke dekkes av kjernen. Vi har utholdenhet, transaksjoner, klient / server, REST-utvidelser, etc.

Vi kan aktivere disse utvidelsene ved å legge til passende avhengigheter til Maven- eller Gradle-konfigurasjonsfiler.

Vanlige utvidelser er Drone, Graphene og Selen.

3. Maven-avhengigheter og oppsett

La oss legge til følgende avhengighet til vår pom.xml fil:

 org.jboss.arquillian arquillian-bom 1.1.13.Final import pom org.glassfish.main.extras glassfish-embedded-all 4.1.2 test org.jboss.arquillian.container arquillian-glassfish-embedded-3.1 1.0.0.Final test 

Den siste versjonen av avhengighetene finner du her: arquillian-bom, org.glassfish.main.extras, org.jboss.arquillian.container.

4. Enkel test

4.1. Lag en komponent

La oss starte med en enkel komponent. Vi inkluderer ikke noen avansert logikk her for å kunne fokusere på tester:

public class Component {public void sendMessage (PrintStream to, String msg) {to.println (message (msg)); } offentlig strengmelding (streng msg) {return "Melding," + msg; }}

Ved hjelp av Arquillian vil vi teste at denne klassen oppfører seg riktig når den påkalles som en CDI-bønne.

4.2. Skriv vår første Arquillian-test

Først må vi spesifisere at testklassen vår skal kjøres ved hjelp av den rammespesifikke løperen:

@RunWith (Arquillian.class) 

Hvis vi skal kjøre testene våre i en container, må vi bruke @Utplassering kommentar.

Arquillian bruker ikke hele klassestien til å isolere testarkivet. I stedet bruker den ShrinkWrap klasse, det er et Java API for å lage arkiver. Når vi oppretter arkivet for å teste, spesifiserer vi hvilke filer som skal inkluderes i klassestien for å bruke testen. Under distribusjonen, ShrinkWrap isolerer bare klassene som trengs for testen.

Bruker tilleggsklasse () metoden kan vi spesifisere alle nødvendige klasser, og også legge til en tom manifestressurs.

De JavaArchive.class oppretter et mockup-webarkiv som heter test.war, denne filen distribueres i containeren og brukes deretter av Arquillian til å utføre tester:

@Deployment offentlig statisk JavaArchive createDeployment () {return ShrinkWrap.create (JavaArchive.class) .addClass (Component.class) .addAsManifestResource (EmptyAsset.INSTANCE, "beans.xml"); }

Deretter injiserer vi komponenten vår i testen:

@Injiser privat komponentkomponent;

Til slutt utfører vi testen vår:

assertEquals ("Message, MESSAGE", component.message (("MESSAGE"))); component.sendMessage (System.out, "MESSAGE");

5. Testing av Enterprise Java Beans

5.1. Enterprise Java Bean

Med Arquillian kan vi teste avhengighetsinjeksjon av en Enterprise Java Bean, for å gjøre det lager vi en klasse som har en metode for å konvertere et hvilket som helst ord til små bokstaver:

offentlig klasse ConvertToLowerCase {public String convert (String word) {return word.toLowerCase (); }}

Ved å bruke denne klassen oppretter vi en statsløs klasse for å kalle metoden opprettet før:

@Stateless public class CapsConvertor {public ConvertToLowerCase getLowerCase () {return new ConvertToLowerCase (); }}

De CapsConvertor klasse blir injisert i en servicebønne:

@Stateless public class CapsService {@Inject private CapsConvertor capsConvertor; public String getConvertedCaps (final String word) {return capsConvertor.getLowerCase (). convert (word); }}

5.2. Test Enterprise Java Bean

Nå kan vi bruke Arquillian til å teste vår bedrift Java Bean ved å injisere CapsService:

@Injiser private CapsService capsService; @Test offentlig ugyldig givenWord_WhenUppercase_ThenLowercase () {assertTrue ("kapitaliser" .equals (capsService.getConvertedCaps ("CAPITALIZE"))); assertEquals ("kapitaliser", capsService.getConvertedCaps ("CAPITALIZE")); }

Ved hjelp av ShrinkWrap, vi sørger for at alle klassene er kablet riktig:

@Deployment offentlig statisk JavaArchive createDeployment () {return ShrinkWrap.create (JavaArchive.class) .addClasses (CapsService.class, CapsConvertor.class, ConvertToLowerCase.class) .addAsManifestResource (EmptyAsset.INSTANCE, " }

6. Testing av JPA

6.1. Standhaftighet

Vi kan også bruke Arquillian til å teste utholdenhet. Først skal vi lage vår enhet:

@Entity offentlig klasse bil {@Id @GeneratedValue privat Lang id; @NotNull privat strengnavn; // getters og setters}

Vi har et bord som inneholder navn på biler.

Så skal vi lage vår EJB for å utføre grunnleggende operasjoner på dataene våre:

@Stateless public class CarEJB {@PersistenceContext (unitName = "defaultPersistenceUnit") private EntityManager em; public Car saveCar (Car car) {em.persist (car); returbil; } offentlig liste findAllCars () {Query query = em.createQuery ("SELECT b FROM Car b ORDER BY b.name ASC"); Listeoppføringer = query.getResultList (); returnere oppføringer == null? ny ArrayList (): oppføringer; public void deleteCar (Car car) {car = em.merge (car); em.remove (bil); }}

Med saveCar vi kan lagre bilnavnene i databasen, vi kan lagre alle biler med findAllCars, og vi kan også slette en bil fra databasen med deleteCar.

6.2. Test utholdenhet med Arquillian

Nå kan vi utføre noen grunnleggende tester ved hjelp av Arquillian.

Først legger vi klassene våre til ShrinkWrap:

.addClasses (Car.class, CarEJB.class) .addAsResource ("META-INF / persistence.xml")

Så lager vi testen vår:

@Test offentlige ugyldige testCars () {assertTrue (carEJB.findAllCars (). IsEmpty ()); Bil c1 = ny bil (); c1.setName ("Impala"); Bil c2 = ny bil (); c2.setName ("Lincoln"); carEJB.saveCar (c1); carEJB.saveCar (c2); assertEquals (2, carEJB.findAllCars (). størrelse ()); carEJB.deleteCar (c1); assertEquals (1, carEJB.findAllCars (). størrelse ()); }

I denne testen oppretter vi først fire bilforekomster, og vi sjekker at antall rader i databasen er det samme vi opprettet.

8. Konklusjon

I denne opplæringen:

• introduserte Arquillian kjernekonsepter
• injiserte en komponent i Arquillian-testen
• testet en EJB
• testet utholdenhet
• utførte Arquillian-testen ved hjelp av Maven

Du finner koden fra artikkelen på Github.