Pepino - Guía rápida

Para aprovechar mejor las pruebas de software, las organizaciones hoy en día están dando un paso adelante. Implementan escenarios de prueba de aceptación importantes mientras el desarrollo está en progreso. Este enfoque se conoce comúnmente comoBehavior Driven Development (BDD).

El desarrollo impulsado por el comportamiento nos brinda la oportunidad de crear scripts de prueba desde la perspectiva del desarrollador y del cliente. Entonces, al principio, los desarrolladores, gerentes de proyectos, QA, probadores de aceptación de usuarios y el propietario del producto (accionista), se reúnen y hacen una lluvia de ideas sobre qué escenarios de prueba deben aprobarse para que este software / aplicación sea exitoso. De esta forma, crean un conjunto de escenarios de prueba. Todos estos guiones de prueba están en un idioma inglés simple, por lo que también sirve como documentación.

Ejemplo

Si estamos desarrollando una función de autenticación de usuario, los siguientes pueden ser algunos escenarios de prueba clave, que deben aprobarse para que sea un éxito.

  • El usuario debe poder iniciar sesión con el nombre de usuario y la contraseña correctos.

  • El usuario no debería poder iniciar sesión con un nombre de usuario incorrecto y una contraseña correcta.

  • El usuario no debería poder iniciar sesión con el nombre de usuario correcto y la contraseña incorrecta.

Cómo funciona

Para cuando el código esté listo, los scripts de prueba también estarán listos. El código tiene que pasar los scripts de prueba definidos en BDD. Si no sucede, será necesario refactorizar el código. El código se congela solo después de la ejecución exitosa de los scripts de prueba definidos.

Es una noción muy simple, pero lo que necesitamos para implementar este concepto. La respuesta es el marco de desarrollo impulsado por el comportamiento (BDD). El pepino es una de esas herramientas de código abierto, que apoya el desarrollo impulsado por el comportamiento. Para ser más precisos, Cucumber se puede definir como un marco de prueba, impulsado por texto en inglés simple. Sirve como documentación, pruebas automatizadas y ayuda al desarrollo, todo en uno.

Entonces, ¿qué hace Pepino? Se puede describir en los siguientes pasos:

Cucumber lee el código escrito en texto sin formato en inglés (Language Gherkin, que se presentará más adelante en este tutorial) en el archivo de características (que se presentará más adelante).

Encuentra la coincidencia exacta de cada paso en la definición del paso (un archivo de código; los detalles se proporcionan más adelante en el tutorial).

El fragmento de código a ejecutar puede ser diferentes marcos de software como Selenium, Ruby on Rails, etc. No todas las herramientas del marco BDD son compatibles con todas las herramientas.

Esta se ha convertido en la razón de la popularidad de Cucumber sobre otros marcos, como JBehave, JDave, Easyb, etc.

Cucumber admite más de una docena de plataformas de software diferentes como:

  • Ruby on Rails
  • Selenium
  • PicoContainer
  • Marco de primavera
  • Watir

Ventajas del pepino sobre otras herramientas

  • Cucumber admite diferentes lenguajes como Java.net y Ruby.

  • Actúa como un puente entre el lenguaje comercial y técnico. Podemos lograr esto creando un caso de prueba en texto sin formato en inglés.

  • Permite que el script de prueba se escriba sin conocimiento de ningún código, también permite la participación de no programadores.

  • Cumple el propósito de un marco de prueba de un extremo a otro a diferencia de otras herramientas.

  • Debido a la arquitectura de script de prueba simple, Cucumber proporciona reutilización de código.

En este capítulo, veremos la configuración del entorno para Cucumber con Selenium WebDriver y Java, en Windows Machine.

Requisitos previos para la configuración del entorno

Los siguientes son los requisitos previos necesarios para configurar con:

Java

Why we need- Java es un lenguaje de programación robusto. Cucumber es compatible con la plataforma Java para la ejecución.

How to install -

Step 1 - Descarga jdk y jre desde el siguiente enlace http://www.oracle.com/technetwork/java/javase/downloads/index.html

Step 2 - Aceptar contrato de licencia.

Step 3 - Instale JDK y JRE.

Step 4 - Establezca la variable de entorno como se muestra en las siguientes capturas de pantalla.

Eclipse

Why we need- Eclipse es un entorno de desarrollo integrado (IDE). Contiene un espacio de trabajo básico y un sistema de complementos extensible para personalizar el entorno.

How to install -

Step 1 - Asegúrese de que JAVA esté instalado en su máquina.

Step 2 - Descarga Eclipse desde https://eclipse.org/downloads/

Step 3 - Descomprimir y Eclipse está instalado.

Maven

Why we need- Maven es una herramienta de automatización de compilación que se utiliza principalmente para proyectos Java. Proporciona una plataforma común para realizar actividades como generar código fuente, compilar código, empaquetar código en un jar, etc. Más tarde, si alguna de las versiones del software se cambia, Maven proporciona una manera fácil de modificar el proyecto de prueba en consecuencia.

How to install -

Step 1 - Descarga Maven desde el siguiente enlace - https://maven.apache.org/download.cgi

Step 2 - Descomprime el archivo y recuerda la ubicación.

Step 3 - Cree la variable de entorno MAVEN_HOME como se muestra en la siguiente captura de pantalla.

Step 4 - Edite la variable de ruta e incluya Maven como se muestra en la siguiente captura de pantalla.

Step 5 - Descarga el complemento MAVEN de Eclipse.

Step 6 - Abre Eclipse.

Step 7 - Vaya a Ayuda → Eclipse Marketplace → Buscar Maven → Integración de Maven para Eclipse → INSTALAR.

Configurar Cucumber con Maven

Step 1 - Crea un proyecto Maven.

  • Vaya a Archivo → Nuevo → Otros → Maven → Proyecto Maven → Siguiente.

  • Proporcione la identificación del grupo (la identificación del grupo identificará su proyecto de manera única en todos los proyectos).

  • Proporcione la identificación del artefacto (la identificación del artefacto es el nombre del jar sin la versión. Puede elegir cualquier nombre, que está en minúsculas). Haga clic en Finalizar.

Step 2 - Abra pom.xml.

  • Vaya al explorador de paquetes en el lado izquierdo de Eclipse.

  • Expandir el proyecto CucumberTest.

  • Localizar pom.xml archivo.

  • Haga clic derecho y seleccione la opción, abra con "Editor de texto".

Step 3 - Agregar dependencia para el selenio: esto le indicará a Maven qué archivos jar de Selenium se descargarán del repositorio central al repositorio local.

  • Abierto pom.xml está en el modo de edición, cree la etiqueta de dependencias (<dependencies> </dependencies>), dentro de la etiqueta del proyecto.

  • Dentro de la etiqueta de dependencias, cree la etiqueta de dependencia (<dependency> </dependency>).

  • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>

Step 4 - Agregar dependencia para Cucumber-Java: esto indicará Maven, qué archivos de Cucumber se descargarán del repositorio central al repositorio local.

  • Cree una etiqueta de dependencia más.

  • Proporcione la siguiente información dentro de la etiqueta de dependencia

<dependency> 
   <groupId>info.cukes</groupId>
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

Step 5 - Agregar dependencia para Cucumber-JUnit: Esto indicará a Maven, qué archivos de Cucumber JUnit se deben descargar del repositorio central al repositorio local.

  • Cree una etiqueta de dependencia más.

  • Proporcione la siguiente información dentro de la etiqueta de dependencia

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

Step 6 - Agregar dependencia para JUnit: Esto indicará a Maven, qué archivos JUnit se deben descargar del repositorio central al repositorio local.

  • Cree una etiqueta de dependencia más.

  • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

Step 7 - Verificar binarios.

  • Una vez pom.xml se edita correctamente, guárdelo.

  • Vaya a Proyecto → Limpiar: le llevará unos minutos.

Podrá ver un repositorio de Maven como se muestra en la siguiente captura de pantalla.

  • Cree un archivo de características (que se tratará más adelante).

  • Cree un archivo de definición de pasos (que se tratará más adelante).

  • Cree un corredor JUnit para ejecutar la prueba (se tratará más adelante).

Hasta ahora, entendemos el pepino y lo que hace. Ejecuta los scripts de prueba, que se han definido en el archivo de características (que se tratarán en capítulos posteriores). El idioma en el que se escriben estos archivos de características ejecutables se conoce comoGherkin. Gherkin es un lenguaje de texto simple en inglés, que ayuda a la herramienta - Cucumber a interpretar y ejecutar los guiones de prueba.

Uno puede pensar que, se ha discutido muchas veces que Cucumber admite texto en inglés simple, entonces por qué necesitamos un idioma separado: Gherkins. La respuesta está en el concepto de desarrollo impulsado por el comportamiento.

Como se discutió anteriormente, hemos visto que BDD incorpora diferentes perspectivas al crear scripts de prueba. Puede ser prospectivo de desarrollo, prospectivo de negocios, etc. Dicho esto, necesitaremos personas de diferentes comunidades como desarrolladores, gerentes de proyectos, propietarios de productos y probadores mientras desarrollamos scripts de prueba. Como estas personas no pertenecen a la misma categoría, existe el riesgo de no utilizar el lenguaje común para la conceptualización del guión de prueba. Este fue el punto de evolución de Gherkins.

Gherkin proporciona el conjunto común de palabras clave en texto en inglés, que pueden ser utilizadas por personas de diferentes comunidades y, sin embargo, obtener el mismo resultado en forma de scripts de prueba.

Ejemplo

Feature - Funcionalidad de inicio de sesión para un sitio de redes sociales. Given Soy usuario de un sitio de redes sociales. When Ingrese el nombre de usuario como username1. And Introduzco contraseña como contraseña 1. Then Debería ser redirigido a la página de inicio del sitio.

El escenario mencionado anteriormente es de una función llamada inicio de sesión de usuario. Todas las palabras resaltadas en negrita son palabras clave de Gherkin.

Ejemplo de algunas otras palabras clave:

  • Background
  • But
  • *
  • Esquema del escenario
  • Examples

Gherkin analizará cada paso escrito en el archivo de definición de pasos (que se tratará más adelante). Por lo tanto, los pasos mencionados en el archivo de características y el archivo de definición de pasos (que se tratará más adelante) deben coincidir.

Puede ubicar los frascos de pepinillos en la carpeta Dependencia de Maven en el Explorador de paquetes. Se descarga junto con los otros frascos de pepino. Se verá como la siguiente captura de pantalla:

Otro dato interesante sobre Gherkin es que admite no solo inglés, sino muchos otros idiomas nativos como francés, finlandés, indonesio, húngaro, hindi, urdu, gujarati, etc.

UN Featurese puede definir como una unidad independiente o una funcionalidad de un proyecto. Tomemos un ejemplo muy común de un sitio de redes sociales. ¿Cómo se ve la característica de este producto / proyecto? Pocas características básicas se pueden determinar como:

  • Cree y elimine al usuario del sitio de redes sociales.

  • Funcionalidad de inicio de sesión de usuario para el sitio de redes sociales.

  • Compartir fotos o videos en el sitio de redes sociales.

  • Envío de una solicitud de amistad.

  • Logout.

A estas alturas, está claro que cada funcionalidad independiente del producto bajo prueba se puede calificar como una característica cuando hablamos de Pepino. Es una buena práctica más adelante, cuando comience a probar, que antes de derivar los scripts de prueba, debemos determinar las características que se probarán.

Una característica generalmente contiene una lista de escenarios que se probarán para esa característica. Un archivo en el que almacenamos características, descripción sobre las características y escenarios a probar se conoce comoFeature File. Veremos más acerca de los archivos de características en el siguiente capítulo.

La palabra clave para representar una característica bajo prueba en Gherkins es "Característica". La mejor práctica sugerida es escribir una pequeña descripción de la característica debajo del título de la característica en el archivo de características. Esto también satisfará la necesidad de una buena documentación.

Ejemplo

Feature - Funcionalidad de inicio de sesión para un sitio de redes sociales.

El usuario debe poder iniciar sesión en el sitio de redes sociales si el nombre de usuario y la contraseña son correctos.

Se debe mostrar el mensaje de error al usuario si el nombre de usuario y la contraseña son incorrectos.

El usuario debe navegar a la página de inicio, si el nombre de usuario y la contraseña son correctos.

Archivos de características

El archivo, en el que se escriben las pruebas de Cucumber, se conoce como feature files. Es aconsejable que haya un archivo de características separado, para cada característica bajo prueba. La extensión del archivo de características debe ser ".feature".

Se pueden crear tantos archivos de características como sea necesario. Para tener una estructura organizada, cada característica debe tener un archivo de características.

Por ejemplo:

No Señor Característica Característica Nombre de archivo
1 Inicio de sesión de usuario userLogin.feature
2 Comparte la publicación sharePost.feature
3 Crear una cuenta createAccount.feature
4 Borrar cuenta deleteAccount.feature

La convención de nomenclatura que se utilizará para el nombre de la función, el nombre del archivo de la función depende de la elección del individuo. No hay una regla básica en Pepino sobre los nombres.

Un archivo de características simple consta de las siguientes palabras clave / partes:

  • Feature - Nombre de la característica bajo prueba.

  • Description (opcional): describe la función que se está probando.

  • Scenario - Cuál es el escenario de prueba.

  • Given - Requisito previo antes de que se ejecuten los pasos de prueba.

  • When - Condición específica que debe coincidir para ejecutar el siguiente paso.

  • Then - Qué debería suceder si se cumple la condición mencionada en CUÁNDO.

Ejemplo

Feature - Inicio de sesión de usuario en el sitio de redes sociales.

El usuario debe poder iniciar sesión en el sitio de redes sociales cuando el nombre de usuario y la contraseña sean correctos.

Al usuario se le debe mostrar un mensaje de error cuando el nombre de usuario y la contraseña son incorrectos.

El usuario debe navegar a la página de inicio si el nombre de usuario y la contraseña son correctos.

Outline - Funcionalidad de inicio de sesión para un sitio de redes sociales.

El usuario dado navega a Facebook. Cuando ingreso el nombre de usuario como "<nombre de usuario>" y la contraseña como "<contraseña>". Entonces, el inicio de sesión no debería ser exitoso.

| username  | password  |
| username1 | password1 |

* AND La palabra clave se utiliza para mostrar la conjunción entre dos condiciones. AND se puede utilizar con otras palabras clave como GIVEN, WHEN y THEN.

No hay detalles lógicos escritos en el archivo de características.

Definiciones de pasos

Tenemos nuestro archivo de características listo con los escenarios de prueba definidos. Sin embargo, este no es el trabajo completo. Cucumber realmente no sabe qué fragmento de código se ejecutará para cualquier escenario específico descrito en un archivo de características.

Esto llama la necesidad de un archivo de definición de paso intermedio. El archivo de definición de pasos almacena el mapeo entre cada paso del escenario definido en el archivo de características con un código de función a ejecutar.

Entonces, ahora, cuando Cucumber ejecuta un paso del escenario mencionado en el archivo de características, escanea el archivo de definición del paso y determina qué función debe llamarse.

Ejemplo de archivo de definición de pasos

public void goToFacebook() { 
   driver = new FirefoxDriver(); 
   driver.navigate().to("https://www.facebook.com/"); 
} 
@When "^user logs in using Username as \"([^\"]*)\" and Password as \"([^\"]*)\"$" public void I_enter_Username_as_and_Password_as(String arg1, String arg2) { driver.findElement(By.id("email")).sendKeys(arg1); driver.findElement(By.id("pass")).sendKeys(arg2); driver.findElement(By.id("u_0_v")).click(); } @Then"^login should be unsuccessful$" 
public void validateRelogin() { 
   if(driver.getCurrentUrl().equalsIgnoreCase(
      "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
         System.out.println("Test Pass");
   } else { 
      System.out.println("Test Failed"); 
   } 
   driver.close(); 
}

Entonces, con cada función, cualquier código que desee ejecutar con cada paso de prueba (es decir, DADO / ENTONCES / CUANDO), puede escribirlo dentro del archivo de Definición de pasos. Asegúrese de que se haya definido el código / función para cada uno de los pasos.

Esta función puede ser funciones de Java, donde podemos usar comandos de Java y Selenium para automatizar nuestros pasos de prueba.

Scenarioes una de las estructuras centrales de Gherkin. Cada escenario comienza con la palabra clave "Escenario:" (o uno localizado) y va seguido de un título de escenario opcional. Cada característica puede tener uno o más escenarios y cada escenario consta de uno o más pasos. Un ejemplo muy simple de escenario puede ser:

Scenario - Verificar la funcionalidad de la ayuda.

El usuario dado navega a Facebook.

Cuando el usuario hace clic en Ayuda, se abre la página de Ayuda.

Considere un caso en el que necesitamos ejecutar un escenario de prueba más de una vez. Supongamos que debemos asegurarnos de que la funcionalidad de inicio de sesión funcione para todo tipo de titulares de suscripción. Eso requiere la ejecución del escenario de funcionalidad de inicio de sesión varias veces. Copiar y pegar los mismos pasos para simplemente volver a ejecutar el código, no parece ser una buena idea. Para ello, Gherkin proporciona una estructura más, que es el esquema del escenario.

El esquema del escenario es similar a la estructura del escenario; la única diferencia es la provisión de múltiples entradas. Como puede ver en el siguiente ejemplo, el caso de prueba sigue siendo el mismo y no se puede repetir. En la parte inferior, hemos proporcionado varios valores de entrada para las variables "Nombre de usuario" y "Contraseña". Mientras ejecuta la prueba real, Cucumber reemplazará la variable con los valores de entrada proporcionados y ejecutará la prueba. Una vez que se ha ejecutado el paso 1, la prueba se volverá a ejecutar para la segunda iteración con otro valor de entrada. Dicha variable o marcadores de posición se pueden representar con ”<>” mientras se mencionan con declaraciones de pepinillo.

Ejemplo

Scenario Outline- Funcionalidad de inicio de sesión para un sitio de redes sociales. El usuario dado navega a Facebook.

Cuando el usuario inicia sesión con el nombre de usuario como "<nombre de usuario>" y la contraseña como "<contraseña>", el inicio de sesión debe ser exitoso.

| username | password  | 
| user1    | password1 | 
| user2    | password2 |

Hay algunos consejos y trucos para definir inteligentemente los escenarios de Pepino.

  • Cada paso debe estar claramente definido, de modo que no cree confusión para el lector.

  • No repita el escenario de prueba; si es necesario, utilice el esquema del escenario para implementar la repetición.

  • Desarrolle un paso de prueba de manera que pueda usarse en múltiples escenarios y esquemas de escenarios.

  • En la medida de lo posible, mantenga cada paso completamente independiente. Por ejemplo: "Dado que el usuario está conectado". Esto se puede dividir en dos pasos

    • Dado que el usuario ingresa el nombre de usuario.
    • Hace clic en iniciar sesión.

Annotationes un texto predefinido, que tiene un significado específico. Le permite al compilador / intérprete saber qué se debe hacer en la ejecución. Pepino tiene las siguientes anotaciones:

  • Given -

    • Describe el requisito previo para que se ejecute la prueba.

    • Ejemplo: DADO que soy un usuario de Facebook

  • When -

    • Define el punto de activación para la ejecución de cualquier escenario de prueba.

    • Ejemplo: CUANDO ingreso "<nombre de usuario>"

  • Then -

    • Luego contiene el resultado esperado para que se ejecute la prueba.

    • Ejemplo: ENTONCES el inicio de sesión debería ser exitoso.

  • And -

    • Proporciona la condición lógica AND entre dos declaraciones. Y se puede utilizar junto con las instrucciones GIVEN, WHEN y THEN.

    • Ejemplo: CUANDO ingreso mi "<nombre de usuario>" Y mi "<contraseña>"

  • But -

    • Significa una condición lógica OR entre dos declaraciones. OR se puede utilizar junto con las instrucciones GIVEN, WHEN y THEN.

    • Ejemplo: ENTONCES el inicio de sesión debería ser exitoso. PERO no debe faltar la página de inicio.

  • Scenario -

    • Los detalles sobre el escenario bajo prueba deben capturarse después de la palabra clave "Escenario:"

    • Ejemplo -

      Guión:

      DADO Soy usuario de Facebook

      CUANDO entro en mi

      Y entro en mi

      ENTONCES el inicio de sesión debería ser exitoso.

      PERO no debe faltar la página de inicio.

  • Scenario Outline - (se tratará más adelante)

  • Examples - (se tratará más adelante)

  • Background -

    • En general, los antecedentes tienen instrucciones sobre qué configurar antes de que se ejecute cada escenario. Sin embargo, se ejecuta después del gancho "Antes" (se tratará más adelante). Así que esto es ideal para usarlo como código cuando queremos configurar el navegador web o queremos establecer la conectividad de la base de datos.

      • Ejemplo -

        Antecedentes:

        Vaya a la página de inicio de Facebook.

Escenario de ejemplo

Automaticemos un escenario para comprender mejor las anotaciones.

Step 1

Cree un proyecto de prueba de Maven con el nombre AnnotationTest.

  • Vaya a Archivo → Nuevo → Otros → Maven → Proyecto Maven → Siguiente.

  • Proporcione la identificación del grupo (la identificación del grupo identificará su proyecto de manera única en todos los proyectos).

  • Proporcione la identificación del artefacto (la identificación del artefacto es el nombre del frasco sin versión. Puede elegir cualquier nombre que esté en minúsculas).

  • Haga clic en Finalizar.

  • Abierto pom.xml −

    • Vaya al explorador de paquetes en el lado izquierdo de Eclipse.

    • Expanda el proyecto AnnotationTest.

    • Busque el archivo pom.xml.

    • Haga clic derecho y seleccione la opción Abrir con “Editor de texto”.

  • Agregar dependencia para Selenium: esto indicará Maven, qué archivos jar de Selenium se descargarán del repositorio central al repositorio local.

    • Abrir pom.xml está en modo de edición, crear etiqueta de dependencias (<dependencies> </dependencies>), dentro de la etiqueta del proyecto.

    • Dentro de la etiqueta de dependencias, cree la etiqueta de dependencia (<dependency> </dependency>).

    • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>
  • Agregar dependencia para Cucumber-Java: esto indicará Maven, qué archivos de Cucumber se descargarán desde el repositorio central al repositorio local.

    • Cree una etiqueta de dependencia más.

    • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>
  • Agregar dependencia para Cucumber-JUnit: esto indicará Maven, qué archivos de Cucumber JUnit deben descargarse del repositorio central al repositorio local.

    • Cree una etiqueta de dependencia más.

    • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>
  • Agregar dependencia para JUnit: esto indicará Maven, qué archivos JUnit deben descargarse del repositorio central al repositorio local.

    • Cree una etiqueta de dependencia más.

    • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>
  • Verifique los binarios.

    • Una vez que pom.xml se edite correctamente, guárdelo.

    • Vaya a Proyecto → Limpiar: le llevará unos minutos.

Step 2

Cree un paquete llamado Anotación en src/test/java

  • Seleccione el proyecto recién creado.

  • Haz clic derecho y selecciona 'Nuevo'.

  • Seleccione la opción como 'Paquete'.

  • Nómbrelo como 'Anotación'.

  • Guárdalo.

Step 3

Cree un archivo de características llamado annotation.feature.

  • Seleccione y haga clic con el botón derecho en el esquema del paquete.

  • Haga clic en el archivo 'Nuevo'.

  • Asigne al archivo un nombre como outline.feature.

  • Escriba el siguiente texto dentro del archivo y guárdelo.

Feature: annotation 
#This is how background can be used to eliminate duplicate steps 

Background: 
   User navigates to Facebook Given 
   I am on Facebook login page 

#Scenario with AND 
Scenario: 
   When I enter username as "TOM"
   And I enter password as "JERRY" 
   Then Login should fail 

#Scenario with BUT 
Scenario: 
   When I enter username as "TOM" 
   And I enter password as "JERRY" 
   Then Login should fail 
   But Relogin option should be available

Step 4

Cree un archivo de definición de pasos.

  • Seleccione y haga clic con el botón derecho en el esquema del paquete.

  • Haga clic en el archivo 'Nuevo'.

  • Dar el nombre del archivo como annotation.java

  • Escriba el siguiente texto dentro del archivo y guárdelo.

package Annotation; 

import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; 
import cucumber.annotation.en.When; 

public class annotation { 
   WebDriver driver = null; 
   @Given("^I am on Facebook login page$") public void goToFacebook() { driver = new FirefoxDriver(); driver.navigate().to("https://www.facebook.com/"); } @When("^I enter username as \"(.*)\"$") 
   public void enterUsername(String arg1) {   
      driver.findElement(By.id("email")).sendKeys(arg1); 
   }
	
   @When ("^I enter password as \"(.*)\"$") public void enterPassword(String arg1) { driver.findElement(By.id("pass")).sendKeys(arg1); driver.findElement(By.id("u_0_v")).click(); } @Then("^Login should fail$") 
   public void checkFail() {  
      if(driver.getCurrentUrl().equalsIgnoreCase(
         "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
            System.out.println("Test1 Pass"); 
      } else { 
         System.out.println("Test1 Failed"); 
      } 
      driver.close(); 
   } 
	
   @Then("^Relogin option should be available$") 
   public void checkRelogin() { 
      if(driver.getCurrentUrl().equalsIgnoreCase(
         "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
            System.out.println("Test2 Pass"); 
      } else { 
         System.out.println("Test2 Failed"); 
      } 
      driver.close(); 
   }
}

Step 5

Crea un archivo de clase de corredor.

  • Seleccione y haga clic con el botón derecho en el esquema del paquete.

  • Haga clic en el archivo 'Nuevo'.

  • Asigne un nombre al archivo, como runTest.java

  • Escriba el siguiente texto dentro del archivo y guárdelo.

package Annotation; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"})
 
public class runTest { 
}

Step 6

Ejecute la prueba usando la opción -

  • Seleccione el archivo runTest.java del explorador de paquetes.

  • Haga clic derecho y seleccione la opción ‘Run as’

  • Seleccione prueba JUnit.

Observará las siguientes cosas cuando ejecute este archivo de clase:

  • Facebook se abre en una nueva instancia del navegador web Firefox.

  • TOM se pasará como entrada al campo de nombre de usuario.

  • JERRY se pasará como entrada al campo de contraseña.

  • Se hará clic en iniciar sesión.

  • Se mostrará un mensaje en el navegador con respecto al inicio de sesión fallido.

  • En la consola, verá "Test Pass" impreso

  • Resultado del paso 1. a 5. Se volverá a ejecutar para el nombre de usuario como "" y la contraseña como "".

Scenario outlinebásicamente reemplaza la variable / palabras clave con el valor de la tabla. Cada fila de la tabla se considera un escenario.

Continuemos con el mismo ejemplo de la función de inicio de sesión de Facebook. Hasta ahora hemos estado ejecutando un escenario: al proporcionar el nombre de usuario correcto, el inicio de sesión es exitoso. Ahora, suponga que queremos verificar si el inicio de sesión es exitoso para los tres posibles tipos de entradas, que son nombre de usuario, dirección de correo electrónico o número de teléfono. Para lograr esto, necesitaremos escribir tres escenarios diferentes, donde cada escenario variará con el tipo de entrada, el inicio de sesión es exitoso. En este caso, los escenarios se verán como los siguientes.

Scenario:

El usuario dado navega a Facebook

Cuando ingreso el nombre de usuario y la contraseña correctos

Entonces el inicio de sesión debería ser exitoso

Scenario:

El usuario dado navega a Facebook

Cuando ingreso la dirección de correo electrónico y la contraseña correctas

Entonces el inicio de sesión debería ser exitoso

Scenario:

El usuario dado navega a Facebook

Cuando ingrese el número de teléfono y la contraseña correctos

Entonces el inicio de sesión debería ser exitoso

Aquí, si vemos de cerca, para los tres escenarios anteriores: las declaraciones son iguales, solo el parámetro de entrada (nombre de usuario / dirección de correo electrónico / número de teléfono) está cambiando. Ahí es donde entra en escena la importancia del esquema del escenario.

Cuando definimos cualquier escenario con un esquema de escenario, podemos especificar un escenario de prueba y en la parte inferior podemos proporcionar una serie de entradas. El escenario se ejecutará tantas veces como el número de entradas proporcionadas.

Ejemplo

Creemos un ejemplo de un esquema de escenario:

Step 1 - Cree un proyecto de prueba de Maven con el nombre ScenarioOutlineTest

  • Vaya a Archivo → Nuevo → Otros → Maven → Proyecto Maven → Siguiente.

  • Proporcione la identificación del grupo (la identificación del grupo identificará su proyecto de manera única en todos los proyectos).

  • Proporcione la identificación del artefacto (la identificación del artefacto es el nombre del frasco sin versión. Puede elegir cualquier nombre que esté en minúsculas).

  • Haga clic en Finalizar.

  • Abierto pom.xml -

    • Vaya al explorador de paquetes en el lado izquierdo de Eclipse.

    • Expanda el proyecto CucumberTest.

    • Busque el archivo pom.xml.

    • Haga clic derecho y seleccione la opción Abrir con “Editor de texto”.

  • Agregar dependencia para Selenium: esto indicará Maven, qué archivos jar de Selenium se descargarán del repositorio central al repositorio local.

    • Abrir pom.xml está en modo de edición, crear etiqueta de dependencias (<dependencies> </dependencies>), dentro de la etiqueta del proyecto.

    • Dentro de la etiqueta de dependencias, cree la etiqueta de dependencia (<dependency> </dependency>).

    • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>
  • Agregar dependencia para Cucumber-Java: esto indicará Maven, qué archivos de Cucumber se descargarán del repositorio central al repositorio local.

    • Cree una etiqueta de dependencia más.

    • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>
  • Agregar dependencia para Cucumber-JUnit: Esto indicará Maven, qué archivos de Cucumber JUnit se descargarán del repositorio central al repositorio local.

    • Cree una etiqueta de dependencia más.

    • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>
  • Agregar dependencia para JUnit: esto indicará Maven, qué archivos JUnit deben descargarse del repositorio central al repositorio local.

    • Cree una etiqueta de dependencia más.

    • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>
  • Agregar dependencia para JUnit: esto indicará Maven, qué archivos JUnit deben descargarse del repositorio central al repositorio local.

    • Cree una etiqueta de dependencia más.

    • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>
  • Verifique los binarios.

    • Una vez que pom.xml se edite correctamente, guárdelo.

    • Vaya a Proyecto → Limpiar: le llevará unos minutos.

Step 2 - Cree un paquete llamado "esquema" debajo src/test/java

Step 3 - Cree un archivo de características llamado “outline.feature”

  • Seleccione y haga clic con el botón derecho en el esquema del paquete.

  • Haga clic en el archivo 'Nuevo'.

  • Dé el nombre del archivo como “outline.feature”

    • Escriba el siguiente texto dentro del archivo y guárdelo.

      Feature - Esquema del escenario

      Scenario Outline - Funcionalidad de inicio de sesión para un sitio de redes sociales.

      El usuario dado navega a Facebook

      Cuando ingreso el nombre de usuario como "<nombre de usuario>" y la contraseña como "<contraseña>"

      Entonces el inicio de sesión no debería ser exitoso

Example -

| username  | password  | 
| username1 | password1 | 
| username2 | password2 |

Note- Aquí, la anotación de ejemplo describe el rango de entrada que se proporcionará en la ejecución del escenario. El escenario de prueba se ejecutará para cada una de las entradas proporcionadas. Entonces, en el ejemplo dado, el escenario de prueba se ejecutará tres veces.

Step 4 - Cree un archivo de definición de pasos.

  • Seleccione y haga clic con el botón derecho en el esquema del paquete.

  • Haga clic en el archivo 'Nuevo'.

  • Dar el nombre del archivo como stepdefinition.java

  • Escriba el siguiente texto dentro del archivo y guárdelo.

package Outline;
 
import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; 
import cucumber.annotation.en.When; 

public class stepdefinition { 
   WebDriver driver = null; 
	
   @Given("^user navigates to facebook$") 
   public void goToFacebook() { 
      driver = new FirefoxDriver(); 
      driver.navigate().to("https://www.facebook.com/"); 
   } 
	
   @When("^I enter Username as \"([^\"]*)\" and Password as \"([^\"]*)\"$") public void I_enter_Username_as_and_Password_as(String arg1, String arg2) { driver.findElement(By.id("email")).sendKeys(arg1); driver.findElement(By.id("pass")).sendKeys(arg2); driver.findElement(By.id("u_0_v")).click(); } @Then("^login should be unsuccessful$") 
   public void validateRelogin() { 
      if(driver.getCurrentUrl().equalsIgnoreCase(
      "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){
         System.out.println("Test Pass"); 
      } else { 
         System.out.println("Test Failed"); 
      } 
      driver.close(); 
   }    
}

Note- En el código anterior, tenemos que definir una función que tenga dos argumentos de entrada: un nombre de usuario y otro será para la contraseña. Entonces, para cada conjunto de entrada proporcionado en la etiqueta de ejemplo, se ejecutará el Conjunto de DADO, CUÁNDO y ENTONCES.

Step 5 - Crea un archivo de clase de corredor.

  • Seleccione y haga clic con el botón derecho en el esquema del paquete.

  • Haga clic en el archivo 'Nuevo'.

  • Dé el nombre del archivo como runTest.java

  • Escriba el siguiente texto dentro del archivo y guárdelo.

package Outline; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"})

public class runTest { }
  • Ejecute la prueba usando la opción -

    • Seleccione runTest.java archivo del explorador de paquetes.

    • Haga clic derecho y seleccione la opción ‘Run as’.

    • Seleccione prueba JUnit.

Observará las siguientes cosas cuando ejecute este archivo de clase

  • Facebook se abre en una nueva instancia del navegador web Firefox.

  • El nombre de usuario1 y la contraseña1 se pasarán como entrada al campo de nombre de usuario y contraseña.

  • Se hará clic en iniciar sesión.

  • Se mostrará un mensaje en el navegador con respecto al inicio de sesión fallido.

  • En la consola, verá impreso "Test Pass".

  • Los resultados del paso 1 a 5 se volverán a ejecutar para el nombre de usuario2 y la contraseña2.

En pocas palabras, cuando el escenario no cambia, pero solo cambia el valor de los datos, es aconsejable utilizar tablas de datos de esquema de escenario.

Parece simple cuando solo tenemos uno, dos o quizás cinco escenarios en un archivo de características. Sin embargo, en la vida real no sucede. Para cada característica bajo prueba, podemos tener 10, 20 o más escenarios en un solo archivo de características. Pueden representar diferentes propósitos (prueba de humo / prueba de regresión), diferentes prospectos (Desarrollador / QA / BA), diferentes estados (Listo para ejecución / Trabajo en progreso), etc. ¿Cómo administrar la ejecución para tal masa?

Para ello, Cucumber ya ha proporcionado una forma de organizar la ejecución de su escenario mediante el uso de etiquetas en el archivo de características. Podemos definir cada escenario con una etiqueta útil. Más tarde, en el archivo del corredor, podemos decidir qué etiqueta específica (y así como el escenario (s)) queremos que Cucumber ejecute. La etiqueta comienza con "@". Después de "@" puede tener cualquier texto relevante para definir su etiqueta. Entendamos esto con un ejemplo.

Supongamos que hay dos o más escenarios en un archivo de características. Queremos ejecutar solo un escenario como parte de la prueba de humo. Entonces, lo primero es identificar ese escenario y lo segundo es etiquetarlo con el texto "@SmokeTest" al comienzo del escenario. Echemos un vistazo a esto:

Step 1 - Crea un proyecto Maven llamado cucumberTag.

Step 2- Crea un paquete llamado cucumberTag debajo src/test/java

Step 3- Cree un archivo de características llamado cucumberTag.feature.

Escriba el siguiente texto dentro del archivo y guárdelo. Este archivo de características contiene dos escenarios en los que solo uno se ha marcado comoSmokeTest etiqueta.

Feature - Etiqueta de pepino

Scenario Outline - Funcionalidad de inicio de sesión para un sitio de redes sociales.

El usuario dado navega a Facebook

Cuando ingreso el nombre de usuario como "<nombre de usuario>" y la contraseña como "<contraseña>"

Entonces el inicio de sesión no debería ser exitoso

Ejemplos

| username  | password  | 
| username1 | password1 | 
| username2 | password2 |

El siguiente escenario ha sido etiquetado como SmokeTest y esto debería ejecutarse. @Prueba de humo

Scenario:

El usuario dado navega a Facebook

Cuando ingreso el nombre de usuario como "<>" y la contraseña como "<>"

Entonces el usuario debe ser redirigido para reintentar el inicio de sesión.

Step 4 - Cree un archivo de definición de pasos.

  • Seleccione y haga clic con el botón derecho en el esquema del paquete.

  • Haga clic en el archivo 'Nuevo'.

  • Asigne al archivo un nombre como cucumberTag.java

  • Escriba el siguiente texto dentro del archivo y guárdelo.

package cucumberTag;
 
import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; 
import cucumber.annotation.en.When; 

public class cucumberTag { 
   WebDriver driver = null; 
	
   @Given("^user navigates to facebook$") public void goToFacebook() { driver = new FirefoxDriver(); driver.navigate().to("https://www.facebook.com/"); } @When("^I enter Username as \"([^\"]*)\" and Password as \"([^\"]*)\"$") 
   public void I_enter_Username_as_and_Password_as(String arg1, String arg2) {
      driver.findElement(By.id("email")).sendKeys(arg1);
      driver.findElement(By.id("pass")).sendKeys(arg2);
      driver.findElement(By.id("u_0_v")).click(); 
   } 
	
   @Then("^login should be unsuccessful$") public void validateRelogin() { if(driver.getCurrentUrl().equalsIgnoreCase( "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ System.out.println("Test Pass"); } else { System.out.println("Test Failed"); } driver.close(); } @Then("^User should be redirected to login retry$") 
   public void loginRetry() { 
      if(driver.getCurrentUrl().equalsIgnoreCase(
         "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
            System.out.println("Test Pass"); 
      } else { 
         System.out.println("Test Failed"); 
      } 
      driver.close(); 
   } 
}

Step 5 - Crea un archivo de clase de corredor.

  • Crea una clase de corredor llamada runTest.java dentro del paquete.

  • Escribe el siguiente código.

  • Guarda el archivo.

package cucumberTag; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"}) 

public class runTest { }
  • Ejecute la opción de prueba.

  • Haga clic derecho y seleccione la opción ‘Run as’.

  • Seleccione prueba JUnit.

Observará las siguientes cosas cuando ejecute este archivo de clase.

  • Facebook se abre en una nueva instancia del navegador web Firefox.

  • No se proporcionará ningún valor al campo de nombre de usuario y contraseña.

  • Se hará clic en iniciar sesión.

  • Se cargará la página de reintento de inicio de sesión.

No hay límite para definir etiquetas dentro del archivo de características. Según sus necesidades, puede derivar las etiquetas que se utilizarán y los escenarios que se ejecutarán.

Existen principalmente dos tipos de etiquetas:

  • Default tag- La etiqueta predeterminada tiene sus significados predefinidos. Ejemplo @ Dev, @ Ignorar

  • Custom tag - La etiqueta personalizada le brinda total flexibilidad para elegir el texto apropiado para definir su etiqueta.

La etiqueta también se puede definir a nivel de función. Una vez que define una etiqueta a nivel de característica, se asegura de que todos los escenarios dentro de ese archivo de característica hereden esa etiqueta. Dependiendo de la naturaleza del escenario, podemos usar más de una etiqueta para la característica única. Siempre que Cucumber encuentre una llamada adecuada, se ejecutará un escenario específico.

El pepino también proporciona una forma de invertir la elección de etiquetas. Considere que de 25 escenarios definidos, 10 están marcados como prueba de humo. Estamos obligados a ejecutar solo escenarios de prueba de regresión.

Para esto, podemos usar “~” en la clase de corredor JUnit para excluir el escenario de prueba de humo. Se verá así.

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"}, 
   tags = {"~@SmokeTest"})
	
public class runTest { }

Al definir múltiples etiquetas, también podemos definir operaciones lógicas y / o lógicas.

  • Definición de lógica o en clase de corredor - @dev,@wip - Dice que es necesario ejecutar escenarios que coincidan con cualquiera de esta etiqueta.

  • Definición de lógica o en clase de corredor - [@dev,~@wip] − Dice que es necesario ejecutar escenarios que coincidan con ambas etiquetas.

Mientras trabajamos en la automatización, podemos enfrentar una variedad de escenarios. Cada escenario tiene un significado y unas necesidades diferentes.

Desde el principio, hemos estado tomando un ejemplo de funcionalidad de inicio de sesión para un sitio de redes sociales, donde solo teníamos que pasar dos parámetros de entrada. Pensemos en alguna posibilidad más. ¿Qué hay de la funcionalidad "Registro de nuevo usuario"? Normalmente, ¿cuáles pueden ser los parámetros de entrada al registrar un nuevo usuario en un sitio de redes sociales? Algo como lo siguiente:

  • Nombre de usuario
  • Dirección de correo electrónico
  • Password
  • Escriba la contraseña otra vez
  • Birthdate
  • Gender
  • Número de teléfono

Feature - Registro de nuevo usuario.

Verifique que el registro de nuevo usuario no sea exitoso después de pasar las entradas incorrectas.

Dado que estoy en una nueva página de registro de usuario.

Cuando ingreso el nombre de usuario y una dirección de correo electrónico como dirección de correo electrónico y contraseña como, y vuelvo a ingresar la contraseña como y Fecha de nacimiento como y Sexo como y número de teléfono, entonces el registro de usuario no debería ser exitoso.

Parece un poco desordenado a primera vista. Entonces, ¿hay alguna manera mejor de administrar tal cantidad de entradas? La respuesta puede ser "Tabla de datos". La tabla de datos es un conjunto de entradas que se proporcionarán para una sola etiqueta. Esta etiqueta puede ser GIVEN, WHEN o THEN.

Escribamos el escenario anterior con la ayuda de la tabla de datos y se verá así:

Dado que estoy en una nueva página de registro de usuario

Cuando ingreso datos válidos en la página

| Fields                 | Values              |
| First Name             | Tom                 |
| Last Name              | Kenny               |
| Email Address          | [email protected] |
| Re-enter Email Address | [email protected] |
| Password               | Password1           |
| Birthdate              | 01                  |

Entonces el registro de usuario debería ser exitoso.

Ejemplo

Automaticemos un ejemplo de una tabla de datos.

Step 1 - Cree un proyecto de prueba de Maven llamado "DataTableTest".

  • Vaya a Archivo → Nuevo → Otros → Maven → Proyecto Maven → Siguiente.

  • Proporcionar group Id (La identificación del grupo identificará su proyecto de manera única en todos los proyectos).

  • Proporcionar artifact Id (Artifact Id es el nombre del jar sin versión. Puede elegir cualquier nombre que esté en minúsculas).

  • Haga clic en Finalizar.

  • Abrir pom.xml -

    • Vaya al explorador de paquetes en el lado izquierdo de Eclipse.

    • Expanda el proyecto CucumberTest.

    • Busque el archivo pom.xml.

    • Haga clic derecho y seleccione la opción Abrir con “Editor de texto”.

  • Agregar dependencia para Selenium: esto indicará Maven, qué archivos jar de Selenium se descargarán del repositorio central al repositorio local.

    • Abrir pom.xml está en modo de edición, crear etiqueta de dependencias (<dependencies> </dependencies>), dentro de la etiqueta del proyecto.

    • Dentro de la etiqueta de dependencias, cree la etiqueta de dependencia. (<dependencia> </dependencia>).

    • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>
  • Agregar dependencia para Cucumber-Java: esto indicará Maven, qué archivos de Cucumber se descargarán desde el repositorio central al repositorio local.

    • Cree una etiqueta de dependencia más.

    • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>
  • Agregar dependencia para Cucumber-JUnit: esto indicará Maven, qué archivos de Cucumber JUnit deben descargarse del repositorio central al repositorio local.

    • Cree una etiqueta de dependencia más.

    • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>
  • Agregar dependencia para JUnit: esto indicará Maven, qué archivos JUnit deben descargarse del repositorio central al repositorio local.

    • Cree una etiqueta de dependencia más.

    • Proporcione la siguiente información dentro de la etiqueta de dependencia

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>
  • Verifique los binarios.

    • Una vez que pom.xml se edite correctamente, guárdelo.

    • Vaya a Proyecto → Limpiar: le llevará unos minutos.

Step 2 - Crea un paquete llamado dataTable debajo src/test/java

Step 3 - Cree un archivo de características.

  • Cree un archivo de características, llamado dataTable.feature dentro del paquete dataTable (consulte el esquema del escenario de la sección para conocer los pasos más detallados).

  • Escribe el siguiente texto.

    Feature - Tabla de datos

    Verifique que el registro de nuevo usuario no sea exitoso después de pasar entradas incorrectas.

    Scenario:

    Dado que estoy en la página de registro de nuevo usuario

    Cuando ingreso datos no válidos en la página

| Fields                 | Values              |
| First Name             | Tom                 |
| Last Name              | Kenny               |
| Email Address          | [email protected] |
| Re-enter Email Address | [email protected] |
| Password               | Password1           |
| Birthdate              | 01                  |

Entonces el registro de usuario no debería ser exitoso

  • Guarda el archivo.

Step 4 - Crear archivo de definición de pasos.

  • Cree el archivo de definición de pasos denominado 'dataTable.java' dentro del paquete dataTable (consulte el esquema del escenario de la sección para conocer los pasos más detallados).

  • Escribe el siguiente código.

package dataTable; 

import java.util.List; 

import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.WebElement; 
import org.openqa.selenium.firefox.FirefoxDriver; 
import org.openqa.selenium.support.ui.Select;

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; 
import cucumber.annotation.en.When; 
import cucumber.table.DataTable; 

public class stepdefinition { 
   WebDriver driver = null;
	
   @Given("^I am on new user registration page$") public void goToFacebook() { //Intiate web browser instance. driver = new FirefoxDriver(); driver.navigate().to("https://www.facebook.com/"); } @When("^I enter invalid data on the page$") 
   public void enterData(DataTable table){ 
      //Initialize data table 
      List<list> data = table.raw();
      System.out.println(data.get(1).get(1)); 
      
      //Enter data
      driver.findElement(By.name("firstname")).sendKeys(data.get(1).get(1));
      driver.findElement(By.name("lastname")).sendKeys(data.get(2).get(1));
      driver.findElement(By.name("reg_email__")).sendKeys(data.get(3).get(1));     
      driver.findElement(By.name("reg_email_confirmation__")).
         sendKeys(data.get(4).get(1)); 
      driver.findElement(By.name("reg_passwd__")).sendKeys(data.get(5).get(1)); 
      
      Select dropdownB = new Select(driver.findElement(By.name("birthday_day"))); 
      dropdownB.selectByValue("15"); 
		
      Select dropdownM = new Select(driver.findElement(By.name("birthday_month")));
      dropdownM.selectByValue("6"); 
		
      Select dropdownY = new Select(driver.findElement(By.name("birthday_year")));
      dropdownY.selectByValue("1990"); 
		
      driver.findElement(By.className("_58mt")).click(); 
      // Click submit button driver.findElement(By.name("websubmit")).click(); 
   } 
	
   @Then("^User registration should be unsuccessful$") 
   public void User_registration_should_be_unsuccessful() {
      if(driver.getCurrentUrl().equalsIgnoreCase("https://www.facebook.com/")){
         System.out.println("Test Pass"); 
      } else { 
         System.out.println("Test Failed"); 
      } 
      driver.close(); 
   } 
}
  • Guarda el archivo.

Step 5 - Crea un archivo de clase de corredor.

  • Cree una clase de corredor denominada runTest.java dentro del paquete.

  • Escribe el siguiente código.

package dataTable; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"})
 
public class runTest { }
  • Guarda el archivo.

  • Ejecute la prueba usando la opción

    • Seleccione el archivo runTest.java del explorador de paquetes.

    • Haga clic derecho y seleccione la opción Ejecutar como.

    • Seleccione prueba JUnit.

Puede observar las siguientes cosas después de una ejecución exitosa.

  • Se carga el sitio web de Facebook.

  • Los datos se ingresarán en la página de registro.

  • Se hará clic en el botón Enviar.

  • Veremos que la página de inicio no se mostrará y se escribirá "Test Pass" en la consola.

Commentes básicamente un fragmento de código destinado a la documentación y no a la ejecución. Ya sea un archivo de definición de pasos o un archivo de características, para hacerlo más legible y comprensible. Por lo tanto, es importante usar / colocar comentarios en los lugares apropiados del archivo. Esto también ayuda a depurar el código. Los archivos de características de pepino pueden tener comentarios en cualquier lugar. Para poner comentarios, solo necesitamos comenzar la declaración con el signo "#".

Los diferentes lenguajes de programación tienen diferentes normas para definir los comentarios. Veamos cómo lo maneja Pepino.

  • Archivo de definición de pasos: si está utilizando Java como plataforma, marque sus comentarios con "//".

  • Archivo de características: en el caso de un archivo de características, solo necesitamos poner # antes de comenzar su comentario.

Ejemplo

El texto resaltado en el programa se refiere a los comentarios en el código.

Feature: annotation 

#This is how background can be used to eliminate duplicate steps 
Background: 
User navigates to Facebook 
Given I am on Facebook login page 

#Scenario with AND 
Scenario: 
When I enter username as "TOM" 
And I enter password as "JERRY" 
Then Login should fail 

#Scenario with BUT 
Scenario: 
When I enter username as "TOM" 
And I enter password as "JERRY" 
Then Login should fail 
But Relogin option should be available

Pepino hooknos permite administrar mejor el flujo de trabajo del código y nos ayuda a reducir la redundancia del código. Podemos decir que es un paso invisible, que nos permite realizar nuestros escenarios o pruebas.

Para comprender mejor esta noción, tomemos un ejemplo de un archivo de características y un archivo de definición de pasos.

La parte resaltada en la declaración dada en realidad hace el trabajo de configurar el controlador web y finalizar la sesión del controlador web. Por lo tanto, en realidad no es relevante para la esencia de la "declaración dada", y es más como una configuración para la prueba. Además, si pensamos con una perspectiva más amplia, entonces, en el caso de múltiples escenarios para esta función, esta configuración y limpieza del controlador web se ejecutará con cada declaración dada. Lógicamente, tiene sentido que la configuración y la limpieza se ejecuten solo una vez.

Entonces, para brindar optimización, se pueden utilizar ganchos. Más a menudo utilizamos dos tipos de anzuelos: anzuelo “antes” y anzuelo “después”. El método / función / fragmento de código, definido en los ganchos Antes y Después, siempre se ejecuta, incluso si el escenario pasa o falla.

Como sugiere el nombre, antes de que el gancho se ejecute mucho antes que cualquier otro escenario de prueba, y después del gancho se ejecute después de ejecutar todos los escenarios.

Los ganchos se definen solo en el archivo de definición de pasos.

Automaticemos un ejemplo de gancho antes y después.

Step 1 - Cree el proyecto Maven como hookTest, agregue la dependencia necesaria en pom.xml.

Step 2 - Cree un paquete de Java llamado hookTest en src/test/java

Step 3 - Cree un archivo de definición de pasos con el nombre hookTest.java debajo del paquete.

package hookTest; 

import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; 
import cucumber.annotation.en.When; 

public class hookTest {
   WebDriver driver = null; 
	
   @Before public void setUp(){ 
      driver = new FirefoxDriver(); 
   } 
	
   @Given("^user navigates to facebook$") 
   public void goToFacebook() { 
      driver.navigate().to("https://www.facebook.com/");
   } 
	
   @When("^I enter Username as \"([^\"]*)\" and Password as \"([^\"]*)\"$") public void I_enter_Username_as_and_Password_as(String arg1, String arg2) { driver.findElement(By.id("email")).sendKeys(arg1); driver.findElement(By.id("pass")).sendKeys(arg2); driver.findElement(By.id("u_0_v")).click(); } @Then("^login should be unsuccessful$") 
   public void validateRelogin() { 
      if(driver.getCurrentUrl().equalsIgnoreCase(
         "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
            System.out.println("Test Pass"); 
      } else { 
         System.out.println("Test Failed"); 
      } 
      driver.close(); 
   } 
	
   @After public void cleanUp(){ 
      driver.close(); 
   } 
}

Step 4 - Cree un archivo de características llamado "hookTest.feature" en el paquete.

Feature - Esquema del escenario.

Scenario Outline - Prueba de gancho

El usuario dado navega a Facebook

Cuando ingreso el nombre de usuario como "<nombre de usuario>" y la contraseña como "<contraseña>"

Entonces el inicio de sesión no debería ser exitoso

Ejemplos

| username  | password  | 
| username1 | password1 |

Step 5 - Crea un archivo de clase de corredor.

  • Cree la clase de corredor como runTest.java dentro del paquete dataTable (consulte el esquema del escenario de la sección para conocer los pasos más detallados).

  • Escribe el siguiente código.

package hookTest; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"})  

public class runTest { }
  • Guarda el archivo.

  • Ejecute la prueba usando la opción -

    • Seleccione el archivo runTest.java del explorador de paquetes.

    • Haga clic derecho y seleccione la opción Ejecutar como.

    • Seleccione prueba JUnit.

Entonces, cuando ejecutemos esto, la siguiente será la secuencia de ejecución.

  • Antes del enganche: configure el controlador web y otros requisitos previos para ejecutar la prueba.

  • Declaración dada

  • Cuando declaración

  • Entonces declaración

  • Después del gancho: cierre el controlador web y realice el proceso de limpieza.

Ganchos etiquetados

También podemos indicar si queremos que los ganchos de antes y después se ejecuten solo con una etiqueta específica. Example- @Before ('@ Web'). El mismo concepto de etiqueta lógica y / o también se puede aplicar con ganchos.Example - @Before (@ dev, @ wip), @Before (@ dev, ~ @ wip)

El pepino se puede utilizar para probar casi cualquier sistema informático. Hasta ahora hemos visto cómo ejecutar una prueba usando Eclipse IDE. Hay una forma más a través de la cual podemos ejecutar la prueba de Cucumber que es a través de la interfaz de línea de comandos. Entonces, ¿cuál es la ventaja de hacerlo?

Ejecutar cualquier marco de prueba desde la Terminal tiene sus propias ventajas, como anular las configuraciones de ejecución mencionadas en el código.

Para ejecutar la prueba Cucumber con el símbolo del sistema, siga los siguientes pasos después de la configuración del sistema.

Step 1- Cree un proyecto de prueba de Maven llamado commandLine.

  • Vaya a Archivo → Nuevo → Otros → Maven → Proyecto Maven → Siguiente.

  • Proporcione la identificación del grupo (la identificación del grupo identificará su proyecto de manera única en todos los proyectos).

  • Proporcione la identificación del artefacto (la identificación del artefacto es el nombre del frasco sin versión. Puede elegir cualquier nombre que esté en minúsculas).

  • Haga clic en Finalizar.

  • Abrir pom.xml -

    • Vaya al explorador de paquetes en el lado izquierdo de Eclipse.

    • Expanda el proyecto CucumberTest.

    • Localizar pom.xml archivo.

    • Haga clic derecho y seleccione la opción Abrir con “Editor de texto”.

  • Agregar dependencia para Selenium: esto indicará Maven, qué archivos jar de Selenium se descargarán del repositorio central al repositorio local.

    • Abrir pom.xml está en modo de edición, crear etiqueta de dependencias (<dependencies> </dependencies>), dentro de la etiqueta del proyecto.

    • Dentro de la etiqueta de dependencias, cree la etiqueta de dependencia. (<dependencia> </dependencia>).

    • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>
  • Agregar dependencia para Cucumber-Java: esto indicará Maven, qué archivos de Cucumber se descargarán desde el repositorio central al repositorio local.

    • Cree una etiqueta de dependencia más.

    • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>
  • Agregar dependencia para Cucumber-JUnit: esto indicará Maven, qué archivos de Cucumber JUnit deben descargarse del repositorio central al repositorio local.

    • Cree una etiqueta de dependencia más.

    • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>
  • Agregar dependencia para JUnit: esto indicará Maven, qué archivos JUnit deben descargarse del repositorio central al repositorio local.

    • Cree una etiqueta de dependencia más.

    • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>
  • Verifique los binarios.

    • Una vez que pom.xml se edite correctamente, guárdelo.

    • Vaya a Proyecto → Limpiar - Tardará unos minutos.

Step 2 - Cree un paquete llamado "esquema" en src / test / java

Step 3 - Cree un archivo de características llamado "commandLine.feature".

  • Seleccione y haga clic con el botón derecho en el esquema del paquete.

  • Haga clic en el archivo 'Nuevo'.

  • Asigne al archivo un nombre como "commandLine.feature"

  • Escriba el texto debajo del archivo y guárdelo.

    Feature - Esquema del escenario

    Scenario Outline - Funcionalidad de inicio de sesión para un sitio de redes sociales.

    Dado que el usuario navega a Facebook

    Cuando ingreso el nombre de usuario como "<nombre de usuario>" y la contraseña como "<contraseña>"

    Entonces el inicio de sesión no debería ser exitoso

Ejemplos

| username  | password  | 
| username1 | password1 | 
| username2 | password2 |

Note- Aquí, la anotación de ejemplo describe el rango de entrada que se proporcionará en la ejecución del escenario. El escenario de prueba se ejecutará para cada una de las entradas proporcionadas. Entonces, en el ejemplo dado, el escenario de prueba se ejecutará tres veces.

Step 4 - Cree un archivo de definición de pasos.

  • Seleccione y haga clic con el botón derecho en el esquema del paquete.

  • Haga clic en el archivo 'Nuevo'.

  • Nombra el archivo como commandLine.java

  • Escriba el siguiente texto dentro del archivo y guárdelo.

package Outline; 

import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; i
import cucumber.annotation.en.When; 

public class stepdefinition { 
   WebDriver driver = null;
	
   @Given("^user navigates to facebook$") public void goToFacebook() { driver = new FirefoxDriver(); driver.navigate().to("https://www.facebook.com/"); } @When("^I enter Username as \"([^\"]*)\" and Password as \"([^\"]*)\"$") 
   public void I_enter_Username_as_and_Password_as(String arg1, String arg2) {
      driver.findElement(By.id("email")).sendKeys(arg1);
      driver.findElement(By.id("pass")).sendKeys(arg2);
      driver.findElement(By.id("u_0_v")).click(); 
   } 
	
   @Then("^login should be unsuccessful$") 
   public void validateRelogin() { 
      if(driver.getCurrentUrl().equalsIgnoreCase(
         "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
            System.out.println("Test Pass"); 
      } else { 
         System.out.println("Test Failed"); 
      } 
      driver.close(); 
   } 
}

Note- En código, tenemos que definir una función que tenga dos argumentos de entrada: un nombre de usuario y otro será para contraseña. Por lo tanto, para cada conjunto de entrada proporcionado en la etiqueta de ejemplo, se ejecutará el conjunto de GIVEN, WHEN y THEN.

Step 5 - Crea un archivo de clase de corredor.

  • Seleccione y haga clic con el botón derecho en el esquema del paquete.

  • Haga clic en el archivo 'Nuevo'.

  • Asigne al archivo un nombre como, runTest.java

  • Escriba el siguiente texto dentro del archivo y guárdelo.

package Outline; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"}) 

public class runTest { }
  • Abra un símbolo del sistema.

  • Vaya al directorio donde reside este paquete "commandLine". e: \ Workspace \ LoginTest \ src> cd test \ java

  • Ejecute el comando mvn test: Verá que se han ejecutado todos los escenarios descritos en el archivo de características (si no hay ningún error). Finalmente, en la parte inferior encontrarás la siguiente información.

Resultado

This describes the total test run, along with failure if any.

El comando anterior ejecuta todo como se menciona en la clase JUnit Runner. Sin embargo, si queremos anular las configuraciones mencionadas en el Runner, a continuación se muestran algunos ejemplos para hacerlo.

  • Ahora ejecute el comando mvn test - Dcucumber.options = "- help" en el símbolo del sistema. Ejecutar esto imprimirá todas las opciones disponibles.

  • Para ejecutar solo las etiquetas específicas, ejecute el comando mvn test -Dcucumber.options = "- tags @SmokeTest" en el símbolo del sistema. Solo ejecutará etiquetas, que están marcadas con @SmokeTest.

  • Para cambiar el formato del resultado, ejecute el comando E: \ Workspace \ LoginTest> mvn test -Dcucumber.options = "- plugin junit: target / cucumber-junit-report.xml" en el símbolo del sistema Cambia el informe formato al generador de informes JUnit.

Es importante comprender qué es Junit, antes de comenzar nuestra discusión sobre Cucumber JUnit Runner. JUnites un marco de prueba unitario de código abierto para el lenguaje de programación Java. JUnit ha sido importante en el desarrollo del desarrollo impulsado por pruebas y forma parte de una familia de marcos de pruebas unitarias, que se conocen colectivamente como xUnit que se originó con SUnit.

Beneficios de usar JUnit

  • La unidad tiene un Graphical User Interface (GUI), lo que permite escribir y probar el código fuente de forma rápida y sencilla.

  • JUnit permite al desarrollador crear conjuntos de pruebas de forma incremental para medir el progreso y detectar efectos secundarios no deseados.

  • La prueba se puede ejecutar de forma continua.

  • JUnit muestra el progreso de la prueba en una barra que normalmente es verde pero se vuelve roja cuando falla una prueba.

A estas alturas, hemos visto los beneficios de usar JUnit, pero la razón por la que lo estamos discutiendo ahora es el marco de Cucumber. Por un lado, Cucumber proporciona una forma para que las personas no técnicas definan casos de prueba para un producto y, por otro lado, nuestra expectativa es la ejecución sin problemas y oportuna de dichos casos de prueba.

JUnit actúa como un puente entre estos dos. Entonces, el flujo de ejecución se verá así:

  • Las partes interesadas escriben el archivo de características.

  • El archivo de definición de pasos se creará en consecuencia.

  • Especifique la clase de ejecución JUnit para ejecutar la serie de casos de prueba.

  • Una vez que ejecutamos la clase de corredor JUnit -

    • Analizará el archivo de características de Gherkin.

    • Ejecutará las funciones escritas en el archivo de definición de pasos de acuerdo con las declaraciones del archivo de características.

    • JUnit combinará el resultado del caso de prueba.

    • Construirá el informe de prueba en el formato especificado (que puede ser html / JSON).

El punto importante aquí es cómo configurar JUnit para hacer todas estas cosas. Los siguientes son los pasos:

Step 1 - Instale Java.

  • Descarga jdk y jre desde el enlace http://www.oracle.com/technetwork/java/javase/downloads/index.html

  • Acepta el contrato de licencia.

  • Instale JDK y JRE.

  • Establezca la variable de entorno como se muestra en la siguiente captura de pantalla.

Step 2 - Instala Eclipse.

  • Why we need- Eclipse es un entorno de desarrollo integrado (IDE). Contiene un espacio de trabajo básico y un sistema de complementos extensible para personalizar el entorno.

  • How to install -

    • Asegúrese de que JAVA esté instalado en su máquina.

    • Descarga Eclipse desde http://www.eclipse.org/downloads

    • Descomprima y Eclipse está instalado.

Step 3 - Instala Maven.

  • Why we need- Maven es una herramienta de automatización de compilación que se utiliza principalmente para proyectos Java. Proporciona una plataforma común para realizar actividades como generar código fuente, compilar código, empaquetar código en un jar, etc. También más adelante, si alguna de las versiones del software cambia, Maven proporciona una manera fácil de modificar el proyecto de prueba en consecuencia.

  • How to install -

    • Descarga Maven - https://maven.apache.org/download.cgi

    • Descomprima el archivo y recuerde la ubicación.

    • Cree la variable de entorno MAVEN_HOME como se muestra en la siguiente captura de pantalla.

  • Edite la variable Path e incluya Maven como se muestra en la siguiente captura de pantalla.

  • Descargue el complemento MAVEN de Eclipse.

    • Abra Eclipse.

    • Ir a Ayuda → Eclipse Marketplace → Buscar maven → Integración de Maven para Eclipse → INSTALAR.

Step 4 - Cómo configurar Cucumber con Maven

  • Cree un proyecto de Maven en Eclipse.

    • Vaya a Archivo → Nuevo → Otros → Maven → Proyecto Maven → Siguiente.

    • Proporcione la identificación del grupo (la identificación del grupo identificará su proyecto de manera única en todos los proyectos).

    • Proporcione la identificación del artefacto (la identificación del artefacto es el nombre del frasco sin versión. Puede elegir cualquier nombre que esté en minúsculas).

    • Haga clic en Finalizar.

  • Abrir pom.xml

    • Vaya al explorador de paquetes en el lado izquierdo de Eclipse.

    • Expanda el proyecto CucumberTest.

    • Busque el archivo pom.xml.

    • Haga clic derecho y seleccione la opción Abrir con “Editor de texto”.

  • Agregar dependencia para Selenium: esto indicará Maven, qué archivos jar de Selenium se descargarán del repositorio central al repositorio local.

    • Abrir pom.xml está en modo de edición, crear etiqueta de dependencias (<dependencies> </dependencies>), dentro de la etiqueta del proyecto.

    • Dentro de la etiqueta de dependencias, cree la etiqueta de dependencia. (<dependencia> </dependencia>).

    • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>
  • Agregar dependencia para Cucumber-Java: esto indicará Maven, qué archivos de Cucumber se descargarán desde el repositorio central al repositorio local.

    • Cree una etiqueta de dependencia más.

    • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>
  • Agregar dependencia para Cucumber-JUnit: Esto indicará Maven, qué archivos de Cucumber JUnit se descargarán del repositorio central al repositorio local.

    • Cree una etiqueta de dependencia más.

    • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>
  • Agregar dependencia para JUnit: esto indicará Maven, qué archivos JUnit deben descargarse del repositorio central al repositorio local.

    • Cree una etiqueta de dependencia más.

    • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>
  • Verificar binarios

    • Una vez pom.xml se edita correctamente, guárdelo.

    • Vaya a Proyecto → Limpiar: le llevará unos minutos.

    • Después de eso, podrá ver un repositorio de Maven como la siguiente captura de pantalla.

Step 5 - Crear archivo de características (se tratará más adelante).

Step 6 - Cree un archivo de definición de pasos (se tratará más adelante).

Step 7 - Cree un corredor Junit para ejecutar la prueba (se tratará más adelante).

Realizamos pruebas de ejecución para comprender la estabilidad de un producto, por lo que ya sea una prueba manual o una prueba automatizada, es muy importante generar un informe conciso que pueda representar la estabilidad de un producto. Por lo tanto, mientras automatizamos nuestro escenario de prueba con Cucumber, es esencial saber qué tan mejor podemos generar nuestros informes de prueba de Cucumber. Como sabemos que Cucumber es un marco BDD, no tiene un mecanismo de informes elegante.

Para lograr esto, necesitamos integrar Cucumber con otra herramienta de código abierto como Ant / Junit. Aquí, tomaremos más ejemplos de JUnit porque proporciona soporte para el lenguaje Java.

Veamos los detalles de los diferentes formatos de informes, que están disponibles y son fáciles de usar:

Formato bonito (informe HTML)

Pretty Format genera el informe de prueba de Cucumber en formato HTML, es decir, un archivo HTML. Es el formato de informe más legible. Genera el informe de la misma manera que un archivo de características, por lo que el seguimiento también es sencillo. Además, puede especificar la ubicación donde desea que se coloque este informe después de la ejecución de la prueba. Puede ser

  • Local Directory - Podemos especificar el directorio de destino para el informe como cualquier directorio local de la máquina donde se ejecutará la prueba.

  • Server Directory- También tenemos una disposición para especificar un directorio de destino como cualquier directorio en el servidor, que es de acceso público. Esto generalmente ayuda cuando queremos que nuestros clientes / partes interesadas vean los resultados de la prueba en un momento dado.

Ejemplo

Automaticemos un ejemplo de un formato bonito.

Step 1 - Crea un proyecto Maven llamado cucumberReport en Eclipse.

Step 2 - Crea un paquete llamado CucumberReport debajo src/test/java

Step 3 - Cree un archivo de características llamado cucumberReport.feature

Escriba el siguiente texto dentro del archivo y guárdelo.

Feature - Informe Pepino

# Esto es para verificar el resultado de la prueba para el caso de prueba Pass

Scenario: Existe la funcionalidad de inicio de sesión

Dado que he abierto el navegador

Cuando abro el sitio web de Facebook

Entonces el botón Iniciar sesión debería existir

# Esto es para verificar el resultado de la prueba para el caso de prueba fallido

Scenario: Existe la contraseña olvidada

Dado que he abierto el navegador

Cuando abro el sitio web de Facebook

Entonces debería existir el enlace de contraseña olvidada

Note- Aquí el primer escenario pasará, mientras que el segundo escenario fallará. Para que podamos presenciar cómo se ve el informe aprobado y fallido.

Step 4 - Cree un archivo de definición de pasos.

  • Seleccione y haga clic con el botón derecho en el esquema del paquete.

  • Haga clic en el archivo 'Nuevo'.

  • Dar el nombre del archivo como cucumberReport.java

  • Escriba el siguiente texto dentro del archivo y guárdelo.

package CucumberReport; 

import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; 
import cucumber.annotation.en.When; 

public class cucumberReport { 
   WebDriver driver = null;
	
   @Given("^I have open the browser$") 
   public void openBrowser() { 
      driver = new FirefoxDriver();
   } 
	
   @When("^I open Facebook website$") public void goToFacebook() { driver.navigate().to("https://www.facebook.com/"); } @Then("^Login button should exits$") 
   public void loginButton() { 
      if(driver.findElement(By.id("u_0_v")).isEnabled()) { 
         System.out.println("Test 1 Pass"); 
      } else { 
         System.out.println("Test 1 Fail");
      }
   } 
	
   @Then("^Forgot password link should exist$") 
   public void forgotPWD() { 
      if(driver.findElement(By.id("")).isEnabled()) { 
         System.out.println("Test 1 Pass"); 
      } else {
         System.out.println("Test 1 Fail");
      } 
   } 
}

Step 5 - Crea un archivo de clase de corredor.

  • Crea una clase de corredor llamada runTest.java dentro del paquete.

  • Escribe el siguiente código. Guarda el archivo.

package CucumberReport; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options( 
   format = {"pretty", "html:target/Destination"} ) 
//Specifying pretty as a format option ensure that HTML report will be generated. 
//When we specify html:target/Destination - It will generate the HTML report 

inside the Destination folder, in the target folder of the maven project.
 
public class runTest { }
  • Ejecute la prueba usando la opción

    • Seleccione runTest.java archivo del explorador de paquetes.

    • Haga clic derecho y seleccione la opción, Run as.

    • Seleccione prueba JUnit.

Observará las siguientes cosas cuando ejecute este archivo de clase.

Ambos escenarios se ejecutarán uno por uno.

Se creará una carpeta denominada Destino dentro del directorio de destino.

El informe se denominará allí como "Index.html".

Abra Index.html con el navegador web.

Verá el informe mencionado en la siguiente imagen:

Destaca exactamente el color del escenario fallido. Además, verá resaltado por paso fallido en ese escenario. Esto hace que la depuración sea muy sencilla.

Informe JSON

A estas alturas hemos visto lo fácil que es el informe HTML. Sin embargo, si queremos pasar la información de este informe a cualquier otra aplicación, es un poco complicado en el caso de los informes HTML. Aquí surge la necesidad de otro formato de informe. La notación de objetos de script JSON-Java es otro formato para generar informes de prueba de Cucumber. JSON es un objeto que contiene mucha información almacenada en formato de texto. Los informes JSON aportan un valor diferente a la mesa. El informe JSON también se puede utilizar como una carga útil de información que se transferirá entre diferentes servidores. Además, puede usarse para mostrarse como una página web. En pocas palabras, otras aplicaciones pueden utilizar los informes JSON.

What is payload information?Cuando se envían datos a través de Internet, cada unidad transmitida incluye tanto la información del encabezado como los datos reales que se envían. El encabezado identifica el origen y el destino del paquete, mientras que los datos reales se conocen como carga útil. Para generar un informe JSON, solo necesitamos realizar un cambio en el archivo del corredor.

  • Cambie la opción de formato en el archivo del corredor de la siguiente manera.

package CucumberReport; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options( format={"json:target/Destination/cucumber.json"}) 

//When we specify json:target/Destination/cucumber.json - It will generate the JSON  
report inside the Destination folder, in the target folder of the maven project.

public class runTest {}
  • Ejecute la prueba usando la opción -

    • Seleccione runTest.java archivo del explorador de paquetes.

    • Haga clic derecho y seleccione la opción Run as.

    • Seleccione prueba JUnit.

  • Observará las siguientes cosas cuando ejecute este archivo de clase.

    • Ambos escenarios se ejecutarán uno por uno.

  • El informe se nombrará allí como cucumber.json (según lo previsto en la clase de corredor).

  • Abierto cucumber.json archivo con el editor de texto.

  • Verá el informe mencionado en la siguiente captura de pantalla después de colocar saltos de línea:

Note - JSON es menos legible en comparación con el formato de informe HTML.

Es muy probable que su prueba falle debido a razones desconocidas. Identificar la causa de la falla y corregirla es muy importante. Este proceso se conoce comodebugging. A continuación se presentan algunos consejos y trucos que facilitan un poco la depuración de Cucumber.

La opción de depuración está disponible con Eclipse. Coloque el punto de quiebre. Haga clic en el archivo y depure siguiendo los siguientes pasos:

Step 1 - Coloque los puntos de interrupción manuales en el archivo de definición de pasos de Ruby.

Ejemplo

require 'ruby-debug' 
Then /^the process should exit cleanly$/ do 
breakpoint 
assert @exited_cleanly, "Process did not exit cleanly: #{@stdout}" 
end

Step 2 - También podemos definir un paso de depuración separado como el siguiente en el archivo de definición de pasos.

Then /^I debug$/ do 
breakpoint 
0 
end

Step 3 - Webrates la herramienta predeterminada para probar pepinos con Rails. Le permite hacer cosas como hacer clic en enlaces, escribir y enviar formularios, etc.

Habrá ocasiones en las que intente hacer clic en algo, por ejemplo, y no está allí. Obtendrá una gran cantidad de HTML rechazado, y descubrir qué significa eso exactamente puede ser una verdadera molestia.

save_and_open_page

Webrat proporciona un método save_and_open_page que captura el HTML actual, lo guarda y luego lo abrirá en un navegador. Extremadamente útil.

When /^I follow "(.*)"$/ do |link| 
save_and_open_page 
click_link(link) 
end

Para ejecutar la prueba de Cucumber con Java, los siguientes son los pasos.

Step 1 - Instalar Java -

  • Descarga jdk y jre desde

    http://www.oracle.com/technetwork/java/javase/downloads/index.html

  • Acepta el contrato de licencia.

  • Instale JDK y JRE.

  • Establezca la variable de entorno como se muestra en la siguiente imagen.

Step 2 - Instale Eclipse IDE -

  • Asegúrese de que JAVA esté instalado en su máquina.

  • Descarga Eclipse desde https://eclipse.org/downloads/

  • Descomprimir y Eclipse instalado.

Step 3 - Instalar Maven -

  • Descarga Maven -https://maven.apache.org/download.cgi

  • Descomprima el archivo y recuerde la ubicación.

  • Cree la variable de entorno MAVEN_HOME como se muestra en la siguiente imagen.

  • Edite la variable Path e incluya Maven.

  • Descargar el complemento MAVEN de Eclipse

    • Abra Eclipse.

    • Ir a Ayuda → Eclipse Marketplace → Buscar maven → Integración de Maven para Eclipse → INSTALAR

Step 4 - Configura Cucumber con Maven.

  • Cree un proyecto de Maven.

    • Vaya a Archivo → Nuevo → Otros → Maven → Proyecto Maven → Siguiente.

    • Proporcione la identificación del grupo (la identificación del grupo identificará su proyecto de manera única en todos los proyectos).

    • Proporcione la identificación del artefacto (la identificación del artefacto es el nombre del frasco sin versión. Puede elegir cualquier nombre que esté en minúsculas).

    • Haga clic en Finalizar.

Step 5 - Abrir pom.xml -

  • Vaya al explorador de paquetes en el lado izquierdo de Eclipse.

  • Expanda el proyecto CucumberTest.

  • Busque el archivo pom.xml.

  • Haga clic derecho y seleccione la opción Abrir con “Editor de texto”.

Step 6 - Agregar dependencia para Selenium: esto indicará Maven, qué archivos jar de Selenium se descargarán del repositorio central al repositorio local.

  • Abrir pom.xml está en modo de edición, crear etiqueta de dependencias (<dependencies> </dependencies>), dentro de la etiqueta del proyecto.

  • Dentro de la etiqueta de dependencias, cree la etiqueta de dependencia. (<dependencia> </dependencia>)

  • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>

Step 7 - Agregar dependencia para Cucumber-Java: esto indicará Maven, qué archivos de Cucumber se descargarán del repositorio central al repositorio local.

  • Cree una etiqueta de dependencia más.

  • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

Step 8 - Agregar dependencia para Cucumber-JUnit: esto indicará a Maven, qué archivos de Cucumber JUnit se descargarán del repositorio central al repositorio local.

  • Cree una etiqueta de dependencia más.

  • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

Step 9- Agregar dependencia para JUnit: esto indicará Maven, qué archivos JUnit se descargarán desde el repositorio central al repositorio local.

  • Cree una etiqueta de dependencia más.

  • Proporcione la siguiente información dentro de la etiqueta de dependencia.

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

Step 10 - Verificar binarios.

  • Una vez que pom.xml se edite correctamente, guárdelo.

  • Vaya a Proyecto → Limpiar: le llevará unos minutos.

  • Podrás ver un repositorio de Maven.

Step 11 - Crea un paquete debajo src/test/java nombrado como cucumberJava.

Step 12 - Crear archivo de características

  • Seleccione y haga clic con el botón derecho en el esquema del paquete.

  • Haga clic en el archivo 'Nuevo'.

  • Asigne al archivo un nombre como cucumberJava.feature.

  • Escriba el siguiente texto dentro del archivo y guárdelo.

    Feature: PepinoJava

    Scenario: Existe la funcionalidad de inicio de sesión

    Dado que he abierto el navegador

    Cuando abro el sitio web de Facebook

    Entonces el botón Iniciar sesión debería salir

Step 13 - Crear archivo de definición de pasos -

  • Seleccione y haga clic con el botón derecho en el esquema del paquete.

  • Haga clic en el archivo 'Nuevo'.

  • Asigne al nombre del archivo un nombre como annotation.java.

  • Escriba el siguiente texto dentro del archivo y guárdelo.

package CucumberJava; 
import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; 
import cucumber.annotation.en.When; 

public class cucumberJava { 
   WebDriver driver = null; 
   @Given("^I have open the browser$") public void openBrowser() { driver = new FirefoxDriver(); } @When("^I open Facebook website$") 
   public void goToFacebook() { 
      driver.navigate().to("https://www.facebook.com/"); 
   } 
   @Then("^Login button should exits$") 
   public void loginButton() { 
      if(driver.findElement(By.id("u_0_v")).isEnabled()) { 
         System.out.println("Test 1 Pass"); 
      } else { 
         System.out.println("Test 1 Fail"); 
      } 
      driver.close(); 
   } 
}

Step 14 - Crea un archivo de clase de corredor.

  • Seleccione y haga clic con el botón derecho en el esquema del paquete.

  • Haga clic en el archivo 'Nuevo'.

  • Dar el nombre del archivo como runTest.java.

  • Escriba el siguiente texto dentro del archivo y guárdelo.

package cucumberJava; 
import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"}) 
public class runTest { 
}

Step 15 - Ejecute la prueba usando la opción -

  • Seleccione el archivo runTest.java del explorador de paquetes.

  • Haga clic derecho y seleccione la opción, Run as.

  • Seleccione prueba JUnit.

Observará las siguientes cosas después de la ejecución:

  • Se abrirá una instancia del navegador web Firefox.

  • Abrirá la página de inicio de sesión de Facebook en el navegador.

  • Detectará el botón de inicio de sesión.

  • El navegador se cerrará.

  • En la ventana JUnit, verá un escenario con una marca de verificación verde, que indica el éxito de la ejecución de la prueba.

El lenguaje Ruby tiene las siguientes ventajas:

  • Es fácil de entender.

  • Es un lenguaje orientado a objetos.

  • Es una poderosa biblioteca de clases.

  • Tiene soporte online masivo.

A continuación se muestra el proceso paso a paso de cómo funciona Cucumber con Ruby.

Step 1 - Instala Ruby.

  • Vaya a la página de descarga de RubyInstaller.

  • Descargue la versión que mejor se adapte a su sistema operativo (es decir, 32 o 64 bits).

  • Ejecute el archivo exe descargado.

  • Durante la instalación, marque la opción “Agregar Ruby…” y “Asociar…”, como se muestra en la siguiente imagen.

Step 2 - Descarga y extrae el kit de desarrollo.

  • Vaya a la página de descarga de RubyInstaller.

  • Descargue la versión de Devkit que mejor se adapte a su sistema operativo (es decir, 32 o 64 bits).

  • Extraiga el devkit en la carpeta c: \ Ruby \ Devkit.

  • Abra el símbolo del sistema.

  • Dentro del devkit de Ruby, ejecute el siguiente comando.

C:\Ruby\devkit> ruby dk.rb init 
C:\Ruby\devkit> ruby dk.rb install

Step 3 - Instale Pepino y otras gemas Ruby.

  • Para instalar Cucumber, primero actualice la configuración actual de la gema

C:\Users\Admin> gem update –system
  • A continuación, instale las gemas que necesita para las pruebas web de Cucumber.

C:\Users\Admin> gem install --no-ri --no-rdoc rspec 
C:\Users\Admin> gem install --no-ri --no-rdoc win32console 
C:\Users\Admin> gem install --no-ri --no-rdoc watir-webdriver 
C:\Users\Admin> gem install --no-ri --no-rdoc cucumber
  • Ejecutar pepino

C:\Users\Admin\Documents>cucumber –init 
C:\Users\Admin\Documents>cucumber

Step 4 - Instale IDE - KOMODO.

  • Ir a la pagina http://www.activestate.com/komodo-ide/downloads

  • Descargue el instalador de prueba gratuito.

  • Haga doble clic en el archivo ejecutable descargado.

  • Siga los pasos de instalación.

  • Finalice la instalación y abra el IDE.

Step 5 - Instalar Watir - Vaya al símbolo del sistema y ejecute el siguiente comando, "gem install watir"

Step 6 - Instalar rspec - Vaya al símbolo del sistema y ejecute el siguiente comando, "gem install rspec"

Step 7 - Crear archivo de características.

  • Abra el editor KOMODO.

  • Haga clic en el icono de nuevo archivo.

  • Escribe el siguiente texto.

    Feature: Los usuarios deben poder buscar contenido mediante Google.

    Scenario: Busque un término.

    Dado que he entrado "watir" en la consulta.

    Cuando hago clic "search"

    Entonces debería ver algunos resultados

  • Hacer clic save icono.

  • Dé el nombre como CucumberRuby.feature.

  • Elija cualquier carpeta, por ejemplo: “e:\WithRuby”

  • Guarda el archivo.

Step 8 - Crear archivo de definición de pasos.

  • Abra el editor KOMODO.

  • Haga clic en el icono de archivo 'Nuevo'.

  • Escribe el siguiente código.

require "watir-webdriver" 
require "rspec/expectations" 

Given /^I have entered "([^"]*)" into the query$/ do |term| 
@browser ||= Watir::Browser.new :firefox 
@browser.goto "google.com" 
@browser.text_field(:name => "q").set term 
end 

When /^I click "([^"]*)"$/ do |button_name| @browser.button.click end Then /^I should see some results$/ do 
@browser.div(:id => "resultStats").wait_until_present 
@browser.div(:id => "resultStats").should exist 
@browser.close 
End
  • Haga clic en el icono de guardar.

  • Dar el nombre como CucumberRuby.rb

  • Elija cualquier carpeta, por ejemplo: “e:\WithRuby”

  • Guarda el archivo.

Step 9 - Cree el archivo de prueba.

  • Abra el editor KOMODO.

  • Haga clic en el icono de archivo 'Nuevo'.

  • Escribe el siguiente código.

require "rubygems" 
require "test/unit" 
require "watir-webdriver" 

class GoogleSearch < Test::Unit::TestCase 
def setup 
@browser ||= Watir::Browser.new :firefox 
end 

def teardown 
@browser.close 
end 

def test_search 
@browser.goto "google.com" 
@browser.text_field(:name => "q").set "watir" 
@browser.button.click 
@browser.div(:id => "resultStats").wait_until_present assert 
@browser.title == "watir - Google Search" 
end 
end
  • Haga clic en el icono Guardar.

  • Nombra el archivo como test.rb y elija cualquier carpeta, por ejemplo: "e: \ WithRuby"

  • Guarda el archivo.

Step 10 - Ejecute el archivo de características.

  • Vaya al símbolo del sistema.

  • Ir al directorio e:\WithRuby

  • Ejecute el siguiente comando.

e:\With Ruby>ruby test.rb

Observará las siguientes cosas después de la ejecución:

  • Se abrirá una instancia del navegador web.

  • Se cargará la página web de Google.com.

  • Buscar texto watir será ingresado.

  • Se colocará el botón de búsqueda.

  • Los resultados de la búsqueda se mostrarán en la página web.

  • La instancia del navegador se cerrará.