Page Object Model (POM) con Page Factory | Tutorial sul selenio

Esempio 2:

• Vai a 'https://www.shoppersstop.com/brands'
• Vai al link Haute curry.
• Verifica se la pagina Haute Curry contiene il testo 'Inizia qualcosa di nuovo'.

Struttura del programma

• shopperstopPagefactory.java che include un repository di oggetti utilizzando il concetto pagefactory per shoppersstop.com che è un costruttore per inizializzare tutti gli elementi web viene creato, metodi closeExtraPopup () per gestire una finestra pop-up di avviso che si apre, fare clic su OnHauteCurryLink () per fare clic su Haute Curry Collega e verificaStartNewSomething () per verificare se la pagina Haute Curry contiene il testo 'Inizia qualcosa di nuovo'.
• Shopperstop_CallPagefactory.java è il file di classe principale che chiama tutti i metodi precedenti ed esegue le rispettive azioni sul sito NSE.

shopperstopPagefactory.java

Shopperstop_CallPagefactory.java

POM utilizzando Page Factory

Esercitazioni video - POM con Page Factory

Parte I

Seconda parte

Una classe Factory viene utilizzata per rendere l'uso degli oggetti pagina più semplice e facile.

• Innanzitutto, dobbiamo trovare gli elementi web per annotazione @FindBy nelle classi di pagina .
• Quindi inizializza gli elementi utilizzando initElements () durante la creazione di un'istanza della classe della pagina.

# 1) @FindBy:

L'annotazione @FindBy viene utilizzata in PageFactory per individuare e dichiarare gli elementi Web utilizzando diversi locatori.Qui, passiamo l'attributo e il suo valore utilizzato per individuare l'elemento web all'annotazione @FindBy e quindi viene dichiarato WebElement.

Esistono 2 modi in cui è possibile utilizzare l'annotazione.

Per esempio:

Tuttavia, il primo è il modo standard per dichiarare WebElements.

'Come' è una classe e ha variabili statiche come ID, XPATH, CLASSNAME, LINKTEXT, ecc.
'Utilizzando' - Per assegnare un valore a una variabile statica.

In quanto sopra esempio , abbiamo utilizzato l'attributo 'id' per individuare l'elemento web 'Email'. Allo stesso modo, possiamo usare i seguenti localizzatori con le annotazioni @FindBy:

• nome della classe
• css
• nome
• xpath
• tagName
• linkText
• partialLinkText

# 2) initElements ():

InitElements è un metodo statico della classe PageFactory che viene utilizzato per inizializzare tutti gli elementi web individuati dall'annotazione @FindBy. Così, istanziando facilmente le classi Page.

Dovremmo anche capire che POM segue i principi OOPS.

• Gli elementi Web sono dichiarati come variabili membro private (Nascondere dati).
• Associazione di WebElements con metodi corrispondenti (incapsulamento).

Passaggi per creare POM utilizzando il pattern Page Factory

# 1) Crea un file di classe Java separato per ogni pagina web.

#Due) In ogni classe, tutti i WebElements dovrebbero essere dichiarati come variabili (usando annotation - @FindBy) e inizializzati usando il metodo initElement (). Gli elementi Web dichiarati devono essere inizializzati per essere utilizzati nei metodi di azione.

# 3) Definire i metodi corrispondenti che agiscono su quelle variabili.

Facciamo un esempio di uno scenario semplice:

• Apri l'URL di un'applicazione.
• Digitare i dati dell'indirizzo e-mail e della password.
• Fare clic sul pulsante Accedi.
• Verifica il messaggio di accesso riuscito nella pagina di ricerca.

Livello pagina

Qui abbiamo 2 pagine,

1. HomePage - La pagina che si apre quando viene inserito l'URL e dove inseriamo i dati per il login.
2. SearchPage - Una pagina che viene visualizzata dopo un accesso riuscito.

In Page Layer, ogni pagina nell'applicazione Web è dichiarata come una classe Java separata e i suoi localizzatori e azioni sono menzionati lì.

Passaggi per creare POM con esempio in tempo reale

# 1) Crea una classe Java per ogni pagina:

In questo esempio , accediamo a 2 pagine web, 'Home' e 'Cerca'.

Quindi, creeremo 2 classi Java in Page Layer (o in un pacchetto diciamo, com.automation.pages).

# 2) Definisci gli elementi Web come variabili utilizzando Annotation @FindBy:

Interageremmo con:

• E-mail, password, campo del pulsante di accesso nella home page.
• Messaggio di successo nella pagina di ricerca.

Quindi definiremo WebElements usando @FindBy

Per esempio: Se dobbiamo identificare EmailAddress utilizzando l'attributo id, la sua dichiarazione di variabile è

# 3) Crea metodi per le azioni eseguite su WebElements.

Le seguenti azioni vengono eseguite su WebElements:

• Digita l'azione nel campo Indirizzo e-mail.
• Digita l'azione nel campo Password.
• Fare clic sull'azione sul pulsante di accesso.

Per esempio, I metodi definiti dall'utente vengono creati per ogni azione su WebElement come,

Qui, l'Id viene passato come parametro nel metodo, poiché l'input verrà inviato dall'utente dal caso di test principale.

Nota :È necessario creare un costruttore in ciascuna delle classi nel Page Layer, al fine di ottenere l'istanza del driver dalla classe Main in Test Layer e anche per inizializzare WebElements (Page Objects) dichiarati nella classe della pagina utilizzando PageFactory.InitElement () .

Non iniziamo il driver qui, piuttosto la sua istanza viene ricevuta dalla Main Class quando viene creato l'oggetto della classe Page Layer.

InitElement () - viene utilizzato per inizializzare i WebElements dichiarati, utilizzando l'istanza del driver dalla classe principale. In altre parole, gli elementi Web vengono creati utilizzando l'istanza del driver. Solo dopo che gli elementi Web sono stati inizializzati, possono essere utilizzati nei metodi per eseguire azioni.

Vengono create due classi Java per ogni pagina come mostrato di seguito:

HomePage.java

SearchPage.Java

Livello di prova

I casi di test sono implementati in questa classe. Creiamo un pacchetto separato diciamo, com.automation.test e quindi creiamo una classe Java qui (MainClass.java)

Passaggi per creare casi di test:

• Inizializza il driver e apri l'applicazione.
• Crea un oggetto della classe PageLayer (per ogni pagina web) e passa l'istanza del driver come parametro.
• Utilizzando l'oggetto creato, effettuare una chiamata ai metodi nella classe PageLayer (per ogni pagina web) per eseguire azioni / verifica.
• Ripetere il passaggio 3 fino a quando non vengono eseguite tutte le azioni, quindi chiudere il driver.

Gerarchia dei tipi di annotazione utilizzata per dichiarare gli elementi Web

Le annotazioni vengono utilizzate per creare una strategia di localizzazione per gli elementi dell'interfaccia utente.

# 1) @FindBy

Quando si tratta di Pagefactory, @FindBy agisce come una bacchetta magica. Aggiunge tutta la potenza al concetto. Ora sei consapevole che l'annotazione @FindBy in Pagefactory esegue la stessa operazione di driver.findElement () nel solito modello di oggetti di pagina. Viene utilizzato per individuare WebElement / WebElements con un criterio .

# 2) @FindBys

Viene utilizzato per individuare WebElement con più di un criterio e devono corrispondere a tutti i criteri forniti. Questi criteri dovrebbero essere menzionati in una relazione genitore-figlio. In altre parole, utilizza la relazione condizionale AND per individuare gli elementi Web utilizzando i criteri specificati. Utilizza più @FindBy per definire ogni criterio.

Per esempio:

Codice sorgente HTML di un WebElement:

In POM:

Nell'esempio precedente, il 'Pulsante di ricerca' di WebElement si trova solo se esso corrisponde a entrambi i criteri il cui valore id è 'searchId_1' e il valore del nome è 'search_field'. Tieni presente che il primo criterio appartiene a un tag principale e il secondo a un tag figlio.

# 3) @FindAll

Viene utilizzato per individuare WebElement con più di un criterio e deve corrispondere ad almeno uno dei criteri dati. Questo utilizza relazioni condizionali OR per individuare WebElements. Utilizza più @FindBy per definire tutti i criteri.

Per esempio:

Codice sorgente HTML:

In POM:

Nell'esempio precedente, il nome utente di WebElement si trova se esso corrisponde ad almeno uno dei criteri citati.

# 4) @CacheLookUp

Quando WebElement viene utilizzato più spesso nei casi di test, Selenium cerca WebElement ogni volta che viene eseguito lo script di test. In quei casi, in cui alcuni WebElement sono utilizzati globalmente per tutti i TC ( Per esempio, Lo scenario di accesso si verifica per ogni TC), questa annotazione può essere utilizzata per mantenere quei WebElement nella memoria cache una volta letti per la prima volta.

Questo, a sua volta, aiuta il codice a essere eseguito più velocemente perché ogni volta non deve cercare il WebElement nella pagina, ma può ottenere il suo riferimento dalla memoria.

Può essere un prefisso con uno qualsiasi di @FindBy, @FindBys e @FindAll.

Per esempio:

Si noti inoltre che questa annotazione dovrebbe essere utilizzata solo per WebElements il cui valore di attributo (come xpath, id name, class name, ecc.) Non cambia abbastanza spesso. Una volta che WebElement viene individuato per la prima volta, mantiene il suo riferimento nella memoria cache.

Quindi, dopo alcuni giorni si verifica un cambiamento nell'attributo di WebElement, Selenium non sarà in grado di individuare l'elemento, perché ha già il suo vecchio riferimento nella sua memoria cache e non prenderà in considerazione la recente modifica in WebElement.

Altro su PageFactory.initElements ()

Ora che abbiamo compreso la strategia di Pagefactory sull'inizializzazione degli elementi web utilizzando InitElements (), proviamo a capire le diverse versioni del metodo.

Il metodo come sappiamo prende l'oggetto driver e l'oggetto classe corrente come parametri di input e restituisce l'oggetto pagina inizializzando in modo implicito e proattivo tutti gli elementi sulla pagina.

In pratica, l'uso del costruttore come mostrato nella sezione precedente è più preferibile rispetto alle altre modalità del suo utilizzo.

I modi alternativi per chiamare il metodo sono:

# 1) Invece di utilizzare il puntatore 'this', è possibile creare l'oggetto classe corrente, passarvi l'istanza del driver e chiamare il metodo statico initElements con parametri, ad esempio l'oggetto driver e l'oggetto classe che è stato appena creato.

#Due) Il terzo modo per inizializzare gli elementi usando la classe Pagefactory è usare l'API chiamata 'reflection'. Sì, invece di creare un oggetto classe con una parola chiave 'new', classname.class può essere passato come parte del parametro di input initElements ().

Domande frequenti

D # 1) Quali sono le diverse strategie di localizzazione utilizzate per @FindBy?

Risposta: La semplice risposta a questa domanda è che non esistono diverse strategie di localizzazione utilizzate per @FindBy.

Usano le stesse 8 strategie di localizzazione che il metodo findElement () nel solito POM usa:

1. id
2. nome
3. nome della classe
4. xpath
5. css
6. tagName
7. linkText
8. partialLinkText

D # 2) Esistono versioni differenti anche per l'utilizzo delle annotazioni @FindBy?

Risposta: Quando c'è un elemento web da cercare, usiamo l'annotazione @FindBy. Elaboreremo i modi alternativi di utilizzare @FindBy insieme alle diverse strategie di localizzazione.

Abbiamo già visto come utilizzare la versione 1 di @FindBy:

La versione 2 di @FindBy passa il parametro di input come Come e Utilizzando .

Come cerca la strategia di localizzazione utilizzando la quale sarebbe identificato il webelement. La parola chiave utilizzando definisce il valore del localizzatore.

Vedi sotto per una migliore comprensione,

• How.ID cerca l'elemento utilizzando id strategia e l'elemento che cerca di identificare ha id = cidkeyword.

• How.CLASS_NAME cerca l'elemento utilizzando nome della classe la strategia e l'elemento che cerca di identificare ha class = newclass.

D # 3) C'è una differenza tra le due versioni di @FindBy?

Risposta: La risposta è No, non c'è differenza tra le due versioni. È solo che la prima versione è la più breve e più facile rispetto alla seconda versione.

D # 4) Cosa devo usare in pagefactory nel caso in cui ci sia un elenco di elementi web da individuare?

Risposta: Nel solito modello di progettazione degli oggetti di pagina, abbiamo driver.findElements () per individuare più elementi appartenenti alla stessa classe o nome di tag, ma come individuare tali elementi nel caso del modello di oggetti di pagina con Pagefactory? Il modo più semplice per ottenere tali elementi è utilizzare la stessa annotazione @FindBy.

Capisco che questa frase sembra essere un grattacapo per molti di voi. Ma sì, è la risposta alla domanda.

Diamo un'occhiata all'esempio seguente:

Utilizzando il solito modello di oggetti di pagina senza Pagefactory, si utilizza driver.findElements per individuare più elementi come mostrato di seguito:

Lo stesso può essere ottenuto utilizzando il modello a oggetti della pagina con Pagefactory come indicato di seguito:

Fondamentalmente, l'assegnazione degli elementi a un elenco di tipo WebElement fa il trucco indipendentemente dal fatto che Pagefactory sia stato utilizzato o meno durante l'identificazione e l'individuazione degli elementi.

D # 5) È possibile utilizzare sia il design dell'oggetto Page senza pagefactory che con Pagefactory nello stesso programma?

Risposta: Sì, sia il design dell'oggetto di pagina senza Pagefactory che con Pagefactory possono essere utilizzati nello stesso programma. Puoi seguire il programma indicato di seguito in Risposta alla domanda n. 6 per vedere come vengono utilizzati entrambi nel programma.

Una cosa da ricordare è che il concetto di Pagefactory con la funzionalità cache dovrebbe essere evitato sugli elementi dinamici mentre il design degli oggetti di pagina funziona bene per gli elementi dinamici. Tuttavia, Pagefactory si adatta solo agli elementi statici.

Q # 6) Esistono modi alternativi per identificare gli elementi sulla base di più criteri?

come aprire il file jar con java

Risposta: L'alternativa per identificare gli elementi in base a più criteri è utilizzare le annotazioni @FindAll e @FindBys. Queste annotazioni aiutano a identificare uno o più elementi a seconda dei valori recuperati dai criteri passati in esso.

# 1) @FindAll:

@FindAll può contenere più @FindBy e restituirà tutti gli elementi che corrispondono a @FindBy in un unico elenco. @FindAll viene utilizzato per contrassegnare un campo su un oggetto pagina per indicare che la ricerca deve utilizzare una serie di tag @FindBy. Quindi cercherà tutti gli elementi che corrispondono a uno dei criteri FindBy.

Si noti che non è garantito che gli elementi siano nell'ordine del documento.

La sintassi per utilizzare @FindAll è la seguente:

Spiegazione: @FindAll cercherà e identificherà elementi separati conformi a ciascuno dei criteri @FindBy e li elencherà. Nell'esempio precedente, cercherà prima un elemento il cui id = 'foo' e quindi identificherà il secondo elemento con className = 'bar'.

Supponendo che ci fosse un elemento identificato per ogni criterio FindBy, @FindAll risulterà nell'elencare 2 elementi, rispettivamente. Ricorda, potrebbero esserci più elementi identificati per ogni criterio. Quindi, in parole semplici, @ Trova tutto agisce equivalente al O operatore sui criteri @FindBy passati.

# 2) @FindBys:

FindBys viene utilizzato per contrassegnare un campo su un oggetto pagina per indicare che la ricerca deve utilizzare una serie di tag @FindBy in una catena come descritto in ByChained. Quando gli oggetti WebElement richiesti devono corrispondere a tutti i criteri forniti, utilizzare l'annotazione @FindBys.

La sintassi per utilizzare @FindBys è la seguente:

Spiegazione: @FindBys cercherà e identificherà gli elementi conformi a tutti i criteri di @FindBy e li elencherà. Nell'esempio precedente, cercherà elementi il ​​cui nome = 'foo' e className = 'bar'.

@FindAll risulterà nell'elencare 1 elemento se assumiamo che ci fosse un elemento identificato con il nome e il className nei criteri dati.

Se non c'è un elemento che soddisfa tutte le condizioni di FindBy passate, la risultante di @FindBys sarà zero elementi. Potrebbe esserci un elenco di elementi web identificati se tutte le condizioni soddisfano più elementi. In parole semplici, @ FindBys agisce equivalente al E operatore sui criteri @FindBy passati.

Vediamo l'implementazione di tutte le annotazioni di cui sopra attraverso un programma dettagliato:

Modificheremo il programma www.nseindia.com fornito nella sezione precedente per comprendere l'implementazione delle annotazioni @FindBy, @FindBys e @FindAll

# 1) Il repository degli oggetti di PagefactoryClass viene aggiornato come di seguito:

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

@FindBy (come = come. TAG_NAME , utilizzando = 'a')
privato Elenca findbyvalue;
@Trova tutto ({ @FindBy (className = 'sel'), @FindBy (xpath = '// a (@ id =’ tab5 ′) ')})
privato List findallvalue;
@FindBys ({ @FindBy (className = 'sel'), @FindBy (xpath = '// a (@ id =’ tab5 ′) ')})
privato List findbysvalue;

# 2) Un nuovo metodo seeHowFindWorks () è scritto nella PagefactoryClass e viene invocato come ultimo metodo nella classe Main.

Il metodo è il seguente: