Menú

Ordre d'execució de la prova JUnit: Ordre de proves JUnit 4 Vs JUnit 5

  • Principal
  • Altres
  • Ordre d'execució de la prova JUnit: Ordre de proves JUnit 4 Vs JUnit 5

junit test execution order

Proveu El Nostre Instrument Per Eliminar Problemes

pl sql preguntes d’entrevistes amb respostes

Aquest tutorial explica com establir l'ordre d'execució per als casos de prova de JUnit. Aprendràs sobre les anotacions i les classes per establir l’ordre d’execució de la prova JUnit a JUnit 4 vs JUnit 5:

Vam aprendre a crear un conjunt de proves, a afegir una categoria o etiqueta als casos de prova i a filtrar les proves (excloure o incloure els casos de prova) en funció de la categoria o etiqueta del nostre tutorial anterior.

A més, hem après que a JUnit 4, sí @Categoria, @InclouCategoria, i @ExcludeCategory per filtrar els casos de prova mentre la JUnit 5 ho té @IncludeTags i @ExcludeTags fer el mateix.

La JUnit 5 té opcions de filtratge addicionals mitjançant anotacions @IncludePackages, @ExcludePackages, i també anotacions per incloure o excloure classes mitjançant patrons de nom de classe.

=> Consulteu aquí per veure tutorials de formació A-Z de JUnit .

Ordre d’execució de la prova JUnit

Què aprendreu:

Ordre d’execució de la prova JUnit

En aquest tutorial, aprendrem a establir un ordre per a cada cas de prova perquè s’executin en l’ordre establert. Aprendrem a demanar proves a JUnit 4 i a JUnit 5.

Els mètodes de prova no segueixen un ordre específic de manera predeterminada.Els casos de prova no necessàriament s’han d’executar en l’ordre en què s’han escrit.

Hi ha diferents maneres o maneres d'establir l'ordre d'execució dels casos de prova. També aprofundirem en com varia la JUnit 4 per ordenar els casos de prova en comparació amb la JUnit 5.

JUnitat 4: @FixedMethodOrder, Class MethodSorters

A partir de la JUnit 4.11, tenim l’anotació @FixMethodOrder i MethodSorters.class donant suport a la facilitat d’establir una ordre per a l’execució d’una prova.

El paquet org.junit.runners. * s’ha d’importar per incloure la classe MethodSorters . Aquesta classe decideix com cal ordenar els casos de prova. MethodSorters tenir tres enum valors.

A continuació, es mostren els valors enumerats de la classe juntament amb la finalitat de cadascun dels valors:

MethodSorters.DEFAULT Aquest valor enumeral ordena l'execució de la prova en un ordre específic. Tanmateix, mai no es pot predir en quin ordre es poden executar els casos de prova.
És per això que teniu el control sobre la vostra decisió sobre quina prova de prova s’hauria d’executar primer i quines de seguida.
He observat que una classe amb múltiples mètodes ordenats amb DEUMP enum quan s'executa, l'ordre continua sent la mateixa cada vegada que s'executa la prova.
Tanmateix, no hi ha manera de predir ni esbrinar la forma en què es va establir l'ordre.
MethodSorters.JVM L’ordre d’execució de la prova amb JVM enum és com el seu nom indica que la determina la JVM.
En aquest cas, cada vegada que executeu la classe, les proves s’executaran no en el mateix però en un ordre aleatori.
Dit d’una altra manera, l’ordre de les proves canvia durant cada prova.
MethodSorters.NAME_ASCENDING Aquesta enumera ordena els mètodes de prova per ordre lexicogràfic del nom del mètode. Per tant, pot estar segur, ja que aquesta és la forma més previsible d’ordenar l’execució de la prova.
Per tant, podeu decidir prèviament la seqüència de proves en funció de l’ordre lexicogràfic del seu nom que hàgiu establert.

L'anotació @FixedMethodOrder pren el paràmetre d'entrada de MethodSorters amb el seu valor enum. El paquet necessari per a l’anotació és org.junit.FixedMethodOrder.

Vegem com s’implementa mitjançant el codi.

Implementació de codi per MethodSorters.DEFAULT

Creem un fitxer de classe JUnit ' Junit4TestOrder.java ' on utilitzarem MethodSorters.DEFAULT

El codi de Junit4TestOrder.java

@FixMethodOrder(MethodSorters.DEFAULT) public class JUnit4TestOrder { @Test public void Testcase_3() { System.out.println('Testcase_3 executes'); } @Test public void Testcase_1() { System.out.println('Testcase_1 executes'); } @Test public void Testcase_2() { System.out.println('Testcase_2 executes '); } }

Executem la classe tres vegades i veiem que s’executa el mateix ordre de proves que a continuació, però, els casos de prova es poden executar o no en l’ordre ordenat.

A la finestra de la consola es mostren els resultats a continuació: l'ordre d'execució de la prova és TestCase_3, TestCase_1 i TestCase_2 i l'ordre no canvia amb el nombre de tirades.

finestra de la consola 1

Implementació de codi per MethodSorters. JVM

Ara actualitzarem ‘Junit4TestOrder.java’ per tenir MethodSorters.JVM

El fragment de codi per a Junit4TestOrder.java

@FixMethodOrder(MethodSorters . JVM ) public class JUnit4TestOrder {

Executem la classe dues vegades i l’ordre d’execució de les proves canvia amb cada execució.

La finestra de la consola per al fitxer primer executar és el que es mostra a continuació:

finestra de la consola PRIMERA execució

La finestra de la consola per al fitxer segon executar és el que es mostra a continuació:

finestra de la consola segona execució

Observeu intensament el canvi en l’ordre en què s’executen les proves en ambdues proves. L'ordre de les proves en les dues proves ha estat diferent.

Implementació de codi per MethodSorters.NAME_ASCENDING

Ara actualitzarem ‘Junit4TestOrder.java’ per tenir MethodSorters.NAME_ASCENDING

El fragment de codi per a Junit4TestOrder.java

@FixMethodOrder(MethodSorters.NAME_ASCENDING) public class JUnit4TestOrder {

Executem la classe dues vegades, l'ordre de proves executades continua sent el mateix i s'executa segons l'ordre ascendent del nom del mètode.

La finestra de la consola mostra el resultat de les proves executades en l'ordre TestCase_1, TestCase_2 i TestCase_3.

Resultats de l

JUnitat 5: @TestMethodOrder, @Order, Interface MethodOrderer

Per controlar l'ordre d'execució de les proves, les entitats següents ajuden a fer el mateix:

  1. L'anotació @TestMethodOrder
  2. L'anotació @Order
  3. Les classes que pertanyen a les interfícies MethodOrderer

Les classes MethodOrderer integrades i els seus detalls són els següents:

MethodOrderer construït a classeDes del paquetDetalls
Alfanumèric org.junit.jupiter.api.MethodOrderer.AlphanumericOrdena els mètodes de prova de manera alfanumèrica en funció dels seus noms
Anotació de la comanda org.junit.jupiter.api.MethodOrderer.OrderAnnotationOrdena els mètodes de prova numèricament en funció dels valors passats a l’anotació @Order
Aleatori org.junit.jupiter.api.MethodOrderer.RandomOrdena els mètodes de prova de manera aleatòria, igual que en el cas MethodSorters.JVM a JUnit 4

Vegem ara la demostració de cadascuna d’aquestes estratègies d’ordenació:

Implementació de codi per a Alphanumeric.class

Creem un fitxer de classe JUnit 5 anomenat JUnit5TestOrder.java igual que JUnit4TestOrder.java i fem servir l’anotació amb Alphanumeric.class per ordenar les proves de manera alfanumèrica.

El codi de Junit5TestOrder.java

@TestMethodOrder(Alphanumeric.class) public class JUnit5TestOrder { @Test public void Testcase_3() { System.out.println('Testcase_3 executes'); } @Test public void Testcase_1() { System.out.println('Testcase_1 executes'); } @Test public void Testcase_2() { System.out.println('Testcase_2 executes '); } }

Vam executar la classe tres vegades i encara veiem que s’executa el mateix ordre de proves en l’ordre ordenat alfanumèric del nom del mètode de prova.

Post execució del fitxer de classe, l'ordre d'execució de la prova:

  1. Testcase_1,
  2. Testcase_2 i
  3. Testcase_3

Nota: L'estratègia de classificació alfanumèrica distingeix entre majúscules i minúscules per tant, en cas que tinguéssim un altre cas de prova amb el nom testcase_1.

L'ordre d'execució seria:

  1. Testcase_1,
  2. Testcase_2,
  3. Testcase_3,
  4. testcase_1.

Per tant, les majúscules tenen prioritat sobre els noms de mètodes en minúscules.

Implementació de codi per a Random.class

Actualitzarem la classe JUnit 5 JUnit5TestOrder.java per utilitzar l’anotació amb Random.class

El fragment de codi per a Junit5TestOrder.java

@TestMethodOrder (Random.class) public class JUnit5TestOrder {

Vam dirigir la classe dues vegades i vam veure que cada vegada que dirigíem la classe, l’ordre d’execució de la prova s’ordenava aleatòriament.

Post execució del fitxer de classe per al fitxer primera vegada , l'ordre d'execució de la prova era:

  1. Testcase_2,
  2. Testcase_1
  3. Testcase_3

L'ordre d'execució quan es va executar el fitxer segon el temps va mostrar:

  1. Testcase_2,
  2. Testcase_3
  3. Testcase_1 .

Implementació de codi per a OrderAnnotation.class

Ara actualitzarem la classe JUnit 5 JUnit5TestOrder.java per utilitzar l’anotació amb OrderAnnotation.class. L'anotació @Ordre també tindrà un paper important en la configuració de prioritats dels mètodes de prova aquí.

El fragment de codi per a Junit5TestOrder.java

@TestMethodOrder(OrderAnnotation.class) public class JUnit5TestOrder { @Test @Order(1) public void Testcase_3() { System.out.println('Testcase_3 executes'); } @Test @Order(2) public void Testcase_1() { System.out.println('Testcase_1 executes'); } @Test @Order(3) public void Testcase_2() { System.out.println('Testcase_2 executes '); } }

Per tant, en aquesta estratègia de configurar l’ordre d’execució de la prova, l’anotació @Order aplica els mètodes de prova que s’executaran per valor de la comanda per a això.

Com més baix sigui el valor de l’Orde @ per a un mètode de prova, major serà la seva prioritat durant l’execució.

Després de l'execució, l'ordre de les proves es va executar de la següent manera:

  1. Testcase_3,
  2. Testcase_1
  3. Testcase_2 perquè l'ordre establert per als casos de prova és 1,2 i 3, respectivament.

Per això, no importa si els casos de prova estan escrits en ordre. A més, no importa si els noms dels mètodes estan o no en ordre alfanumèric.

JUnitat 5: creació d'una comanda personalitzada

A més, les classes d’ordre incorporades, JUnit 5 també admet comandes personalitzades implementant la interfície MethodOrderer . A partir de la versió 5.4 de JUnit 5, s'admet l'ordenació personalitzada.

Vegem ràpidament com crear i implementar una comanda personalitzada per longitud del mètode.

Pas 1: Es va crear una classe de comanda personalitzada que implementava la interfície MethodOrderer i es va anomenar la classe com TestCaseLengthOrder

El codi de TestCaseLengthOrder.java

public class TestCaseLengthOrder implements MethodOrderer { @Override public void orderMethods(MethodOrdererContext context) { MethodDescriptor md1; MethodDescriptor md2; context.getMethodDescriptors().sort((md1, md2)-> md1.getMethod().getName().length().compareTo(md2.getMethod().getName().length())); } }

Explicació del codi TestCaseLengthOrder:

  1. Es crea una classe de comanda personalitzada mitjançant la implementació de la interfície MethodOrderer.
  2. void orderMethods (context MethodOrderContext) {} mètode que és el mètode integrat implementat des de la Interface MethodOrderer. Aquí és on definiu la implementació de la lògica d’ordres de prova.
  3. MethodDescriptor és una interfície que inclou detalls sobre un mètode:
    • El mètode MethodDescriptor.getMethod () obté el nom del mètode per a aquest descriptor.
    • El nom del mètode es converteix en String amb el mètode getName () és a dir, MethodDescriptor.getMethod (). GetName () i
    • El mètode length () obté la longitud del mètode (igual que string.length () obté la longitud d’un valor de cadena).
    • Tots els noms dels mètodes es comparen entre si mitjançant el mètode compareTo ().
  4. El mètode getMethodDescriptors () obté la llista de tots els descriptors de mètodes d’una classe.
  5. El mètode sort () ordena els objectes MethodDescriptor.

Ara, ja que hem entès cada API de MethodOrderer amb claredat, esperem que sigui fàcil interpretar el codi anterior.

Pas 2 : Utilitzeu la classe de comanda personalitzada com si feu servir qualsevol ordre integrat a la classe de prova.

Com a entrada a l’anotació @TestMethodOrder.

El codi de JUnit_CustomOrder.java

@TestMethodOrder(TestCaseLengthOrder.class) class JUnit_CustomOrder{ @Test public void subt(){ } @Test public void add(){ } @Test public void multiply(){ } @Test public void divide(){ }

Pas 3:

Post execució de JUnit_CustomOrder.class , l'ordre d'execució de la prova és el següent, basat en l'ordre ascendent de la longitud del nom dels casos de prova:

  1. add (),
  2. subt (),
  3. divideix ()
  4. multiplicar ()

Conclusió

Per concloure aquest tutorial sobre l’ordre d’execució de la prova JUnit.

  1. Vam aprendre a definir l’ordre dels casos de prova amb anotacions específiques i classes específiques.
  2. També vam aprendre diverses maneres d’ordenar proves de JUnit 4 i JUnit 5, basant-nos en què van canviar les estratègies d’ordenació.
  3. A més, hem après com a JUnit 5 també podríem crear una classe d’ordenació personalitzada i utilitzar-la per ordenar els casos de prova durant la seva execució.

=> Feu una ullada a la guia per a principiants de JUnit aquí.

Lectura recomanada

^