Modelo de objeto de página (POM) com fábrica de página | Selenium Tutorial

Exemplo 2:

• Vá para ‘https://www.shoppersstop.com/brands’
• Navegue até o link Haute curry.
• Verifique se a página Haute Curry contém o texto “Começar Novo Algo”.

Estrutura do programa

• shopperstopPagefactory.java que inclui um repositório de objetos usando o conceito pagefactory para shoppersstop.com que é um construtor para inicializar todos os elementos da web é criado, métodos closeExtraPopup () para lidar com uma caixa pop-up de alerta que se abre, clickOnHauteCurryLink () para clicar em Haute Curry Vincule e verifiqueStartNewSomething () para verificar se a página Haute Curry contém o texto “Iniciar algo novo”.
• Shopperstop_CallPagefactory.java é o arquivo de classe principal que chama todos os métodos acima e executa as respectivas ações no site NSE.

shopperstopPagefactory.java

Shopperstop_CallPagefactory.java

POM usando o Page Factory

Tutoriais em vídeo - POM com fábrica de páginas

Parte I

parte II

Uma classe Factory é usada para tornar o uso de objetos de página mais simples e fácil.

• Primeiro, precisamos encontrar os elementos da web por anotação @FindBy nas aulas de página .
• Em seguida, inicialize os elementos usando initElements () ao instanciar a classe de página.

# 1) @FindBy:

A anotação @FindBy é usada em PageFactory para localizar e declarar os elementos da web usando diferentes localizadores.Aqui, passamos o atributo, bem como seu valor usado para localizar o elemento da web para a anotação @FindBy e, em seguida, o WebElement é declarado.

Existem 2 maneiras de usar a anotação.

Por exemplo:

No entanto, o primeiro é a forma padrão de declarar WebElements.

'Quão' é uma classe e tem variáveis ​​estáticas como ID, XPATH, CLASSNAME, LINKTEXT, etc.
'usando' - Para atribuir um valor a uma variável estática.

No acima exemplo , usamos o atributo ‘id’ para localizar o elemento da web ‘Email’. Da mesma forma, podemos usar os seguintes localizadores com as anotações @FindBy:

• nome da classe
• css
• nome
• xpath
• tagName
• Texto do link
• parcialLinkText

# 2) initElements ():

O initElements é um método estático da classe PageFactory que é usado para inicializar todos os elementos da web localizados pela anotação @FindBy. Assim, instanciando as classes da página facilmente.

Devemos também compreender que o POM segue os princípios OOPS.

• WebElements são declarados como variáveis ​​de membro privado (Data Hiding).
• Vinculando WebElements com métodos correspondentes (encapsulamento).

Etapas para criar POM usando o padrão de fábrica de página

# 1) Crie um arquivo de classe Java separado para cada página da web.

#dois) Em cada classe, todos os WebElements devem ser declarados como variáveis ​​(usando a anotação - @FindBy) e inicializados usando o método initElement (). Os WebElements declarados devem ser inicializados para serem usados ​​nos métodos de ação.

# 3) Defina os métodos correspondentes que atuam nessas variáveis.

Vamos dar um exemplo de um cenário simples:

• Abra o URL de um aplicativo.
• Digite os dados do endereço de e-mail e da senha.
• Clique no botão Login.
• Verifique a mensagem de login bem-sucedido na página de pesquisa.

Camada de Página

Aqui temos 2 páginas,

1. Pagina inicial - A página que se abre quando o URL é inserido e onde inserimos os dados para login.
2. SearchPage - Uma página que é exibida após um login bem-sucedido.

Na Camada de Página, cada página no Aplicativo Web é declarada como uma Classe Java separada e seus localizadores e ações são mencionados lá.

Etapas para criar POM com exemplo em tempo real

# 1) Crie uma classe Java para cada página:

Nisso exemplo , acessaremos 2 páginas da web, páginas “Home” e “Search”.

Portanto, criaremos 2 classes Java na Camada de Página (ou em um pacote, digamos, com.automation.pages).

# 2) Defina WebElements como variáveis ​​usando Annotation @FindBy:

Estaríamos interagindo com:

• E-mail, senha, campo do botão Login na página inicial.
• Mensagem de sucesso na página de pesquisa.

Portanto, definiremos WebElements usando @FindBy

Por exemplo: Se vamos identificar o EmailAddress usando o id do atributo, então sua declaração de variável é

# 3) Crie métodos para ações executadas em WebElements.

Abaixo as ações são realizadas em WebElements:

• Digite a ação no campo Endereço de e-mail.
• Digite ação no campo Senha.
• Clique em ação no botão de login.

Por exemplo, Métodos definidos pelo usuário são criados para cada ação no WebElement como,

Aqui, o Id é passado como parâmetro no método, pois a entrada será enviada pelo usuário a partir do caso de teste principal.

Observação :Um construtor deve ser criado em cada classe da Camada de Página, a fim de obter a instância do driver da classe Principal na Camada de Teste e também para inicializar WebElements (Objetos de Página) declarados na classe de página usando PageFactory.InitElement () .

Não iniciamos o driver aqui, em vez disso, sua instância é recebida da Classe Principal quando o objeto da classe Camada de Página é criado.

InitElement () - é usado para inicializar os WebElements declarados, usando a instância do driver da classe principal. Em outras palavras, WebElements são criados usando a instância do driver. Somente depois que os WebElements são inicializados, eles podem ser usados ​​nos métodos para realizar ações.

Duas classes Java são criadas para cada página, conforme mostrado abaixo:

HomePage.java

SearchPage.Java

Camada de Teste

Casos de teste são implementados nesta classe. Criamos um pacote separado, digamos, com.automation.test e, em seguida, criamos uma classe Java aqui (MainClass.java)

Etapas para criar casos de teste:

• Inicialize o driver e abra o aplicativo.
• Crie um objeto da classe PageLayer (para cada página da web) e passe a instância do driver como parâmetro.
• A partir do objeto criado, faça uma chamada aos métodos da classe PageLayer (para cada página da web) para realizar ações / verificação.
• Repita a etapa 3 até que todas as ações sejam realizadas e feche o driver.

Hierarquia de tipo de anotação usada para declarar WebElements

As anotações são usadas para ajudar a construir uma estratégia de localização para os Elementos de UI.

# 1) @FindBy

Quando se trata de Pagefactory, @FindBy atua como uma varinha mágica. Ele adiciona todo o poder ao conceito. Você agora está ciente de que a anotação @FindBy em Pagefactory tem o mesmo desempenho do driver.findElement () no modelo de objeto de página normal. É usado para localizar WebElement / WebElements com um critério .

# 2) @FindBys

É usado para localizar WebElement com mais de um critério e precisa atender a todos os critérios fornecidos. Esses critérios devem ser mencionados em um relacionamento pai-filho. Em outras palavras, isso usa relacionamento condicional AND para localizar os WebElements usando os critérios especificados. Ele usa vários @FindBy para definir cada critério.

Por exemplo:

Código-fonte HTML de um WebElement:

No POM:

No exemplo acima, o WebElement ‘SearchButton’ está localizado apenas se combina com ambos os critérios cujo valor de id é “searchId_1” e o valor do nome é “search_field”. Observe que o primeiro critério pertence a uma tag pai e o segundo critério a uma tag filho.

# 3) @FindAll

É usado para localizar WebElement com mais de um critério e precisa corresponder a pelo menos um dos critérios fornecidos. Isso usa relacionamentos condicionais OR para localizar WebElements. Ele usa vários @FindBy para definir todos os critérios.

Por exemplo:

HTML SourceCode:

No POM:

No exemplo acima, o WebElement ‘Nome de usuário está localizado se corresponde a pelo menos um dos critérios mencionados.

# 4) @CacheLookUp

Quando o WebElement é usado com mais frequência em casos de teste, o Selenium procura o WebElement cada vez que o script de teste é executado. Nesses casos, em que certos WebElements são usados ​​globalmente para todos os TC ( Por exemplo, O cenário de login acontece para cada TC), essa anotação pode ser usada para manter esses WebElements na memória cache, uma vez que é lido pela primeira vez.

Isso, por sua vez, ajuda o código a ser executado mais rapidamente porque, a cada vez, ele não precisa procurar o WebElement na página, mas pode obter sua referência da memória.

Pode ser um prefixo com qualquer um de @FindBy, @FindBys e @FindAll.

Por exemplo:

Observe também que esta anotação deve ser usada apenas para WebElements cujo valor de atributo (como xpath, nome de id, nome de classe, etc.) não muda com frequência. Assim que o WebElement é localizado pela primeira vez, ele mantém sua referência na memória cache.

Então, se ocorrer uma mudança no atributo do WebElement após alguns dias, o Selenium não conseguirá localizar o elemento, pois já tem sua referência antiga em sua memória cache e não considerará a mudança recente no WebElement.

Mais em PageFactory.initElements ()

Agora que entendemos a estratégia do Pagefactory ao inicializar os elementos da web usando InitElements (), vamos tentar entender as diferentes versões do método.

O método, como sabemos, leva o objeto driver e o objeto de classe atual como parâmetros de entrada e retorna o objeto de página inicializando implícita e proativamente todos os elementos da página.

Na prática, o uso do construtor conforme mostrado na seção acima é mais preferível do que as outras formas de seu uso.

Formas alternativas de chamar o método:

# 1) Em vez de usar o ponteiro “this”, você pode criar o objeto da classe atual, passar a instância do driver para ele e chamar o método estático initElements com parâmetros, ou seja, o objeto do driver e o objeto da classe que acabou de ser criado.

#dois) A terceira maneira de inicializar elementos usando a classe Pagefactory é usando a API chamada “reflexão”. Sim, em vez de criar um objeto de classe com uma palavra-chave “nova”, classname.class pode ser passado como parte do parâmetro de entrada initElements ().

perguntas frequentes

P # 1) Quais são as diferentes estratégias de localização usadas para @FindBy?

Responda: A resposta simples para isso é que não há estratégias diferentes de localizador usadas para @FindBy.

Eles usam as mesmas 8 estratégias de localização que o método findElement () no POM normal usa:

1. eu ia
2. nome
3. nome da classe
4. xpath
5. css
6. tagName
7. Texto do link
8. parcialLinkText

P # 2) Existem versões diferentes para o uso de anotações @FindBy também?

Responda: Quando existe um elemento da web a ser pesquisado, usamos a anotação @FindBy. Iremos elaborar sobre as formas alternativas de usar o @FindBy junto com as diferentes estratégias de localização também.

Já vimos como usar a versão 1 de @FindBy:

A versão 2 de @FindBy é passando o parâmetro de entrada como Quão e Usando .

Quão procura a estratégia de localização por meio da qual o elemento da web seria identificado. A palavra-chave usando define o valor do localizador.

Veja abaixo para melhor compreensão,

• How.ID pesquisa o elemento usando eu ia estratégia e o elemento que tenta identificar tem id = cidkeyword.

• Como.CLASS_NAME pesquisa o elemento usando nome da classe estratégia e o elemento que ela tenta identificar tem classe = newclass.

P # 3) Existe uma diferença entre as duas versões de @FindBy?

Responda: A resposta é não, não há diferença entre as duas versões. Acontece que a primeira versão é a mais curta e fácil quando comparada à segunda versão.

P # 4) O que devo usar na pagefactory caso haja uma lista de elementos da web a serem localizados?

Responda: No padrão de design de objeto de página usual, temos driver.findElements () para localizar vários elementos pertencentes à mesma classe ou nome de tag, mas como localizamos esses elementos no caso do modelo de objeto de página com Pagefactory? A maneira mais fácil de obter tais elementos é usar a mesma anotação @FindBy.

Eu entendo que esta linha parece ser um arranha-céus para muitos de vocês. Mas sim, é a resposta à pergunta.

Vejamos o exemplo abaixo:

Usando o modelo de objeto de página normal sem Pagefactory, você usa driver.findElements para localizar vários elementos, conforme mostrado abaixo:

O mesmo pode ser alcançado usando o modelo de objeto de página com Pagefactory conforme fornecido abaixo:

Basicamente, atribuir os elementos a uma lista do tipo WebElement funciona independentemente de a Pagefactory ter sido usada ou não durante a identificação e localização dos elementos.

P # 5) O design do objeto Página sem pagefactory e com Pagefactory pode ser usado no mesmo programa?

Responda: Sim, tanto o design de objeto de página sem Pagefactory quanto com Pagefactory podem ser usados ​​no mesmo programa. Você pode seguir o programa fornecido abaixo no Resposta para a pergunta # 6 para ver como ambos são usados ​​no programa.

Uma coisa a lembrar é que o conceito de Pagefactory com o recurso de cache deve ser evitado em elementos dinâmicos, enquanto o design de objeto de página funciona bem para elementos dinâmicos. No entanto, o Pagefactory serve apenas para elementos estáticos.

P # 6) Existem maneiras alternativas de identificar elementos com base em vários critérios?

como adicionar um inteiro a um array em java

Responda: A alternativa para identificar elementos com base em vários critérios é usar as anotações @FindAll e @FindBys. Essas anotações ajudam a identificar um ou vários elementos, dependendo dos valores obtidos dos critérios passados.

# 1) @FindAll:

@FindAll pode conter vários @FindBy e retornará todos os elementos que correspondem a qualquer @FindBy em uma única lista. @FindAll é usado para marcar um campo em um objeto de página para indicar que a pesquisa deve usar uma série de tags @FindBy. Em seguida, ele pesquisará todos os elementos que correspondam a qualquer um dos critérios FindBy.

Observe que não é garantido que os elementos estejam na ordem do documento.

A sintaxe para usar @FindAll é a seguinte:

Explicação: @FindAll irá pesquisar e identificar elementos separados em conformidade com cada um dos critérios @FindBy e listá-los. No exemplo acima, ele irá primeiro pesquisar um elemento cujo id = ”foo” e então, irá identificar o segundo elemento com className = ”bar”.

Supondo que haja um elemento identificado para cada critério FindBy, @FindAll resultará na listagem de 2 elementos, respectivamente. Lembre-se de que pode haver vários elementos identificados para cada critério. Assim, em palavras simples, @ Encontrar tudo atos equivalentes ao OU operador nos critérios @FindBy aprovados.

# 2) @FindBys:

FindBys é usado para marcar um campo em um objeto de página para indicar que a pesquisa deve usar uma série de tags @FindBy em uma cadeia, conforme descrito em ByChained. Quando os objetos WebElement necessários precisam corresponder a todos os critérios fornecidos, use a anotação @FindBys.

A sintaxe para usar @FindBys é a seguinte:

Explicação: @FindBys irá pesquisar e identificar elementos em conformidade com todos os critérios @FindBy e listá-los. No exemplo acima, ele pesquisará os elementos cujo nome = ”foo” e className = ”bar”.

@FindAll resultará na listagem de 1 elemento se presumirmos que havia um elemento identificado com o nome e o className nos critérios fornecidos.

Se não houver um elemento que satisfaça todas as condições FindBy passadas, a resultante de @FindBys será zero elementos. Pode haver uma lista de elementos da web identificados se todas as condições atenderem a vários elementos. Em palavras simples, @ FindBys atos equivalentes ao E operador nos critérios @FindBy aprovados.

Vamos ver a implementação de todas as anotações acima por meio de um programa detalhado:

Modificaremos o programa www.nseindia.com dado na seção anterior para entender a implementação das anotações @FindBy, @FindBys e @FindAll

# 1) O repositório de objetos de PagefactoryClass é atualizado conforme abaixo:

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

@FindBy (como = como. TAG_NAME , usando = “a”)
privado Lista findbyvalue;
@Encontrar tudo ({ @FindBy (className = “sel”), @FindBy (xpath = ”// a (@ id =’ tab5 ′) ”)})
privado Lista findallvalue;
@FindBys ({ @FindBy (className = “sel”), @FindBy (xpath = ”// a (@ id =’ tab5 ′) ”)})
privado Lista findbysvalue;

# 2) Um novo método seeHowFindWorks () é escrito na PagefactoryClass e é chamado como o último método na classe Main.

O método é o seguinte: