def Write(self, log):
# Only run if the response times is greater than 0
if len(self.TimerList) > 0:
# Locks the writer if other tests are using it
lock(writerLocker)
try:
# If filename doesn't exist, we haven't created the file yet
if self.FileName is None:
self.FileName = "PerformanceTimerResults" + "-" + self.TestName + "-" + DateTime.UtcNow.ToString(
"O").Replace(':', '-') + ".xml"
log.LogMessage(
MessageType.INFORMATION, "filename: " +
LoggingConfig.get_log_directory() + "\\" + self.FileName)
settings = XmlWriterSettings()
settings.WriteEndDocumentOnClose = True
settings.Indent = True
writer = XmlWriter.Create(
string.Format("{0}\\{1}",
LoggingConfig.get_log_directory(),
self.FileName), settings)
x = XmlSerializer(self.GetType())
x.Serialize(writer, self)
writer.Flush()
writer.Close()
except Exception as e:
log.LogMessage(
MessageType.ERROR,
"Could not save response time file. Error was: {}", e)
def test_getConsoleLoggerTest(self):
new_value_map = {"LogType": "CONSOLE", "Log": "YES"}
logging_config = LoggingConfig()
logging_config.add_general_test_setting_values(new_value_map, True)
file_name = "TestLog.txt"
logger = logging_config.get_logger(file_name)
instance = isinstance(logger, ConsoleLogger)
self.assertTrue(instance, "Expected Logger to be of Type ConsoleLogger.")
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 test_getConsoleLoggerLoggingDisabledTest(self):
new_value_map = {"Log": "NO"}
Config().add_general_test_setting_values(new_value_map, True)
file_name = "TestLog.txt"
logging_config = LoggingConfig().get_logger(file_name)
instance = isinstance(logging_config, ConsoleLogger)
self.assertTrue(instance, "Expected Logger to be of Type ConsoleLogger.")
def test_SoftAssertIsFalseTest():
soft_assert = SoftAssert(
FileLogger(LoggingConfig.get_log_directory(),
"UnitTests.SoftAssertUnitTests.SoftAssertIsFalseTest",
MessageType.GENERIC.value, True))
soft_assert.assertFalse(2 == 1, "Test")
soft_assert.fail_test_if_assert_failed()
def test_SoftAssertValidTest():
soft_assert = SoftAssert(
FileLogger(LoggingConfig.get_log_directory(),
"UnitTests.SoftAssertUnitTests.SoftAssertValidTest"))
soft_assert.assertEquals("Yes", "Yes", "Utilities Soft Assert",
"Message is not equal")
soft_assert.assertEquals("YesAgain", "YesAgain",
"Utilities Soft Assert 2")
soft_assert.fail_test_if_assert_failed()
def test_SoftAssertFailTest(self):
with self.assertRaises(AttributeError):
soft_assert = SoftAssert(
FileLogger(LoggingConfig.get_log_directory(),
"UnitTests.SoftAssertUnitTests.SoftAssertFailTest"))
soft_assert.assertEquals("Yes", "No", "Utilities Soft Assert",
"Message is not equal")
soft_assert.assertEquals("Yes", "NoAgain",
"Utilities Soft Assert 2")
soft_assert.fail_test_if_assert_failed()
def test_SoftAssertIsTrueTestFailure(self):
with self.assertRaises(AttributeError):
soft_assert = SoftAssert(
FileLogger(LoggingConfig.get_log_directory(),
"UnitTests.SoftAssertUnitTests.SoftAssertFailTest",
MessageType.GENERIC.name, True))
soft_assert.assertTrue(1 == 2, "Test")
soft_assert.assertTrue(1 == 2, "Test1")
soft_assert.assertTrue(True, "Test2")
soft_assert.fail_test_if_assert_failed()
def test_SoftAssertDidFailCheck(self):
soft_assert = SoftAssert(
FileLogger(LoggingConfig.get_log_directory(),
"UnitTests.SoftAssertUnitTests.SoftAssertIsTrueTest",
MessageType.GENERIC.name, True))
soft_assert.assertTrue(True, "Test1")
self.assertFalse(soft_assert.did_soft_asserts_fail())
soft_assert.assertTrue(1 == 2, "Test2")
self.assertTrue(soft_assert.did_soft_asserts_fail())
def test_HierarchicalTxtFileLogger(self):
log_level, levels = self.single_data
file_logger = FileLogger(
LoggingConfig().get_log_directory(), True,
self.get_file_name(self._testMethodName + log_level, "txt"),
MessageType.GENERIC)
self.hierarchical_logging(file_logger, file_logger.get_file_path(),
log_level, levels)
os.remove(file_logger.get_file_path())
self.assertTrue(path.exists(file_logger.get_file_path()))
def test_HierarchicalHtmlFileLogger(self):
log_level, levels = self.data()
html_logger = HtmlFileLogger(
True,
LoggingConfig().get_log_directory(),
self.get_file_name(self._testMethodName + log_level, "html"),
MessageType.GENERIC.value)
self.hierarchical_logging(html_logger, html_logger.get_file_path(),
log_level, levels)
os.remove(html_logger.get_file_path())
self.assertTrue(path.exists(html_logger.get_file_path()))
def test_FileLoggerAppendLogFolder(self):
append_file_directory_path = LoggingConfig.get_log_directory(
) + "/" + "Append File Directory"
html_logger = HtmlFileLogger(append_file_directory_path, True)
self.assertEquals(append_file_directory_path,
html_logger.get_directory(),
"Expected Directory 'Append File Directory'.")
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.")
def test_FileLoggerLogFolderFileName(self):
log_folder_file_name_directory = LoggingConfig.get_log_directory(
) + "/" + "Log Folder File Name Directory"
html_logger = HtmlFileLogger(log_folder_file_name_directory,
"LogFolderFileName.html")
self.assertEquals(
log_folder_file_name_directory, html_logger.get_directory(),
"Expected Directory 'Log Folder File Name Directory'.")
self.assertEquals("LogFolderFileName.html",
html_logger.get_file_name(),
"Expected correct File Name.")
self.assertEquals(MessageType.INFORMATION.name,
html_logger.get_message_type(),
"Expected Information Message Type.")
def test_HierarchicalConsoleLogger(self):
log_level, levels = self.data()
# Calculate a file path
file_path = LoggingConfig().get_log_directory() + \
self.get_file_name(self._testMethodName + log_level, "txt")
try:
open(file_path).read()
console_logger = ConsoleLogger()
self.hierarchical_logging(console_logger, file_path, log_level,
levels)
except Exception as e:
raise FileExistsError()
os.remove(file_path)
self.assertTrue(path.exists(file_path))
def test_FileLoggerAppendLogFolder(self):
append_file_directory = LoggingConfig().get_log_directory(
) + "/" + "Append File Directory"
file_logger = FileLogger(append_file_directory, True)
self.assertEquals(append_file_directory, file_logger.get_directory(),
"Expected Directory 'Append File Directory'.")
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())
self.assertTrue(path.exists(file_logger.get_file_path()))
def test_FileLoggerLogFolderMessagingLevel(self):
log_folder_messaging_level_directory_path = LoggingConfig.get_log_directory() + "/" \
+ "Log Folder Messaging Level Directory"
html_logger = HtmlFileLogger(log_folder_messaging_level_directory_path,
False, MessageType.WARNING)
self.assertEquals(
log_folder_messaging_level_directory_path,
html_logger.get_directory(),
"Expected Directory 'Log Folder Messaging Level Directory'.")
self.assertEquals("FileLog.html", html_logger.get_file_name(),
"Expected correct File Name.")
self.assertEquals(MessageType.WARNING.name,
html_logger.get_message_type(),
"Expected Warning Message Type.")
def test_SoftAssertVerifyCheckForFailures(self):
soft_assert = SoftAssert(
FileLogger(
LoggingConfig.get_log_directory(),
"UnitTests.SoftAssertUnitTests.SoftAssertVerifyCheckForFailures"
))
soft_assert.assertEquals("Yes", "Yes", "Utilities Soft Assert",
"Message is not equal")
soft_assert.fail_test_if_assert_failed()
self.assertTrue(soft_assert.did_user_check())
soft_assert.assertEquals("Yes", "Yes", "Utilities Soft Assert",
"Message is not equal")
self.assertFalse(soft_assert.did_user_check())
def test_FileLoggerConstructorCreateDirectory(self):
message = "Test to ensure that the file in the created directory can be written to."
file_logger = FileLogger(LoggingConfig().get_log_directory(), True,
"FileLoggerCreateDirectoryDelete",
MessageType.GENERIC)
file_logger.log_message(
MessageType.WARNING.value,
"Test to ensure that the file in the created directory can be written to."
)
file = file_logger.get_file_path()
actual_message = self.read_text_file(file.getCanonicalPath())
self.assertTrue(
message in actual_message, "Expected '" + message + "' but got '" +
actual_message + "' for: " + file.getCanonicalPath())
os.remove(file)
self.assertTrue(path.exists(file_logger.get_file_path()))
def test_FileLoggerAppendLogFolderMessagingLevel(self):
append_log_folder_file_name_directory = LoggingConfig.get_log_directory() + "\\" \
+ "AppendLogFolderFileNameDirectory "
html_logger = HtmlFileLogger(append_log_folder_file_name_directory,
True, MessageType.WARNING)
self.assertEquals(
append_log_folder_file_name_directory, html_logger.get_directory(),
"Expected Directory AppendLogFolderFileNameDirectory")
self.assertEquals("FileLog.html", html_logger.get_file_name(),
"Expected correct File Name.")
self.assertEquals(MessageType.WARNING.name,
html_logger.get_message_type(),
"Expected Warning Message Type.")
file_path = html_logger.get_file_path(
) + "\\" + html_logger.get_file_name()
self.assertFalse(path.exists(file_path))
def test_FileLoggerAppendLogFolderMessagingLevel(self):
append_log_folder_file_name_directory = LoggingConfig().get_log_directory() + "/" + \
"AppendLogFolderFileNameDirectory "
file_logger = FileLogger(True, append_log_folder_file_name_directory,
MessageType.WARNING)
self.assertEquals(
append_log_folder_file_name_directory, file_logger.get_directory(),
" Expected Directory AppendLogFolderFileNameDirectory")
self.assertEquals("FileLog.txt", file_logger.get_file_name(),
"Expected correct File Name.")
self.assertEquals(MessageType.WARNING.name,
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_FileLoggerLogFolderFileName(self):
log_folder_file_name_directory = LoggingConfig().get_log_directory(
) + "/" + "Log Folder File Name Directory"
file_logger = FileLogger(log_folder_file_name_directory,
"LogFolderFileName.txt")
self.assertEquals(
log_folder_file_name_directory, file_logger.get_directory(),
"Expected Directory 'Log Folder File Name Directory'.")
self.assertEquals("LogFolderFileName.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_FileLoggerLogFolderFileNameMessagingLevel(self):
log_folder_file_name_messaging_level_directory = LoggingConfig().get_log_directory() + "/" + \
"LogFolderFileNameMessagingLevelDirectory"
file_logger = FileLogger(
log_folder_file_name_messaging_level_directory,
"LogFolderFileNameMessagingLevel.txt", MessageType.WARNING)
self.assertEquals(
log_folder_file_name_messaging_level_directory,
file_logger.get_directory(),
"Expected Directory 'LogFolderFileNameMessagingLevelDirectory'")
self.assertEquals("LogFolderFileNameMessagingLevel.txt",
file_logger.get_file_name(),
"Expected correct File Name.")
self.assertEquals(MessageType.WARNING.name,
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_FileLoggerLogFolderFileNameMessagingLevel(self):
log_folder_file_name_messaging_level_directory_path = LoggingConfig.get_log_directory() \
+ "/" + "LogFolderFileNameMessagingLevelDirectory"
html_logger = HtmlFileLogger(
log_folder_file_name_messaging_level_directory_path,
"LogFolderFileNameMessagingLevel.html", MessageType.WARNING)
self.assertEquals(
log_folder_file_name_messaging_level_directory_path,
html_logger.get_directory(),
"Expected Directory 'LogFolderFileNameMessagingLevelDirectory'")
self.assertEquals("LogFolderFileNameMessagingLevel.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 test_SoftAssertFailsValidTest(self):
soft_assert = SoftAssert(
FileLogger(
LoggingConfig.get_log_directory(),
"UnitTests.SoftAssertUnitTests.SoftAssertFailsValidTest"))
soft_assert.fails(
lambda x: self.MethodThrowsNoneException(), TypeError,
"Assert Method Throws Explicit Exception",
"Failed to assert that method threw a NullReferenceException")
result = 9 / 0
soft_assert.fails(
self.fail(
f"Result should have thrown an error but is {result} instead"),
# soft_assert.assertFails(lambda x: (result = 9 / 0) self.fail(f"Result should have thrown
# an error but is {result} instead"),
ZeroDivisionError,
"Assert action throws divide by zero exception",
"Failed to assert that we couldn't divide by zero")
soft_assert.fail_test_if_assert_failed()
def test_HtmlFileLoggerConstructorCreateDirectory(self):
html_logger = HtmlFileLogger(True,
LoggingConfig().get_log_directory(),
"HtmlFileLoggerCreateDirectory",
MessageType.GENERIC)
html_logger.log_message(
MessageType.WARNING,
"Test to ensure that the file in the created directory can be written to."
)
file = html_logger.get_file_path()
self.assertTrue(
self.readTextFile(
self.Test_Message in html_logger.get_file_path()))
file.delete()
self.assertTrue(path.exists(html_logger.get_file_path()))
file = html_logger.get_directory()
try:
os.remove(file)
except IOError as e:
e.printStackTrace()
def test_SoftAssertFailsInvalidTest(self):
with self.assertRaises(AttributeError):
soft_assert = SoftAssert(
FileLogger(
LoggingConfig.get_log_directory(),
"UnitTests.SoftAssertUnitTests.SoftAssertFailsInvalidTest")
)
soft_assert.fails(
lambda x: self.MethodThrowsNoneException(),
NotImplementedError, "Assert Method Throws Explicit Exception",
"Failed to assert that method threw a NotImplementedException")
result = 9 / 0
soft_assert.fails(
self.fail(
f"Result should have thrown an error but is {result} instead"
),
# soft_assert.assertFails(lambda x: (result = 9 / 0) self.fail(f"Result should have
# thrown an error but is {result} instead"),
TypeError,
"Assert dividing by zero throws a null reference",
"Failed to assert that we couldn't divide by zero")
soft_assert.fail_test_if_assert_failed()
def Test_SuspendLogger(self):
# Start logging
file_logger = FileLogger(
True,
LoggingConfig().get_log_directory(),
self.get_file_name("TestHierarchicalTxtFileLogger", "txt"),
MessageType.GENERIC.value)
file_logger.set_logging_level(MessageType.VERBOSE)
file_logger.log_message(MessageType.VERBOSE, "HellO")
# Suspend logging
file_logger.suspend_logging()
file_logger.log_message(MessageType.ERROR, "GoodByE")
# Continue logging
file_logger.continue_logging()
file_logger.log_message(MessageType.VERBOSE, "BacK")
# Get the log file content
log_contents = self.read_text_file(file_logger.get_file_path())
# Verify that logging was active
hello_found = "HellO" in log_contents
self.assertTrue(hello_found, "'HellO' was not found. Logging Failed")
# Verify that logging was suspended
goodbye_found = "GoodByE" in log_contents
self.assertFalse(
goodbye_found,
"'GoodByE' was found when it should not be written. Logging Failed"
)
# Verify that logging was active
back_found = "BacK" in log_contents
self.assertTrue(back_found, "'BacK' was not found. Logging Failed")
os.remove(file_logger.get_file_path())
self.assertTrue(path.exists(file_logger.get_file_path()))
def test_getLoggingLevelSuspendedSettingTest(self):
new_value_map = {"LogLevel": "SUSPENDED"}
Config().add_general_test_setting_values(new_value_map, True)
self.assertEquals(MessageType.SUSPENDED.name, LoggingConfig().get_logging_level_setting(),
"Expected Logging Level Setting SUSPENDED.")
def test_getLoggingLevelErrorSettingTest(self):
new_value_map = {"LogLevel": "ERROR"}
Config().add_general_test_setting_values(new_value_map, True)
self.assertEquals(MessageType.ERROR.name, LoggingConfig().get_logging_level_setting(),
"Expected Logging Level Setting ERROR.")
def test_getLoggingLevelWarningSettingTest(self):
new_value_map = {"LogLevel": "WARNING"}
Config().add_general_test_setting_values(new_value_map, True)
self.assertEquals(MessageType.WARNING.name, LoggingConfig().get_logging_level_setting(),
"Expected Logging Level Setting WARNING.")
