2 – Iniciando um Projeto no Selenium e Cucumber – Parte I

Criando classes, features e métodos necessários

Após configurado o ambiente e o projeto, é hora de começar a criar as classes e features necessárias.

OBS: como o objetivo do blog é apresentar o básico da ferramenta para quem está iniciando na área, alguns conceitos poderão ser suprimidos. Contudo, aconselho a sempre buscar informações de boas práticas e padrões de uso adotados nas ferramentas 😉

Vamos começar pela feature “Cliente”.

Para isso, clique com o botão direito sobre “src/test/java” e acesse o menu “New > File”:

Na janela que abrir, digite no campo “File name” o texto “Cliente.feature”:

Após clicar em “Finish” o seguinte arquivo de extensão .feature será criado:

Observe em mais detalhes o arquivo .feature criado:

Já é criado um “template” dentro do arquivo, para auxiliar na montagem dos cenários de testes. Ele contém dicas e exemplos de cenários.

Vamos deletar os cenários de exemplo e criar o seguinte cenário:

Given efetuei login no sistema
And acessei o menu Clientes >> Inserir
When na tela Dados de Identificacao informo os dados de Pessoa Fisica
And na tela Dados de Identificacao clico em Avancar
And na tela Enderecos informo os enderecos
And na tela Enderecos clico em Salvar
Then na tela Enderecos sera exibida mensagem de sucesso
And efetuarei logout do sistema

OBS: note que Given, And, When e Then são palavras reservadas pelo Cucumber.

Após editar o arquivo .feature, tecle Ctrl+Shift+F para formatar o arquivo.

O resultado esperado será:

Ao clicar em Salvar, os passos do cenário ficarão destacados em amarelo:

Isso indica que NÃO EXISTEM métodos elaborados para os passos de testes. Imaginem que cada um dos passos de teste no Selenium equivale a um keywordTest no TestComplete. Lembram que este keywordTest pode ser considerado como um método? Pois bem, aqui iremos criar um método para cada um dos passos destacados em amarelo acima. OBS: note que temos mais Steps que Keywordtests se comparados ao visto nas aulas de TestComplete. Isso se deve ao fato que aqui alguns keywordtests foram “quebrados” em dois ou mais Steps.

Mas esses métodos serão criados em uma classe java chamada ClienteSteps. O sufixo “Steps” indica que nela somente teremos os métodos responsáveis pelos passos de testes.

Para isso, será clicado com o botão direito sobre “src/test/java” e acessado o menu “New > Class”:

Na janela que abrir, informar o nome “ClienteSteps” no campo “Name”:

Ao clicar em “Finish” o arquivo será adicionado:

Agora vamos copiar os passos (steps) contidos no Cliente.feature e colar no ClienteSteps.java:

Fizemos isso para facilitar a visualização de quais métodos teremos que criar.

Agora colocaremos um “@” na frente de cada step:

Agora é preciso colocar o texto de cada step (com exceção da palavra reservada) dentro de um (“ ”), conforme ilustrado abaixo:

Agora é necessário montar os métodos para cada um dos steps. Para fins didáticos, nesse momento será feita somente a “casca” dos métodos, conforme mostrado:

Observe a imagem acima: cada step possui um método. É dentro desses métodos que os campos de tela serão preenchidos, botões serão clicados e menus serão acessados.

Mas antes de prosseguir, há mais uma coisa a se ajustar: o import para as palavras reservadas (note que elas estão sublinhadas em vermelho, o que indica que há um “erro”)

Para isso, posicione o ponteiro do mouse encima de cada uma das palavras e espere o menu popup aparecer:

Clique sobre o primeiro item mostrado: “Import Given (cucumber.api.java.en)”. Ele então será adicionado à lista de imports da classe java:

Note na imagem acima que depois da importação não há mais erros para ele, inclusive a palavra mudou de cor (ficou cinza).

Após repetir os passos acima para as palavras “And”, “When” e “Then”, tem-se:

Agora a classe não apresenta mais erros.

Ao ir para a classe Cliente.feature e teclar “Ctrl + Shift + F”, não serão mais apresentados passos destacados em amarelo:

Nesse momento temos a “Cliente.feature” que é equivalente ao “Test Items” do TestComplete e temos a “ClienteSteps.java” que contém métodos equivalentes aos “keywordTests” do TestComplete.

Agora é preciso criar a classe que seria o equivalente ao objeto “NameMapping” do TestComplete.

Para isso, será criada uma nova classe java, chamada “ClienteElementMap.java”, conforme mostrado na sequencia abaixo:

É nessa classe que serão “mapeados” os objetos de tela. Para isso será utilizado um recurso muito útil do Selenium: o PageFactory!

Basicamente esse recurso é o seguinte: ao declarar os objetos de tela na classe “ClienteElementMap.java”, utilizaremos o id/name desses objetos em sua declaração.

Exemplo: Observe a página de inserção de clientes abaixo:

Tecle F12 para aparecer os elementos da tela:

Agora basta clicar sobre o ícone destacado na seta da imagem abaixo:

Em seguida, mova o ponteiro do mouse sobre a caixa de texto “CPF/CNPJ”:

Observe que a caixa de texto foi destacada. Após clicar sobre a caixa de texto, seu correspondente código html será destacado na janela da direita, conforme ilustrado abaixo:

Observe a propriedade “id” desse elemento: id=”cpf_cnpj”. Esse id é o que iremos utilizar para “mapear” o objeto na classe “ClienteElementMap.java”:

A imagem abaixo ilustra o “mapeamento”:

Isso nada mais é do que a declaração de uma variável do tipo “WebElement” chamada “cpf_cnpj”. Contudo, observe na imagem acima que o tipo “WebElement” não está sendo reconhecido (está sublinhado em vermelho). Isso é porque ainda não foram realizados os “imports” do Selenium.

Para isso, posicione o ponteiro do mouse sobre a palavra “WebElement”:

No menu suspenso que aparecer, clique em “Import ‘WebElement (org.openqa.selenium)’”.

O resultado pode ser visto abaixo:

Agora é necessário repetir os passos para os demais elementos da tela de dados de identificação (campos de texto, radiobuttons, combos e botão). O resultado é apresentado abaixo:

Observe que os nomes dos elementos são IDÊNTICOS aos id’s deles na página.

Nesse momento tem-se 3 classes/arquivos no projeto:

1. Cliente.feature: onde descrevemos os cenários baseados em chamadas de Steps;
2. ClienteSteps.java: onde serão chamadas as implementações dos Steps (o equivalente aos KeywordTests do TestComplete);
3. ClienteElementMap.java: onde ficam as informações dos objetos de tela (o equivalente ao NameMapping do TestComplete);

Mas, como faríamos para executar os testes propriamente dito? Como executar os cenários de testes que estão descritos nos arquivos .feature?

Para executá-los, é necessário criar uma outra classe que será responsável por somente executar os testes.

Para isso, clique com o botão direito sobre “src/test/java” e acesse o menu “New Class”:

Na janela que abrir, informe “ClienteTest” no campo “Name” conforme ilustrado abaixo:

Após clicar em “Finish”, a classe é adicionada ao projeto:

Nessa classe, adicione o seguinte código:

@RunWith(Cucumber.class)
@CucumberOptions(features = “src/test/java/Cliente.feature”,
glue = { “” }, monochrome = true, dryRun = false)

Obviamente apresentou alguns erros pois ainda não foram realizados os devidos imports.

A sequência de imagens abaixo mostra os imports sendo realizados:

A classe “ClienteTest.java” será a responsável por executar os testes. Nela estão indicadas as features que serão chamadas por ela.

Nesse exemplo, o caminho “src/test/java/Cliente.feature” exibe qual feature ele chama: a “Cliente.feature”.

Embora a estrutura do projeto já pareça completa nesse instante, ainda há mais algumas classes a serem adicionadas. Observe abaixo a classe “ClienteSteps.java”:

Observe que entre seus métodos temos Steps relacionados a ações que são realizadas não só na página Dados de Identificação, mas também Steps referentes a ações como efetuar login, efetuar logout e acessar menus, os quais não necessariamente são ações realizadas no preenchimento de um cliente (“Dados de Identificação” e “Endereços”). Se fizermos a chamada dos objetos de tela diretamente na classe Steps, “amontoaríamos” objetos de diversas partes/páginas do sistema. Para evitar isso, e também para organizar melhor o código, criaremos classes com o sufixo “Page”, as quais irão chamar os objetos contidos nas classes de sufixo “ElementMap”. Assim, uma classe de sufixo “Step” irá chamar os métodos de classe de sufixo “Page”.

Embora não pareça claro o objetivo descrito acima ou até confuso, vamos prosseguir com a criação de mais classes, assim tudo ficará mais claro 😉

Dica: para facilitar a compreensão, imagine que um KeywordTest no TestComplete agora é representado por uma classe de sufixo “Step” + uma classe de sufixo “Page” + uma classe de sufixo “ElementMap”.

Do mesmo jeito que foram criadas as classes .java anteriores, crie a classe “ClientePage.java”, conforme ilustrado abaixo:

Adicione na classe um “extends ClienteElementMap” conforme ilustrado abaixo, assim a classe poderá “enxergar” os objetos contidos na classe “ClienteElementMap”:

Agora é só colocar nessas classes de sufixo “Page” os métodos que serão utilizados pelos Steps lá da classe “ClienteSteps.java”. Soa complicado não? Não é não 😉

Uma dica muito boa é criar somente a “casca” desses métodos com o uso da classe “ClienteSteps.java”.

Observe novamente a classe “ClienteSteps.java”, especialmente os métodos destacados abaixo:

Os métodos destacados são métodos cujas ações/interações ocorrem na tela de cadastro de cliente, sejam os dados de identificação ou endereço. Começaremos a criação dos métodos da classe “ClientePage.java” com base nos métodos da página “ClienteSteps.java”:

Basicamente foi feito o seguinte: foi instanciada a classe “ClientePage.java” e chamado os métodos necessários dessa classe. Obviamente há várias marcações de erro na imagem acima pois a classe “ClientePage.java” ainda não possui os métodos ali chamados. É hora de criá-los. Naturalmente agora está mais fácil pois já sabemos quais métodos criar na classe “ClientePage.java”.

Ainda na classe “ClienteSteps.java”, posicione o ponteiro do mouse sobre um dos métodos que estão com erro, conforme exemplo abaixo:

No exemplo acima, ao posicionar o ponteiro do mouse sobre o método que não existe, o Eclipse mostra uma janela sugerindo a criação do método na classe “ClientePage.java”. Basta então clicar sobre a opção “Create method ‘InformarDadosIdentificacaoPF() in type ‘ClientePage’” para criá-lo automaticamente, conforme ilustrado abaixo:

Note que foi criado “automagicamente” o método “informarDadosIdentificacaoPF()” na classe “ClientePage.java”. Agora é só refazer os passos para os demais métodos, resultando em:

Agora é só “preencher” esses métodos com os passos de testes, como os cliques em botões, preenchimento de caixas de texto, etc…

Comecemos pelo mais simples: “clicarAvancar()”:

Ao digitar “avancar.” dentro do método “clicarAvancar”, estamos simplesmente chamando o objeto “WebElement avancar” declarado na classe “ClienteElementMap.java” (observe as imagens acima). É possível chamá-lo assim facilmente pois a classe “ClientePage.java” possui aquele “extends ClienteElementMap.java”, ou seja: a classe “ClientePage.java” é uma extensão da classe “ClienteElementMap.java”:

Nas imagens acima, note o menu que apareceu depois de digitar o “.”: ali tem-se todas as ações que dispomos sobre o objeto WebElement “avancar”. Nesse caso, queremos somente clicar no botão “Avançar” para podermos avançar de página, então será selecionada a opção “click()”, conforme ilustrado abaixo:

Pronto! Método finalizado. Agora é só realizar o mesmo para o método “informarDadosIdentificacaoPF()”, colocando os objetos na ordem desejada junto com as ações necessárias:

Segue abaixo o código necessário para os campos “Tipo de Pessoa”, “CPF/CNPJ”, “Nome/Razão Social”, “Email” e “Data de Nascimento”:

Para selecionar um objeto do tipo radiobutton, basta efetuar um “.click()”, e para os campos que são uma caixa de texto, utiliza-se o “.sendKeys(“Texto desejado”)”.

O método está quase pronto, faltando apenas os campos “Sexo” e “Estado Civil”:

Mas esses campos são combos. Como selecionar um item dentro de um combo? A resposta está abaixo:

É preciso criar um objeto do tipo “Select” a partir do objeto “WebElement sexo” conforme ilustrado acima. E não pode esquecer de realizar o import correto, que é o segundo da lista: “Import ‘Select’ (org.openqa.selenium.support.ui)”. Após isso, é só utilizar o novo objeto “cmbSexo” para selecionar o item desejado, conforme ilustrado na imagem abaixo:

Repetindo os mesmos passos para o combo “Estado Civil”, tem-se:

Finalmente, tem-se os métodos para preencher os dados de identificação de um cliente pessoa física e então avançar para a próxima página.

Nesse momento é preciso preencher os métodos da classe “ClientePage.java” relacionados aos dados de endereço, conforme destacados abaixo:

Antes de tudo, precisamos “mapear” os elementos dos dados de endereço da tela do sistema abaixo:

Efetuando o mapeamento desses elementos de modo análogo ao efetuado para os elementos de dados de identificação, tem-se:

Efetuado o mapeamento desse elementos, é momento de preencher os métodos “informarEnderecos” e “clicarSalvar” da classe “ClientePage.java”. Esse preenchimento é ilustrado abaixo:

Resta agora o método “verificarMensagemSucesso” da classe “ClientePage.java”, que simplesmente verificará se foi mostrada a mensagem de sucesso ou não. Mas esse método veremos num momento posterior. Afinal, com tantas classes e métodos criados “para cá e para lá”, precisamos fazer uma recapitulação senão quem não tem intimidade com desenvolvimento vai se sentir perdido, e esse não é o objetivo do blog.

Recapitulação do que foi visto na aula

É comum vermos bons profissionais da área de qualidade terem um “receio” ou até “medo” da expressão “testes automatizados” pois ao ouvirem essa expressão logo vem em mente: métodos e classes intermináveis, códigos complexos de entender, entre outros pensamentos. Esses pensamentos, além de ansiedade e impaciência (na minha opinião), são os que fazem muitos deixarem de dar o primeiro passo.

Quando me refiro a “ansiedade e impaciência”, me refiro à “curva de aprendizagem”: não é do dia para a noite que você vai sair dominando tudo a respeito de uma linguagem de programação ou de uma ferramenta de automação. É preciso ir aos poucos, e ter consciência que quanto mais praticar melhor desenvolverá suas habilidades. Não se compare a desenvolvedores plenos ou seniors que “despejam” linhas e linhas de códigos em minutos e que dominam diversas tecnologias/frameworks. Pare eles chegarem no nível que estão, eles também tiveram que passar por muito estudo, aprendizado e muita prática, o que não foi do dia para noite.

Enfim, se você sentiu “ansiedade e impaciência” na aula de hoje, e está com a sensação de ter se perdido, meu conselho é: esvazie a mente! Sim, tire de sua mente todo esse pensamento de “código, código, código…. AAAAHHHHH! ME PERDI! Eu quero a minha mãe!”. Em vez disso, proponho o seguinte: utilize sua imaginação e suas skills de analista de testes!

Como analista de testes, você já deve ter elaborado alguns cenários de testes, correto? Pois bem, como você faria um pequeno cenário de teste (caminho feliz) para a funcionalidade de cadastro de clientes do nosso sistema? Uma sugestão é apresentada abaixo:

• Efetuar login no sistema;
• Acessar o menu “Clientes >> Inserir”;
• Na tela “Dados de Identificação”, preencher os campos e clicar no botão “Avançar”;
• Na tela “Endereços”, preencher os campos e clicar no botão “Salvar”;
• Na tela “Endereços”, deve aparecer a mensagem de “Cadastro efetuado com sucesso”;

Veja que nosso cenário de teste é bem simples e objetivo, típico daqueles que temos que fazer em provas de entrevista de emprego, concorda?

Pois bem! Imagine que este cenário de teste é o ponto de partida para iniciar a automação de testes funcionais. E a ligação desse cenário de testes no Selenium se dá através do Cucumber!

Com o uso de palavras reservadas do Cucumber (Given, And, When, Then) nós “escrevemos” o cenário de teste no Cucumber:

• Given efetuei login no sistema
• And acessei o menu Clientes >> Inserir
• When na tela Dados de Identificacao informo os dados de Pessoa Fisica
• And na tela Dados de Identificacao clico em Avancar
• And na tela Enderecos informo os enderecos
• And na tela Enderecos clico em Salvar
• Then na tela Enderecos sera exibida mensagem de sucesso
• And efetuarei logout do sistema

Note que no Cucumber temos mais passos de testes do que antes. Isso se deve ao fato que “quebramos” alguns passos em passos menores. Isso foi feito pelos seguintes motivos:

• Cada passo de teste escrito no Cucumber terá um método Java correspondente;
• Quebrando em passos de testes menores, os correspondentes métodos serão menores, facilitando a manutenção;
• Quebrando em passos de testes menores, aumentam as possibilidades de reutilização do passo em cenários diferentes;

Pergunta: “Até que ponto devo quebrar os passos de testes em passos menores? ”

Resposta: “Praticando! ”

Utilize sua imaginação: imagine que aquele passo de teste do teu cenário de testes é um passo de teste do Cucumber, e que aquele passo de teste do Cucumber tem um método Java correspondente. Está claro até aqui? Escreva num papel, faça desenhos, etc, até que você consiga visualizar essa estrutura se formando em sua mente:

O desenho acima mostra algo que fiz para visualizar a estrutura se formando em minha mente. Para mim ela mostra a relação entre um cenário de teste e o Cucumber, e entre o Cucumber e o Java. Ela me mostra que um passo de teste do meu cenário de testes pode se transformar em 1, 2 ou mais passos de teste no Cucumber. E que um passo no Cucumber irá chamar um método no Java.

Essa foi a imagem que eu fiz em minha mente. Qual foi a sua? Desenhe aí! 😉

Agora vem a visualização da parte Java. Na aula de hoje criamos algumas classes java, com os sufixos “ElementMap”, “Page”, “Steps” e “Test”.

Pergunta: “Porque tanta classe Java?”
Resposta: “Boas práticas! ”
Réplica da pergunta: “Resposta besta e evasiva! ”
Réplica da resposta: “É porque eu ainda não expliquei! Controle a ansiedade!”
Tréplica da pergunta: “Tá bom! ”

Piadas infames à parte, a razão por termos tantas classes Java com esses sufixos são justamente para melhor organização da estrutura do teste automatizado, o que lhe auxiliará no futuro a eventual manutenção delas, bem como uma melhor reutilização de métodos, evitando ficar escrevendo códigos e mais códigos repetitivos que na prática fariam a mesma coisa. Além disso, criando seu teste automatizado seguindo estruturas recomendadas, você irá facilitar o entendimento de seu teste para outras pessoas que forem efetuar manutenção nele de modo que não encontrem dificuldades.

Essas boas práticas você encontra em blogs e sites especializados em Selenium e Cucumber.

Bom, voltemos ao uso da nossa mais importante ferramenta: a imaginação. Está claro para você que um passo de teste do Cucumber chama um método Java, correto? E onde raios está esse método Java? Ele está em uma classe que contém somente métodos chamados por passos de testes do Cucumber: a classe de sufixo Steps (Steps = Passos, em inglês).

Entendeu agora o porquê do uso do sufixo “Steps”? É para identificar onde colocamos os métodos chamados por passos de testes do Cucumber. Imagine, rabisque num papel, desenhe essa relação entre passos de testes do Cucumber e a classe de sufixo “Steps”

O desenho que eu fiz acima demonstra claramente para mim que um passo de teste do Cucumber irá chamar um método Java de uma classe de sufixo “Steps”. E para você?

Mas que método é esse, como eu faria ele? Novamente, desenhe-o:

O desenho acima mostra como eu teria que fazer o método java na classe de sufixo “Steps” para o meu passo de teste do Cucumber:

Seguindo a nomenclatura do Cucumber, eu copio o passo de teste para a classe de sufixo “Steps” correspondente, colocaria um “@” na frente da palavra reservada “And” e colocaria dentro de um “(“”)” todo o resto do passo de teste. Depois disso só colocaria uma “casca” de um método com nome sugestivo (no exemplo “clicarAvancar”).

Essa estrutura você fará para todos os passos de testes que você tiver. Simples não? Observe que até esse momento você poderia montar toda a estrutura sem pensar em uma única linha de código. Você só precisou se preocupar em fazer um bom cenário de testes e seus respectivos métodos java.

Tranquilo até aqui? Então vamos imaginar mais agora, olhando para as classes de sufixo “Page” e “ElementMap”.

Sobre as classes de sufixo “Page” e “ElementMap”, são as classes que irão interagir com os elementos de tela:

• “ElementMap”: mapeia os objetos da tela;
• “Page”: contém os métodos que chamam os objetos de tela e interagem com eles (preencher o campo, clicar no botão, selecionar um item, essas coisas);

A classe de sufixo “ElementMap” é utilizada somente pela classe de sufixo “Page” correspondente.

OBS: Poderíamos ter simplificado nesse ponto e colocado a declaração dos elementos (o “mapeamento” deles) dentro da “Page” e não ter criado a “ElementMap”. Isso vai da escolha de cada um. Aqui optou-se por criá-la para mostrar que também é possível organizar a declaração dos elementos em uma classe separada dos métodos.

E aqui entra a pergunta: “que métodos eu terei que criar nas classes de sufixo “Page”? ”. A resposta é bem simples: aqueles métodos que tu precisar utilizar dentro dos métodos da classe de sufixo “Steps”!

Veja o método de uma classe de sufixo “Steps” abaixo:

    @And (“na tela Dados de Identificacao clico em Avancar”)
public void clicarAvancar(){

}

Essa “casca” é um método da classe de sufixo “Steps”, que diz que precisa clicar no botão “Avançar” da tela “Dados de Identificação”. Mas o responsável por efetuar o clique no botão propriamente dito é um método da classe de sufixo “Page”, o qual sequer foi criado ainda.

É aqui que vemos quais métodos devemos criar na classe de sufixo “Page”: serão criados de acordo com as necessidades dos métodos da classe de sufixo “Steps”. Observe o método abaixo, agora completo:

@And (“na tela Dados de Identificacao clico em Avancar”)
public void clicarAvancar(){
ClientePage clientePage = new ClientePage();
clientePage.clicarAvancar();
}

São somente duas linhas de código: a primeira declara uma variável do tipo “ClientePage”, e a segunda linha chama o método (de nome sugestivo) “clicarAvancar()” dessa classe.

Conforme visto nessa aula, é possível gerar “automagicamente” a casca desse método na “ClientePage”. Sendo assim:

public void clicarAvancar() {
// TODO Auto-generated method stub
}

Aqui está a “casca” do método “clicarAvancar()” da classe de sufixo “Page”. Agora é só preencher com os elementos de tela que desejamos interagir, informando qual interação. Nesse exemplo, clicar no botão “Avançar”:

public void clicarAvancar() {
avancar.click();
}

Pronto! Está feito! Do início ao fim você foi capaz de automatizar o passo de teste “clicar no botão Avançar”. Complexo? Difícil? Se tiver paciência e usar sua imaginação, não! Utilize sua imaginação! Desenhe!

Agora que tudo ficou mais claro, releia com bastante atenção essa aula do início ao fim, tendo a visão de como as classes se relacionam entre si! Você verá que tudo vai fazer mais sentido.

Essa aula termina por aqui senão ficará muito extensa. E o objetivo dessa aula é ajudá-lo a “pensar” e “visualizar” a estrutura das classes e como elas se relacionam entre si, então não faz sentido avançar muito. É extremamente importante que você tenha captado o propósito dessa aula pois ela é a base de tudo.

EXERCÍCIO: o objetivo desse exercício é ajudá-lo a fixar os conceitos mostrados nessa aula, para isso:

1. Releia com bastante atenção essa aula;
2. Baixe o arquivo versao-2.ppt  e renomeie ele para “versao2.zip” e extraia. Ele é o nosso sistema;
3. Dentro da pasta do sistema, abra o arquivo “configurar_bancodedados.html” pelo Google Chrome e clique em “Gerar Base de Dados”. Esse passo é muito importante para que o sistema funcione em seu navegador Google Chrome.
4. Rabisque em uma folha de papel alguma estrutura de classes e suas relações de forma que elas fiquem claras em sua mente.
5. Crie a classe “Cliente.feature” e adicione os passos de teste necessários conforme visto na aula;
6. Crie a classe “ClienteSteps.java” e adicione nela os passos de testes criados na classe “Cliente.feature” e faça os ajustes necessários conforme apresentado na aula (uso do @, imports necessários, criação da “casca” dos métodos);
7. De volta à classe “Cliente.feature” tecle “CTRL + SHIFT + F” e salve para se certificar que nenhum passo ficou destacado em amarelo. Se ficou é porque ele não teve seu correspondente método java criado na classe “ClienteSteps.java”;
8. Na pasta do sistema (aquele que você baixou no item 2), abra o arquivo “index.html” no Google Chrome, logue no sistema (utilizando login = john e pass = john), e acesse o menu “Clientes >> Inserir”;
9. Crie a classe “ClienteElementMap.java” e, com o sistema aberto, mapeie todos os elementos das seções “Dados de Identificação” e “Endereços”;
10. Crie a classe “ClienteTest.java” conforme apresentado nessa aula, realizando todos os imports necessários;
11. Crie a classe “ClientePage.java”, não esquecendo de adicionar o “extends” correspondente;
12. De volta à classe “ClienteSteps.java”, “preencha” os métodos necessários, fazendo as chamadas aos métodos da classe “ClientePage.java” conforme visto na aula;
13. Com base na classe “ClienteSteps.java”, crie na classe “ClientePage.java” os métodos correspondentes. Dica: utilize os “atalhos” mostrados nessa aula: posicione o ponteiro do mouse sobre o método que ainda não existe na classe “ClientePage.java” e faça o Eclipse gerar “automagicamente” a casca desse método;
14. Com as cascas dos métodos da classe “ClientePage.java” criados, preencha-os conforme visto na aula – métodos “informarDadosIdentificacaoPF()”, “informarEnderecos()” e “clicarSalvar()”;

IMPORTANTE: guarde seu projeto ao final da aula, pois será dado continuidade a ele na próxima aula.