We shall discuss how to introduce logging to our tests and how logging is important. After execution of test cases if we want to know the failures and how the test execution has taken place, we look at the test reports. However, if we want to investigate why the failures have taken place we should have proper logging in our code.<\/p>\n
The logs should describe each step of the test script. So that in case of failures we can find the root cause of the failure easily. There should be a separate file<\/b> maintained for the logging purpose. Any non-technical person <\/b>like business analysts, manual test engineers <\/b>and so on <\/b>should be able to open the log file and understand<\/b> which step of the test case failed and for what reason.<\/p>\n
As per industry standards, the logging is followed in the below format:<\/p>\n
<time stamp> : <Logging levels> : <test case name> : <Log message><\/b><\/p>\n
The timestamp of when the actual test step gets executed should be captured in the log file. The logging levels are of different types like DEBUG, INFO, WARNING, ERROR<\/b> and CRITICAL.<\/b> The INFO<\/b> logging level is used to message the purpose<\/b> of the test step. The WARNING<\/b> logging level is used to alert<\/b> the user of a particular step. However it does not indicate a failure in the test step. If the expected result has not matched with the actual result [for example: failure in assertion], the ERROR<\/b> logging level is used. If there is a test that is blocking the entire execution, then CRITICAL<\/b> logging level is used. The DEBUG<\/b> logging level is used to give debugging<\/b> information useful for the developer.<\/b><\/p>\n
The below image shows a sample log file with logging.<\/p>\n
<\/p>\n
Conclusion: Thus we have discussed what logs are and its importance. For more details, you can refer to the link:<\/p>\n
https:\/\/courses.rahulshettyacademy.com\/courses\/learn-selenium-automation-in-easy-python-language\/lectures\/13248498<\/a><\/p>\n In the next section we shall discuss the importance of Filehandler in logging.<\/p>\n To implement logging in Python, we have to import package logging by adding the statement import logging <\/b>in our code. This is by default available with Python and we don\u2019t have to download any external plugin for that.<\/p>\n Next we have to create an object of the logging class with the help of the getLogger<\/b> method.<\/p>\n logger = logging.getLogger()<\/b><\/p>\n The logger object is responsible for all the loggings. In the log file, it is essential to have the test case name to get its corresponding log information. To capture the test case file name at the run time, we shall pass the argument __name__<\/b> to the getLogger<\/b> method. In this way, the name gets printed in the log file. If the argument is omitted in the getLogger<\/b> method, the root<\/b> is printed in the log file.<\/p>\n logger = logging.getLogger(__name__)<\/b><\/p>\n Next we shall add the logging levels with the logger<\/b> object. The ways to use the logging levels are described below.<\/p>\n Now the logger object should have the knowledge of the location and the format of the log file where the logging levels along with their message needs to be captured. We shall then call the addHandler<\/b> method with the help of the logger object.<\/p>\n There is FileHandler<\/b> class [is a part of the parent logging<\/b> package] that accepts the location of the log file as an argument. We shall then create a filehandler<\/b> object of that class and pass that as an argument to the addHandler method. The filehandler<\/b> object has the knowledge of the location of the log file.<\/p>\n fileHandler = logging.FileHandler(‘logfile.log’)<\/b><\/p>\n logger.addHandler(fileHandler)<\/b><\/p>\n Now we shall explore how to describe the format of the log file. For this we have to take help of the Formatter<\/b> class [is a part of the parent logging<\/b> package] that accepts the format in which the log file as an argument. There are multiple formats to capture the content of the log file. But here we shall discuss the mostly widely used industry standard format of the log file.<\/p>\n First to get the current date and time in the below format in Python, we have to pass the value as %(asctime)s.<\/b><\/p>\n Next to describe the logging level in the log file, we have to pass the value as %(levelname)s. <\/b>Then the test case name or the test file name can be added to the log file by passing %(name)s <\/b>as an argument to the Formatter class. Finally %(message)s <\/b>is passed as argument to print the logging message.<\/p>\n To sum up, we shall pass the parameters – %(asctime)s, %(levelname)s, %(name)s <\/b>and %(message)s <\/b>one by one separated by :<\/b> as arguments to the Formatter class.<\/p>\n logging.Formatter(“%(asctime)s :%(levelname)s : %(name)s :%(message)s”)<\/b><\/p>\n Our next task is to pass the Formatter class information to the logger object. For this we shall first store logging.Formatter<\/b> in an object variable named formatter<\/b>. We shall then call the setFormatter<\/b> method with the help of the fileHandler<\/b> object and pass the formatter <\/b>object as an argument to that method.<\/p>\n fileHandler.setFormatter(formatter)<\/b><\/p>\n Thus our formatter<\/b> object is now logically connected to the fileHandler<\/b> object. This fileHandler<\/b> object is connected to the logger<\/b> object with the help of the addHandler<\/b> method. So the logger object holds information of both the log file location and format in which logging information is to be captured.<\/p>\n Finally we have to set the level of logging in the log file. For that we shall call the setLevel<\/b> method with the help of the logger object. Then pass the logging level as a parameter to that method.<\/p>\n Please note the logging levels follow the below hierarchy:<\/p>\n This means if we set the logging level to INFO, then all the logs from the INFO, WARNING, ERROR and CRITICAL shall get captured in the log file. If it is set to ERROR, only the ERROR and CRITICAL logs shall be reflected in the log file.<\/p>\n import logging<\/b><\/p>\n def test_logDemo():<\/b><\/p>\n # to get the name of the test case file name at runtime<\/b><\/p>\n logger = logging.getLogger(__name__)<\/b><\/p>\n # FileHandler class to set the location of log file<\/b><\/p>\n fileHandler = logging.FileHandler(‘logfile.log’)<\/b><\/p>\n # Formatter class to set the format of log file<\/b><\/p>\n formatter = logging.Formatter(“%(asctime)s :%(levelname)s : %(name)s :%(message)s”)<\/b><\/p>\n # object of FileHandler gets formatting info from setFormatter #method<\/b><\/p>\n fileHandler.setFormatter(formatter)<\/b><\/p>\n # logger object gets formatting, path of log file info with addHandler #method<\/b><\/p>\n logger.addHandler(fileHandler) <\/b><\/p>\n # setting logging level to INFO<\/b><\/p>\n logger.setLevel(logging.INFO)<\/b><\/p>\n # logging debug message with logger object<\/b><\/p>\n logger.debug(“A debug statement is executed”)<\/b><\/p>\n # logging info message with logger object<\/b><\/p>\n logger.info(“An information statement is executed”)<\/b><\/p>\n # logging warning message with logger object<\/b><\/p>\n logger.warning(“A warning message is executed”)<\/b><\/p>\n # logging error message with logger object<\/b><\/p>\n logger.error(“An error message is executed”)<\/b><\/p>\n # logging critical message with logger object<\/b><\/p>\n logger.critical(“A critical message is executed”)<\/b><\/p>\n Output:<\/strong><\/p>\n A new file named logfile.log<\/b> gets created in the project folder. The log file contains the date and time stamp, the logging levels, test case file name pytestDemo<\/b>.test_p <\/b>and the logging messages.<\/p>\n As we set the logging level to INFO, INFO, WARNING, ERROR<\/b> and CRITICAL<\/b> logging messages are captured. The DEBUG<\/b> log message is skipped. This is as per the hierarchy of logging levels discussed.<\/p>\n Thus we have discussed the importance of Filehandler in logging in Python. For more details, you can refer to the links:<\/p>\n https:\/\/courses.rahulshettyacademy.com\/courses\/learn-selenium-automation-in-easy-python-language\/lectures\/13248501<\/a><\/p>\nImportance of Filehandler in Logging tests<\/b><\/h3>\n
\n
<\/p>\n
\n
Code Implementation<\/h5>\n
<\/strong><\/p>\n
Conclusion<\/h3>\n