def log_message(self, message="", args=None, message_type=MessageType.INFORMATION):
super(FileLogger, self).log_message(message, args, message_type)
# If the message level is greater that the current log level then do not log it.
if super(FileLogger, self).should_message_be_logged(message_type):
# Log the message
try:
writer = open(super().get_file_path(), "w")
date_object = datetime.now()
date_format = date_object.strftime(Logger.DEFAULT_DATE_FORMAT)
date = date_format.format(date_object)
# Set the style
writer.write(self.get_text_with_color_flag(message_type))
# Add the content
writer.write(StringProcessor.safe_formatter("{}{}", [os.linesep, date]))
writer.write(StringProcessor.safe_formatter("{}:\t", message_type.name()))
writer.write(StringProcessor.safe_formatter(os.linesep + message, args))
# Close off the style
writer.write("</p>")
# Close the pre tag when logging Errors
if message_type is "ERROR":
writer.write("</pre>")
except Exception as e:
# Failed to write to the event log, write error to the console instead
console_logger = ConsoleLogger()
console_logger.log_message(MessageType.ERROR,
StringProcessor.safe_formatter(self.LOG_ERROR_MESSAGE, e.args))
console_logger.log_message(message_type, message, args)
def assertFalse(self, condition, soft_assert_name, failure_message=""):
if condition:
if failure_message is None:
raise SoftAssertException(
StringProcessor.safe_formatter(
"SoftAssert.IsFalse failed for: {}", soft_assert_name))
raise SoftAssertException(
StringProcessor.safe_formatter(
"SoftAssert.IsFalse failed for: {}. {}",
[soft_assert_name, failure_message]))
return self.invoke_test(self.test_name, soft_assert_name,
failure_message)
def log_message(self, expected_text, actual_text, message, result):
if result:
self.Log.log_message(
MessageType.SUCCESS,
StringProcessor.safe_formatter(
"Soft Assert '{}' passed. Expected Value = '{}', Actual Value = '{}'.",
[message, expected_text, actual_text]))
else:
self.Log.log_message(
MessageType.WARNING,
StringProcessor.safe_formatter(
"Soft Assert '{}' failed. Expected Value = '{}', Actual Value = '{}'.",
[message, expected_text, actual_text]))
def write_to_console(self, line, message, args, message_type):
# Just return if there is no message
if message is None or not self.should_message_be_logged(message_type):
return
result = StringProcessor.safe_formatter(message, args)
try:
# If this a write-line command
if line:
print(result)
else:
print(result)
except Exception as e:
print(StringProcessor.safe_formatter(
"Failed to write to the console because: {}", e.args))
def assertEquals(self,
expected_text,
actual_text,
soft_assert_name,
message=""):
if expected_text is not actual_text:
if message is not None:
raise SoftAssertException(StringProcessor().safe_formatter(
"SoftAssert.AreEqual failed for {}. Expected '{}' but got '{}'",
[soft_assert_name, expected_text, actual_text]))
raise SoftAssertException(StringProcessor().safe_formatter(
"SoftAssert.AreEqual failed for {}. Expected '{}' but got '{}'. {}",
[soft_assert_name, expected_text, actual_text, message]))
return self.invoke_test_text(self.test_name, expected_text,
actual_text, message)
def get_logging_level_setting(self, default_value=None):
value = str(self.config.get_general_value("LogLevel",
default_value)).upper()
if value == "VERBOSE":
# Includes this and all of those below
return MessageType.VERBOSE.name
elif value == "INFORMATION":
# Includes this and all of those below
return MessageType.INFORMATION.name
elif value == "GENERIC":
# Includes this and all of those below
return MessageType.GENERIC.name
elif value == "SUCCESS":
# Includes this and all of those below
return MessageType.SUCCESS.name
elif value == "WARNING":
# Includes this and all of those below
return MessageType.WARNING.name
elif value == "ERROR":
# Includes this and all of those below
return MessageType.ERROR.name
elif value == "SUSPENDED":
# Includes this and all of those below
return MessageType.SUSPENDED.name
else:
raise AttributeError(
StringProcessor.safe_formatter(
"Logging level value '{}' is not a valid option",
Config().get_general_value("LogLevel")))
def unknown_message_type_message(new_type):
args = [
new_type, os.linesep,
"Message will be displayed with the MessageType of: ",
MessageType.GENERIC.Name
]
return StringProcessor.safe_formatter("Unknown MessageType: {}{}{}{}",
args)
def test_ThrowSingleExceptionSafeFormatter(self):
try:
raise SyntaxError("Format Exception")
except SyntaxError as e:
formatted_exception = StringProcessor.safe_exception_formatter(e)
self.assertTrue("Format Exception" in formatted_exception)
self.assertTrue("utilitiesUnitTest\\StringProcessorUnitTest.py" in formatted_exception)
self.assertTrue("in test_ThrowSingleExceptionSafeFormatter" in formatted_exception)
def close(self):
if os.path.exists(self.get_file_path()):
try:
writer = open(self.get_file_path(), "w")
writer.write("</body></html>")
except IOError as e:
console_logger = ConsoleLogger()
console_logger.log_message(MessageType.ERROR,
StringProcessor.safe_formatter(self.LOG_ERROR_MESSAGE, e.getMessage()))
def __init__(self, log_folder="", append=False, message_level=MessageType.INFORMATION,
log_name=DEFAULT_LOG_NAME):
super().__init__(log_folder, append, message_level, log_name)
try:
writer = open(super().get_file_path(), "w")
writer.write(self.DEFAULT_HTML_HEADER)
except IOError as e:
console = ConsoleLogger()
console.log_message(MessageType.ERROR,
StringProcessor.safe_formatter(self.LOG_ERROR_MESSAGE, e.args))
def log_verbose(self, message, args=None):
messages = list()
messages.append(
StringProcessor.safe_formatter(message, args) + os.linesep)
for element in traceback.format_exc():
# If the stack trace element is from the com.magenic package
# (excluding this method) append the stack trace line
if element.startsWith("com.magenic") and not ("BaseTest.logVerbose"
in str(element)):
messages.append(element + os.linesep)
self.get_logger().logMessage(MessageType.VERBOSE, messages)
def test_FileLoggerNoParameters(self):
file_logger = FileLogger("")
self.assertEquals(
tempfile.TemporaryFile(), file_logger.get_directory(),
StringProcessor.safe_formatter("Expected Directory '{}'.",
file_logger.DEFAULT_LOG_FOLDER))
self.assertEquals("FileLog.txt", file_logger.get_file_name(),
"Expected correct File Name.")
self.assertEquals(MessageType.INFORMATION,
file_logger.get_message_type(),
"Expected Information Message Type.")
os.remove(file_logger.get_file_path())
self.assertTrue(path.exists(file_logger.get_file_path()))
def test_FileLoggerAppendMessagingLevel(self):
file_logger = FileLogger(True, MessageType.WARNING.value)
self.assertEquals(
tempfile.TemporaryFile(), file_logger.get_directory(),
StringProcessor.safe_formatter("Expected Directory '{}'.",
file_logger.DEFAULT_LOG_FOLDER))
self.assertEquals("FileLog.txt", file_logger.get_file_name(),
"Expected correct File Name.")
self.assertEquals(MessageType.WARNING.value,
file_logger.get_message_type(),
"Expected Warning Message Type.")
os.remove(file_logger.get_file_path())
self.assertTrue(path.exists(file_logger.get_file_path()))
def test_FileLoggerMessageTypeOnly(self):
html_logger = HtmlFileLogger("", False, MessageType.WARNING)
self.assertEquals(
html_logger.DEFAULT_LOG_FOLDER, html_logger.get_directory(),
StringProcessor.safe_formatter("Expected Directory '{}'.",
html_logger.DEFAULT_LOG_FOLDER))
self.assertEquals("FileLog.html", html_logger.get_file_name(),
"Expected correct File Name.")
self.assertEquals(MessageType.WARNING, html_logger.get_message_type(),
"Expected Warning Message Type.")
file_path = html_logger.get_file_path(
) + "\\" + html_logger.get_file_name()
self.assertTrue(path.exists(file_path))
def create_logger(self):
self.loggingEnabledSetting = LoggingConfig.get_logging_level_setting(
Config())
self.set_logged_exceptions(list)
if self.loggingEnabledSetting != LoggingEnabled.NO:
log = LoggingConfig().get_logger(
StringProcessor.safe_formatter("{} - {}", [
self.fullyQualifiedTestClassName,
str(datetime.now().strftime("uuuu-MM-dd-HH-mm-ss-SSSS"))
]), Config())
else:
log = ConsoleLogger()
return log
def get_logging_enabled_setting(self, default_value=None):
value = str(self.config.get_general_value("Log",
default_value)).upper()
if value == "YES":
return LoggingEnabled.YES.name
elif value == "ONFAIL":
return LoggingEnabled.ONFAIL.name
elif value == "NO":
return LoggingEnabled.NO.name
else:
raise NotImplementedError(
StringProcessor.safe_formatter(
"Log value {} is not a valid option",
Config().get_general_value("Log", "NO")))
def test_FileLoggerAppendOnly(self):
file_logger = FileLogger("", True)
self.assertEquals(
file_logger.DEFAULT_LOG_FOLDER, file_logger.get_directory(),
StringProcessor.safe_formatter("Expected Directory '{}'.",
file_logger.DEFAULT_LOG_FOLDER))
self.assertEquals("FileLog.txt", file_logger.get_file_name(),
"Expected correct File Name.")
self.assertEquals(MessageType.INFORMATION.name,
file_logger.get_message_type(),
"Expected Information Message Type.")
# os.remove(file_logger.get_file_path() + file_logger.get_file_name())
self.assertFalse(
path.exists(os.path.abspath(file_logger.get_file_path())))
def log_message(self,
message="",
args=None,
message_type=MessageType.INFORMATION):
# If the message level is greater that the current log level then do not log it.
if self.should_message_be_logged(message_type):
try:
with open(self.filePath, "w") as writer:
writer.write(
StringProcessor.safe_formatter(
"{}{}",
[os.linesep,
int(round(time.time() * 1000))]))
writer.write(
StringProcessor.safe_formatter("{}:\t", message_type))
writer.write(StringProcessor.safe_formatter(message, args))
except IOError as e:
# Failed to write to the event log, write error to the console instead
console = ConsoleLogger()
console.log_message(
StringProcessor.safe_formatter(
"Failed to write to event log because: {}",
e.strerror), args, MessageType.ERROR)
console.log_message(message, args, message_type)
def test_FileLoggerAppendOnly(self):
html_logger = HtmlFileLogger("", True)
self.assertEquals(
html_logger.DEFAULT_LOG_FOLDER, html_logger.get_directory(),
StringProcessor.safe_formatter("Expected Directory '{}'.",
html_logger.DEFAULT_LOG_FOLDER))
self.assertEquals("FileLog.html", html_logger.get_file_name(),
"Expected correct File Name.")
self.assertEquals(MessageType.INFORMATION.name,
html_logger.get_message_type(),
"Expected Information Message Type.")
file_path = html_logger.get_file_path(
) + "\\" + html_logger.get_file_name()
self.assertFalse(path.exists(file_path))
def try_to_log(self, message_type, message, args=None):
# Get the formatted message
formatted_message = StringProcessor.safe_formatter(message, args)
try:
# Write to the log
self.get_logger().logMessage(message_type, formatted_message)
# If this was an error and written to a file, add it to the console
# output as well
if message_type == MessageType.ERROR and not isinstance(
ConsoleLogger, self.get_logger()):
print(formatted_message)
except Exception as e:
print(formatted_message)
print("Logging failed because: " + e.message)
def make_valid_file_name(new_name):
if new_name is None or new_name == "":
raise FileExistsError("Blank or null file name was provided")
# Replace invalid characters
replaced_name = new_name
try:
replaced_name = new_name.replace("[^a-zA-Z0-9\\._\\- ]+", "~")
except Exception as e:
console = ConsoleLogger()
console.log_message(
MessageType.ERROR,
StringProcessor.safe_formatter(
"Failed to Replace Invalid Characters because: {}",
e.args))
return replaced_name
def get_file(self):
# default config.xml file name.
config_file = pathlib.Path(__file__).with_name("config.xml")
try:
if path.exists(config_file):
tree = ElementTree.parse(config_file)
root = tree.getroot()
new_config_values = {}
for parent in root:
new_config_values[parent.tag] = {}
for child in parent:
new_config_values[parent.tag][child.tag] = child.text
return new_config_values
except Exception as e:
raise TimeoutError(StringProcessor.safe_formatter(
"Exception creating the xml configuration object from the file : " + e.args))
def get_logger(self, file_name):
# Disable logging means we just send any logged messages to the console
if self.get_logging_enabled_setting(
self.config) == LoggingEnabled.NO.name:
return ConsoleLogger()
log_directory = self.get_log_directory()
logging_level = self.get_logging_level_setting(Config())
# value = Config().get_general_value("LogType", "CONSOLE").upper()
value = self.config.get_general_value("LogType").upper()
if value == "CONSOLE":
return ConsoleLogger(logging_level)
elif value == "TXT":
return FileLogger(log_directory, False, file_name, logging_level)
else:
raise AttributeError(
StringProcessor.safe_formatter(
"Log type {} is not a valid option",
Config().get_general_value("LogType", "CONSOLE")))
def close(self, closing=False):
if not closing:
if self.managerStore is None:
return
self.logger.logMessage(MessageType.VERBOSE, "Start dispose")
# for (final DriverManager<?> singleDriver : this.managerStore.values()) {
for singleDriver in self.managerStore:
if singleDriver is not None:
try:
singleDriver.close()
except Exception as e:
# raise DriverDisposalException(StringProcessor.safe_formatter("Unable to properly dispose of
# driver"), e)
raise Error(
StringProcessor.safe_formatter(
"Unable to properly dispose of driver"), e)
self.managerStore = None
self.logger.logMessage(MessageType.VERBOSE, "End dispose")
self.isClosed = True
def log_final_assert_data(self):
message = ""
message += StringProcessor.safe_formatter(
"Total number of Asserts: {1}. Passed Asserts = {2} Failed Asserts = {2}{3}",
[
self.NumberOfAsserts, self.NumberOfPassedAsserts,
self.NumberOfFailedAsserts, os.linesep
])
if len(self.listOfExceptions) > 0:
message_type = MessageType.ERROR.value
message += "List of failed exceptions:"
for exception in self.listOfExceptions:
# Will log all the exceptions that were caught in Asserts to the log file.
message += exception
else:
# There are no exceptions that were caught in Asserts.
message_type = MessageType.INFORMATION.value
message += "There are no failed exceptions in the Asserts."
self.Log.log_message(type, message)
def __init__(self,
log_folder="",
append=False,
message_level=MessageType.INFORMATION,
log_name=DEFAULT_LOG_NAME):
super().__init__(message_level)
if log_folder is None or log_folder == "":
self.directory = self.DEFAULT_LOG_FOLDER
else:
self.directory = log_folder
if not os.path.exists(self.directory):
os.makedirs(self.directory)
name = self.make_valid_file_name(log_name)
if not name.lower().endswith(self.extension()):
name += self.extension()
self.fileName = name
self.filePath = self.directory
self.messageType = message_level
if path.exists(self.filePath) and not append:
try:
with open(self.filePath, "w") as writer:
# writer = open(self.filePath, "w")
writer.write(" ")
except IOError as e:
# Failed to write to the event log, write error to the console instead
console = ConsoleLogger()
console.log_message(
MessageType.ERROR,
StringProcessor.safe_formatter(
"Failed to write to event log because: {}",
e.strerror + self.filePath))
def test_StringFormatterCheckForStringFormat(self):
message = StringProcessor.safe_formatter('This {} should return {}', ["Test", "Test"])
self.assertEqual("This Test should return Test", message)
def test_getLogDirectoryTest(self):
default_path = os.path.abspath(os.path.dirname(__file__)) + "\\Logs"
self.assertEquals(LoggingConfig().get_log_directory(), default_path,
StringProcessor.safe_formatter("Expected Default Path '{}'.", default_path))
def test_SingleExceptionSafeFormatter(self):
format_exception = SyntaxError("Format Exception")
formatted_exception = StringProcessor.safe_exception_formatter(format_exception)
self.assertTrue("Format Exception" in formatted_exception)
def test_SafeFormatterMessage(self):
successful = StringProcessor.safe_formatter("This is a message.")
self.assertEqual(successful, "This is a message.")