Meniu

Depanarea scripturilor Selenium cu jurnale (Tutorial Log4j) - Tutorial Selenium # 26

debugging selenium scripts with logs selenium tutorial 26

Încercați Instrumentul Nostru Pentru Eliminarea Problemelor

Acum ne îndreptăm spre sfârșitul celui mai cuprinzător Tutoriale gratuite pentru instrumentul de testare a seleniului . Tutorialele pe care le postăm acum fac parte din pregătirea avansată în seleniu.

În tutorialul anterior, ne-am păstrat atenția asupra Instrument de integrare continuă numit Hudson . Este un instrument gratuit și are mult mai multe capacități de a construi proiectul de testare, de a executa cursurile de testare de la distanță și de a trimite un e-mail de notificare părților interesate, informându-le despre starea cererii în ceea ce privește cazurile de testare trecute și nereușite.

În tutorialul actual, ne-am îndrepta către unele concepte avansate care ar ajuta direct sau indirect optimizarea cadrului de automatizare și aduce mai multă vizibilitate utilizatorilor.

Astfel, în tutorialul actual, am discuta despre caracteristica de logare, potențialul său, capacitățile de depanare și mult mai mult.

Depanarea scripturilor Selenium cu jurnale 1

Uneori, înregistrarea este considerată a fi o cheltuială a mecanismului existent de creare a scriptului, dar experții consideră că este una dintre cele mai bune practici dacă este utilizată în proporție exactă din cauza următoarelor avantaje:

Avantajele înregistrării în scripturile Selenium:

  • Oferă o înțelegere completă a execuției suitelor de testare
  • Mesajele jurnal pot fi stocate în fișiere externe pentru examinare post-execuție
  • Jurnalele sunt un asistent excepțional în depanarea problemelor și erorilor de execuție a programului
  • Jurnalele pot fi, de asemenea, revizuite pentru a stabili starea aplicației de către părțile interesate

Ce veți învăța:

enumerați toate sistemele de operare cu care sunteți familiarizați

Log4j - Un API de înregistrare bazat pe Java

Trecând la detaliile tehnice despre jurnalizare, permiteți-ne să discutăm originea API pe care am folosi-o pe tot parcursul tutorial log4j pentru a genera jurnale. Log4j a fost un rezultat al eforturilor de colaborare ale oamenilor de la Secure Electronic Marketplace for Europe de a dezvolta un utilitar care să ne ajute să generăm jurnale și, prin urmare, log4j a intrat în centrul atenției în anul 1996. Log4j este un instrument open source și licențiat sub licența publică IBM.

Există trei componente principale care constituie implementarea log4j. Aceste componente reprezintă detalii despre nivelul jurnalului, formatele mesajului jurnal în care ar fi redate și mecanismele lor de salvare.

Constituenții Log4j

  1. Lemnari
  2. Anexe
  3. Aspecte

# 1) Lemn

Următorii pași trebuie să fie efectuați pentru a implementa jurnalele în proiect.

Pasul 1 : Crearea unei instanțe a clasei Logger

Pasul 2 : Definirea nivelului jurnalului

Clasa Logger - Este un utilitar bazat pe java care are toate metodele generice deja implementate, astfel încât să avem posibilitatea de a utiliza log4j.

Nivelurile jurnalului - Nivelurile jurnalului sunt cunoscute popular ca metode de imprimare. Acestea sunt utilizate pentru imprimarea mesajelor de jurnal. Există în principal cinci tipuri de niveluri de jurnal.

  • eroare()
  • a avertiza()
  • info ()
  • debug ()
  • Buturuga()

Astfel, pentru a putea genera jurnale, tot ce trebuie să facem este să apelăm oricare dintre metodele de imprimare prin instanța de înregistrare. Vom analiza mai în detaliu în faza de implementare.

# 2) Anexe

Acum, că știm cum să generăm aceste jurnale, următorul lucru care ar trebui să apară în mintea noastră este că unde pot să văd jurnalele? Răspunsul la această întrebare constă în definiția „Anexelor”.

Anexele sunt utilizate în mod constant pentru a specifica sursa / suportul de date în care ar trebui generate jurnalele. Domeniul de aplicare al surselor de date se întinde de la diferite medii externe, cum ar fi consola, GUI, fișiere text etc.

# 3) Aspecte

Uneori, utilizatorul dorește ca anumite informații să fie anexate sau anexate la fiecare instrucțiune de jurnal. De exemplu, doresc să imprime un timestamp împreună cu declarația mea de jurnal. Astfel, astfel de cerințe pot fi îndeplinite prin „Layouts”.

Aspectele sunt un utilitar care permite utilizatorului să opteze pentru formatul dorit în care vor fi redate jurnalele. Anexele și aspectul au o cuplare strânsă între ele. Astfel, ni se cere să mapăm fiecare dintre anexi cu un aspect specific.

Rețineți că utilizatorul este folosit pentru a defini mai mulți anexe, fiecare hartă cu un aspect distinct.

Acum, că suntem conștienți de elementele log4j și componentele sale, ne vom îndrepta atenția către fenomenul de implementare.

Să înțelegem întregul proces de implementare pas cu pas.

Instalare / Configurare

Pentru instalare și configurare, ne-am gândi la proiectul „Learning_Selenium” pe care l-am creat deja în sesiunile anterioare ale acestei serii.

Pasul 1 : Primul și cel mai important pas este să descărcați cel mai recent jar pentru log4j API. Borcanul poate fi găsit cu ușurință pe site-ul său oficial de distribuție - „ http://logging.apache.org/log4j/1.2/download.html ”.

Pasul 2 : Următorul pas este să configurați calea de construire și să furnizați log4j.jar ca bibliotecă externă.

Implementare

Înregistrarea utilizând log4j poate fi implementată și configurată în două moduri:

  1. Programatic prin script
  2. Manual prin fișiere de configurare

Ambele metode de configurare menționate mai sus au merit, precum și dezavantaje. Pentru acest tutorial, am lua în considerare configurarea manuală a log4j prin fișiere de configurare pe baza ușurinței și simplității sale. Fișierul de configurare este încă un alt fișier XML pentru a configura artefacte legate de log4j.

Crearea fișierului log4j.xml

Pasul 1 . Creați un fișier log4j.xml. Copiați și lipiți codul de mai jos în fișierul de configurare.

Prezentare generală a fișierului de configurare

consoleAppender

Appenderul consolei este utilizat pentru a imprima declarațiile jurnalului pe consolă.

fișier appender

Fișierul appender este utilizat pentru a imprima declarațiile jurnal într-un fișier extern. Utilizatorul este pârghiat pentru a seta o valoare de pornire și oprire pentru eticheta adăugată, care ar spune sistemului să atașeze și să înregistreze declarații la cel creat anterior sau să suprascrie jurnalele create anterior și să genereze jurnalele noi în totalitate.

'append' value= 'false' />

Valoarea parametrului fișierului este setată la o anumită locație pentru a notifica sistemului să creeze fișierul jurnal anticipat la locația menționată. De asemenea, specificăm numele fișierului jurnal în parametrul valoare.

Aspect

După cum sa discutat în primele secțiuni ale acestui tutorial, aspectele sunt utilizate pentru a specifica mecanismul de redare pentru instrucțiunile jurnal. Log4j oferă diverse modele de aspect. Utilizatorul este folosit pentru a specifica modelul dorit în valoarea parametrului ConversionPattern.

Rezultatul aspectului de mai sus ar trebui să fie ceva de genul:

01-07-2014 12:56:32 INFO (GmailLogin): Exemplu de mesaj jurnal

În rezultatul de mai sus:

  • Primul câmp - Data execuției
  • Al doilea câmp - Timp exact în hh: mm: ss la care a fost executată etapa de testare
  • Al treilea câmp - Un nivel de jurnal
  • Al patrulea câmp - Numele clasei de testare
  • Al cincilea câmp - Mesaj jurnal

Pasul 2 . De îndată ce am terminat cu crearea fișierului log4j.XML, următorul pas este să introduceți fișierul log4j.XML în directorul rădăcină / directorul de bază al proiectului.

Implementarea la nivel de program

Pasul 3 : Următorul pas este să utilizați oricare dintre configuratori pentru a configura și analiza fișierul log4j.xml.

Sintaxă:

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); } } }

Notă : Jurnalele pot fi implementate și la nivel de clasă, în loc de suita de testare. Tot ce trebuie să faceți este să faceți modificările necesare în clasa de testare, mai degrabă decât în ​​suita de testare.

Pasul 4 : Următorul pas este crearea unei clase de test „GmailLogin.java” în cadrul proiectului. Implementați funcționalitatea de conectare Gmail în cadrul clasei.

Pasul 5 : Următorul pas este să importați clasa logger pentru a putea implementa instrucțiunile jurnal.

Sintaxă:

import org.apache.log4j.Logger;

Pasul 6 : Următorul pas al procesului este instanțierea obiectului clasei Logger.

Sintaxă:

// Inițializarea obiectului pentru jurnal

static Jurnale Buturuga Logger.getLogger (Demo. clasă .getName ());

Pasul 7 : Variabila de jurnal creată mai sus de tip Logger ar fi utilizată în întreaga clasă de testare pentru a genera instrucțiunile de jurnal. Consultați următorul cod pentru același lucru.

Sintaxă:

@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.'); } }

Rezultă în fișierul jurnal

01-07-2014 12:56:11 INFO (GmailLogin): Încărcat fișierul în Sistem: FileExample.txt
01-07-2014 12:56:11 INFO (GmailLogin): Trimiterea modificărilor
01-07-2014 12:56:15 EROARE (GmailLogin): autentificare nereușită.

ACTUALIZARE în martie 2020

Jurnale

Un jurnal este un mesaj pe care îl înregistrăm sau îl generăm pentru fiecare tranzacție pe care o facem. Putem analiza jurnalele pentru a verifica ce a mers sau nu. Să presupunem că dacă vreun sistem se închide brusc atunci analizând jurnalele, putem intra în cauza principală a eșecului.

Astfel, jurnalele sunt generate în fiecare ciclu de dezvoltare. În același mod, putem genera, de asemenea, jurnale în codul nostru Selenium pentru testare înainte și după fiecare condiție de testare sau instrucțiune de testare, pentru a verifica dacă toate funcționează conform așteptărilor.

log4j Framework

Pentru a genera aceste fișiere jurnal în codul Selenium, folosim cadrul log4j furnizat de Apache. Cu acest cadru, putem genera jurnalele noastre personalizate.

Clic Aici pentru a descărca log4j jar din depozitul Maven.

Putem genera jurnale în 2 moduri:

  1. Folosind fișierul log4j.properties
  2. Folosind fișierul log4j.xml

Aceste fișiere vor conține configurația despre ce fel de jurnale doriți să generați. Puteți folosi oricare dintre ele. Dacă doriți să le utilizați pe ambele, atunci log4j.xml va avea prioritate mai mare. Modul preferat de a genera jurnale este utilizarea fișierului de proprietăți, așa că aici vom explora mai multe despre generarea numai prin fișierul de proprietăți.

Implementarea log4j

Descărcați fișierul jar log4j din calea de mai sus și adăugați-l în calea de construire a proiectului. Creați fișierul log4j.properties și adăugați fișierul de proprietăți paralel cu folderul sursă atunci când utilizați aplicația Java independentă.

aplicație Java independentă

Fișierul Log4j.properties este un fișier de configurare care stochează valori în perechea cheie-valoare.

Conține 3 componente principale:

  • Jurnalisti: Captează informații de înregistrare.
  • Anexe : Publicați informații de înregistrare într-o altă destinație preferată, cum ar fi console, fișiere, socluri, jurnale de evenimente NT etc.
  • Aspecte : Formatați informațiile de înregistrare în diferite stiluri, cum ar fi HTML, Aspect XML etc.

Sintaxa fișierului log4j.properties

# 1) Definiți loggerul rădăcină cu INFO la nivel de înregistrare și appender X (appender poate fi orice consolă, fișier, soclu, jurnal de evenimente NT).

log4j.rootLogger = INFO, X

#Două) Setați apelantul numit X să fie un fișier Appender.

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

# 3) Definiți aspectul pentru X appender.

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

log4j.properties Exemplu

Creați un fișier log4j.properties, referindu-vă la sintaxa de mai sus:

# inițializați loggerul rădăcină cu INFO de nivel și imprimați-l în consolă folosind stdout și fout.

log4j.rootLogger=INFO,stdout,fout

# adăugați un ConsoleAppender în stdout logger pentru a scrie pe consolă.

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

# folosiți un model simplu de aspect format format de mesaj definit este% m% n, care tipărește mesajele de înregistrare într-o linie nouă.

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

# adăugați un FileAppender la fout-ul logger.

log4j.appender.fout=org.apache.log4j.FileAppender

# Fișierul appender este definit ca org.apache.log4j.FileAppender. Se scrie într-un fișier numit SoftwareTestingHelp.

log4j.appender.fout.File=SoftwareTestingHelp.log

# utilizați un model de mesaj mai detaliat.

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

Diferite niveluri de exploatare

  • DEBUG
  • INFO
  • A AVERTIZA
  • EROARE
  • FATAL

Fiecare nivel are propria sa prioritate. Să presupunem că dacă folosim nivelul „DEBUG”, atunci acesta va înregistra toate mesajele de nivel precum INFO >> WARN >> ERROR >> FATAL.

Să presupunem că dacă folosim nivelul „EROARE”, atunci acesta va ignora DEBUG >> INFO >> WARN și va înregistra doar EROARE >> FATALĂ.

În toate aceste niveluri trebuie să definim în fișierul nostru de proprietăți. Jurnalele vor fi generate, în funcție de configurația noastră.

Implementarea jurnalelor pentru același exemplu menționat mai sus:

Pasul 1: Creați un obiect pentru clasa Logger.

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

Metoda de mai sus ajută la obținerea obiectului logger. Această metodă va lua ca argument fie clasa, fie numele clasei. Folosind acest obiect logger, puteți genera jurnale personalizate.

În acest exemplu, ne-am referit la cadrul apache log4j, dacă utilizați cadrul TestNG, atunci trebuie să utilizați clasa de jurnal TestNG.

Clasa jurnal TestNG

Clasa jurnal TestNG

Aici, am încercat să generăm jurnalul, fără a implementa fișierul de proprietăți.

generează jurnalul

Nu sunt generate jurnale nici în consolă, nici în niciun fișier de jurnal creat. Se primește o eroare în consolă, deoarece fișierul jurnal nu este implementat corect. Pentru a-l implementa, trebuie să folosim - clasa PropertyConfigurator. Urmați pasul 2.

Pasul 2: Inițializați fișierul de configurare a proprietăților și treceți argumentul ca numele fișierului de proprietăți log4j.

PropertyConfigurator.configure („log4j.properties”);

Cod complet pentru generarea fișierului jurnal:

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'); } }

Clasa PropertyConfigurator

Fișierul de proprietăți:

Fișierul de proprietăți

Concluzie

În tutorialul actual, ne-am concentrat asupra implicații tehnice în timpul implementării înregistrării într-un cadru. Am exploatat utilitarul log4j pentru a implementa logarea. Am discutat despre componentele de bază care constituie log4j dintr-o perspectivă de utilizare. Cu Anexele și aspectele, utilizatorul este folosit pentru a alege formatul / modelul de înregistrare dorit și sursa de date / locația.

În acest tutorial, explorăm de ce jurnalele sunt utilizate în testul nostru și în cadrul log4j acoperit și implementarea cadrului log4j în Selenium pentru generarea jurnalelor.

Următorul tutorial nr. 27 : În viitorul tutorial, am discuta câteva subiecte mai avansate legate de scripting eficient și pentru depanarea scenariilor în cazul în care utilizatorul este obligat să gestioneze evenimentele de la mouse și tastatură. Mai mult decât atât, am discuta, de asemenea, despre modul de stocare a mai multor elemente web într-o listă.

Lectură recomandată

^