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.