Objetos de la pagina con Selenium

Este capítulo es una introducción tutorial al patrón de diseño de objetos de la página. Un objeto de página representa un área en la interfaz de usuario de la aplicación web que su prueba está interactuando.

Ventajas de usar el patrón de objeto de página:

• Creación de código reutilizable que puede compartirse en múltiples casos de prueba
• Reducir la cantidad de código duplicado
• Si la interfaz de usuario cambia, el arreglo necesita cambios en un solo lugar.

Caso de prueba

Este es un caso de prueba que busca una palabra en el sitio web python. org y se asegura de que se encuentren algunos resultados.

import unittest
from selenium import webdriver
import page

class PythonOrgSearch(unittest.TestCase):
    """Una clase de prueba de muestra para mostrar cómo funciona el objeto de página."""

    def setUp(self):
        self.driver = webdriver.Firefox(executable_path=r'C:\Users...añade tu ruta del... \geckodriver.exe')
        self.driver.get("http://www.python.org")

    def test_search_in_python_org(self):
        #Prueba la función de búsqueda de python.org. 
        #Busca la palabra "pycon" y luego verifica que aparecen algunos resultados.
        #Tenga en cuenta que no busca ningún texto en particular en la página de resultados de búsqueda. 
        #Esta prueba verifica que los resultados no estaban vacíos. 

        #Cargar la página principal. En este caso la página de inicio de Python.org.
        main_page = page.MainPage(self.driver)
        #Comprueba si la palabra "Python" está en el título
        assert main_page.is_title_matches(), "python.org titulo no es."
        #Establece el texto del cuadro de texto de búsqueda en "pycon"
        main_page.search_text_element = "pycon"
        main_page.click_go_button()
        search_results_page = page.SearchResultsPage(self.driver)
        #Verifica que la página de resultados no esté vacía.
        assert search_results_page.is_results_found(), "No results found."

    def tearDown(self):
        self.driver.close()

if __name__ == "__main__":
    unittest.main()

Clases de objeto de página

El patrón de objeto de página intenta crear un objeto para cada página web. Siguiendo esta técnica se crea una capa de separación entre el código de prueba y la implementación técnica.

La page.py se verá así:

from element import BasePageElement
from locators import MainPageLocators

class SearchTextElement(BasePageElement):
    """Esta clase obtiene el texto de búsqueda del localizador especificado."""

    #El localizador para el cuadro de búsqueda donde se ingresa la cadena de búsqueda
    locator = 'q'


class BasePage(object):
    #Clase base para inicializar la página base que será llamada desde todas las páginas

    def __init__(self, driver):
        self.driver = driver


class MainPage(BasePage):
    """Los métodos de acción de la página de inicio vienen aquí. Es decir. Python.org"""

    #Declara una variable que contendrá el texto recuperado.
    search_text_element = SearchTextElement()

    def is_title_matches(self):
        """Verifica que el texto codificado "Python" aparezca en el título de la página."""
        return "Python" in self.driver.title

    def click_go_button(self):
        """hace la busqueda"""
        element = self.driver.find_element(*MainPageLocators.GO_BUTTON)
        element.click()


class SearchResultsPage(BasePage):
    """Los métodos de acción de la página de resultados de búsqueda vienen aquí."""

    def is_results_found(self):
        #Probablemente debería buscar este texto en la página específica
        #elemento, pero en cuanto a ahora funciona bien
        return "No resultado encontrado." not in self.driver.page_source

Elementos de página

El elemento.py se verá así

from selenium.webdriver.support.ui import WebDriverWait


class BasePageElement(object):
    """Clase de página base que se inicializa en cada clase de objeto de página."""

    def __set__(self, obj, value):
        """Establece el texto al valor suministrado."""
        driver = obj.driver
        WebDriverWait(driver, 100).until(
            lambda driver: driver.find_element_by_name(self.locator))
        driver.find_element_by_name(self.locator).clear()
        driver.find_element_by_name(self.locator).send_keys(value)

    def __get__(self, obj, owner):
        """Obtiene el texto del objeto especificado."""
        driver = obj.driver
        WebDriverWait(driver, 100).until(
            lambda driver: driver.find_element_by_name(self.locator))
        element = driver.find_element_by_name(self.locator)
        return element.get_attribute("value")

Localizadores

Una de las prácticas es separar las cadenas del localizador del lugar donde se utilizan. En este ejemplo, los localizadores de la misma página pertenecen a la misma clase.

Los locators.py se verán así:

from selenium.webdriver.common.by import By

class MainPageLocators(object):
    #Una clase para localizadores de páginas principales. Todos los localizadores de la página principal deberían venir aquí.
    GO_BUTTON = (By.ID, 'submit')

class SearchResultsPageLocators(object):
    #Una clase para los localizadores de resultados de búsqueda. Todos los localizadores de resultados de búsqueda deberían venir aquí.
    pass

➡ ¡Felicidades por llegar hasta aquí con nosotros! ? pasa a la sigiente lección del curso de Selenium con Python en el que implementaremos ejemplos usando la red social Facebook.

Curso de Selenium con Python