[JUnit] Conceptos básicos de JUnit5 3: inyección de dependencia, asumir, habilitar/deshabilitar pruebas y pruebas anidadas

[JUnit] Conceptos básicos de JUnit5 3: inyección de dependencia, asumir, habilitar/deshabilitar pruebas y pruebas anidadas

Inyección de dependencia

Antes de Junit5, Junit no admitía muy bien pasar parámetros en constructores o métodos de prueba, pero Junit5 permite pasar metadatos a constructores y métodos, por lo que la inyección de dependencia también se puede usar en métodos/constructores de prueba.

Por ejemplo, el TestInfoobjeto se puede obtener en tiempo de ejecución a través de DI:

package com.example;

import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInfo;

@DisplayName("App Test with spaces")
public class AppTest
{
    
    
    @BeforeAll
    public static void beforeAll(TestInfo testInfo){
    
    
        System.out.println("********* execute beforeAll() *********");
        System.out.println("Display name - " + testInfo.getDisplayName());
        System.out.println("Test Class   - " + testInfo.getTestClass());
        System.out.println("Test Method  - " + testInfo.getTestMethod());
        System.out.println("****************************************");
    }

    public AppTest(TestInfo testInfo) {
    
    
        System.out.println("********* execute constructor **********");
        System.out.println("Display name - " + testInfo.getDisplayName());
        System.out.println("Test Class   - " + testInfo.getTestClass());
        System.out.println("Test Method  - " + testInfo.getTestMethod());
        System.out.println("****************************************");
    }

    @BeforeEach
    public void BeforeEach(TestInfo testInfo) {
    
    
        System.out.println("********* execute beforeEach() *********");
        System.out.println("Display name - " + testInfo.getDisplayName());
        System.out.println("Test Class   - " + testInfo.getTestClass());
        System.out.println("Test Method  - " + testInfo.getTestMethod());
        System.out.println("****************************************");
    }

    @Test
    public void testOne(TestInfo testInfo) {
    
    
        System.out.println("********* execute testOne() ***********");
        System.out.println("Display name - " + testInfo.getDisplayName());
        System.out.println("Test Class   - " + testInfo.getTestClass());
        System.out.println("Test Method  - " + testInfo.getTestMethod());
        System.out.println("****************************************");
    }
}

El resultado de ejecución es:

A través de la inserción de dependencias, TestInfolos diferentes nombres y métodos para mostrar pueden juzgarse por sí mismos en tiempo de ejecución, en lugar de que el usuario los declare manualmente.

Asumir

Además de afirmaciones , Junit5 también juzgar valores a través de suposiciones.

asumir verdadero y asumir falso

package com.example;

import static org.junit.jupiter.api.Assumptions.assumeFalse;
import static org.junit.jupiter.api.Assumptions.assumeTrue;

import org.junit.jupiter.api.Test;

public class AppTest
{
    
    
    @Test
    void testAssumeTrue() {
    
    
        int num1 = 1, num2 = 1;
        assumeTrue(num1 == num2);
    }

    @Test
    void testAssumeTrueFail() {
    
    
        int num1 = 1, num2 = 1;
        assumeTrue(num1 != num2, "assumption fail");
    }

    @Test
    void testAssumeFalse() {
    
    
        int num1 = 1, num2 = 1;
        assumeFalse(num1 != num2);
    }
}

resultado de la operación:

asumir que

package com.example;

import static org.junit.jupiter.api.Assumptions.assumingThat;

import org.junit.jupiter.api.Test;

public class AppTest
{
    
    
    @Test
    void testAssumeThat1() {
    
    
        int val1 = 1, val2 = 0;
        assumingThat(val1 == val2, () -> {
    
    
            System.out.println("working on this part");
        });
    }

    @Test
    void testAssumeThat2() {
    
    
        int val1 = 1, val2 = 0;
        assumingThat(val1 != val2, () -> {
    
    
            System.out.println("will skip this part");
        });

        System.out.println("still print this line");
    }
}

resultado de la operación:

Escenarios de aplicación de asumir

A primera vista assume, assertparece que no hay diferencia, pero en assumeTruey assumeFalse, la testAssumeTrueFail()función no es un ❌, sino un ❔, esto se debe a que Junit5 omite este método y pasa directamente al siguiente método de prueba. Si assertusa , Junit5 juzgará que el método de prueba falla y devolverá ❌ directamente.

assumingThatEn el método, la diferencia es más obvia. testAssumeThat2()Aunque assumingThatel juicio en es incorrecto, el método de prueba no termina, sino que omite assumingThatel contenido en , salta directamente a la siguiente línea de código y emite.

Esto también hace que assumelos escenarios de aplicación sean más claros: se puede usar para probar en diferentes entornos, como:

package com.example;

import static org.junit.jupiter.api.Assumptions.assumingThat;

import org.junit.jupiter.api.Test;

public class AppTest
{
    
    
    @Test
    void testAssumeTha2() {
    
    
        System.setProperty("ENV", "DEV");
        assumingThat("DEV".equals(System.getProperty("ENV")), () -> {
    
    
            // 使用 assert 进行测试
        });

        System.out.println("运行所有环境下都要运行的测试");
    }
}

Habilitar y deshabilitar las pruebas

Deshabilitar pruebas

@DisabledLas anotaciones se pueden usar para deshabilitar las pruebas:

package com.example;

import static org.junit.jupiter.api.Assertions.assertTrue;

import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;

@Disabled
public class AppTest
{
    
    
    @Test
    void test1() {
    
    
        assertTrue(1 == 2);
    }

    @Test
    void test2() {
    
    
        assertTrue(1 == '1');
    }
}

Los resultados de su funcionamiento son los siguientes:

Como puede ver en la interfaz de prueba a la izquierda, Junit omite todas las pruebas directamente, sin indicar éxito ni fracaso.

De manera similar, @Disabledtambién se puede usar en métodos. Cuando se monta en un método, omitirá el método de prueba actual y pasará a la siguiente prueba.

habilitar/deshabilitar sistema operativo

Este método puede hacer que el método de prueba no se ejecute en un sistema operativo específico, como:

package com.example;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.condition.DisabledOnOs;
import org.junit.jupiter.api.condition.OS;

public class AppTest
{
    
    
    @Test
    void test1() {
    
    
        System.out.println("Linux/MacOS/Windows");
    }

    @DisabledOnOs(OS.MAC)
    @Test
    void test2() {
    
    
        System.out.println("Linux/Windows");
    }

    @DisabledOnOs(OS.WINDOWS)
    @Test
    void test3() {
    
    
        System.out.println("Linux/MacOS");
    }
}

Mi sistema es Windows, por lo test3()que está deshabilitado:

Sí @DisabledOnOs(), también lo hay @EnabledOnOs().

activar/desactivar JRE

Esto es similar a la configuración de habilitar y deshabilitar el sistema operativo, y ambos permiten que el método de prueba se ejecute en el entorno JRE especificado.

Condiciones de propiedad del sistema

Esto se refiere a SystemPropertyvariables , y las anotaciones correspondientes son @DisabledIfSystemPropertyy @EnabledIfSystemProperty.

package com.example;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.condition.DisabledIfSystemProperty;

public class AppTest
{
    
    
    @DisabledIfSystemProperty(named="os.name", matches="Windows 10")
    @Test
    void test2() {
    
    
        System.out.println("not windows 10");
    }
}

resultado de la operación:

condición de variable de entorno

Similar al uso de las condiciones de propiedad del sistema, su anotación es: @DisabledIfEnvironmentVariabley @EnabledIfEnvironmentVariable.

Pruebas anidadas

Pruebas anidadas, es decir, pruebas anidadas que utilizan clases anónimas.

package com.example;

import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

public class AppTest
{
    
    
    @Test
    void test() {
    
    
        System.out.println("outer");
    }

    @Nested
    class NestedClass {
    
    
        @Test
        void test2() {
    
    
            System.out.println("nested inner");
        }
    }
}

Los resultados son los siguientes: