Modèle d'objet de page (POM) avec Page Factory | Tutoriel Selenium

Exemple 2:

• Accédez à «https://www.shoppersstop.com/brands»
• Accédez au lien Haute curry.
• Vérifiez si la page Haute Curry contient le texte «Start New Something».

Structure du programme

• shopperstopPagefactory.java qui inclut un référentiel d'objets utilisant le concept pagefactory pour shoppersstop.com qui est un constructeur pour l'initialisation de tous les éléments Web est créé, les méthodes closeExtraPopup () pour gérer une fenêtre contextuelle d'alerte qui s'ouvre, cliquez surOnHauteCurryLink () pour cliquer sur Haute Curry Liez et verifyStartNewSomething () pour vérifier si la page Haute Curry contient le texte «Commencer quelque chose».
• Shopperstop_CallPagefactory.java est le fichier de classe principal qui appelle toutes les méthodes ci-dessus et effectue les actions respectives sur le site NSE.

shopperstopPagefactory.java

Shopperstop_CallPagefactory.java

POM utilisant Page Factory

Tutoriels vidéo - POM avec Page Factory

Partie I

Partie II

Une classe Factory est utilisée pour simplifier et simplifier l'utilisation des objets de page.

• Tout d'abord, nous devons trouver les éléments Web par annotation @FindBy dans les classes de page .
• Ensuite, initialisez les éléments à l'aide de initElements () lors de l'instanciation de la classe de page.

#1) @FindBy:

L'annotation @FindBy est utilisée dans PageFactory pour localiser et déclarer les éléments Web à l'aide de différents localisateurs.Ici, nous transmettons l'attribut ainsi que sa valeur utilisée pour localiser l'élément Web à l'annotation @FindBy, puis le WebElement est déclaré.

L'annotation peut être utilisée de deux manières.

Par exemple:

Cependant, le premier est la méthode standard de déclaration des WebElements.

'Comment' est une classe et elle a des variables statiques comme ID, XPATH, CLASSNAME, LINKTEXT, etc.
'utilisant' - Pour affecter une valeur à une variable statique.

Au dessus exemple , nous avons utilisé l'attribut 'id' pour localiser l'élément Web 'Email'. De même, nous pouvons utiliser les localisateurs suivants avec les annotations @FindBy:

• nom du cours
• css
• Nom
• xpath
• tagName
• linkText
• partialLinkText

# 2) initElements ():

L'initElements est une méthode statique de la classe PageFactory qui est utilisée pour initialiser tous les éléments Web localisés par l'annotation @FindBy. Ainsi, instancier facilement les classes Page.

Nous devons également comprendre que POM suit les principes OOPS.

• Les WebElements sont déclarés en tant que variables membres privées (masquage de données).
• Liaison des WebElements avec les méthodes correspondantes (Encapsulation).

Étapes pour créer un POM à l'aide d'un modèle de fabrique de pages

#1) Créez un fichier de classe Java distinct pour chaque page Web.

#deux) Dans chaque classe, tous les WebElements doivent être déclarés en tant que variables (en utilisant l'annotation - @FindBy) et initialisés en utilisant la méthode initElement (). Les WebElements déclarés doivent être initialisés pour être utilisés dans les méthodes d'action.

# 3) Définissez les méthodes correspondantes agissant sur ces variables.

Prenons un exemple de scénario simple:

• Ouvrez l'URL d'une application.
• Saisissez l'adresse e-mail et le mot de passe.
• Cliquez sur le bouton Connexion.
• Vérifiez le message de connexion réussi sur la page de recherche.

Couche de page

Ici nous avons 2 pages,

1. Page d'accueil - La page qui s'ouvre lorsque l'URL est saisie et où nous saisissons les données pour la connexion.
2. RecherchePage - Une page qui s'affiche après une connexion réussie.

Dans la couche de page, chaque page de l'application Web est déclarée en tant que classe Java distincte et ses localisateurs et actions y sont mentionnés.

Étapes pour créer un POM avec un exemple en temps réel

# 1) Créez une classe Java pour chaque page:

Dans ce exemple , nous accèderons à 2 pages Web, les pages «Accueil» et «Recherche».

Par conséquent, nous allons créer 2 classes Java dans Page Layer (ou dans un package, disons com.automation.pages).

# 2) Définissez les WebElements en tant que variables en utilisant Annotation @FindBy:

Nous interagirions avec:

• Courriel, mot de passe, champ du bouton de connexion sur la page d'accueil.
• Message réussi sur la page de recherche.

Nous allons donc définir les WebElements en utilisant @FindBy

Par exemple: Si nous allons identifier EmailAddress à l'aide de l'ID d'attribut, sa déclaration de variable est

# 3) Créez des méthodes pour les actions effectuées sur WebElements.

Les actions ci-dessous sont effectuées sur WebElements:

• Saisissez une action dans le champ Adresse e-mail.
• Saisissez une action dans le champ Mot de passe.
• Cliquez sur l'action sur le bouton de connexion.

Par exemple, Les méthodes définies par l'utilisateur sont créées pour chaque action sur le WebElement comme suit:

Ici, l'ID est passé en paramètre dans la méthode, car l'entrée sera envoyée par l'utilisateur à partir du scénario de test principal.

Remarque :Un constructeur doit être créé dans chacune des classes de la couche de page, afin d'obtenir l'instance de pilote de la classe Main dans la couche de test et également d'initialiser les WebElements (objets de page) déclarés dans la classe de page à l'aide de PageFactory.InitElement () .

Nous n'initions pas le pilote ici, mais son instance est reçue de la classe principale lorsque l'objet de la classe Page Layer est créé.

InitElement () - est utilisé pour initialiser les WebElements déclarés, en utilisant l'instance de pilote de la classe principale. En d'autres termes, les WebElements sont créés à l'aide de l'instance de pilote. Ce n'est qu'après l'initialisation des WebElements qu'ils peuvent être utilisés dans les méthodes pour effectuer des actions.

Deux classes Java sont créées pour chaque page, comme indiqué ci-dessous:

HomePage.java

SearchPage.Java

Couche de test

Les cas de test sont implémentés dans cette classe. Nous créons un package séparé, disons com.automation.test, puis créons une classe Java ici (MainClass.java)

Étapes pour créer des scénarios de test:

• Initialisez le pilote et ouvrez l'application.
• Créez un objet de la classe PageLayer (pour chaque page Web) et transmettez l'instance de pilote en tant que paramètre.
• À l'aide de l'objet créé, appelez les méthodes de la classe PageLayer (pour chaque page Web) afin d'effectuer des actions / vérification.
• Répétez l'étape 3 jusqu'à ce que toutes les actions soient effectuées, puis fermez le pilote.

Hiérarchie des types d'annotations utilisée pour déclarer des éléments Web

Les annotations sont utilisées pour aider à construire une stratégie de localisation pour les éléments de l'interface utilisateur.

# 1) @FindBy

Quand il s'agit de Pagefactory, @FindBy agit comme une baguette magique. Cela ajoute toute la puissance au concept. Vous savez maintenant que l'annotation @FindBy dans Pagefactory fonctionne de la même manière que celle de driver.findElement () dans le modèle d'objet de page habituel. Il est utilisé pour localiser WebElement / WebElements avec un critère .

# 2) @FindBys

Il est utilisé pour localiser WebElement avec plus d'un critère et doivent correspondre à tous les critères donnés. Ces critères doivent être mentionnés dans une relation parent-enfant. En d'autres termes, cela utilise la relation conditionnelle ET pour localiser les WebElements à l'aide des critères spécifiés. Il utilise plusieurs @FindBy pour définir chaque critère.

Par exemple:

Code source HTML d'un WebElement:

Dans POM:

Dans l'exemple ci-dessus, le WebElement ‘SearchButton’ est localisé uniquement s'il correspond aux deux les critères dont la valeur d'id est «searchId_1» et la valeur de nom est «search_field». Veuillez noter que les premiers critères appartiennent à une balise parent et les seconds à une balise enfant.

# 3) @FindAll

Il est utilisé pour localiser WebElement avec plus d'un critère et il doit correspondre à au moins un des critères donnés. Cela utilise des relations conditionnelles OR afin de localiser les WebElements. Il utilise plusieurs @FindBy pour définir tous les critères.

Par exemple:

Code source HTML:

Dans POM:

Dans l'exemple ci-dessus, le nom d'utilisateur WebElement est localisé s'il correspond à au moins un des critères mentionnés.

# 4) @CacheLookUp

Lorsque le WebElement est plus souvent utilisé dans les cas de test, Selenium recherche le WebElement à chaque fois que le script de test est exécuté. Dans ces cas, certains WebElements sont globalement utilisés pour tous les TC ( Par exemple, Le scénario de connexion se produit pour chaque TC), cette annotation peut être utilisée pour maintenir ces WebElements dans la mémoire cache une fois qu'ils sont lus pour la première fois.

Ceci, à son tour, aide le code à s’exécuter plus rapidement car à chaque fois, il n’a pas à rechercher le WebElement dans la page, mais il peut obtenir sa référence à partir de la mémoire.

Cela peut être comme un préfixe avec l'un des @FindBy, @FindBys et @FindAll.

Par exemple:

Notez également que cette annotation ne doit être utilisée que pour les WebElements dont la valeur d'attribut (comme xpath, nom d'id, nom de classe, etc.) ne change pas assez souvent. Une fois le WebElement localisé pour la première fois, il conserve sa référence dans la mémoire cache.

Ainsi, il se produit un changement dans l’attribut de WebElement après quelques jours, Selenium ne pourra pas localiser l’élément, car il a déjà son ancienne référence dans sa mémoire cache et ne tiendra pas compte du changement récent de WebElement.

Plus sur PageFactory.initElements ()

Maintenant que nous comprenons la stratégie de Pagefactory sur l'initialisation des éléments Web à l'aide d'InitElements (), essayons de comprendre les différentes versions de la méthode.

La méthode que nous connaissons prend l'objet pilote et l'objet de classe actuel comme paramètres d'entrée et retourne l'objet de page en initialisant implicitement et proactivement tous les éléments de la page.

En pratique, l'utilisation du constructeur comme indiqué dans la section ci-dessus est plus préférable aux autres modes d'utilisation.

Les autres façons d'appeler la méthode sont:

#1) Au lieu d'utiliser le pointeur «this», vous pouvez créer l'objet de classe actuel, lui passer l'instance de pilote et appeler la méthode statique initElements avec des paramètres, c'est-à-dire l'objet pilote et l'objet de classe qui vient d'être créé.

#deux) La troisième façon d'initialiser des éléments à l'aide de la classe Pagefactory consiste à utiliser l'API appelée «reflet». Oui, au lieu de créer un objet de classe avec un mot clé «new», classname.class peut être passé dans le cadre du paramètre d'entrée initElements ().

Questions fréquemment posées

Q # 1) Quelles sont les différentes stratégies de localisation utilisées pour @FindBy?

Répondre: La réponse simple à cela est qu'il n'y a pas de stratégies de localisation différentes utilisées pour @FindBy.

Ils utilisent les 8 mêmes stratégies de localisation que la méthode findElement () dans le POM habituel utilise:

1. identifiant
2. Nom
3. nom du cours
4. xpath
5. css
6. tagName
7. linkText
8. partialLinkText

Q # 2) Existe-t-il également différentes versions de l'utilisation des annotations @FindBy?

Répondre: Lorsqu'il y a un élément Web à rechercher, nous utilisons l'annotation @FindBy. Nous développerons également les différentes manières d'utiliser @FindBy ainsi que les différentes stratégies de localisation.

Nous avons déjà vu comment utiliser la version 1 de @FindBy:

La version 2 de @FindBy consiste à transmettre le paramètre d'entrée comme Comment et Utilisant .

Comment recherche la stratégie de localisation à l'aide de laquelle le webelement serait identifié. Le mot clé utilisant définit la valeur du localisateur.

Voir ci-dessous pour une meilleure compréhension,

• How.ID recherche l'élément en utilisant identifiant stratégie et l'élément qu'il tente d'identifier a id = cidkeyword.

• Comment.CLASS_NAME recherche l'élément à l'aide de nom du cours stratégie et l'élément qu'il tente d'identifier a class = newclass.

Q # 3) Y a-t-il une différence entre les deux versions de @FindBy?

Répondre: La réponse est non, il n'y a aucune différence entre les deux versions. C'est juste que la première version est la plus courte et la plus facile par rapport à la deuxième version.

Q # 4) Que dois-je utiliser dans la pagefactory au cas où il y aurait une liste d'éléments Web à localiser?

Répondre: Dans le modèle de conception d'objet de page habituel, nous avons driver.findElements () pour localiser plusieurs éléments appartenant à la même classe ou au même nom de balise, mais comment localiser ces éléments dans le cas d'un modèle d'objet de page avec Pagefactory? Le moyen le plus simple d'obtenir de tels éléments est d'utiliser la même annotation @FindBy.

Je comprends que cette ligne semble être un casse-tête pour beaucoup d'entre vous. Mais oui, c'est la réponse à la question.

Regardons l'exemple ci-dessous:

En utilisant le modèle d'objet de page habituel sans Pagefactory, vous utilisez driver.findElements pour localiser plusieurs éléments comme indiqué ci-dessous:

La même chose peut être obtenue en utilisant le modèle d'objet de page avec Pagefactory comme indiqué ci-dessous:

Fondamentalement, l'affectation des éléments à une liste de type WebElement fait l'affaire indépendamment du fait que Pagefactory a été utilisé ou non lors de l'identification et de la localisation des éléments.

Q # 5) Est-ce que la conception d'objet de page sans pagefactory et avec Pagefactory peut être utilisée dans le même programme?

Répondre: Oui, la conception d'objet de page sans Pagefactory et avec Pagefactory peut être utilisée dans le même programme. Vous pouvez suivre le programme ci-dessous dans le Réponse à la question 6 pour voir comment les deux sont utilisés dans le programme.

Une chose à retenir est que le concept Pagefactory avec la fonctionnalité mise en cache doit être évité sur les éléments dynamiques alors que la conception d'objet de page fonctionne bien pour les éléments dynamiques. Cependant, Pagefactory ne convient qu'aux éléments statiques.

Q # 6) Existe-t-il d'autres façons d'identifier les éléments en fonction de plusieurs critères?

quel est le plan de test dans les tests logiciels

Répondre: L'alternative pour identifier les éléments en fonction de plusieurs critères consiste à utiliser les annotations @FindAll et @FindBys. Ces annotations aident à identifier les éléments uniques ou multiples en fonction des valeurs extraites des critères qui y sont passés.

# 1) @FindAll:

@FindAll peut contenir plusieurs @FindBy et renverra tous les éléments qui correspondent à n'importe quel @FindBy dans une seule liste. @FindAll est utilisé pour marquer un champ sur un objet de page pour indiquer que la recherche doit utiliser une série de balises @FindBy. Il recherchera ensuite tous les éléments qui correspondent à l'un des critères FindBy.

Notez que les éléments ne sont pas garantis d'être dans l'ordre du document.

La syntaxe à utiliser @FindAll est la suivante:

Explication: @FindAll recherchera et identifiera des éléments séparés conformes à chacun des critères @FindBy et les listera. Dans l'exemple ci-dessus, il recherchera d'abord un élément dont l'id = 'foo', puis identifiera le deuxième élément avec className = 'bar'.

En supposant qu'il y avait un élément identifié pour chaque critère FindBy, @FindAll entraînera la liste de 2 éléments, respectivement. N'oubliez pas que plusieurs éléments peuvent être identifiés pour chaque critère. Ainsi, en termes simples, @ Trouver tout actes équivalents au OU opérateur sur les critères @FindBy passés.

# 2) @FindBys:

FindBys est utilisé pour marquer un champ sur un objet de page pour indiquer que la recherche doit utiliser une série de balises @FindBy dans une chaîne comme décrit dans ByChained. Lorsque les objets WebElement requis doivent correspondre à tous les critères donnés, utilisez l'annotation @FindBys.

La syntaxe à utiliser @FindBys est la suivante:

Explication: @FindBys recherchera et identifiera les éléments conformes à tous les critères @FindBy et les listera. Dans l'exemple ci-dessus, il recherchera les éléments dont le nom = 'foo' et className = 'bar'.

@FindAll aboutira à lister 1 élément si nous supposons qu'il y avait un élément identifié avec le nom et le className dans les critères donnés.

S'il n'y a pas un élément satisfaisant toutes les conditions FindBy passées, alors la résultante de @FindBys sera zéro élément. Il pourrait y avoir une liste d'éléments Web identifiés si toutes les conditions satisfont plusieurs éléments. En termes simples, @ FindBys actes équivalents au ET opérateur sur les critères @FindBy passés.

Voyons la mise en œuvre de toutes les annotations ci-dessus à travers un programme détaillé:

Nous modifierons le programme www.nseindia.com donné dans la section précédente pour comprendre l'implémentation des annotations @FindBy, @FindBys et @FindAll

# 1) Le référentiel d'objets de PagefactoryClass est mis à jour comme ci-dessous:

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

@FindBy (comment = comment. TAG_NAME , en utilisant = 'a')
privé Liste findbyvalue;
@Trouver tout ({ @FindBy (className = 'sel'), @FindBy (xpath = ”// a (@ id =’ tab5 ′) ”)})
privé Liste findallvalue;
@FindBys ({ @FindBy (className = 'sel'), @FindBy (xpath = ”// a (@ id =’ tab5 ′) ”)})
privé Liste findbysvalue;

# 2) Une nouvelle méthode seeHowFindWorks () est écrite dans PagefactoryClass et est appelée comme dernière méthode de la classe Main.

La méthode est la suivante: