streamalism.org

1. Oversikt

Som standard, JUnit kjører tester i en deterministisk, men uforutsigbar rekkefølge (MethodSorters.DEFAULT).

I de fleste tilfeller er atferden helt grei og akseptabel; men det er tilfeller når vi trenger å håndheve en bestemt bestilling.

2. Testordre i JUnit 5

I JUnit 5, Vi kan bruke @TestMethodOrder å kontrollere utførelsesrekkefølgen for tester.

Vi kan bruke våre egne Metode Bestilling, som vi vil se senere, eller vi kan velge en av tre innebygde bestillere:

1. @Rekkefølge Kommentar
2. Alfanumerisk Rekkefølge
3. Tilfeldig rekkefølge

2.1. Bruker @Rekkefølge Kommentar

Vi kan bruke @Rekkefølge kommentar for å håndheve tester for å kjøre i en bestemt rekkefølge.

I det følgende eksemplet vil metodene kjøre i denne rekkefølgen - førstetest (), deretter andre test (), og endelig, tredje test ():

@TestMethodOrder (OrderAnnotation.class) offentlig klasse OrderAnnotationUnitTest {privat statisk StringBuilder-utgang = ny StringBuilder (""); @Test @Order (1) public void firstTest () {output.append ("a"); } @ Test @ Order (2) offentlig ugyldig secondTest () {output.append ("b"); } @ Test @ Order (3) offentlig ugyldig thirdTest () {output.append ("c"); } @AfterAll offentlig statisk ugyldighet assertOutput () {assertEquals (output.toString (), "abc"); }}

2.2. Ved hjelp av Alfanumerisk Rekkefølge

Vi kan også kjøre tester basert på navnene i alfanumerisk rekkefølge:

@TestMethodOrder (Alphanumeric.class) offentlig klasse AlphanumericOrderUnitTest {privat statisk StringBuilder-utgang = ny StringBuilder (""); @Test offentlig annullere myATest () {output.append ("A"); } @Test offentlig ugyldig myBTest () {output.append ("B"); } @Test offentlig ugyldig myaTest () {output.append ("a"); } @AfterAll offentlig statisk ugyldighet assertOutput () {assertEquals (output.toString (), "ABa"); }}

Merk at alfanumerisk rekkefølge er mellom store og små bokstaver, så store bokstaver kommer først og små bokstaver.

Testene kjøres i denne rekkefølgen: myATest (), myBTest () og endelig myaTest ().

2.3. Bruke en tilpasset ordre

Endelig, vi kan bruke vår egen tilpassede ordre ved å implementere Metode Bestilling grensesnitt.

I vår CustomOrder, vil vi bestille testene basert på navnene deres i en bokstavsfølsom alfanumerisk rekkefølge:

offentlig klasse CustomOrder implementerer MethodOrderer {@Override public void orderMethods (MethodOrdererContext context) {context.getMethodDescriptors (). sort ((MethodDescriptor m1, MethodDescriptor m2) -> m1.getMethod (). getName (). CompareToIgnoreCase (m2.get) .getName ())); }}

Så bruker vi CustomOrder å kjøre de samme testene fra vårt forrige eksempel i denne rekkefølgen - myATest (), myaTest (), og endelig, myBTest ():

@TestMethodOrder (CustomOrder.class) public class CustomOrderUnitTest {// ... @AfterAll public static void assertOutput () {assertEquals (output.toString (), "AaB"); }}

3. Testordre i JUnit 4

Hvis du fortsatt bruker JUnit 4, er API-ene for bestillingstester litt forskjellige.

La oss gå gjennom alternativene for å oppnå dette også i tidligere versjoner.

3.1. Ved hjelp av MethodSorters.DEFAULT

Denne standardstrategien sammenligner testmetoder ved hjelp av deres hashkoder. I tilfelle hasjkollisjon brukes leksikografisk rekkefølge:

@FixMethodOrder (MethodSorters.DEFAULT) offentlig klasse DefaultOrderOfExecutionTest {privat statisk StringBuilder-utgang = ny StringBuilder (""); @Test offentlig ugyldig secondTest () {output.append ("b"); } @Test offentlig ugyldig thirdTest () {output.append ("c"); } @Test offentlig ugyldig firstTest () {output.append ("a"); } @AfterClass public static void assertOutput () {assertEquals (output.toString (), "cab"); }}

Når vi utfører testene i klassen ovenfor, vil vi se at de alle består, inkludert assertOutput ().

3.2. Ved hjelp av MethodSorters.JVM

En annen bestillingsstrategi er MethodSorters.JVM – denne strategien bruker den naturlige JVM-bestillingen - som kan være forskjellig for hver løp:

@FixMethodOrder (MethodSorters.JVM) offentlig klasse JVMOrderOfExecutionTest {// samme som ovenfor}

Hver gang vi utfører testene i denne klassen, får vi et annet resultat.

3.3. Ved hjelp av MethodSorters.NAME_ASCENDING

Til slutt kan denne strategien brukes til å kjøre test i deres leksikografiske rekkefølge:

@FixMethodOrder (MethodSorters.NAME_ASCENDING) offentlig klasse NameAscendingOrderOfExecutionTest {// samme som ovenfor @AfterClass offentlig statisk ugyldig assertOutput () {assertEquals (output.toString (), "abc"); }}

På samme måte, når vi utfører testene i denne klassen, ser vi at de alle består, inkludert assertOutput (), som bekrefter utførelsesordren som vi angav med kommentaren.

4. Konklusjon

I denne raske opplæringen gikk vi gjennom måtene å sette kjøringsordren som er tilgjengelig i JUnit.

Og som alltid kan eksemplene som brukes i denne artikkelen finnes på GitHub.