debugging selenium scripts with logs selenium tutorial 26
Teraz zbliżamy się do końca naszego najbardziej wszechstronnego Darmowe samouczki dla narzędzia do testowania selenu . Samouczki, które teraz publikujemy, są częścią zaawansowanego szkolenia Selenium.
W poprzednim samouczku skupialiśmy się na Narzędzie Continuous Integration o nazwie Hudson . Jest to bezpłatne narzędzie i ma znacznie więcej możliwości budowania projektu testowego, zdalnego wykonywania zajęć testowych i wysyłania wiadomości e-mail z powiadomieniem do interesariuszy, informując ich o stanie aplikacji w odniesieniu do przypadków testowych, które przeszły i nie powiodły się.
W tym samouczku wskazalibyśmy pewne zaawansowane koncepcje, które bezpośrednio lub pośrednio pomogłyby optymalizacja struktury automatyzacji i zapewnia większą widoczność użytkownikom.
Dlatego w obecnym samouczku omówimy funkcja logowania, jej potencjał, możliwości debugowania i wiele więcej.
Czasami rejestrowanie jest uważane za obciążenie dla istniejącego mechanizmu tworzenia skryptów, ale eksperci uważają, że jest to jedna z najlepszych praktyk, jeśli jest używane w odpowiednich proporcjach ze względu na następujące zalety:
Zalety logowania w skryptach selenium:
- Zapewnia pełne zrozumienie wykonywania zestawów testów
- Komunikaty dziennika mogą być przechowywane w plikach zewnętrznych w celu kontroli po wykonaniu
- Dzienniki są wyjątkowym pomocnikiem w debugowaniu problemów z wykonywaniem programów i awarii
- Dzienniki mogą być również przeglądane w celu ustalenia stanu aplikacji przez interesariuszy
Czego się nauczysz:
Log4j - oparty na języku Java interfejs API do rejestrowania
Przechodząc do szczegółów technicznych dotyczących logowania, omówmy pochodzenie interfejsu API, którego będziemy używać w całym samouczek log4j do generowania dzienników. Log4j był wynikiem wspólnych wysiłków ludzi z Secure Electronic Marketplace for Europe w celu opracowania narzędzia, które pomogłoby nam w generowaniu dzienników, dlatego też log4j znalazł się w centrum uwagi w 1996 roku. Log4j jest narzędziem open source i jest licencjonowane na licencji IBM Public License.
Istnieją trzy główne komponenty, które składają się na implementację log4j. Te komponenty przedstawiają szczegóły dotyczące poziomu dziennika, formatów komunikatu dziennika, w którym byłyby renderowane, oraz ich mechanizmów zapisywania.
Składniki Log4j
- Rejestratory
- Appenders
- Układy
1) Rejestratory
Aby zaimplementować rejestratory w projekcie, należy wykonać następujące kroki.
strona do oglądania anime online za darmo
Krok 1 : Tworzenie instancji klasy Logger
Krok 2 : Definiowanie poziomu dziennika
Logger Class - Jest to narzędzie oparte na Javie, które ma już zaimplementowane wszystkie ogólne metody, dzięki czemu możemy używać log4j.
Poziomy dziennika - Poziomy dziennika są powszechnie znane jako metody drukowania. Są one używane do drukowania komunikatów dziennika. Istnieje pięć rodzajów poziomów dziennika.
- błąd()
- ostrzec()
- info ()
- odpluskwić()
- log()
Tak więc, aby móc generować dzienniki, wystarczy wywołać dowolną metodę drukowania za pośrednictwem instancji rejestratora. Na etapie wdrażania przyjrzymy się temu szerzej.
# 2) Appenders
Teraz, gdy wiemy, jak wygenerować te dzienniki, następną rzeczą, która powinna pojawić się w naszych głowach, jest to, gdzie mogę wyświetlić dzienniki? Odpowiedź na to pytanie znajduje się w definicji „Appenders”.
Dodatki są konsekwentnie używane do określania źródła / nośnika danych, na którym mają być generowane dzienniki. Zakres źródeł danych rozciąga się od różnych zewnętrznych nośników, takich jak konsola, GUI, pliki tekstowe itp.
# 3) Układy
Czasami użytkownik chce, aby pewne informacje były poprzedzane lub dołączane do każdej instrukcji dziennika. Na przykład chcę wydrukować znacznik czasu wraz z moim wyciągiem z dziennika. Zatem takie wymagania można spełnić za pomocą „układów”.
Układy to narzędzie, które pozwala użytkownikowi wybrać żądany format, w jakim dzienniki będą renderowane. Appenders i Layout mają ścisłe powiązanie między nimi. W związku z tym jesteśmy zobowiązani do odwzorowania każdego z dołączających za pomocą określonego układu.
Zwróć uwagę, że użytkownik jest wykorzystywany do definiowania wielu dołączających, z których każda ma inny układ.
Teraz, gdy jesteśmy świadomi podstaw log4j i jego składników, skupimy się na zjawisku implementacji.
Pozwól nam zrozumieć krok po kroku cały proces wdrożenia.
Instalacja / konfiguracja
W przypadku instalacji i konfiguracji rozważalibyśmy projekt „Learning_Selenium”, który stworzyliśmy już we wcześniejszych sesjach z tej serii.
Krok 1 : Pierwszym i najważniejszym krokiem jest pobranie najnowszego jar dla API log4j. Słoik można łatwo znaleźć na oficjalnej stronie dystrybucji - „ http://logging.apache.org/log4j/1.2/download.html ”.
Krok 2 : Następnym krokiem jest skonfigurowanie ścieżki budowania i udostępnienie log4j.jar jako biblioteki zewnętrznej.
Realizacja
Logowanie za pomocą log4j można zaimplementować i skonfigurować na dwa sposoby:
- Programowo za pomocą skryptu
- Ręcznie za pośrednictwem plików konfiguracyjnych
Obie wyżej wymienione metody konfiguracji mają swoje zalety i wady. W tym samouczku rozważymy ręczne skonfigurowanie log4j za pomocą plików konfiguracyjnych w oparciu o jego łatwość i prostotę. Plik konfiguracyjny to kolejny plik XML do konfigurowania artefaktów związanych z log4j.
Utworzenie pliku log4j.xml
Krok 1 . Utwórz plik log4j.xml. Skopiuj i wklej poniższy kod w pliku konfiguracyjnym.
Przewodnik po pliku konfiguracyjnym
consoleAppender
Program dołączający konsolę służy do drukowania instrukcji dziennika na konsoli.
appender pliku
Program dołączający plik jest używany do drukowania instrukcji dziennika w pliku zewnętrznym. Użytkownik jest wykorzystywany do ustawiania wartości włączania i wyłączania dla dołączonego tagu, który informowałby system o dołączaniu i zapisywaniu instrukcji do wcześniej utworzonego lub nadpisywaniu wcześniej utworzonych dzienników i generowaniu nowych dzienników.
'append' value= 'false' />
Wartość parametru pliku jest ustawiana na określoną lokalizację, aby powiadomić system o utworzeniu przewidywanego pliku dziennika we wspomnianej lokalizacji. W parametrze value określamy również nazwę pliku dziennika.
Układ
Jak omówiono we wczesnych sekcjach tego samouczka, układy są używane do określenia mechanizmu renderowania instrukcji dziennika. Log4j udostępnia różne wzorce układu. Użytkownik jest wykorzystywany do określenia żądanego wzorca w wartości parametru ConversionPattern.
Wynik powyższego układu powinien wyglądać następująco:
01-07-2014 12:56:32 INFO (GmailLogin): Przykładowy komunikat dziennika
Na powyższym wyjściu:
- Pierwsze pole - Data wykonania
- Drugie pole - Dokładny czas w gg: mm: ss, w którym został wykonany krok testowy
- Trzecie pole - jedno z poziomów dziennika
- Czwarte pole - nazwa klasy testowej
- Piąte pole - komunikat dziennika
Krok 2 . Gdy tylko zakończymy tworzenie pliku log4j.XML, następnym krokiem jest umieszczenie pliku log4j.XML w folderze głównym / katalogu podstawowym projektu.
Wdrażanie na poziomie programu
Krok 3 : Następnym krokiem jest użycie dowolnego z konfiguratorów do skonfigurowania i przeanalizowania pliku log4j.xml.
Składnia:
najlepsze strony internetowe do oglądania darmowych anime
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); } } }
Uwaga : Logi można zaimplementować na poziomie klasy również zamiast poziomu zestawu testów. Wszystko, co musisz zrobić, to wprowadzić wymagane zmiany w klasie testowej, a nie w zestawie testów.
Krok 4 : Następnym krokiem jest utworzenie klasy testowej „GmailLogin.java” w ramach projektu. Zaimplementuj w klasie funkcję logowania do Gmaila.
Krok 5 : Następnym krokiem jest zaimportowanie klasy programu rejestrującego, aby móc zaimplementować instrukcje dziennika.
Składnia:
import org.apache.log4j.Logger;
Krok 6 : Następnym krokiem procesu jest utworzenie instancji obiektu klasy Logger.
Składnia:
// Inicjalizacja obiektu dla dziennika
statyczny Dzienniki log Logger.getLogger (Demo. klasa .getName ());
Krok 7 : Powyższa zmienna dziennika typu Logger byłaby używana w całej klasie testowej do generowania instrukcji dziennika. Zobacz poniższy kod dla tego samego.
Składnia:
@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.'); } }
Wynik w pliku dziennika
01-07-2014 12:56:11 INFO (GmailLogin): przesłano plik do systemu: FileExample.txt
01-07-2014 12:56:11 INFO (GmailLogin): Przesyłanie zmian
01-07-2014 12:56:15 ERROR (GmailLogin): Nieudane logowanie.
AKTUALIZACJA w marcu 2020 r
Dzienniki
Dziennik to wiadomość, którą rejestrujemy lub generujemy dla każdej wykonywanej przez nas transakcji. Możemy analizować dzienniki, aby sprawdzić, co poszło dobrze, a co nie. Załóżmy, że jeśli jakikolwiek system nagle się zamyka, to analizując dzienniki, możemy znaleźć główną przyczynę awarii.
W ten sposób dzienniki są generowane w każdym cyklu rozwoju. W ten sam sposób możemy również generować dzienniki w naszym kodzie Selenium do testowania przed i po każdym warunku testowym lub instrukcji testowej, aby sprawdzić, czy wszystkie działają zgodnie z oczekiwaniami.
log4j Framework
Aby wygenerować te pliki dziennika w kodzie Selenium, używamy frameworka log4j dostarczonego przez Apache. Dzięki tej strukturze możemy generować nasze niestandardowe dzienniki.
Kliknij tutaj aby pobrać plik log4j jar z repozytorium Maven.
Logi możemy generować na 2 sposoby:
- Korzystanie z pliku log4j.properties
- Korzystanie z pliku log4j.xml
Pliki te będą zawierać konfigurację dotyczącą rodzaju dzienników, które chcesz generować. Możesz użyć dowolnego z nich. Jeśli chcesz używać obu, wyższy priorytet będzie miał plik log4j.xml. Preferowanym sposobem generowania dzienników jest użycie pliku właściwości, więc tutaj omówimy więcej na temat generowania tylko za pomocą pliku właściwości.
Implementacja log4j
Pobierz plik jar log4j z powyższej ścieżki i dodaj go do ścieżki budowania projektu. Utwórz plik log4j.properties i dodaj plik właściwości równolegle do folderu źródłowego, jeśli używasz autonomicznej aplikacji Java.
Plik Log4j.properties to plik konfiguracyjny przechowujący wartości w parze klucz-wartość.
Zawiera 3 główne składniki:
- Rejestratory: Przechwytuje informacje logowania.
- Appenders : Publikuj informacje logowania w innym preferowanym miejscu docelowym, takim jak konsole, pliki, gniazda, dzienniki zdarzeń NT itp.
- Układy : Formatuj informacje logowania w różnych stylach, takich jak HTML, układ XML itp.
Składnia pliku log4j.properties
# 1) Zdefiniuj główny program rejestrujący z poziomem rejestrowania INFO i aplikatorem X (appender może być dowolna konsola, pliki, gniazda, dzienniki zdarzeń NT).
log4j.rootLogger = INFO, X
#dwa) Ustaw program dołączający o nazwie X, aby był aplikatorem plików.
log4j.appender.X = org.apache.log4j.FileAppender
# 3) Zdefiniuj układ dla X appender.
log4j.appender.X.layout = org.apache.log4j.PatternLayout log4j.appender.X.layout.conversionPattern = %m%n
log4j.properties Przykład
Utwórz plik log4j.properties, korzystając z powyższej składni:
# zainicjuj root logger z poziomem INFO i wydrukuj go w konsoli używając stdout i fout.
log4j.rootLogger=INFO,stdout,fout
# dodaj ConsoleAppender do standardowego wyjścia loggera, aby zapisywać w konsoli.
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
# użyj prostego wzorca układu formatu wiadomości, zdefiniowanego jako% m% n, który wyświetla komunikaty logowania w nowej linii.
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout log4j.appender.stdout.layout.ConversionPattern=%m%n
# dodaj FileAppender do loggera.
log4j.appender.fout=org.apache.log4j.FileAppender
# Plik appender PLIK jest zdefiniowany jako org.apache.log4j.FileAppender. Zapisuje do pliku o nazwie SoftwareTestingHelp.
log4j.appender.fout.File=SoftwareTestingHelp.log
# użyj bardziej szczegółowego wzorca wiadomości.
log4j.appender.fout.layout=org.apache.log4j.PatternLayout log4j.appender.fout.layout.ConversionPattern=%p %d{ISO8601} %r %c (%t) %m%n
Różne poziomy rejestrowania
- ODPLUSKWIĆ
- INFO
- OSTRZEC
- BŁĄD
- FATALNY
Każdy poziom ma swój własny priorytet. Załóżmy, że jeśli użyjemy poziomu „DEBUG”, będzie on rejestrował wszystkie komunikaty poziomu, takie jak INFO >> WARN >> ERROR >> FATAL.
Załóżmy, że jeśli użyjemy poziomu „ERROR”, to zignoruje DEBUG >> INFO >> WARN i zarejestruje tylko ERROR >> FATAL.
Na wszystkich tych poziomach musimy zdefiniować w naszym pliku właściwości. Dzienniki zostaną wygenerowane w zależności od naszej konfiguracji.
Implementacja dzienników dla tego samego przykładu, o którym mowa powyżej:
Krok 1: Utwórz obiekt dla klasy Logger.
final static Logger logger = Logger.getLogger(Frame.class);
Powyższa metoda pomaga w uzyskaniu obiektu rejestratora. Ta metoda przyjmuje klasę lub nazwę klasy jako argument. Korzystając z tego obiektu rejestrującego, można generować dostosowane dzienniki.
W tym przykładzie odwołaliśmy się do frameworka Apache log4j, jeśli używasz frameworka TestNG, musisz użyć klasy dziennika TestNG.
Tutaj próbowaliśmy wygenerować dziennik bez implementowania pliku właściwości.
Żadne dzienniki nie są generowane ani w konsoli, ani w żadnym utworzonym pliku dziennika. W konsoli pojawił się błąd, ponieważ plik dziennika nie jest poprawnie zaimplementowany. Aby to zaimplementować, potrzebujemy klasy - PropertyConfigurator. Wykonaj krok 2.
Krok 2: Zainicjuj plik Property Configurator i przekaż argument jako nazwę pliku właściwości log4j.
PropertyConfigurator.configure („log4j.properties”);
Kompletny kod do generowania pliku dziennika:
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'); } }
Plik właściwości:
Wniosek
W bieżącym samouczku skupiliśmy się na implikacje techniczne przy wdrażaniu logowania w ramach. Do implementacji logowania wykorzystaliśmy narzędzie log4j. Omówiliśmy podstawowe komponenty, które tworzą log4j z perspektywy użyteczności. Dzięki aplikatorom i układom użytkownik może wybrać żądany format / wzorzec rejestrowania oraz źródło / lokalizację danych.
SQL Database Pytania i odpowiedzi do wywiadów
W tym samouczku wyjaśnimy, dlaczego dzienniki są używane w naszym testowym i omówionym frameworku log4j oraz implementacji frameworka log4j w Selenium do generowania dzienników.
Następny samouczek # 27 : W nadchodzącym samouczku omówimy bardziej zaawansowane tematy związane z wydajne tworzenie skryptów i rozwiązywanie problemów w scenariuszach gdzie użytkownik musi obsługiwać zdarzenia myszy i klawiatury. Ponadto omówilibyśmy również, jak przechowywać więcej niż jeden element sieciowy na liście.
rekomendowane lektury
- Dogłębne samouczki dotyczące Eclipse dla początkujących
- Wprowadzenie do Selenium WebDriver - samouczek Selenium # 8
- Efektywne skrypty Selenium i scenariusze rozwiązywania problemów - samouczek Selenium nr 27
- Cucumber Selenium Tutorial: Cucumber Java Selenium Integracja WebDriver
- 30+ najlepszych samouczków dotyczących selenu: naucz się selenu z prawdziwymi przykładami
- Jak zlokalizować elementy w przeglądarkach Chrome i IE do tworzenia skryptów selenium - Samouczek Selenium nr 7
- Wdrożenie naszego pierwszego skryptu WebDriver - Selenium WebDriver Tutorial # 10
- WebDriver Cała konfiguracja i instalacja z Eclipse - samouczek Selenium # 9