Menu

Debug degli script di selenio con i registri (tutorial di Log4j) - Esercitazione di selenio # 26

debugging selenium scripts with logs selenium tutorial 26

Prova Il Nostro Strumento Per Eliminare I Problemi

Ora ci stiamo muovendo verso la fine del nostro più completo Tutorial gratuiti per lo strumento di test del selenio . I tutorial che pubblichiamo ora fanno parte della formazione avanzata sul selenio.

Nel tutorial precedente, ci siamo concentrati sul Strumento di integrazione continua denominato Hudson . È uno strumento gratuito e ha molte più capacità per costruire il progetto di test, eseguire le classi di test da remoto e inviare un'e-mail di notifica alle parti interessate informandole sullo stato dell'applicazione rispetto ai casi di test superati e falliti.

Nell'attuale tutorial, avanzeremmo verso alcuni concetti avanzati che potrebbero aiutare direttamente o indirettamente ottimizzazione del framework di automazione e porta più visibilità agli utenti.

Pertanto, nel tutorial corrente, discuteremo di funzionalità di registrazione, il suo potenziale, capacità di debug e altro ancora.

Debug degli script del selenio con i registri 1

A volte la registrazione è considerata un sovraccarico del meccanismo di creazione di script esistente, ma gli esperti la considerano una delle migliori pratiche se utilizzata nella proporzione accurata a causa dei seguenti vantaggi:

Vantaggi della registrazione negli script di selenio:

  • Garantisce una comprensione completa dell'esecuzione delle suite di test
  • I messaggi di registro possono essere archiviati in file esterni per il controllo post-esecuzione
  • I registri sono un assistente eccezionale nel debug dei problemi di esecuzione del programma e degli errori
  • I registri possono anche essere esaminati per accertare lo stato di salute dell'applicazione da parte delle parti interessate

Cosa imparerai:

Log4j: un'API di registrazione basata su Java

Passando ai dettagli tecnici sulla registrazione, discutiamo l'origine dell'API che utilizzeremo in tutto il file tutorial di log4j per generare log. Log4j è stato il risultato degli sforzi di collaborazione delle persone di Secure Electronic Marketplace for Europe per sviluppare un'utilità che ci aiutasse a generare log e quindi log4j è venuto alla ribalta nel 1996. Log4j è uno strumento open source e concesso in licenza con IBM Public License.

Ci sono tre componenti principali che costituiscono l'implementazione di log4j. Questi componenti rappresentano i dettagli sul livello di registro, i formati del messaggio di registro in cui verranno visualizzati e i relativi meccanismi di salvataggio.

Costituenti di Log4j

  1. Logger
  2. Appendici
  3. Layout

# 1) Registratori

I seguenti passaggi devono essere eseguiti per implementare i logger nel progetto.

Passo 1 : Creazione di un'istanza della classe Logger

Passo 2 : Definizione del livello di registro

Classe logger - È un'utilità basata su java che ha tutti i metodi generici già implementati in modo da poter utilizzare log4j.

Livelli di registro - I livelli di registro sono comunemente noti come metodi di stampa. Questi vengono utilizzati per stampare i messaggi di registro. Esistono principalmente cinque tipi di livelli di registro.

  • errore()
  • avvisare()
  • Informazioni()
  • debug ()
  • log ()

Pertanto, per essere in grado di generare log, tutto ciò che dobbiamo fare è chiamare uno qualsiasi dei metodi di stampa sull'istanza del logger. Lo approfondiremo durante la fase di implementazione.

# 2) Appendici

Ora che sappiamo come generare questi log, la prossima cosa che dovrebbe venirci in mente è: dove posso visualizzare i log? La risposta a questa domanda sta nella definizione di 'Appendici'.

Le appendici vengono utilizzate in modo coerente per specificare l'origine dati / il supporto in cui devono essere generati i registri. L'ambito delle origini dati si estende da vari mezzi esterni come la console, la GUI, i file di testo ecc.

# 3) Layout

A volte, l'utente desidera che determinate informazioni siano anteposte o allegate a ciascuna istruzione di registro. Ad esempio, desidero stampare un timestamp insieme alla mia dichiarazione di log. Pertanto, tali requisiti possono essere soddisfatti da 'Layout'.

I layout sono un'utilità che consente all'utente di optare per il formato desiderato in cui verranno visualizzati i log. Le appendici e il layout hanno uno stretto accoppiamento tra di loro. Pertanto, siamo tenuti a mappare ciascuna delle appendici con un layout specifico.

Prendi nota che l'utente è utilizzato per definire più appendici, ciascuna mappa con un layout distinto.

Ora che siamo consapevoli delle basi di log4j e dei suoi componenti, sposteremo la nostra attenzione verso il fenomeno dell'implementazione.

Cerchiamo di comprendere l'intero processo di implementazione passo dopo passo.

Installazione / configurazione

Per l'installazione e il setup, prenderemmo in considerazione il progetto “Learning_Selenium” che abbiamo già creato nelle sessioni precedenti di questa serie.

Passo 1 : Il primo e il più importante passo è scaricare l'ultimo jar per l'API log4j. Il barattolo può essere facilmente trovato sul suo sito web di distribuzione ufficiale - ' http://logging.apache.org/log4j/1.2/download.html '.

Passo 2 : Il passaggio successivo consiste nel configurare il percorso di compilazione e fornire log4j.jar come libreria esterna.

Implementazione

La registrazione tramite log4j può essere implementata e configurata in due modi:

  1. A livello di codice tramite script
  2. Manualmente tramite i file di configurazione

Entrambi i metodi di configurazione sopra menzionati hanno pregio oltre che demeriti. Per questo tutorial, prenderemo in considerazione la configurazione manuale di log4j tramite i file di configurazione in base alla sua facilità e semplicità. Il file di configurazione è ancora un altro file XML per configurare gli artefatti relativi a log4j.

Creazione del file log4j.xml

Passo 1 . Crea un file log4j.xml. Copia e incolla il codice sottostante nel file di configurazione.

Procedura dettagliata del file di configurazione

consoleAppender

L'appender della console viene utilizzato per stampare le istruzioni di log sulla console.

appender file

L'appender file viene utilizzato per stampare le istruzioni di registro all'interno di un file esterno. L'utente può impostare un valore di attivazione e disattivazione per il tag aggiunto che indicherebbe al sistema di aggiungere e registrare le istruzioni a quello creato in precedenza o di sovrascrivere i registri creati in precedenza e generare tutti i nuovi registri.

'append' value= 'false' />

Il valore del parametro file è impostato su una posizione particolare per notificare al sistema di creare il file di registro previsto in tale posizione. Specifichiamo anche il nome del file di registro all'interno del parametro value.

disposizione

Come discusso nelle prime sezioni di questo tutorial, i layout vengono utilizzati per specificare il meccanismo di rendering per le istruzioni di log. Log4j fornisce vari modelli di layout. L'utente viene utilizzato per specificare il modello desiderato nel valore del parametro ConversionPattern.

L'output del layout sopra dovrebbe essere qualcosa del tipo:

01-07-2014 12:56:32 INFO (GmailLogin): messaggio di log di esempio

Nell'output sopra:

  • Primo campo: data di esecuzione
  • Secondo campo - Ora esatta in hh: mm: ss in cui è stata eseguita la fase di test
  • Terzo campo: uno del livello di registro
  • Quarto campo: nome della classe di test
  • Il quinto campo: messaggio di registro

Passo 2 . Non appena abbiamo finito con la creazione del file log4j.XML, il passaggio successivo è inserire il file log4j.XML nella cartella principale / directory di base del progetto.

Implementazione a livello di programma

Passaggio 3 : Il passaggio successivo consiste nell'utilizzare uno qualsiasi dei configuratori per configurare e analizzare il file log4j.xml.

Sintassi:

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

Nota : I log possono essere implementati anche a livello di classe invece che a livello di suite di test. Tutto quello che devi fare è apportare le modifiche richieste nella classe di test piuttosto che nella suite di test.

Passaggio 4 : Il passaggio successivo consiste nel creare una classe di prova 'GmailLogin.java' nell'ambito del progetto. Implementa la funzionalità di accesso a Gmail all'interno della classe.

Passaggio 5 : Il passaggio successivo consiste nell'importare la classe logger per poter implementare le istruzioni di log.

Sintassi:

import org.apache.log4j.Logger;

Passaggio 6 : Il passaggio successivo del processo consiste nell'istanziare l'oggetto della classe Logger.

Sintassi:

// Inizializzazione dell'oggetto per il registro

statico Registri log Logger.getLogger (Demo. classe .getName ());

Passaggio 7 : La variabile di log di tipo Logger creata sopra verrebbe utilizzata in tutta la classe di test per generare le istruzioni di log. Fare riferimento al codice seguente per lo stesso.

Sintassi:

i 5 migliori downloader di mp3 per Android
@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.'); } }

Risultato nel file di registro

01-07-2014 12:56:11 INFO (GmailLogin): Caricato il file nel Sistema: FileExample.txt
01-07-2014 12:56:11 INFO (GmailLogin): invio delle modifiche
01-07-2014 12:56:15 ERRORE (GmailLogin): accesso non riuscito.

AGGIORNAMENTO a marzo 2020

Registri

Un log è un messaggio che stiamo registrando o generando per ogni transazione che facciamo. Possiamo analizzare i log per verificare cosa è andato bene o male. Supponiamo che se un sistema si chiude bruscamente, analizzando i registri, possiamo entrare nella causa principale dell'errore.

Pertanto i log vengono generati in ogni ciclo di sviluppo. Allo stesso modo, possiamo anche generare log nel nostro codice Selenium per i test prima e dopo ogni condizione di test o dichiarazione di test, per verificare se tutti funzionano come previsto.

Log4j Framework

Per generare questi file di registro nel codice Selenium, utilizziamo il framework log4j fornito da Apache. Con questo framework, possiamo generare i nostri log personalizzati.

Clic Qui per scaricare log4j jar dal repository Maven.

Possiamo generare log in 2 modi:

  1. Utilizzo del file log4j.properties
  2. Utilizzando il file log4j.xml

Questi file conterranno la configurazione sul tipo di log che desideri generare. Puoi usarne uno qualsiasi. Se desideri utilizzare entrambi, log4j.xml avrà la precedenza maggiore. Il modo preferito per generare i log è usare il file delle proprietà, quindi qui esploreremo di più sulla generazione solo tramite il file delle proprietà.

Implementazione di log4j

Scarica il file jar log4j dal percorso precedente e aggiungilo nel percorso di compilazione del progetto. Creare il file log4j.properties e aggiungere il file delle proprietà parallelamente alla cartella di origine quando si utilizza un'applicazione Java autonoma.

applicazione Java standalone

Il file Log4j.properties è un file di configurazione che memorizza i valori nella coppia chiave-valore.

Contiene 3 componenti principali:

  • Registratori: Cattura le informazioni di registrazione.
  • Appendici : Pubblica le informazioni di registrazione su una diversa destinazione preferita come console, file, socket, registri eventi NT, ecc.
  • Layout : Formatta le informazioni di registrazione in diversi stili come HTML, layout XML, ecc.

Sintassi del file log4j.properties

# 1) Definire il logger principale con il livello di registrazione INFO e l'appender X (l'appender può essere qualsiasi console, file, socket, registro eventi NT).

log4j.rootLogger = INFO, X

#Due) Imposta l'appender denominato X come file Appender.

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

# 3) Definisci il layout per l'appender X.

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

log4j.properties Esempio

Crea un file log4j.properties, facendo riferimento alla sintassi precedente:

# inizializza il logger di root con il livello INFO e lo stampa nella console usando stdout e fout.

log4j.rootLogger=INFO,stdout,fout

# aggiunge un ConsoleAppender allo stdout del logger per scrivere sulla console.

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

# usa un semplice schema di layout del formato dei messaggi definito è% m% n, che stampa i messaggi di registrazione in una nuova riga.

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

# aggiunge un FileAppender al fout logger.

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

# L'appender FILE è definito come org.apache.log4j.FileAppender. Scrive in un file denominato SoftwareTestingHelp.

log4j.appender.fout.File=SoftwareTestingHelp.log

# usa un modello di messaggio più dettagliato.

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

Diversi livelli di registrazione

  • DEBUG
  • INFORMAZIONI
  • AVVISARE
  • ERRORE
  • FATALE

Ogni livello ha la sua priorità. Supponiamo che se usiamo il livello 'DEBUG', registrerà tutti i messaggi di livello come INFO >> WARN >> ERROR >> FATAL.

Supponiamo che se usiamo il livello 'ERROR', allora ignorerà DEBUG >> INFO >> WARN e registrerà solo ERROR >> FATAL.

In tutti questi livelli dobbiamo definire nel nostro file delle proprietà. I log verranno generati, a seconda della nostra configurazione.

Implementazione dei log per lo stesso esempio di cui sopra:

Passo 1: Crea un oggetto per la classe Logger.

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

Il metodo precedente aiuta a ottenere l'oggetto logger. Questo metodo prenderà la classe o il nome della classe come argomento. Utilizzando questo oggetto logger, è possibile generare log personalizzati.

In questo esempio, abbiamo fatto riferimento al framework apache log4j, se stai usando il framework TestNG, allora devi usare la classe log TestNG.

Classe di registro TestNG

Classe di registro TestNG

Qui abbiamo provato a generare il log, senza implementare il file delle proprietà.

generare il registro

Nessun registro viene generato nella console o in qualsiasi file di registro creato. Viene ricevuto un errore nella console poiché il file di registro non è implementato correttamente. Per implementarlo, dobbiamo usare la classe - PropertyConfigurator. Segui il passaggio 2.

Passo 2: Inizializza il file Property Configurator e passa l'argomento come nome del file delle proprietà log4j.

PropertyConfigurator.configure ('log4j.properties');

Codice completo per la generazione del file di registro:

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

PropertyConfigurator classe

File delle proprietà:

File delle proprietà

Conclusione

Nel tutorial corrente, ci siamo concentrati sul implicazioni tecniche durante l'implementazione della registrazione in un framework. Abbiamo sfruttato l'utilità log4j per implementare la registrazione. Abbiamo discusso i componenti di base che costituiscono log4j dal punto di vista dell'usabilità. Con le appendici e i layout, l'utente può scegliere il formato / modello di registrazione desiderato e l'origine / posizione dei dati.

In questo tutorial, esploriamo il motivo per cui i log vengono utilizzati nel nostro framework log4j di test e coperto e l'implementazione del framework log4j in Selenium per la generazione di log.

Prossimo tutorial n. 27 : Nel prossimo tutorial, discuteremo alcuni argomenti più avanzati relativi a scripting efficiente e per risolvere gli scenari dove l'utente è tenuto a gestire gli eventi del mouse e della tastiera. Inoltre, discuteremo anche su come memorizzare più di un elemento web in un elenco.

Lettura consigliata

^