java - example - Cómo deshabilitar la prueba de TestNG basada en una condición

testng listeners

Question

¿Hay actualmente una manera de deshabilitar la prueba de TestNG basada en una condición

Sé que actualmente puedes deshabilitar la prueba como en TestNG:

@Test(enabled=false, group={"blah"})
public void testCurrency(){
...
}

Me gustaría deshabilitar la misma prueba basada en una condición pero no sé cómo. algo como esto:

@Test(enabled={isUk() ? false : true), group={"blah"})
public void testCurrency(){
...
}

Cualquiera tiene una pista sobre si esto es posible o no.

Answer 1

Hay dos formas que conozco que le permiten controlar las pruebas de "desactivación" en TestNG.

La diferenciación que es muy importante tener en cuenta es que SkipException eliminará todas las pruebas subsiguientes mientras implementa IAnnotationTransformer utiliza Reflection para desempaquetar pruebas individuales, en función de una condición que usted especifique. Explicaré tanto SkipException como IAnnotationTransfomer.

Ejemplo de excepción SKIP

import org.testng.*;
import org.testng.annotations.*;

public class TestSuite
{
    // You set this however you like.
    boolean myCondition;

    // Execute before each test is run
    @BeforeMethod
    public void before(Method methodName){
        // check condition, note once you condition is met the rest of the tests will be skipped as well
        if(myCondition)
            throw new SkipException();
    }

    @Test(priority = 1)
    public void test1(){}

    @Test(priority = 2)
    public void test2(){}

    @Test(priority = 3)
    public void test3(){}
}

Ejemplo de IAnnotationTransformer

Un poco más complicado, pero la idea detrás de esto es un concepto conocido como Reflexión.

Wiki - http://en.wikipedia.org/wiki/Reflection_(computer_programming)

Primero implemente la interfaz IAnnotation, guarde esto en un archivo * .java.

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import org.testng.IAnnotationTransformer;
import org.testng.annotations.ITestAnnotation;

public class Transformer implements IAnnotationTransformer {

// Do not worry about calling this method as testNG calls it behind the scenes before EVERY method (or test).
// It will disable single tests, not the entire suite like SkipException
public void transform(ITestAnnotation annotation, Class testClass, Constructor testConstructor, Method testMethod){

    // If we have chose not to run this test then disable it.
    if (disableMe()){
        annotation.setEnabled(false);
    }
}

// logic YOU control
private boolean disableMe()){
}

Luego, en el archivo java de prueba, haga lo siguiente en la función @BeforeClass

import org.testng.*;
import org.testng.annotations.*;

/* Execute before the tests run. */    
@BeforeClass
public void before(){

    TestNG testNG = new TestNG();
    testNG.setAnnotationTransformer(new Transformer());
}

@Test(priority = 1)
public void test1(){}

@Test(priority = 2)
public void test2(){}

@Test(priority = 3)
public void test3(){}

Un último paso es asegurarse de agregar una escucha en su archivo build.xml. El mío terminó pareciéndose a esto, esto es solo una línea del build.xml:

<testng classpath="${test.classpath}:${build.dir}" outputdir="${report.dir}" 
    haltonfailure="false" useDefaultListeners="true"
    listeners="org.uncommons.reportng.HTMLReporter,org.uncommons.reportng.JUnitXMLReporter,Transformer" 
    classpathref="reportnglibs"></testng>

Answer 2

Lanzar un SkipException en un método anotado con @BeforeMethod no funcionó para mí porque omitió todas las pruebas restantes de mi conjunto de pruebas sin SkipException si se lanzaba una SkipException para esas pruebas.

No lo investigué a fondo, pero encontré otra forma: usando el atributo dependsOnMethods en la anotación @Test :

import org.testng.SkipException;
import org.testng.annotations.Test;

public class MyTest {

  private boolean conditionX = true;
  private boolean conditionY = false;

  @Test
  public void isConditionX(){
    if(!conditionX){
      throw new SkipException("skipped because of X is false");
    }
  }

  @Test
  public void isConditionY(){
    if(!conditionY){
      throw new SkipException("skipped because of Y is false");
    }
  }

  @Test(dependsOnMethods="isConditionX")
  public void test1(){

  }

  @Test(dependsOnMethods="isConditionY")
  public void test2(){

  }
}

Answer 3

SkipException: es útil en caso de que solo tengamos un método @Test en la clase. Al igual que con Data Driven Framework, solo tengo un método de prueba que debe ejecutarse o omitirse en función de alguna condición. Por lo tanto, puse la lógica para verificar la condición dentro del método @Test y obtuve el resultado deseado. Me ayudó a obtener el Informe de extensión con el resultado del caso de prueba como Pasar / Reprobar y Salto en particular también.

Answer 4

Tienes dos opciones:

• Implementar un transformador de anotación .
• Utilice BeanShell .

Su transformador de anotación probaría la condición y luego anularía la anotación @Test para agregar el atributo "habilitado = falso" si la condición no se cumple.

Answer 5

Una tercera opción también puede ser Suposiciones de supuestos para TestNG : cuando falla una suposición, se le indicará a TestNG que ignore el caso de prueba y, por lo tanto, no lo ejecute.

• Utilizando la anotación @ asunción
• Uso de AssumptionListener mediante el método Assumes.assumeThat (...)

Puedes usar este ejemplo: example

Answer 6

Una opción más fácil es usar la anotación @BeforeMethod en un método que verifique su condición. Si desea omitir las pruebas, simplemente lance un SkipException . Me gusta esto:

@BeforeMethod
protected void checkEnvironment() {
  if (!resourceAvailable) {
    throw new SkipException("Skipping tests because resource was not available.");
  }
}