Menu

Depurando Scripts Selenium com Logs (Tutorial Log4j) - Tutorial Selenium # 26

debugging selenium scripts with logs selenium tutorial 26

Experimente Nosso Instrumento Para Eliminar Problemas

Agora estamos avançando para o final do nosso mais abrangente Tutoriais grátis para ferramenta de teste Selenium . Os tutoriais que estamos postando agora fazem parte do treinamento avançado do Selenium.

No tutorial anterior, mantivemos nosso foco no Ferramenta de integração contínua chamada Hudson . É uma ferramenta gratuita e tem muito mais recursos para construir o projeto de teste, executar as classes de teste remotamente e enviar um e-mail de notificação para as partes interessadas informando-os sobre o status do aplicativo em relação aos casos de teste aprovados e reprovados.

No tutorial atual, avançaríamos em direção a alguns conceitos avançados que ajudariam direta ou indiretamente em otimizar a estrutura de automação e traz mais visibilidade aos usuários.

Assim, no tutorial atual, discutiríamos o recurso de registro, seu potencial, capacidades de depuração e muito mais.

Depurando Scripts Selenium com Logs1

Às vezes, o registro é considerado uma sobrecarga no mecanismo de criação de script existente, mas os especialistas consideram que é uma das melhores práticas se usado na proporção exata devido às seguintes vantagens:

Vantagens de registro em scripts Selenium:

  • Concede uma compreensão completa da execução de suítes de teste
  • As mensagens de log podem ser armazenadas em arquivos externos para análise pós-execução
  • Os registros são um assistente excepcional na depuração de problemas e falhas de execução do programa
  • Os registros também podem ser revisados ​​para verificar a integridade do aplicativo pelas partes interessadas

O que você aprenderá:

Log4j - uma API de registro baseada em Java

Passando para os detalhes técnicos sobre registro, vamos discutir a origem da API que usaríamos em todo o tutorial log4j para gerar logs. Log4j foi o resultado de esforços colaborativos de pessoas do Secure Electronic Marketplace for Europe para desenvolver um utilitário que nos ajudasse a gerar logs e, portanto, o log4j ganhou destaque no ano de 1996. Log4j é uma ferramenta de código aberto licenciada sob a Licença Pública IBM.

Existem três componentes principais que constituem a implementação do log4j. Esses componentes representam os detalhes sobre o nível de log, formatos da mensagem de log em que seriam renderizados e seus mecanismos de salvamento.

Constituintes do Log4j

  1. Madeireiros
  2. Anexos
  3. Layouts

# 1) Loggers

As etapas a seguir precisam ser realizadas para implementar madeireiros no projeto.

Passo 1 : Criando uma instância da classe Logger

Passo 2 : Definindo o nível de registro

Classe Logger - É um utilitário baseado em java que possui todos os métodos genéricos já implementados para que possamos usar o log4j.

Níveis de registro - Os níveis de log são conhecidos popularmente como métodos de impressão. Eles são usados ​​para imprimir as mensagens de log. Existem basicamente cinco tipos de níveis de registro.

  • erro()
  • avisar()
  • info ()
  • depurar()
  • registro()

Assim, para poder gerar logs, tudo o que precisamos fazer é chamar qualquer um dos métodos de impressão na instância do logger. Teremos uma visão mais ampla disso durante a fase de implementação.

# 2) Anexos

Agora que sabemos como gerar esses logs, a próxima coisa que deve surgir em nossas mentes é onde posso ver os logs? A resposta a esta pergunta está na definição de “Anexos”.

Anexadores são usados ​​de forma consistente para especificar a fonte / mídia de dados onde os logs devem ser gerados. O escopo das fontes de dados se estende a partir de vários meios externos, como console, GUI, arquivos de texto, etc.

# 3) Layouts

Às vezes, o usuário deseja que certas informações sejam adicionadas ou anexadas a cada declaração de log. Por exemplo, desejo imprimir um carimbo de data / hora junto com minha instrução de log. Assim, tais requisitos podem ser cumpridos por “Layouts”.

Layouts é um utilitário que permite ao usuário optar pelo formato desejado no qual os logs serão renderizados. Anexadores e Layout têm um acoplamento estreito entre eles. Assim, somos obrigados a mapear cada um dos anexadores com um layout específico.

Observe que o usuário é alavancado para definir vários appenders, cada mapa com um layout distinto.

Agora que estamos cientes dos fundamentos do log4j e de seus componentes, devemos direcionar nosso foco para o fenômeno de implementação.

Vamos entender todo o processo de implementação passo a passo.

Instalação / configuração

Para a instalação e configuração, estaríamos considerando o projeto “Learning_Selenium” que já criamos nas sessões anteriores desta série.

Passo 1 : A primeira e mais importante etapa é fazer o download do jar mais recente para a API log4j. O frasco pode ser facilmente encontrado em seu site oficial de distribuição - “ http://logging.apache.org/log4j/1.2/download.html ”.

Passo 2 : A próxima etapa é configurar o caminho de construção e fornecer log4j.jar como uma biblioteca externa.

Implementação

O registro usando log4j pode ser implementado e configurado de duas maneiras:

  1. Programaticamente via script
  2. Manualmente por meio de arquivos de configuração

Ambos os métodos de configuração mencionados acima têm méritos e deméritos. Para este tutorial, consideraríamos configurar log4j manualmente por meio de arquivos de configuração com base em sua facilidade e simplicidade. O arquivo de configuração é outro arquivo XML para configurar artefatos relacionados ao log4j.

Criação do arquivo log4j.xml

Passo 1 . Crie um arquivo log4j.xml. Copie e cole o código abaixo no arquivo de configuração.

Passo a passo do arquivo de configuração

consoleAppender

O appender do console é usado para imprimir as instruções de log no console.

anexador de arquivo

O anexador de arquivo é usado para imprimir as instruções de log em um arquivo externo. O usuário é alavancado para definir um valor ativado e desativado para a tag anexada, que diria ao sistema para anexar e registrar as instruções na tag criada anteriormente ou para sobrescrever os logs criados anteriormente e gerar os logs novos completamente.

'append' value= 'false' />

O valor do parâmetro de arquivo é definido para um local específico para notificar o sistema para criar o arquivo de log antecipado nesse local. Também especificamos o nome do arquivo de log no parâmetro value.

Layout

Conforme discutido nas primeiras seções deste tutorial, os layouts são usados ​​para especificar o mecanismo de renderização para instruções de log. Log4j fornece vários padrões de layout. O usuário é alavancado para especificar o padrão desejado no valor do parâmetro ConversionPattern.

A saída do layout acima deve ser algo como:

01-07-2014 12:56:32 INFO (GmailLogin): Exemplo de mensagem de registro

Na saída acima:

  • Primeiro campo - Data de execução
  • Segundo campo - hora exata em hh: mm: ss em que a etapa de teste foi executada
  • Terceiro campo - um do nível de registro
  • Quarto campo - Nome da classe de teste
  • O quinto campo - mensagem de log

Passo 2 . Assim que terminarmos a criação do arquivo log4j.XML, a próxima etapa é colocar o arquivo log4j.XML na pasta raiz do projeto / diretório base.

Implementação em nível de programa

etapa 3 : A próxima etapa é usar qualquer um dos configuradores para configurar e analisar o arquivo log4j.xml.

Sintaxe:

package com.logExample; import org.apache.log4j.xml.DOMConfigurator; import org.junit.AfterClass; import org.junit.BeforeClass; import org.junit.runner.JUnitCore; import org.junit.runner.Result; import org.junit.runner.RunWith; import org.junit.runner.notification.Failure; import org.junit.runners.Suite; @RunWith(Suite.class) @Suite.SuiteClasses({ Demo.class }) public class TestSuite { /** * Setup method to set system property for log file name */ @BeforeClass public static void Setup() { // loading log4j.xml file DOMConfigurator.configure('log4j.xml'); } /** * @param args */ public static void main(String() args) { Result result = JUnitCore.runClasses(TestSuite.class); for (Failure failure : result.getFailures()) { System.out.println(' TEST NAME: ' + failure.getTestHeader()); System.out.println(' ERROR: ' + failure.getMessage() + ' '); System.out.println(failure.getTrace()); System.exit(1); } } }

Observação : Os logs podem ser implementados no nível da classe também, em vez do nível do conjunto de testes. Tudo o que você precisa fazer é fazer as alterações necessárias na classe de teste, e não no conjunto de testes.

Passo 4 : A próxima etapa é criar uma classe de teste “GmailLogin.java” no projeto. Implemente a funcionalidade de login do Gmail na classe.

Etapa 5 : A próxima etapa é importar a classe de logger para poder implementar as instruções de log.

Sintaxe:

import org.apache.log4j.Logger;

Etapa 6 : A próxima etapa do processo é instanciar o objeto da classe Logger.

Sintaxe:

// Inicialização do objeto para log

estático Histórico registro Logger.getLogger (Demo. aula .getName ());

Etapa 7 : A variável de log do tipo Logger criada acima seria usada em toda a classe de teste para gerar as instruções de log. Consulte o seguinte código para o mesmo.

Sintaxe:

@Test public void testGmailLogin() throws Exception{ // enter a valid email address driver.findElement(By.id('Email')).sendKeys('TestSelenium1607@gmail.com'); log.info('Entered a valid Email Address.'); // enter a invalid password driver.findElement(By.id('Passwd')).sendKeys('InvalidPassword'); log.info('Entered a invalid Password.'); // click on sign in button driver.findElement(By.id('signIn')).click(); log.info('Clicked on the Sign In Button.'); try{ //Verify the home page assertTrue('Verification Failed: User successfully landed on the Home Page.', driver.getTitle().equals('Gmail')); log.info('Verified that the user landed on the Home Page.'); } catch (Exception e) { log.error('Unsuccessfull Login.'); } }

Resultado no arquivo de log

01-07-2014 12:56:11 INFO (GmailLogin): Carregou o arquivo para o sistema: FileExample.txt
01-07-2014 12:56:11 INFO (GmailLogin): Enviando as alterações
01-07-2014 12:56:15 ERROR (GmailLogin): Login malsucedido.

ATUALIZAÇÃO em março de 2020

Histórico

Um log é uma mensagem que estamos gravando ou gerando para cada transação que fazemos. Podemos analisar os logs para verificar o que deu certo ou errado. Suponha que se algum sistema fecha abruptamente, então, analisando os logs, podemos descobrir a causa raiz da falha.

Assim, os logs são gerados em cada ciclo de desenvolvimento. Da mesma forma, também podemos gerar logs em nosso código Selenium para teste antes e depois de cada condição de teste ou instrução de teste, para verificar se todos estão funcionando conforme o esperado.

Log4j Framework

Para gerar esses arquivos de log no código Selenium, usamos a estrutura log4j fornecida pelo Apache. Com esta estrutura, podemos gerar nossos logs personalizados.

Clique aqui para baixar log4j jar do repositório Maven.

Podemos gerar logs de 2 maneiras:

  1. Usando o arquivo log4j.properties
  2. Usando o arquivo log4j.xml

Esses arquivos conterão a configuração sobre os tipos de logs que você deseja gerar. Você pode usar qualquer um deles. Se você deseja usar ambos, o log4j.xml terá precedência mais alta. A maneira preferida de gerar logs é usando o arquivo de propriedades, portanto, exploraremos mais sobre a geração apenas por meio do arquivo de propriedades.

Implementação de log4j

Baixe o arquivo log4j jar do caminho acima e inclua-o no caminho de construção do projeto. Crie o arquivo log4j.properties e inclua o arquivo de propriedades paralelamente à sua pasta de origem quando estiver usando o aplicativo java independente.

aplicativo java autônomo

O arquivo Log4j.properties é um arquivo de configuração que armazena valores no par chave-valor.

Ele contém 3 componentes principais:

  • Loggers: Captura informações de registro.
  • Anexos : Publique informações de registro em um destino preferencial diferente, como consoles, arquivos, soquetes, registros de eventos NT, etc.
  • Layouts : Formate as informações de registro em diferentes estilos, como HTML, Layout XML, etc.

Sintaxe do arquivo log4j.properties

# 1) Defina o logger raiz com o nível de registro INFO e appender X (appender pode ser qualquer consoles, arquivos, sockets, logs de eventos NT).

log4j.rootLogger = INFO, X

#dois) Defina o anexador denominado X como um anexador de arquivo.

log4j.appender.X = org.apache.log4j.FileAppender

# 3) Defina o layout para o appender X.

log4j.appender.X.layout = org.apache.log4j.PatternLayout log4j.appender.X.layout.conversionPattern = %m%n

log4j.properties Exemplo

Crie um arquivo log4j.properties, referindo-se à sintaxe acima:

# inicialize o logger root com o nível INFO e imprima-o no console usando stdout e fout.

log4j.rootLogger=INFO,stdout,fout

# adicione um ConsoleAppender ao logger stdout para gravar no console.

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

# use um padrão de layout de formato de mensagem simples definido como% m% n, que imprime mensagens de registro em uma nova linha.

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout log4j.appender.stdout.layout.ConversionPattern=%m%n

# adicione um FileAppender ao logger fout.

converter ascii para int c ++
log4j.appender.fout=org.apache.log4j.FileAppender

# O anexador FILE é definido como org.apache.log4j.FileAppender. Ele grava em um arquivo denominado SoftwareTestingHelp.

log4j.appender.fout.File=SoftwareTestingHelp.log

# use um padrão de mensagem mais detalhado.

log4j.appender.fout.layout=org.apache.log4j.PatternLayout log4j.appender.fout.layout.ConversionPattern=%p %d{ISO8601} %r %c (%t) %m%n

Diferentes níveis de registro

  • DEPURAR
  • INFO
  • AVISAR
  • ERRO
  • FATAL

Cada nível tem sua própria prioridade. Suponha que se usarmos o nível “DEBUG”, ele registrará todas as mensagens de nível como INFO >> WARN >> ERROR >> FATAL.

Suponha que se usarmos o nível “ERROR”, ele irá ignorar DEBUG >> INFO >> WARN e só irá registrar ERROR >> FATAL.

Em todos esses níveis, precisamos definir em nosso arquivo de propriedades. Os logs serão gerados, dependendo de nossa configuração.

Implementando os logs para o mesmo exemplo referido acima:

Passo 1: Crie um objeto para a classe Logger.

final static Logger logger = Logger.getLogger(Frame.class);

O método acima ajuda a obter o objeto logger. Este método tomará a classe ou o nome da classe como argumento. Usando este objeto logger, você pode gerar logs personalizados.

Neste exemplo, nos referimos à estrutura apache log4j, se você estiver usando a estrutura TestNG, então você precisa usar a classe de log TestNG.

Classe de registro TestNG

Classe de registro TestNG

Aqui, tentamos gerar o log, sem implementar o arquivo de propriedades.

gerar o log

Nenhum log é gerado no console ou em qualquer arquivo de log criado. Um erro é recebido no console porque o arquivo de log não foi implementado corretamente. Para implementá-lo, precisamos usar a classe - PropertyConfigurator. Siga a etapa 2.

Passo 2: Inicialize o arquivo do Configurador de Propriedades e transmita o argumento como o nome do arquivo de propriedades log4j.

PropertyConfigurator.configure (“log4j.properties”);

Código completo para geração de arquivo de log:

package com.wordpress.pages; import java.util.List; import org.apache.log4j.Logger; import org.apache.log4j.PropertyConfigurator; import org.junit.Assert; import org.junit.Test; import org.openqa.selenium.Alert; import org.openqa.selenium.By; import org.openqa.selenium.WebDriver; import org.openqa.selenium.WebElement; import org.openqa.selenium.chrome.ChromeDriver; public class Frame { static WebDriver driver; final static Logger logger = Logger.getLogger(Frame.class); @Test public void Test(){ PropertyConfigurator.configure('log4j.properties.txt'); System.setProperty('webdriver.chrome.driver', 'D:\New folder\exe\chromedriver.exe'); logger.debug('Debug this path for chrome path issue'); driver = new ChromeDriver(); logger.info('Chrome driver is up and running'); driver.get('http://www.dwuser.com/education/content/the-magical-iframe-tag-an-introduction/'); logger.warn('Url is not loaded properly'); //identifying the frame using locator or say using webelement driver.switchTo().frame(driver.findElement(By.xpath('//div(@id='eduFooterWrap')//iframe(1)'))); logger.error('Frame is not available'); driver.findElement(By.xpath('//input(@name='name')')).sendKeys('SoftwareTestingHelp.com'); logger.fatal('Message not entered'); } }

Classe PropertyConfigurator

Arquivo de propriedades:

Arquivo de propriedades

Conclusão

No tutorial atual, nos concentramos no implicação técnica durante a implementação de registro em uma estrutura. Exploramos o utilitário log4j para implementar o registro. Discutimos os componentes básicos que constituem o log4j de uma perspectiva de usabilidade. Com os Appenders e layouts, o usuário é alavancado para escolher o formato / padrão de registro desejado e a fonte de dados / localização.

Neste tutorial, exploramos porque os logs são usados ​​em nosso teste e na estrutura log4j coberta, e a implementação da estrutura log4j no Selenium para gerar logs.

Próximo tutorial nº 27 : No próximo tutorial, discutiríamos alguns tópicos mais avançados relacionados a scripts eficientes e para solucionar problemas de cenários onde o usuário é obrigado a manipular eventos de mouse e teclado. Além disso, também discutiríamos como armazenar mais de um elemento da web em uma lista.

Leitura recomendada

^