TestNG Tutorial: ¿Qué son las anotaciones y el marco? Selenium

¿Qué es el TestNG?

TestNG es un marco de pruebas de automatización en el que NG significa "Próxima Generación". TestNG está inspirado en JUnit que utiliza las anotaciones (@). TestNG supera las desventajas de JUnit y está diseñado para hacer pruebas de extremo a extremo fácil.

Gracias a TestNG, puede generar un informe adecuado y puede saber fácilmente cuántos casos de prueba se aprobaron, fallaron y se omitieron. Puede ejecutar los casos de prueba fallidos por separado.

Por ejemplo:

Supongamos que tiene cinco casos de prueba, un método está escrito para cada caso de prueba (supongamos que el programa está escrito utilizando el método principal sin utilizar testNG). Cuando ejecuta este programa primero, tres métodos se ejecutan correctamente y el cuarto método falla. Luego corrija los errores presentes en el cuarto método, ahora desea ejecutar solo el cuarto método porque los primeros tres métodos se ejecutan correctamente de todos modos. Esto no es posible sin utilizar TestNG.
La TestNG in Selenium Proporciona una opción, es decir, el archivo testng-failed.xml en la carpeta test-output. Si desea ejecutar solo los casos de prueba fallidos, significa que debe ejecutar este archivo XML. Se ejecutarán solo los casos de prueba fallidos.

Además del concepto anterior, aprenderá más sobre TestNG, como ¿cuáles son las ventajas de TestNG, cómo crear métodos de prueba utilizando anotaciones @test, cómo convertir estas clases en un archivo de suite de pruebas y ejecutarlas a través de eclipse y desde la línea de comandos.

Por qué usar TestNG con Selenium?

Predeterminado Selenium Las pruebas no generan un formato adecuado para los resultados de las pruebas. Usando TestNG in Selenium, podemos generar resultados de pruebas.

La mayoría de las Selenium Los usuarios usan esto más de junit por sus ventajas. Hay tantas características de TestNG, pero sólo nos centraremos en los más importantes que podemos utilizar en SeleniumA continuación se presentan las características clave de Selenium TestNG:

Genere el informe en un formato adecuado que incluya una cantidad de casos de prueba ejecutados, la cantidad de casos de prueba aprobados, la cantidad de casos de prueba fallidos y la cantidad de casos de prueba omitidos.
Se pueden agrupar varios casos de prueba más fácilmente si se convierten en un archivo testng.xml, en el que se pueden priorizar los casos de prueba que se deben ejecutar primero.
El mismo caso de prueba se puede ejecutar varias veces sin bucles simplemente usando la palabra clave llamada "recuento de invocaciones".
Usando testng, puedes ejecutar múltiples casos de prueba en múltiples navegadores, es decir, de forma cruzada. prueba del navegador.
La TestNG El marco se puede integrar fácilmente con herramientas como TestNG Maven, Jenkins, etc.
Las anotaciones utilizadas en las pruebas son muy fáciles de entender, por ejemplo: @BeforeMethod, @AfterMethod, @BeforeTest, @AfterTest.
WebDriver no tiene ningún mecanismo nativo para generar informes. TestNG puede generar el informe en un formato legible como el que se muestra a continuación.

TestNG simplifica la forma en que se codifican las pruebas. Ya no es necesario un método principal estático en nuestras pruebas. La secuencia de acciones está regulada por anotaciones fáciles de entender que no requieren que los métodos sean estáticos.

Las excepciones no detectadas son manejadas automáticamente por TestNG sin finalizar la prueba prematuramente. Estas excepciones se informan como pasos fallidos en el informe.

Ventajas de TestNG sobre JUnit

Hay tres ventajas principales de TestNG sobre JUnit:

Las anotaciones son más fáciles de entender.
Los casos de prueba se pueden agrupar más fácilmente
Es posible realizar pruebas en paralelo

¿Qué es la anotación en TestNG?

Anotaciones en TestNG son líneas de código que pueden controlar cómo se ejecutará el método debajo de ellas. Siempre van precedidos del símbolo @. Un muy temprano y rápido TestNG El ejemplo es el que se muestra a continuación.

Las anotaciones se analizarán más adelante en la sección denominada “Anotaciones utilizadas en TestNG"Así que está perfectamente bien si no entiendes lo anterior. TestNG Ejemplo todavía. Es importante señalar por ahora que las anotaciones en TestNG son más fáciles de codificar y comprender que en JUnit.

La capacidad de ejecutar pruebas en paralelo está disponible en TestNG pero no en JUnit, Por lo que el TestNG El marco es más preferido para los probadores que usan Selenium Rejilla

Cómo escribir casos de prueba en TestNG?

Paso 1) Escriba su lógica de negocios e inserte el TestNG anotaciones en su código.
Paso 2) Agregue más información como nombre de clase, nombre de grupo, nombre de paquete, etc.
Paso 3) Ejecute el TestNG.

Crear caso de prueba usando TestNG Anotaciones

Ahora, aprenderemos cómo crear nuestro primer caso de prueba usando TestNG Anotaciones en Selenium:

Antes de crear un caso de prueba, primero debemos configurar un nuevo TestNG Proyecto en Eclipse y llámalo como “PrimeroTestNGProyecto".

Configurando un nuevo TestNG Proyectos

Paso 1: Haga clic en Archivo > Nuevo > Java Proyectos

Paso 2: Escriba "PrimeroTestNGProyecto” como Nombre del proyecto y luego haga clic en Siguiente.

Paso 3: Ahora comenzaremos a importar el TestNG Bibliotecas en nuestro proyecto. Haga clic en la pestaña "Bibliotecas" y luego en "Agregar biblioteca..."

Paso 4: En el cuadro de diálogo Agregar biblioteca, elija "TestNG”Y haga clic en Siguiente.

Paso 5: Haga clic en Finalizar.

Deberías notar que TestNG está incluido en la lista de Bibliotecas.

Paso 6: Ahora agregaremos los archivos JAR que contienen el Selenium API. Estos archivos se encuentran en el Java controlador de cliente que descargamos de https://www.selenium.dev/downloads/ cuando estábamos instalando Selenium y Eclipse en los capítulos anteriores.

Luego, navega hasta donde has colocado el Selenium Archivos JAR.

Después de agregar los JAR externos, su pantalla debería verse así.

Paso 7: Haga clic en Finalizar y verifique que nuestro PrimerTestNGEl proyecto es visible en EclipseLa ventana del Explorador de paquetes.

Cómo crear un nuevo TestNG Archivo de prueba

Ahora que hemos terminado de configurar nuestro proyecto en este TestNG tutorial, vamos a crear un nuevo TestNG archivo.

Paso 1: Haga clic en 'src' y elija otro.
Haga clic derecho en la carpeta del paquete "src" y luego elija Nuevo > Otro...

Paso 2: Seleccionar TestNG clase.
Haga clic en el TestNG carpeta y seleccione “TestNG opción clase”. Haga clic en Siguiente.

Paso 3: Escriba los valores.
Escriba los valores que se indican a continuación en los cuadros de entrada correspondientes y haga clic en Finalizar. Observe que hemos nombrado nuestro Java archivo como “PrimeroTestNGArchivo".

Paso 4: Plantilla creada.
Eclipse debería crear automáticamente la plantilla para nuestro TestNG archivo que se muestra a continuación.

Codificación de nuestra Primera TestNG Ejemplo de caso de prueba

Creemos ahora nuestro primer Caso de prueba eso comprobará si Mercury La página de inicio de Tours es correcta. Escriba su código como se muestra a continuación TestNG Ejemplo:

package firsttestngpackage;
import org.openqa.selenium.*;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.testng.Assert;
import org.testng.annotations.*;

public class firsttestngfile {
    public String baseUrl = "http://demo.guru99.com/test/newtours/";
    String driverPath = "C:\\geckodriver.exe";
    public WebDriver driver ; 
     
  @Test
  public void verifyHomepageTitle() {
       
      System.out.println("launching firefox browser"); 
      System.setProperty("webdriver.gecko.driver", driverPath);
      driver = new FirefoxDriver();
      driver.get(baseUrl);
      String expectedTitle = "Welcome: Mercury Tours";
      String actualTitle = driver.getTitle();
      Assert.assertEquals(actualTitle, expectedTitle);
      driver.close();
  }
}

Tenga en cuenta lo siguiente:

TestNG no requiere que tengas un método main().
Los métodos no tienen por qué ser estáticos.
Usamos la anotación @Test. @Test se usa para indicar que el método que se describe a continuación es un caso de prueba.. En este caso, hemos configurado el método verificarHomepageTitle() para que sea nuestro caso de prueba, por lo que colocamos una anotación "@Test" encima.
Dado que utilizamos anotaciones en TestNG, necesitábamos importar el paquete org.testng.annotations.*.
Usamos la clase Assert. La clase Assert se utiliza para realizar operaciones de verificación en TestNGPara usarlo, necesitamos importar el paquete org.testng.Assert.

Es posible que tenga varios casos de prueba (por lo tanto, varias anotaciones @Test) en un solo TestNG archivo. Esto se abordará con más detalle más adelante en la sección “Anotaciones utilizadas en TestNG."

Ejecución de la prueba

Para ejecutar la prueba, simplemente ejecute el archivo en Eclipse como lo hace normalmente. Eclipse proporcionará dos salidas: una en la ventana de la Consola y la otra en la TestNG Ventana de resultados.

Comprobación de informes creados por TestNG

La ventana de la consola en Eclipse proporciona un informe basado en texto de los resultados de nuestros casos de prueba, mientras que el TestNG La ventana de resultados nos da una gráfica.

Generando informes HTML

TestNG tiene la capacidad de generar informes en formato HTML.

Paso 1: Después de ejecutar nuestro primerTestNGArchivo que creamos en la sección anterior, haga clic derecho en el nombre del proyecto (PrimeraTestNGProyecto) en la ventana del Explorador de proyectos y luego haga clic en la opción "Actualizar".

Paso 2: Observe que se creó una carpeta de "salida de prueba". Amplíelo y busque un archivo index.html. Este archivo HTML es un informe de los resultados de la ejecución de prueba más reciente.

Paso 3: Double-haga clic en ese archivo index.html para abrirlo dentro EclipseEl navegador web integrado de. Puede actualizar esta página en cualquier momento después de volver a ejecutar la prueba simplemente presionando F5 como en los navegadores web normales.

Anotaciones utilizadas en TestNG

En la sección anterior, conoció la anotación @Test. Ahora, estudiaremos anotaciones más avanzadas y sus usos.

Múltiples casos de prueba

Podemos usar múltiples anotaciones @Test en una sola TestNG archivo. De forma predeterminada, los métodos anotados por @Test se ejecutan alfabéticamente. Vea el código a continuación. Aunque los métodos c_test, a_test y b_test no están ordenados alfabéticamente en el código, se ejecutarán como tales.

Ejecute este código y en la página index.html generada, haga clic en "Vista cronológica".

parámetros

Si desea que los métodos se ejecuten en un orden diferente, utilice el parámetro "prioridad". Los parámetros son palabras clave que modifican la función de la anotación..

Los parámetros requieren que les asigne un valor. Para ello, coloque un “=" al lado de ellos y luego seguido del valor.
Los parámetros están encerrados entre un par de paréntesis que se colocan justo después de la anotación, como el fragmento de código que se muestra a continuación.

TestNG ejecutará la anotación @Test con el valor de prioridad más bajo hasta el más grande. No es necesario que sus valores de prioridad sean consecutivos.

La TestNG El informe HTML confirmará que los métodos se ejecutaron según el valor ascendente de prioridad.

Múltiples parámetros

Además de "prioridad", @Test tiene otro parámetro llamado "alwaysRun" que sólo se puede establecer en "verdadero" o "falso". Para utilizar dos o más parámetros en una sola anotación, sepárelos con una coma como el que se muestra a continuación.

@Test(priority = 0, alwaysRun = true)

@Antes de la prueba y @Después de la prueba

@AntesTest	Los métodos bajo esta anotación serán ejecutados. antes del primer caso de prueba en el TestNG presentar.
@Después de la prueba	Los métodos bajo esta anotación serán ejecutados. después de todos los casos de prueba en el TestNG el archivo se ejecuta.

Considere el código a continuación.

package firsttestngpackage;
import org.openqa.selenium.*;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.testng.Assert;
import org.testng.annotations.*;
public class firsttestngfile {
    public String baseUrl = "http://demo.guru99.com/test/newtours/";
    String driverPath = "C:\\geckodriver.exe";
    public WebDriver driver ; 
     
     @BeforeTest
      public void launchBrowser() {
          System.out.println("launching firefox browser"); 
          System.setProperty("webdriver.gecko.driver", driverPath);
          driver = new FirefoxDriver();
          driver.get(baseUrl);
      }
      @Test
      public void verifyHomepageTitle() {
          String expectedTitle = "Welcome: Mercury Tours";
          String actualTitle = driver.getTitle();
          Assert.assertEquals(actualTitle, expectedTitle);
     }
      @AfterTest
      public void terminateBrowser(){
          driver.close();
      }
}

Aplicando la lógica presentada por la tabla y el código anterior, podemos predecir que la secuencia mediante la cual se ejecutarán los métodos es:

1^st – iniciar navegador()
2^nd – verificar el título de la página de inicio ()
3^rd – terminar el navegador()

La ubicación de los bloques de anotaciones se puede intercambiar sin afectar el orden cronológico en el que se ejecutarán.. entendamos con un TestNG Ejemplo e intente reorganizar los bloques de anotaciones de manera que su código se vea similar al siguiente.

package firsttestngpackage;
import org.openqa.selenium.*;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.testng.Assert;
import org.testng.annotations.*;
public class firsttestngfile {
    public String baseUrl = "http://demo.guru99.com/test/newtours/";
    String driverPath = "C:\\geckodriver.exe";
    public WebDriver driver ; 
     @AfterTest                            //Jumbled
      public void terminateBrowser(){
          driver.close();
      }
     @BeforeTest                            //Jumbled
      public void launchBrowser() {
          System.out.println("launching firefox browser"); 
          System.setProperty("webdriver.gecko.driver", driverPath);
          driver = new FirefoxDriver();
          driver.get(baseUrl);
      }
      @Test                                //Jumbled
      public void verifyHomepageTitle() {
          String expectedTitle = "Welcome: Mercury Tours";
          String actualTitle = driver.getTitle();
          Assert.assertEquals(actualTitle, expectedTitle);
     }
      
}

Ejecute el código anterior y observe que

@BeforeMethod y @AfterMethod

@Antes del método	Los métodos bajo esta anotación serán ejecutados. antes de cada método en cada caso de prueba.
@Después del método	Los métodos bajo esta anotación serán ejecutados. después de cada método en cada caso de prueba.

In Mercury Tours, supongamos que queremos verificar los títulos de las páginas de destino de los dos enlaces siguientes.

El flujo de nuestra prueba sería:

Vaya a la página de inicio y verifique su título.
Haga clic en REGISTRAR y verifique el título de su página de destino.
Vuelve a la página de inicio y verifica si todavía tiene el título correcto.
Haga clic en SOPORTE y verifique el título de su página de destino.
Vuelve a la página de inicio y verifica si todavía tiene el título correcto.

El siguiente código ilustra cómo se utilizan @BeforeMethod y @AfterMethod para ejecutar de manera eficiente el escenario mencionado anteriormente.

package firsttestngpackage;
import org.openqa.selenium.*;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.testng.Assert;
import org.testng.annotations.*;
@Test
public class firsttestngfile {
    public String baseUrl = "http://demo.guru99.com/test/newtours/";
    String driverPath = "C:\\geckodriver.exe";
    public WebDriver driver; 
    public String expected = null;
    public String actual = null;
        @BeforeTest
      public void launchBrowser() {
          System.out.println("launching firefox browser"); 
          System.setProperty("webdriver.gecko.driver", driverPath);
          driver= new FirefoxDriver();
          driver.get(baseUrl);
      }
      
      @BeforeMethod
      public void verifyHomepageTitle() {
          String expectedTitle = "Welcome: Mercury Tours";
          String actualTitle = driver.getTitle();
          Assert.assertEquals(actualTitle, expectedTitle);
      }
          @Test(priority = 0)
      public void register(){
          driver.findElement(By.linkText("REGISTER")).click() ;
          expected = "Register: Mercury Tours";
          actual = driver.getTitle();
          Assert.assertEquals(actual, expected);
      }
          @Test(priority = 1)
      public void support() {
            driver.findElement(By.linkText("SUPPORT")).click() ;
            expected = "Under Construction: Mercury Tours";
            actual = driver.getTitle();
            Assert.assertEquals(actual, expected);
      }
      @AfterMethod
      public void goBackToHomepage ( ) {
            driver.findElement(By.linkText("Home")).click() ;
      }
       
      @AfterTest
      public void terminateBrowser(){
          driver.close();
      }
}

Después de ejecutar esta prueba, su TestNG Debe informar la siguiente secuencia.

En pocas palabras, @BeforeMethod debe contener los métodos que necesitas ejecutar. antes cada caso de prueba, mientras que @AfterMethod debe contener los métodos que necesita ejecutar después de cada caso de prueba.

Resumen de TestNG Anotaciones

@AntesSuite: El método anotado se ejecutará antes de que se hayan ejecutado todas las pruebas de este conjunto.

@DespuésSuite: El método anotado se ejecutará después de que se hayan ejecutado todas las pruebas de este conjunto.

@AntesTest: El método anotado se ejecutará antes de ejecutar cualquier método de prueba que pertenezca a las clases dentro de la etiqueta.

@Después de la prueba: El método anotado se ejecutará después de que se hayan ejecutado todos los métodos de prueba que pertenecen a las clases dentro de la etiqueta.

@AntesGrupos: La lista de grupos que este método de configuración ejecutará antes. Se garantiza que este método se ejecutará poco antes de que se invoque el primer método de prueba que pertenece a cualquiera de estos grupos.

@DespuésGrupos: La lista de grupos después de los cuales se ejecutará este método de configuración. Se garantiza que este método se ejecutará poco después de que se invoque el último método de prueba que pertenece a cualquiera de estos grupos.

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

@Después de clases: El método anotado se ejecutará después de que se hayan ejecutado todos los métodos de prueba de la clase actual.

@Antes del método: El método anotado se ejecutará antes de cada método de prueba.

@Después del método: El método anotado se ejecutará después de cada método de prueba.

@Prueba: El método anotado es parte de un caso de prueba.

Conclusión

TestNG es un las pruebas marco que es capaz de hacer Selenium pruebas más fáciles de entender y de generar informes que sean fáciles de entender.
Las principales ventajas de TestNG sobre JUnit son los siguientes.
- Las anotaciones son más fáciles de usar y comprender.
- Los casos de prueba se pueden agrupar más fácilmente.
- TestNG nos permite crear pruebas paralelas.
La ventana de la consola en Eclipse genera un resultado basado en texto mientras que el TestNG La ventana es más útil porque nos brinda una salida gráfica del resultado de la prueba más otros detalles significativos como:
- Tiempos de ejecución de cada método.
- El orden cronológico por el cual se ejecutaron los métodos.
TestNG es capaz de generar informes basados en HTML.
Las anotaciones pueden usar parámetros como lo habitual. Java TestNG métodos.
TestNG El proveedor de datos es una forma de pasar parámetros a la función de prueba que pasa diferentes valores en casos de prueba en una sola ejecución.

Te podría gustar: