Modelo de objeto de página (POM) con Page Factory | Tutorial de selenio

page object model with page factory selenium tutorial

Este tutorial en profundidad explica todo sobre el modelo de objetos de página (POM) con ejemplos de uso de Pagefactory. También puede aprender la implementación de POM en Selenium:

En este tutorial, entenderemos cómo crear un modelo de objetos de página utilizando el enfoque de Page Factory. Nos centraremos en:

• Clase de fábrica
• Cómo crear un POM básico usando Page Factory Pattern
• Diferentes anotaciones utilizadas en el enfoque de fábrica de páginas

Antes de ver qué es Pagefactory y cómo se puede usar junto con el modelo de objetos de página, comprendamos qué es el modelo de objetos de página, que comúnmente se conoce como POM.

=> Visite aquí para ver la serie de capacitación sobre selenio para todos.

Lo que vas a aprender:

• ¿Qué es el modelo de objetos de página (POM)?
  • Entendiendo POM con el ejemplo
  • ¿Por qué utilizamos el modelo de objetos de página?
  • Implementación de POM simple en selenio
    • # 1) Escenario para automatizar
    • # 2) Scripts de selenio para el escenario anterior en POM
• ¿Qué es Pagefactory?
• POM usando Page Factory
  • Tutoriales en video - POM con Page Factory
  • Pasos para crear POM usando el patrón de fábrica de páginas
  • Capa de página
  • Pasos para crear POM con ejemplo en tiempo real
  • Capa de prueba
  • Jerarquía de tipos de anotación utilizada para declarar elementos web
    • # 1) @FindBy
    • # 2) @FindBys
    • # 3) @FindAll
    • # 4) @CacheLookUp
  • Más sobre PageFactory.initElements ()
• Preguntas frecuentes
• Conclusión
  • Lectura recomendada

¿Qué es el modelo de objetos de página (POM)?

Las terminologías teóricas describen la Modelo de objeto de página como un patrón de diseño utilizado para construir un repositorio de objetos para los elementos web disponibles en la aplicación bajo prueba. Pocos otros se refieren a él como un marco para la automatización de Selenium para la aplicación dada bajo prueba.

Sin embargo, lo que he entendido sobre el término Modelo de objeto de página es:

#1) Es un patrón de diseño en el que tiene un archivo de clase Java separado correspondiente a cada pantalla o página de la aplicación. El archivo de clase podría incluir el repositorio de objetos de los elementos de la interfaz de usuario, así como los métodos.

#2) En caso de que haya elementos web enormes en una página, la clase de repositorio de objetos para una página se puede separar de la clase que incluye métodos para la página correspondiente.

Ejemplo: Si la página Registrar cuenta tiene muchos campos de entrada, entonces podría haber una clase RegisterAccountObjects.java que forma el repositorio de objetos para los elementos de la interfaz de usuario en la página de registro de cuentas.

Se podría crear un archivo de clase independiente RegisterAccount.java que extienda o herede RegisterAccountObjects que incluya todos los métodos que realizan diferentes acciones en la página.

#3) Además, podría haber un paquete genérico con un archivo {roperties, datos de prueba de Excel y métodos comunes en un paquete.

Ejemplo: DriverFactory que se puede utilizar muy fácilmente en todas las páginas de la aplicación

Entendiendo POM con el ejemplo

Controlar Aquí para obtener más información sobre POM.

A continuación se muestra una instantánea de la página web:

Al hacer clic en cada uno de estos enlaces, el usuario se redirigirá a una nueva página.

Aquí está la instantánea de cómo se construye la estructura del proyecto con Selenium utilizando el modelo de objetos Page correspondiente a cada página del sitio web. Cada clase de Java incluye un repositorio de objetos y métodos para realizar diferentes acciones dentro de la página.

Además, habrá otro JUNIT o TestNG o un archivo de clase Java que invoca llamadas a archivos de clase de estas páginas.

¿Por qué utilizamos el modelo de objetos de página?

Hay un rumor sobre el uso de este poderoso marco de Selenium llamado POM o modelo de objetos de página. Ahora, la pregunta surge como '¿Por qué utilizar POM?'.

La respuesta simple a esto es que POM es una combinación de marcos modulares e híbridos impulsados ​​por datos. Es un enfoque para organizar sistemáticamente los scripts de tal manera que facilita que el control de calidad mantenga el código libre de problemas y también ayuda a prevenir el código redundante o duplicado.

Por ejemplo, si hay un cambio en el valor del localizador en una página específica, entonces es muy fácil identificar y realizar ese cambio rápido solo en el script de la página respectiva sin afectar el código en otra parte.

Usamos el concepto de Modelo de objeto de página en Selenium Webdriver por las siguientes razones:

1. Se crea un repositorio de objetos en este modelo POM. Es independiente de los casos de prueba y se puede reutilizar para un proyecto diferente.
2. La convención de nomenclatura de los métodos es muy fácil, comprensible y más realista.
3. En el modelo de objetos de página, creamos clases de página que se pueden reutilizar en otro proyecto.
4. El modelo de objetos Page es fácil para el marco desarrollado debido a sus diversas ventajas.
5. En este modelo, se crean clases separadas para diferentes páginas de una aplicación web como la página de inicio de sesión, la página de inicio, la página de detalles del empleado, la página de cambio de contraseña, etc.
6. Si hay algún cambio en cualquier elemento de un sitio web, solo necesitamos realizar cambios en una clase y no en todas las clases.
7. El script diseñado es más reutilizable, legible y fácil de mantener en el enfoque del modelo de objetos de página.
8. Su estructura de proyecto es bastante sencilla y comprensible.
9. Puede usar PageFactory en el modelo de objetos de página para inicializar el elemento web y almacenar elementos en la caché.
10. TestNG también se puede integrar en el enfoque del Modelo de objetos de página.

Implementación de POM simple en selenio

# 1) Escenario para automatizar

Ahora automatizamos el escenario dado usando el Modelo de objetos de página.

El escenario se explica a continuación:

Paso 1: Inicie el sitio 'https: //demo.vtiger.com'.
Paso 2: Ingrese la credencial válida.
Paso 3: Inicie sesión en el sitio.
Paso 4: Verifique la página de inicio.
Paso 5: Cierre la sesión del sitio.
Paso 6: Cierre el navegador.

# 2) Scripts de selenio para el escenario anterior en POM

Ahora creamos la estructura POM en Eclipse, como se explica a continuación:

Paso 1: Cree un proyecto en Eclipse - Estructura basada en POM:

a) Crear proyecto “Modelo de objetos de página”.

b) Cree 3 paquetes bajo el proyecto.

• Biblioteca
• paginas
• Casos de prueba

Biblioteca: Debajo de esto, colocamos los códigos que necesitan ser llamados una y otra vez en nuestros casos de prueba, como el inicio del navegador, capturas de pantalla, etc. El usuario puede agregar más clases en función de la necesidad del proyecto.

Paginas: Bajo esto, las clases se crean para cada página en la aplicación web y pueden agregar más clases de página según el número de páginas en la aplicación.

Casos de prueba: Debajo de esto, escribimos el caso de prueba de inicio de sesión y podemos agregar más casos de prueba según sea necesario para probar toda la aplicación.

c) Las clases de los Paquetes se muestran en la siguiente imagen.

Paso 2: Cree las siguientes clases en el paquete de la biblioteca.

Browser.java: En esta clase, se definen 3 navegadores (Firefox, Chrome e Internet Explorer) y se llama en el caso de prueba de inicio de sesión. Según el requisito, el usuario también puede probar la aplicación en diferentes navegadores.

ScreenShot.java: En esta clase, se escribe un programa de captura de pantalla y se llama en el caso de prueba cuando el usuario desea tomar una captura de pantalla de si la prueba falla o pasa.

Paso 3 : Cree clases de página en el paquete de páginas.

HomePage.java: Esta es la clase de página de inicio, en la que se definen todos los elementos y métodos de la página de inicio.

LoginPage.java: Esta es la clase de página de inicio de sesión, en la que se definen todos los elementos de la página de inicio de sesión y los métodos.

Paso 4: Cree casos de prueba para el escenario de inicio de sesión.

LoginTestCase.java: Esta es la clase LoginTestCase, donde se ejecuta el caso de prueba. El usuario también puede crear más casos de prueba según la necesidad del proyecto.

Paso 5: Ejecute 'LoginTestCase.java'.

Paso 6: Salida del modelo de objetos de página:

• Inicie el navegador Chrome.
• El sitio web de demostración se abre en el navegador.
• Inicie sesión en el sitio de demostración.
• Verifique la página de inicio.
• Cierre la sesión del sitio.
• Cierre el navegador.

Ahora, exploremos el concepto principal de este tutorial que llama la atención, es decir, “Pagefactory”.

¿Qué es Pagefactory?

PageFactory es una forma de implementar el 'Modelo de objetos de página'. Aquí, seguimos el principio de separación del repositorio de objetos de página y los métodos de prueba. Es un concepto incorporado de Page Object Model que está muy optimizado.

Tengamos ahora más claridad sobre el término Pagefactory.

#1) En primer lugar, el concepto llamado Pagefactory, proporciona una forma alternativa en términos de sintaxis y semántica para crear un repositorio de objetos para los elementos web en una página.

#2) En segundo lugar, utiliza una estrategia ligeramente diferente para la inicialización de los elementos web.

#3) El repositorio de objetos para los elementos web de la interfaz de usuario se puede construir usando:

• 'POM sin Pagefactory' habitual y,
• Alternativamente, puede utilizar 'POM con Pagefactory'.

A continuación se muestra una representación pictórica del mismo:

Ahora veremos todos los aspectos que diferencian el POM habitual de POM con Pagefactory.

a) La diferencia en la sintaxis de localizar un elemento usando POM habitual vs POM con Pagefactory.

Por ejemplo , Haga clic en Aquí para localizar el campo de búsqueda que aparece en la página.

POM sin Pagefactory:

# 1) A continuación se muestra cómo ubica el campo de búsqueda utilizando el POM habitual:

# 2) El siguiente paso pasa el valor 'inversión' al campo de búsqueda NSE.

POM usando Pagefactory:

#1) Puede localizar el campo de búsqueda utilizando Pagefactory como se muestra a continuación.

La anotación @FindBy se utiliza en Pagefactory para identificar un elemento, mientras que POM sin Pagefactory utiliza el driver.findElement () método para localizar un elemento.

La segunda declaración de Pagefactory después @FindBy está asignando un tipo de WebElement clase que funciona exactamente de manera similar a la asignación de un nombre de elemento de tipo WebElement class como tipo de retorno del método driver.findElement () que se utiliza en el POM habitual (searchNSETxt en este ejemplo).

Miraremos el @FindBy anotaciones en detalle en la próxima parte de este tutorial.

#2) El siguiente paso pasa el valor 'inversión' al campo de búsqueda NSE y la sintaxis sigue siendo la misma que la del POM habitual (POM sin Pagefactory).

b) La diferencia en la estrategia de Inicialización de Elementos Web usando POM habitual vs POM con Pagefactory.

Usando POM sin Pagefactory:

A continuación se muestra un fragmento de código para establecer la ruta del controlador de Chrome. Se crea una instancia de WebDriver con el nombre del controlador y ChromeDriver se asigna al 'controlador'. El mismo objeto controlador se utiliza para iniciar el sitio web de la Bolsa de Valores Nacional, ubicar el cuadro de búsqueda e ingresar el valor de la cadena en el campo.

El punto que deseo resaltar aquí es que cuando es POM sin fábrica de páginas, la instancia del controlador se crea inicialmente y cada elemento web se inicializa nuevamente cada vez que hay una llamada a ese elemento web usando driver.findElement () o driver .findElements ().

Esta es la razón por la que, con un nuevo paso de driver.findElement () para un elemento, la estructura DOM se examina nuevamente y se actualiza la identificación del elemento en esa página.

Usando POM con Pagefactory:

Además de usar la anotación @FindBy en lugar del método driver.findElement (), el siguiente fragmento de código se usa adicionalmente para Pagefactory. El método estático initElements () de la clase PageFactory se usa para inicializar todos los elementos de la interfaz de usuario en la página tan pronto como se carga la página.

La estrategia anterior hace que el enfoque de PageFactory sea ligeramente diferente del POM habitual. En el POM habitual, el elemento web debe inicializarse explícitamente, mientras que en el enfoque de Pagefactory todos los elementos se inicializan con initElements () sin inicializar explícitamente cada elemento web.

Por ejemplo: Si el WebElement se declaró pero no se inicializó en el POM habitual, se produce el error 'initialize variable' o NullPointerException. Por lo tanto, en el POM habitual, cada WebElement debe inicializarse explícitamente. PageFactory viene con una ventaja sobre el POM habitual en este caso.

No inicialicemos el elemento web BDate (POM sin Pagefactory), puede ver que se muestra el error 'Inicializar variable' y solicita al usuario que la inicialice en nulo, por lo tanto, no puede asumir que los elementos se inicializan implícitamente al ubicarlos.

Elemento BDate inicializado explícitamente (POM sin Pagefactory):

Ahora, veamos un par de casos de un programa completo que usa PageFactory para descartar cualquier ambigüedad en la comprensión del aspecto de implementación.

Ejemplo 1:

• Vaya a 'http://www.nseindia.com/'
• En el menú desplegable junto al campo de búsqueda, seleccione 'Derivados de divisas'.
• Busque 'USDINR'. Verifique el texto 'Dólar estadounidense-Rupia india - USDINR' en la página resultante.

Estructura del programa:

• PagefactoryClass.java que incluye un repositorio de objetos que utiliza el concepto de fábrica de páginas para nseindia.com que es un constructor para inicializar todos los elementos web, se crea el método selectCurrentDerivative () para seleccionar el valor del campo desplegable del cuadro de búsqueda, selectSymbol () para seleccionar un símbolo en el página que aparece a continuación y verifytext () para verificar si el encabezado de la página es el esperado o no.
• NSE_MainClass.java es el archivo de clase principal que llama a todos los métodos anteriores y realiza las acciones respectivas en el sitio NSE.

PagefactoryClass.java

NSE_MainClass.java

Ejemplo 2:

• Vaya a 'https://www.shoppersstop.com/brands'
• Vaya al enlace Haute curry.
• Verifique si la página de Haute Curry contiene el texto 'Comenzar algo nuevo'.

Estructura del programa

• shopperstopPagefactory.java que incluye un repositorio de objetos usando el concepto pagefactory para shoppersstop.com que es un constructor para inicializar todos los elementos web se crea, los métodos closeExtraPopup () para manejar un cuadro emergente de alerta que se abre, haga clic en OnHauteCurryLink () para hacer clic en Haute Curry Vincula y verificaStartNewSomething () para verificar si la página de Haute Curry contiene el texto 'Comenzar algo nuevo'.
• Shopperstop_CallPagefactory.java es el archivo de clase principal que llama a todos los métodos anteriores y realiza las acciones respectivas en el sitio NSE.

shopperstopPagefactory.java

Shopperstop_CallPagefactory.java

POM usando Page Factory

Tutoriales en video - POM con Page Factory

Parte I

Parte II

Una clase Factory se utiliza para simplificar y facilitar el uso de Page Objects.

• Primero, necesitamos encontrar los elementos web por anotación. @FindBy en clases de página .
• Luego, inicialice los elementos usando initElements () al crear una instancia de la clase de página.

#1) @FindBy:

La anotación @FindBy se usa en PageFactory para ubicar y declarar los elementos web usando diferentes localizadores.Aquí, pasamos el atributo así como su valor usado para ubicar el elemento web a la anotación @FindBy y luego se declara el WebElement.

Hay dos formas en las que se puede utilizar la anotación.

Por ejemplo:

Sin embargo, la primera es la forma estándar de declarar WebElements.

'Cómo' es una clase y tiene variables estáticas como ID, XPATH, CLASSNAME, LINKTEXT, etc.
'usando' - Asignar un valor a una variable estática.

En lo de arriba ejemplo , hemos utilizado el atributo 'id' para localizar el elemento web 'Correo electrónico'. De manera similar, podemos usar los siguientes localizadores con las anotaciones @FindBy:

• nombre de la clase
• css
• nombre
• xpath
• tagName
• Texto del enlace
• parcialLinkText

# 2) initElements ():

InitElements es un método estático de la clase PageFactory que se utiliza para inicializar todos los elementos web ubicados por la anotación @FindBy. Por lo tanto, instanciar las clases de Page fácilmente.

También debemos entender que POM sigue los principios de OOPS.

• Los elementos web se declaran como variables miembro privadas (ocultación de datos).
• Vinculación de WebElements con los métodos correspondientes (encapsulación).

Pasos para crear POM usando el patrón de fábrica de páginas

#1) Cree un archivo de clase Java independiente para cada página web.

#2) En cada clase, todos los WebElements deben declararse como variables (usando la anotación - @FindBy) e inicializarse usando el método initElement (). Los WebElements declarados deben inicializarse para ser utilizados en los métodos de acción.

#3) Defina los métodos correspondientes que actúen sobre esas variables.

Tomemos un ejemplo de un escenario simple:

• Abra la URL de una aplicación.
• Escriba la dirección de correo electrónico y la contraseña.
• Haga clic en el botón Iniciar sesión.
• Verifique el mensaje de inicio de sesión exitoso en la página de búsqueda.

Capa de página

Aquí tenemos 2 páginas,

1. Página principal - La página que se abre cuando se ingresa la URL y donde ingresamos los datos para iniciar sesión.
2. SearchPage - Una página que se muestra después de iniciar sesión correctamente.

En Page Layer, cada página de la aplicación web se declara como una clase Java separada y sus localizadores y acciones se mencionan allí.

Pasos para crear POM con ejemplo en tiempo real

# 1) Cree una clase Java para cada página:

En esto ejemplo , accederemos a 2 páginas web, las páginas “Inicio” y “Búsqueda”.

Por lo tanto, crearemos 2 clases Java en Page Layer (o en un paquete, por ejemplo, com.automation.pages).

# 2) Defina WebElements como variables usando Annotation @FindBy:

Estaríamos interactuando con:

• Correo electrónico, contraseña, campo de botón de inicio de sesión en la página de inicio.
• Mensaje exitoso en la página de búsqueda.

Entonces definiremos WebElements usando @FindBy

Por ejemplo: Si vamos a identificar EmailAddress usando el atributo id, entonces su declaración de variable es

# 3) Crea métodos para acciones realizadas en WebElements.

Las siguientes acciones se realizan en WebElements:

• Escriba acción en el campo Dirección de correo electrónico.
• Escriba acción en el campo Contraseña.
• Haga clic en acción en el botón Iniciar sesión.

Por ejemplo, Los métodos definidos por el usuario se crean para cada acción en el WebElement como,

Aquí, el Id se pasa como un parámetro en el método, ya que el usuario enviará la entrada desde el caso de prueba principal.

Nota :Se debe crear un constructor en cada una de las clases en la capa de página, para obtener la instancia del controlador de la clase principal en la capa de prueba y también para inicializar WebElements (objetos de página) declarados en la clase de página usando PageFactory.InitElement () .

No iniciamos el controlador aquí, sino que su instancia se recibe de la clase principal cuando se crea el objeto de la clase de capa de página.

InitElement () - se usa para inicializar los WebElements declarados, usando la instancia del controlador de la clase principal. En otras palabras, los WebElements se crean utilizando la instancia del controlador. Solo después de inicializar los WebElements, se pueden usar en los métodos para realizar acciones.

Se crean dos clases de Java para cada página, como se muestra a continuación:

HomePage.java

SearchPage.Java

Capa de prueba

Los casos de prueba se implementan en esta clase. Creamos un paquete separado, por ejemplo, com.automation.test y luego creamos una clase Java aquí (MainClass.java)

Pasos para crear casos de prueba:

• Inicialice el controlador y abra la aplicación.
• Cree un objeto de la clase PageLayer (para cada página web) y pase la instancia del controlador como parámetro.
• Usando el objeto creado, haga una llamada a los métodos en la clase PageLayer (para cada página web) para realizar acciones / verificación.
• Repita el paso 3 hasta que se realicen todas las acciones y luego cierre el controlador.

Jerarquía de tipos de anotación utilizada para declarar elementos web

Las anotaciones se utilizan para ayudar a construir una estrategia de ubicación para los elementos de la interfaz de usuario.

# 1) @FindBy

Cuando se trata de Pagefactory, @FindBy actúa como una varita mágica. Agrega todo el poder al concepto. Ahora sabe que la anotación @FindBy en Pagefactory funciona igual que la del driver.findElement () en el modelo de objeto de página habitual. Se utiliza para localizar WebElement / WebElements con un criterio .

# 2) @FindBys

Se utiliza para localizar WebElement con más de un criterio y debe cumplir con todos los criterios dados. Estos criterios deben mencionarse en una relación padre-hijo. En otras palabras, esto usa la relación condicional AND para ubicar los WebElements usando los criterios especificados. Utiliza múltiples @FindBy para definir cada criterio.

Por ejemplo:

Código fuente HTML de un WebElement:

En POM:

En el ejemplo anterior, el WebElement 'SearchButton' se encuentra solo si coincide con ambos los criterios cuyo valor de id es 'searchId_1' y el valor del nombre es 'search_field'. Tenga en cuenta que el primer criterio pertenece a una etiqueta principal y el segundo criterio para una etiqueta secundaria.

# 3) @FindAll

Se utiliza para localizar WebElement con más de un criterio y debe coincidir con al menos uno de los criterios dados. Esto usa relaciones condicionales OR para ubicar WebElements. Utiliza múltiples @FindBy para definir todos los criterios.

Por ejemplo:

Código fuente HTML:

En POM:

En el ejemplo anterior, el nombre de usuario de WebElement se encuentra si coincide con al menos uno de los criterios mencionados.

# 4) @CacheLookUp

Cuando WebElement se usa con más frecuencia en casos de prueba, Selenium busca WebElement cada vez que se ejecuta el script de prueba. En esos casos, en los que determinados WebElements se utilizan globalmente para todos los TC ( Por ejemplo, El escenario de inicio de sesión ocurre para cada TC), esta anotación se puede usar para mantener esos WebElements en la memoria caché una vez que se lee por primera vez.

Esto, a su vez, ayuda a que el código se ejecute más rápido porque cada vez no tiene que buscar el WebElement en la página, sino que puede obtener su referencia de la memoria.

Puede ser un prefijo con cualquiera de @FindBy, @FindBys y @FindAll.

Por ejemplo:

También tenga en cuenta que esta anotación debe usarse solo para WebElements cuyo valor de atributo (como xpath, nombre de identificación, nombre de clase, etc.) no cambia con mucha frecuencia. Una vez que el WebElement se encuentra por primera vez, mantiene su referencia en la memoria caché.

Entonces, cuando ocurre un cambio en el atributo de WebElement después de unos días, Selenium no podrá ubicar el elemento, porque ya tiene su referencia anterior en su memoria caché y no considerará el cambio reciente en WebElement.

Más sobre PageFactory.initElements ()

Ahora que entendemos la estrategia de Pagefactory para inicializar los elementos web usando InitElements (), intentemos comprender las diferentes versiones del método.

El método, como sabemos, toma el objeto controlador y el objeto de la clase actual como parámetros de entrada y devuelve el objeto de la página inicializando implícita y proactivamente todos los elementos de la página.

En la práctica, el uso del constructor como se muestra en la sección anterior es más preferible que las otras formas de uso.

Las formas alternativas de llamar al método son:

#1) En lugar de usar el puntero 'this', puede crear el objeto de clase actual, pasarle la instancia del controlador y llamar al método estático initElements con parámetros, es decir, el objeto controlador y el objeto de clase que acaba de crear.

#2) La tercera forma de inicializar elementos usando la clase Pagefactory es usando la API llamada 'reflexión'. Sí, en lugar de crear un objeto de clase con una palabra clave 'nueva', classname.class se puede pasar como parte del parámetro de entrada initElements ().

Preguntas frecuentes

P # 1) ¿Cuáles son las diferentes estrategias de localización que se utilizan para @FindBy?

Responder: La respuesta simple a esto es que no hay diferentes estrategias de localización que se utilicen para @FindBy.

Usan las mismas 8 estrategias de localización que usa el método findElement () en el POM habitual:

1. identificación
2. nombre
3. nombre de la clase
4. xpath
5. css
6. tagName
7. Texto del enlace
8. parcialLinkText

P # 2) ¿Existen diferentes versiones para el uso de las anotaciones @FindBy también?

Responder: Cuando hay un elemento web para buscar, usamos la anotación @FindBy. También explicaremos las formas alternativas de usar @FindBy junto con las diferentes estrategias de localización.

Ya hemos visto cómo usar la versión 1 de @FindBy:

La versión 2 de @FindBy pasa el parámetro de entrada como Cómo y Usando .

Cómo busca la estrategia de localización mediante la cual se identificaría el elemento web. La palabra clave usando define el valor del localizador.

Vea a continuación para una mejor comprensión,

• How.ID busca el elemento usando identificación estrategia y el elemento que intenta identificar tiene id = cidkeyword.

• Cómo.CLASS_NAME busca el elemento usando nombre de la clase estrategia y el elemento que intenta identificar tiene clase = Nueva clase.

P # 3) ¿Hay alguna diferencia entre las dos versiones de @FindBy?

Responder: La respuesta es No, no hay diferencia entre las dos versiones. Es solo que la primera versión es más corta y fácil en comparación con la segunda versión.

P # 4) ¿Qué uso en la pagefactory en caso de que haya una lista de elementos web para ubicar?

Responder: En el patrón de diseño de objeto de página habitual, tenemos driver.findElements () para ubicar varios elementos que pertenecen a la misma clase o nombre de etiqueta, pero ¿cómo ubicamos dichos elementos en el caso del modelo de objeto de página con Pagefactory? La forma más fácil de lograr tales elementos es usar la misma anotación @FindBy.

Entiendo que esta línea parece ser un rasguño para muchos de ustedes. Pero sí, es la respuesta a la pregunta.

Veamos el siguiente ejemplo:

Usando el modelo de objeto de página habitual sin Pagefactory, usa driver.findElements para ubicar varios elementos como se muestra a continuación:

Se puede lograr lo mismo utilizando el modelo de objetos de página con Pagefactory como se indica a continuación:

Básicamente, asignar los elementos a una lista de tipo WebElement hace el truco independientemente de si se ha utilizado Pagefactory o no al identificar y localizar los elementos.

P # 5) ¿Se pueden usar tanto el diseño del objeto Page sin pagefactory como con Pagefactory en el mismo programa?

Responder: Sí, tanto el diseño del objeto de página sin Pagefactory como con Pagefactory se pueden utilizar en el mismo programa. Puede seguir el programa que se indica a continuación en el Respuesta a la pregunta 6 para ver cómo se utilizan ambos en el programa.

Una cosa para recordar es que el concepto de Pagefactory con la función de caché debe evitarse en elementos dinámicos, mientras que el diseño de objetos de página funciona bien para elementos dinámicos. Sin embargo, Pagefactory solo se adapta a elementos estáticos.

P # 6) ¿Existen formas alternativas de identificar elementos basados ​​en múltiples criterios?

¿Qué capa del modelo osi funciona con marcos?

Responder: La alternativa para identificar elementos en base a múltiples criterios es usar las anotaciones @FindAll y @FindBys. Estas anotaciones ayudan a identificar elementos únicos o múltiples en función de los valores obtenidos de los criterios pasados ​​en él.

# 1) @FindAll:

@FindAll puede contener varios @FindBy y devolverá todos los elementos que coincidan con cualquier @FindBy en una sola lista. @FindAll se usa para marcar un campo en un objeto de página para indicar que la búsqueda debe usar una serie de etiquetas @FindBy. A continuación, buscará todos los elementos que coincidan con cualquiera de los criterios de FindBy.

Tenga en cuenta que no se garantiza que los elementos estén en el orden del documento.

La sintaxis para usar @FindAll es la siguiente:

Explicación: @FindAll buscará e identificará elementos separados que se ajusten a cada uno de los criterios de @FindBy y los enumerará. En el ejemplo anterior, primero buscará un elemento cuyo id = ”foo” y luego, identificará el segundo elemento con className = ”bar”.

Suponiendo que hubo un elemento identificado para cada criterio FindBy, @FindAll dará como resultado una lista de 2 elementos, respectivamente. Recuerde, podría haber múltiples elementos identificados para cada criterio. Así, en palabras simples, @ Encuentra todos actos equivalentes a la O operador en los criterios @FindBy pasados.

# 2) @FindBys:

FindBys se usa para marcar un campo en un objeto de página para indicar que la búsqueda debe usar una serie de etiquetas @FindBy en una cadena como se describe en ByChained. Cuando los objetos WebElement necesarios deben coincidir con todos los criterios dados, utilice la anotación @FindBys.

La sintaxis para usar @FindBys es la siguiente:

Explicación: @FindBys buscará e identificará elementos que cumplan con todos los criterios de @FindBy y los enumerará. En el ejemplo anterior, buscará elementos cuyo nombre = ”foo” y className = ”bar”.

@FindAll dará como resultado una lista de 1 elemento si asumimos que hubo un elemento identificado con el nombre y el className en los criterios dados.

Si no hay un elemento que satisfaga todas las condiciones de FindBy aprobadas, el resultado de @FindBys será cero elementos. Podría haber una lista de elementos web identificados si todas las condiciones satisfacen varios elementos. En palabras simples, @ FindBys actos equivalentes a la Y operador en los criterios @FindBy pasados.

Veamos la implementación de toda la anotación anterior a través de un programa detallado:

Modificaremos el programa www.nseindia.com dado en la sección anterior para comprender la implementación de las anotaciones @FindBy, @FindBys y @FindAll

# 1) El repositorio de objetos de PagefactoryClass se actualiza de la siguiente manera:

Lista newlist = driver.findElements (By.tagName ('a'));

@FindBy (cómo = Cómo. TAG_NAME , usando = 'a')
privado Lista findbyvalue;
@Encuentra todos ({ @FindBy (className = 'sel'), @FindBy (xpath = ”// a (@ id =’ tab5 ′) ”)})
privado Lista findallvalue;
@FindBys ({ @FindBy (className = 'sel'), @FindBy (xpath = ”// a (@ id =’ tab5 ′) ”)})
privado Lista de findbysvalue;

# 2) Se escribe un nuevo método seeHowFindWorks () en PagefactoryClass y se invoca como último método en la clase Main.

El método es el siguiente:

A continuación se muestra el resultado que se muestra en la ventana de la consola después de la ejecución del programa:

Intentemos ahora entender el código en detalle:

#1) A través del patrón de diseño del objeto de la página, el elemento 'lista nueva' identifica todas las etiquetas con el ancla 'a'. En otras palabras, obtenemos un recuento de todos los enlaces de la página.

Aprendimos que pagefactory @FindBy hace el mismo trabajo que driver.findElement (). El elemento findbyvalue se crea para obtener el recuento de todos los enlaces de la página mediante una estrategia de búsqueda que tiene un concepto de pagefactory.

Resulta correcto que tanto driver.findElement () como @FindBy hagan el mismo trabajo e identifiquen los mismos elementos. Si observa la captura de pantalla de la ventana de la consola resultante, el recuento de enlaces identificados con el elemento newlist y el de findbyvalue son iguales, es decir, 299 enlaces que se encuentran en la página.

El resultado se muestra a continuación:

#2) Aquí explicamos el funcionamiento de la anotación @FindAll que pertenecerá a la lista de elementos web con el nombre findallvalue.

Observando atentamente cada criterio @FindBy dentro de la anotación @FindAll, el primer criterio @FindBy busca elementos con className = 'sel' y el segundo criterio @FindBy busca un elemento específico con XPath = “// a (@ id = 'tab5')

Ahora presionemos F12 para inspeccionar los elementos en la página nseindia.com y obtener cierta claridad sobre los elementos correspondientes a los criterios @FindBy.

Hay dos elementos en la página correspondientes a className = ”sel”:

a) El elemento 'Fundamentos' tiene la etiqueta de lista, es decir