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.")