A veces nuestras pruebas automatizadas en Selenium necesitan profundizar un poco más. Algunas veces, necesitamos validar algo más que el camino feliz. Pero en otras ocasiones, necesitamos hacer pruebas negativas. Esta es una tarea fácil para una mente humana, pero ¿cómo le decimos a un guión que descubra cómo reacciona algo cuando sucede lo inesperado? Eso es lo que cubriremos hoy en este artículo.

PRUEBAS NEGATIVAS

En primer lugar, necesitamos saber qué es la prueba negativa. Según SmartBear, una prueba negativa garantiza que la aplicación bajo prueba, puede manejar acciones inválidas con gracia. En otras palabras, las pruebas negativas verifican qué sucede cuando las cosas salen mal.

Algunas pruebas negativas son más fáciles de implementar que otras. La mayoría de las veces, esta tendrá que validar cuando aparece un error si el usuario hace algo que se considera no válido. Es fácil de encontrar con Selenium y no debería ser un dolor de cabeza. ¿Pero qué sucede cuando quieres asegurarte de que algo no aparezca? Digamos que hay un componente visual que actualmente no está en el DOM y que quiere asegurarse de que no se muestre. Ahí es donde se pone difícil.

Hoy veremos algunas formas de hacer pruebas negativas con Selenium, incluido ese escenario complicado. Para este artículo, usaremos el sitio web de Instagram. Vamos a crear algunas pruebas negativas para ello.

Otra cosa que vale la pena señalar es que usaremos el Modelo de Objetos de Página como se muestra en este tutorial . Si algo sobre las muestras de abajo parece confuso, por favor revise este tutorial

PRUEBAS DE LÍMITE DE CARÁCTER

Existen 2 formas en que se puede implementar un límite de caracteres en un sitio web. Pueden mostrar un error cuando el usuario excede el límite de caracteres, o pueden evitar que el usuario escriba una vez que alcancen el límite. Dado que el enfoque de “mostrar un error” se verifica de la misma manera, independientemente de este, nos centraremos en cómo probar si el sitio realmente impide que el usuario escriba una vez que alcance el límite.

Si echamos un vistazo más de cerca al campo de nombre de usuario de Instagram. El usuario solo puede ingresar 30 caracteres.

La idea de esto es que localizaremos la carpeta  de Nombre de Usuario, le enviaremos más de 50 caracteres y luego capturaremos sus datos para verificar si el campo contiene más de 30 caracteres o no. Así que vamos a hacer esto paso a paso.

Pasos

1. 1. Primero, necesitamos ubicar el elemento en nuestro objeto de página. Haremos esto con el siguiente código:

      import pytest as pytest
      from selenium.webdriver.common.by import By
      from selenium.webdriver.support import expected_conditions as EC
      from selenium.webdriver.support.wait import WebDriverWait
      
      
      class SignUpPage:
      
          def __init__(self, driver):
              self.driver = driver
              .
              .
              .
              self.username_textbox = WebDriverWait(self.driver.instance, 5).until(
                  EC.visibility_of_element_located((
                      By.NAME, "username")))
              .
              .
              .

   2. Ahora tenemos que enviarle caracteres. Crearemos un método en nuestro Objeto de Página para enviar las claves a WebElement. Luego llamaremos a este método desde nuestro archivo de Caso de Prueba.

      import pytest as pytest
      from selenium.webdriver.common.by import By
      from selenium.webdriver.support import expected_conditions as EC
      from selenium.webdriver.support.wait import WebDriverWait
      
      
      class SignUpPage:
      
          def __init__(self, driver):
              self.driver = driver
              .
              .
              .
              self.username_textbox = WebDriverWait(self.driver.instance, 5).until(
                  EC.visibility_of_element_located((
                      By.NAME, "username")))
              .
              .
              .
      
          def write_username(self, username):
              self.username_textbox.send_keys(username)

      Nuestro archivo de Caso de Prueba se verá así a estas alturas.

      import unittest
      
      from pageobjects.sign_up_page import SignUpPage
      from values import strings
      from webdriver import Driver
      
      
      class TestInstagram(unittest.TestCase):
      
          def setUp(self):
              self.driver = Driver()
              self.driver.navigate(strings.base_url)
      
          def test_verify_username_character_limit(self):
              sign_up_page = SignUpPage(self.driver)
              sign_up_page.write_username(strings.long_username)

      Nuestro archivo de cadena que puede ver en el código, es solo un archivo con todas las cadenas que usaremos en nuestro código. Por el momento esto es lo que parece.

      base_url= "https://www.instagram.com/?hl=en"
      long_username = "cbalsdhblsdahfvlsdahbflksadjbfcbalsdhblsdahfvlsdahbflksadjbf"

   3. Ahora que tenemos nuestro elemento y parte de nuestra prueba, debemos escribir el método que validará si el campo tiene el límite de caracteres implementado o no. Haremos esto obteniendo el atributo “valor” del cuadro de texto del nombre de usuario. Luego afirmando si el recuento es igual a lo que necesitamos.

      import pytest as pytest
      from selenium.webdriver.common.by import By
      from selenium.webdriver.support import expected_conditions as EC
      from selenium.webdriver.support.wait import WebDriverWait
      
      
      class SignUpPage:
      
          def __init__(self, driver):
              self.driver = driver
              self.username_textbox = WebDriverWait(self.driver.instance, 5).until(
                  EC.visibility_of_element_located((
                      By.NAME, "username")))
              
          def write_username(self, username):
              self.username_textbox.send_keys(username)
      
          def verify_character_count(self, count):
              character_count = len(self.username_textbox.get_attribute('value'))
              assert character_count == count, "Character count is not equal to " + str(count)

      Así es como se vería nuestra prueba ahora.

          def test_verify_username_character_limit(self):
              sign_up_page = SignUpPage(self.driver)
              sign_up_page.write_username(strings.long_username)
              sign_up_page.verify_character_count(30)

   4. Ahora podemos ejecutar nuestra prueba con el siguiente comando y funcionará bien.

FALTA DE PRUEBAS DE CAMPOS REQUERIDOS

La mayoría de los formularios tratan los campos obligatorios de una de las dos maneras. O bien muestran al usuario en tiempo real que falta un campo una vez que lo pasan, o muestran los errores una vez que el usuario envía el formulario. Cualquiera que sea, se valida de la misma manera desde el punto de vista de Selenium. En este caso, veremos un caso de un formulario que muestra el error después de que el usuario envía el formulario.

Ejecutaremos este escenario negativo escribiendo información no válida en el campo “Número de teléfono móvil o correo electrónico”, dejando solo el resto de los campos y luego haz clic en el botón “Siguiente”.

Pasos

1. Primero, necesitamos ubicar nuestro elemento en el objeto de página. Haremos esto agregando el elemento web a nuestro objeto de página:

           self.mobile_or_email_textbox = WebDriverWait(self.driver.instance, 5).until(
               EC.visibility_of_element_located((
                   By.NAME, "emailOrPhone"))

2. Ahora tenemos que enviar personajes a este campo. Al igual que en el escenario anterior, necesitaremos un método en nuestro objeto de página que escriba en el elemento Web y un método en nuestro caso de prueba. Para esto agregaremos este método a nuestro objeto de página:

       def write_email_or_phone(self, email_or_phone):
           self.mobile_or_email_textbox.send_keys(email_or_phone)

   Luego agregaremos esto a nuestro caso de prueba:

       def test_verify_required_fields(self):
           sign_up_page = SignUpPage(self.driver)
           sign_up_page.write_email_or_phone(strings.invalid_email)

3. El tercer paso es agregar el método que validará que el error está presente. En este caso, el error se muestra con un <span> cuya clase es ” coreSpriteInputError gBp1f “. Lo que haremos es eso, ya que este error aparece en varios campos y no tiene un especificador único, lo haremos por cuenta. Sabemos que en este escenario debemos obtener 3 errores. Esto dependerá del sitio que estés probando. También necesitaremos un método que haga clic en el botón ” Siguiente ” para que aparezcan los errores. Para esto necesitaremos agregar estos métodos a nuestro objeto de página:

       def click_next_button(self):
           self.next_button.click()
   
       def verify_form_errors(self, count):
           form_errors = WebDriverWait(self.driver.instance, 5).until(
               EC.visibility_of_all_elements_located((
                   By.CLASS_NAME, "coreSpriteInputError")))
           assert len(form_errors) == count, "The amount of errors is not equal to " + str(count)

   Nuestro caso de prueba ahora se verá así:

       def test_verify_required_fields(self):
           sign_up_page = SignUpPage(self.driver)
           sign_up_page.write_email_or_phone(strings.invalid_email)
           sign_up_page.click_next_button()
           sign_up_page.verify_form_errors(3)

4. ¡Ahora todo lo que tenemos que hacer es ejecutar nuestra prueba y verla pasar!

python3 -m pytest testcases/test_instagram.py -k test_verify_required_fields

FALTAN PRUEBAS DE COMPONENTES DE LA INTERFAZ DE USUARIO

Un buen ejemplo de este caso es que cuando abrimos este sitio de Instagram desde un navegador que nunca lo ha abierto (como la sesión limpia que comienza Selenium para cada prueba), no queremos ver la pantalla de inicio de sesión . Pero, ¿cómo podemos confirmar esto a través de la automatización?

La cosa es que Selenium no puede buscar algo que no está presente en el DOM. Entonces, ¿cómo verifica si algo no existe? Bueno, buscándolo y dejando que la búsqueda falle. Lo complicado de esto es que cuando la búsqueda falla, obtendremos una excepción y nuestra prueba fallará. La solución para esto es manejar esa excepción y si obtenemos lo que esperamos, entonces continuamos con nuestra prueba.

Pasos

1. En este caso, estaremos escribiendo directamente el método que hará la validación. La idea es que intentaremos encontrar un botón con el texto “Iniciar sesión” y, si no podemos encontrarlo, lo marcaremos como aprobado. Si lo encontramos, haremos una afirmación y lo marcaremos como fallido con un mensaje. Para esto, necesitamos agregar este método a nuestro objeto de página:

       def verify_login_button_is_not_present(self):
           try:
               login_button = WebDriverWait(self.driver.instance, 5).until(
                   EC.visibility_of_element_located((
                       By.XPATH, "//button[text() = 'Log in']")))
               assert False, "Login button was found when it was not supposed to."
           except TimeoutException:
               assert True, "Login button was not found, as expected."

   Y esto a nuestros Casos de Prueba:

       def test_login_button_is_not_present(self):
           sign_up_page = SignUpPage(self.driver)
           sign_up_page.verify_login_button_is_not_present()

2. Ahora, solo tenemos que ejecutar nuestro caso de prueba.

python3 -m pytest testcases/test_instagram.py -k test_login_button_is_not_present

Y con esto, hemos terminado! Si desea consultar el código fuente, puede encontrarlo aquí

Autor: Mike Arias
Ingeniero Senior de Pruebas de Software en TechAID.
Twitter: @theqaboy
Blog: qaboy.com/