selenium - testng example

Diferencia entre BeforeClass y BeforeTest en TestNG

Question

As we know from official TestNG documentation:

@BeforeClass: el método anotado se ejecutará antes de que se invoque el primer método de prueba en la clase actual.

@BeforeTest: el método anotado se ejecutará antes de ejecutar cualquier método de prueba perteneciente a las clases dentro de la etiqueta <test> .

Ambas anotaciones de prueba anteriores se ven similares en funcionalidad. Sin embargo, debe haber una diferencia única en la característica. ¿Alguien puede enfatizar esto?

Answer 1

SeleniumAbstractTest.class

public abstract class SeleniumAbstractTest {

  @BeforeSuite
  public void beforeSuite() {
    System.out.println("BeforeSuite");
  }

  @BeforeTest
  public void beforeTest() {
    System.out.println("BeforeTest");
  }

  @BeforeClass
  public void beforeClass() {
    System.out.println("BeforeClass");
  }

  @BeforeMethod
  public void beforeMethod() {
    System.out.println("BeforeMethod");
  }

  @AfterMethod
  public void afterMethod() {
    System.out.println("AfterMethod");
  }

  @AfterClass
  public void afterClass() {
    System.out.println("AfterClass");
  }

  @AfterTest
  public void afterTest() {
    System.out.println("AfterTest");
  }

  @AfterSuite
  public void afterSuite() {
    System.out.println("AfterSuite");
  }

}

MyTestClass1.class

public class MyTestClass1 extends SeleniumAbstractTest {

  @Test
  public void myTestMethod1() {
    System.out.println("myTestMethod1");
  }

  @Test
  public void myTestMethod2() {
    System.out.println("myTestMethod2");
  }
}

MyTestClass2.class

public class MyTestClass2 extends SeleniumAbstractTest {

  @Test
  public void myTestMethod3() {
    System.out.println("myTestMethod3");
  }

  @Test
  public void myTestMethod4() {
    System.out.println("myTestMethod4");
  }
}

Si tiene el siguiente Test Suite ...

<suite name="Suite">
  <test name="Test1" >
    <classes>
       <class name="MyTestClass2" />
    </classes>
  </test>

  <test name="Test2">
    <classes>
      <class name="MyTestClass1"/>
      <class name="MyTestClass2"/>
    </classes>
  </test>
</suite>

... entonces la salida será

BeforeSuite
BeforeTest
BeforeClass
BeforeMethod
myTestMethod3
AfterMethod
BeforeMethod
myTestMethod4
AfterMethod
AfterClass
AfterTest
BeforeTest
BeforeClass
BeforeMethod
myTestMethod1
AfterMethod
BeforeMethod
myTestMethod2
AfterMethod
AfterClass
BeforeClass
BeforeMethod
myTestMethod3
AfterMethod
BeforeMethod
myTestMethod4
AfterMethod
AfterClass
AfterTest
AfterSuite

Espero eso ayude :)

Answer 2

si se extiende desde otra clase, estos son los resultados:

parentTest - BeforeTest- parent     
testClass1 - BeforeTest- test1    
parentTest - BeforeClass- parent    
testClass1 - BeforeClass- test1    
parentTest - BeforeMethod- parent    
testClass1 - BeforeMethod- test1    
testClass1 - myTestMethod1    
testClass1 - AfterMethod- test1    
parentTest - AfterMethod- parent    
parentTest - BeforeMethod- parent    
testClass1 - BeforeMethod- test1    
testClass1 - myTestMethod2    
testClass1 - AfterMethod- test1    
parentTest - AfterMethod- parent
testClass1 - AfterClass- test1    
parentTest - AfterClass- parent
testClass1 - AfterTest- test1
parentTest – AfterTest- parent

Answer 3

Mis opiniones:

@BeforeClass: el método anotado se ejecutará antes de que se invoque el primer método de prueba en la clase actual

@BeforeTest: el método anotado se ejecutará antes de ejecutar cualquier método de prueba en el paquete actual

Answer 4

@BeforeMethod - se ejecuta antes de cada método de prueba, por ejemplo, el método que utiliza la anotación @Test

@BeforeTest: se ejecuta solo antes de la etiqueta proporcionada en el archivo testng.xml.

En pocas palabras, @BeforeMethod funciona en la prueba definida en las clases de Java. Y @BeforeTest funciona en la prueba definida en testng.xml, es decir, archivos XML.