Menu

Débogage de scripts Selenium avec des journaux (Tutoriel Log4j) - Tutoriel Selenium # 26

debugging selenium scripts with logs selenium tutorial 26

Essayez Notre Instrument Pour Éliminer Les Problèmes

Nous nous dirigeons maintenant vers la fin de notre plus complet Tutoriels gratuits pour l'outil de test Selenium . Les tutoriels que nous publions maintenant font partie de la formation avancée sur Selenium.

Dans le didacticiel précédent, nous nous sommes concentrés sur la Outil d'intégration continue nommé Hudson . Il s’agit d’un outil gratuit et offre beaucoup plus de fonctionnalités pour créer le projet de test, exécuter les classes de test à distance et envoyer un e-mail de notification aux parties prenantes les informant de l’état de l’application par rapport aux cas de test réussis et échoués.

Dans le didacticiel actuel, nous nous dirigerions vers des concepts avancés qui aideraient directement ou indirectement à optimisation du cadre d'automatisation et apporte plus de visibilité aux utilisateurs.

Ainsi, dans le tutoriel actuel, nous discuterons de la fonction de journalisation, son potentiel, capacités de débogage et beaucoup plus.

Débogage de scripts Selenium avec des journaux1

Parfois, la journalisation est considérée comme une surcharge du mécanisme de création de script existant, mais les experts la considèrent comme l'une des meilleures pratiques si elle est utilisée dans les proportions exactes en raison des avantages suivants:

Avantages de la journalisation dans les scripts Selenium:

  • Donne une compréhension complète de l'exécution des suites de tests
  • Les messages de journal peuvent être stockés dans des fichiers externes pour un examen post-exécution
  • Les journaux sont un assistant exceptionnel dans le débogage des problèmes et des échecs d'exécution du programme
  • Les journaux peuvent également être consultés pour vérifier l’intégrité de l’application par les parties prenantes

Ce que vous apprendrez:

outils de test de résistance pour application web

Log4j - Une API de journalisation basée sur Java

Passant aux détails techniques sur la journalisation, discutons de l'origine de l'API que nous utiliserions tout au long de la tutoriel log4j pour générer des journaux. Log4j était le résultat des efforts de collaboration des personnes de Secure Electronic Marketplace pour l'Europe pour développer un utilitaire qui nous aiderait à générer des journaux et donc le log4j est entré en vedette en 1996. Log4j est un outil open source sous licence publique IBM.

Il existe trois composants principaux qui constituent l'implémentation de log4j. Ces composants représentent les détails sur le niveau de journalisation, les formats du message de journal dans lequel ils seraient rendus et leurs mécanismes de sauvegarde.

Constituants de Log4j

  1. Enregistreurs
  2. Appenders
  3. Mises en page

# 1) Enregistreurs

Les étapes suivantes doivent être effectuées pour implémenter les enregistreurs dans le projet.

Étape 1 : Création d'une instance de la classe Logger

Étape 2 : Définition du niveau de journalisation

Classe enregistreur - C'est un utilitaire basé sur Java qui a déjà implémenté toutes les méthodes génériques afin que nous puissions utiliser log4j.

Niveaux de journal - Les niveaux de journal sont communément appelés méthodes d'impression. Ceux-ci sont utilisés pour imprimer les messages du journal. Il existe principalement cinq types de niveaux de journalisation.

  • Erreur()
  • prévenir()
  • Info()
  • déboguer()
  • Journal()

Ainsi, pour pouvoir générer des journaux, tout ce que nous devons faire est d'appeler l'une des méthodes d'impression sur l'instance de l'enregistreur. Nous l'examinerons plus en détail pendant la phase de mise en œuvre.

# 2) Appenders

Maintenant que nous savons comment générer ces journaux, la prochaine chose qui devrait nous venir à l'esprit est la suivante: où puis-je consulter les journaux? La réponse à cette question réside dans la définition des «Appenders».

Les appenders sont systématiquement utilisés pour spécifier la source de données / le support sur lequel les journaux doivent être générés. La portée des sources de données s'étend de divers supports externes tels que la console, l'interface graphique, les fichiers texte, etc.

# 3) Mises en page

Parfois, l'utilisateur souhaite que certaines informations soient pré-ajoutées ou ajoutées à chaque instruction de journal. Par exemple, je souhaite imprimer un horodatage avec mon instruction de journal. Ainsi, de telles exigences peuvent être remplies par des «mises en page».

Les mises en page sont un utilitaire qui permet à l'utilisateur d'opter pour le format souhaité dans lequel les journaux seraient rendus. Les appenders et la mise en page sont étroitement liés. Ainsi, nous devons mapper chacun des appenders avec une disposition spécifique.

Notez que l'utilisateur est mis à profit pour définir plusieurs appenders, chaque carte ayant une disposition distincte.

Maintenant que nous sommes conscients des bases de log4j et de ses composants, nous allons orienter notre attention vers le phénomène de mise en œuvre.

Comprenons tout le processus de mise en œuvre étape par étape.

Installation / configuration

Pour l'installation et la configuration, nous envisagerions le projet «Learning_Selenium» que nous avons déjà créé dans les sessions précédentes de cette série.

Étape 1 : La première et la plus importante étape consiste à télécharger le dernier fichier jar pour l'API log4j. Le pot peut être facilement trouvé sur son site de distribution officiel - ' http://logging.apache.org/log4j/1.2/download.html ».

Étape 2 : L'étape suivante consiste à configurer le chemin de construction et à fournir log4j.jar en tant que bibliothèque externe.

Mise en œuvre

La journalisation à l'aide de log4j peut être implémentée et configurée de deux manières:

  1. Programmation via script
  2. Manuellement via les fichiers de configuration

Les deux méthodes de configuration mentionnées ci-dessus ont des avantages et des inconvénients. Pour ce didacticiel, nous envisagerions de configurer log4j manuellement via des fichiers de configuration en fonction de sa facilité et de sa simplicité. Le fichier de configuration est encore un autre fichier XML pour configurer les artefacts liés à log4j.

Création du fichier log4j.xml

Étape 1 . Créez un fichier log4j.xml. Copiez et collez le code ci-dessous dans le fichier de configuration.

Procédure pas à pas du fichier de configuration

consoleAppender

L'appender de console est utilisé pour imprimer les instructions de journal sur la console.

appender de fichier

L'ajout de fichier est utilisé pour imprimer les instructions de journal dans un fichier externe. L'utilisateur est mis à profit pour définir une valeur d'activation et de désactivation pour la balise ajoutée qui indiquerait au système d'ajouter et de consigner des instructions à celle créée précédemment ou d'écraser les journaux précédemment créés et de générer complètement les nouveaux journaux.

'append' value= 'false' />

La valeur du paramètre de fichier est fixée à un emplacement particulier pour notifier au système de créer le fichier journal anticipé audit emplacement. Nous spécifions également le nom du fichier journal dans le paramètre value.

Disposition

Comme indiqué dans les premières sections de ce didacticiel, les dispositions sont utilisées pour spécifier le mécanisme de rendu des instructions de journal. Log4j fournit divers modèles de disposition. L'utilisateur est mis à profit pour spécifier le modèle souhaité dans la valeur du paramètre ConversionPattern.

La sortie de la mise en page ci-dessus devrait être quelque chose comme:

01-07-2014 12:56:32 INFO (GmailLogin): Exemple de message de journal

Dans la sortie ci-dessus:

  • Premier champ - Date d'exécution
  • Deuxième champ - Heure exacte en hh: mm: ss à laquelle l'étape de test a été exécutée
  • Troisième champ - Un des niveaux de journalisation
  • Quatrième champ - Nom de la classe de test
  • Le cinquième champ - Message de journal

Étape 2 . Dès que nous avons terminé la création du fichier log4j.XML, l’étape suivante consiste à placer le fichier log4j.XML dans le dossier racine / répertoire de base du projet.

Mise en œuvre au niveau du programme

Étape 3 : L'étape suivante consiste à utiliser l'un des configurateurs pour configurer et analyser le fichier log4j.xml.

Syntaxe:

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

Remarque : Les journaux peuvent également être implémentés au niveau de la classe au lieu du niveau de la suite de tests. Tout ce que vous avez à faire est d'apporter les modifications requises dans la classe de test plutôt que dans la suite de tests.

Étape 4 : La toute prochaine étape consiste à créer une classe de test «GmailLogin.java» sous le projet. Implémentez la fonctionnalité de connexion Gmail dans la classe.

Étape 5 : L'étape suivante consiste à importer la classe de journalisation pour pouvoir implémenter les instructions de journal.

Syntaxe:

import org.apache.log4j.Logger;

Étape 6 : L'étape suivante du processus consiste à instancier l'objet de la classe Logger.

Syntaxe:

// Initialisation d'objet pour le journal

statique Journaux Journal Logger.getLogger (Démo. classe .getName ());

Étape 7 : La variable de journal de type Logger créée ci-dessus serait utilisée dans toute la classe de test pour générer les instructions de journal. Reportez-vous au code suivant pour le même.

Syntaxe:

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

Résultat dans le fichier journal

01-07-2014 12:56:11 INFO (GmailLogin): a téléchargé le fichier sur le système: FileExample.txt
01-07-2014 12:56:11 INFO (GmailLogin): Soumission des modifications
01-07-2014 12:56:15 ERREUR (GmailLogin): connexion infructueuse.

MISE À JOUR en mars 2020

Journaux

Un journal est un message que nous enregistrons ou générons pour chaque transaction que nous effectuons. Nous pouvons analyser les journaux pour vérifier ce qui a été correct ou incorrect. Supposons que si un système se ferme brusquement, en analysant les journaux, nous pouvons entrer dans la cause première de l'échec.

Ainsi, des journaux sont générés à chaque cycle de développement. De la même manière, nous pouvons également générer des journaux dans notre code Selenium pour les tests avant et après chaque condition de test ou instruction de test, pour vérifier si tout fonctionne comme prévu.

Framework log4j

Pour générer ces fichiers journaux en code Selenium, nous utilisons le framework log4j fourni par Apache. Avec ce framework, nous pouvons générer nos journaux personnalisés.

Cliquez sur Ici pour télécharger le fichier jar log4j depuis le référentiel Maven.

Nous pouvons générer des journaux de 2 manières:

  1. Utilisation du fichier log4j.properties
  2. Utilisation du fichier log4j.xml

Ces fichiers contiendront la configuration du type de journaux que vous souhaitez générer. Vous pouvez utiliser n'importe lequel d'entre eux. Si vous souhaitez utiliser les deux, log4j.xml aura une priorité plus élevée. La meilleure façon de générer des journaux est d'utiliser le fichier de propriétés, nous allons donc explorer plus en détail la génération via le fichier de propriétés uniquement.

Implémentation de log4j

Téléchargez le fichier jar log4j à partir du chemin ci-dessus et ajoutez-le dans le chemin de génération de votre projet. Créez le fichier log4j.properties et ajoutez le fichier de propriétés parallèlement à votre dossier source lorsque vous utilisez une application Java autonome.

application Java autonome

commandes grep sous unix avec exemples

Le fichier Log4j.properties est un fichier de configuration qui stocke les valeurs dans la paire clé-valeur.

Il contient 3 composants principaux:

  • Enregistreurs: Capture les informations de journalisation.
  • Appenders : Publiez les informations de journalisation vers une destination préférée différente comme les consoles, les fichiers, les sockets, les journaux d'événements NT, etc.
  • Mises en page : Formatez les informations de journalisation dans différents styles comme HTML, XML Layout, etc.

Syntaxe du fichier log4j.properties

#1) Définissez l'enregistreur racine avec le niveau de journalisation INFO et appender X (appender peut être n'importe quelle console, fichier, sockets, journaux d'événements NT).

log4j.rootLogger = INFO, X

#deux) Définissez l'appender nommé X comme File Appender.

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

# 3) Définissez la mise en page de l'appender X.

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

Exemple de log4j.properties

Créez un fichier log4j.properties, en vous référant à la syntaxe ci-dessus:

# initialisez l'enregistreur racine avec le niveau INFO et imprimez-le dans la console en utilisant stdout et fout.

log4j.rootLogger=INFO,stdout,fout

# ajoutez un ConsoleAppender à la sortie stdout du journal pour écrire dans la console.

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

# utiliser un modèle de mise en page de format de message simple défini est% m% n, qui imprime les messages de journalisation dans une nouvelle ligne.

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

# ajoutez un FileAppender à la fout logger.

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

# L'appender FILE est défini comme org.apache.log4j.FileAppender. Il écrit dans un fichier nommé SoftwareTestingHelp.

log4j.appender.fout.File=SoftwareTestingHelp.log

# utiliser un modèle de message plus détaillé.

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

Différents niveaux de journalisation

  • DÉBOGUER
  • INFO
  • PRÉVENIR
  • ERREUR
  • MORTEL

Chaque niveau a sa propre priorité. Supposons que si nous utilisons le niveau «DEBUG», alors il enregistrera tous les messages de niveau comme INFO >> WARN >> ERROR >> FATAL.

Supposons que si nous utilisons le niveau «ERROR», alors il ignorera DEBUG >> INFO >> WARN et il n'enregistrera que ERROR >> FATAL.

Dans tous ces niveaux, nous devons définir dans notre fichier de propriétés. Les journaux seront générés, en fonction de notre configuration.

Implémentation des journaux pour le même exemple mentionné ci-dessus:

Étape 1: Créez un objet pour la classe Logger.

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

La méthode ci-dessus permet d'obtenir l'objet enregistreur. Cette méthode prendra soit la classe, soit le nom de la classe comme argument. À l'aide de cet objet de journalisation, vous pouvez générer des journaux personnalisés.

Dans cet exemple, nous avons fait référence au framework apache log4j, si vous utilisez le framework TestNG, vous devez utiliser la classe de journal TestNG.

Classe de journal TestNG

Classe de journal TestNG

Ici, nous avons essayé de générer le journal, sans implémenter le fichier de propriétés.

générer le journal

Aucun journal n'est généré dans la console ni dans aucun fichier journal créé. Une erreur est reçue dans la console car le fichier journal n'est pas correctement implémenté. Pour l'implémenter, nous devons utiliser la classe PropertyConfigurator. Suivez l'étape 2.

Étape 2: Initialisez le fichier du configurateur de propriétés et transmettez l'argument comme nom du fichier de propriétés log4j.

PropertyConfigurator.configure («log4j.properties»);

Code complet pour la génération du fichier journal:

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

Fichier de propriétés:

Fichier de propriétés

Conclusion

Dans le didacticiel actuel, nous nous sommes concentrés sur la implication technique lors de la mise en œuvre de la journalisation dans un cadre. Nous avons exploité l'utilitaire log4j pour implémenter la journalisation. Nous avons discuté des composants de base qui constituent log4j du point de vue de la convivialité. Avec les ajouts et les mises en page, l'utilisateur est mis à profit pour choisir le format / modèle de journalisation souhaité et la source / l'emplacement des données.

Dans ce didacticiel, nous explorons pourquoi les journaux sont utilisés dans notre cadre de test et couvert log4j, ainsi que l'implémentation du cadre log4j dans Selenium pour générer des journaux.

Tutoriel suivant # 27 : Dans le prochain didacticiel, nous aborderons des sujets plus avancés liés à scripts efficaces et pour dépanner des scénarios où l'utilisateur doit gérer les événements de la souris et du clavier. De plus, nous discuterons également de la manière de stocker plus d'un élément Web dans une liste.

lecture recommandée