Added logger and improved service provider

src/tests/logger.py

@@ -0,0 +1,50 @@
+import os
+from string import Template
+
+from sh_edraft.configuration import ApplicationHost
+from sh_edraft.logging.base.logger_base import LoggerBase
+from sh_edraft.logging.logger import Logger
+from sh_edraft.logging.model.log_settings import LoggingSettings
+from sh_edraft.time.model.time_format_settings import TimeFormatSettings
+
+
+class LoggerTest:
+
+    @staticmethod
+    def start(app_host: ApplicationHost):
+        services = app_host.services
+
+        log_settings = LoggingSettings()
+        log_settings.from_dict({
+            "Path": "logs/",
+            "Filename": "log_$start_time.log",
+            "ConsoleLogLevel": "TRACE",
+            "FileLogLevel": "TRACE"
+        })
+
+        time_format_settings = TimeFormatSettings()
+        time_format_settings.from_dict({
+            "DateFormat": "%Y-%m-%d",
+            "TimeFormat": "%H:%M:%S",
+            "DateTimeFormat": "%Y-%m-%d %H:%M:%S.%f",
+            "DateTimeLogFormat": "%Y-%m-%d_%H-%M-%S"
+        })
+
+        services.add_singleton(Logger, log_settings, time_format_settings, app_host)
+        logger: Logger = services.get_service(LoggerBase)
+
+        if logger is None:
+            raise Exception(f'{__name__}: Service is None')
+
+        logger.create()
+        logger.info(__name__, 'test')
+
+        if not os.path.isdir(log_settings.path):
+            raise Exception(f'{__name__}: Log path was not created')
+
+        log_file = Template(log_settings.filename).substitute(
+            date_time_now=app_host.date_time_now.strftime(time_format_settings.date_time_format),
+            start_time=app_host.start_time.strftime(time_format_settings.date_time_log_format)
+        )
+        if not os.path.isfile(log_settings.path + log_file):
+            raise Exception(f'{__name__}: Log file was not created')

src/tests/publisher.py

@@ -1,6 +1,7 @@
 import os
 
-from sh_edraft.service import ServiceProvider
+from sh_edraft.publish.base import PublisherBase
+from sh_edraft.service.base import ServiceProviderBase
 from sh_edraft.source_code.model import Version
 from sh_edraft.publish import Publisher
 from sh_edraft.publish.model import Template
@@ -9,7 +10,7 @@ from sh_edraft.publish.model import Template
 class PublisherTest:
 
     @staticmethod
-    def start(services: ServiceProvider):
+    def start(services: ServiceProviderBase):
         templates = [
             Template(
                 '../../publish_templates/*_template.txt',
@@ -43,7 +44,7 @@ class PublisherTest:
         dist = '../../dist'
 
         services.add_singleton(Publisher, None, source, dist, templates)
-        publisher: Publisher = services.get_service(Publisher)
+        publisher: Publisher = services.get_service(PublisherBase)
 
         publisher.exclude('../tests/')
         publisher.include('../../LICENSE')

src/tests/service_provider.py

@@ -1,23 +1,21 @@
 from sh_edraft.publish import Publisher
-from sh_edraft.service import ServiceProvider
+from sh_edraft.publish.base import PublisherBase
+from sh_edraft.service.base import ServiceProviderBase
 
 
 class ServiceProviderTest:
 
     @staticmethod
-    def start() -> ServiceProvider:
-        provider = ServiceProvider()
+    def start(provider: ServiceProviderBase):
         provider.create()
 
         provider.add_transient(Publisher, None, '../', '../../dist', [])
 
-        publisher: Publisher = provider.get_service(Publisher)
+        publisher: Publisher = provider.get_service(PublisherBase)
 
-        if publisher.source_path != '../' or publisher.dist_path != '../../dist':
+        if publisher is None or publisher.source_path != '../' or publisher.dist_path != '../../dist':
             raise Exception(f'{__name__}: Invalid value in {Publisher.__name__}')
 
-        provider.remove_service(Publisher)
-        if provider.get_service(Publisher) is not None:
+        provider.remove_service(PublisherBase)
+        if provider.get_service(PublisherBase) is not None:
             raise Exception(f'{__name__}: Service {Publisher.__name__} was not removed')
-
-        return provider

src/tests/tester.py

@@ -1,28 +1,27 @@
 import os
 import sys
+import traceback
 from typing import Optional
 
 from termcolor import colored
 
+from sh_edraft.configuration import ApplicationHost
 from sh_edraft.service import ServiceProvider
+from tests.logger import LoggerTest
 from tests.publisher import PublisherTest
 from tests.service_provider import ServiceProviderTest
 
 
-class Test:
+class Tester:
 
     def __init__(self):
+        self._app_host = ApplicationHost()
         self._services: Optional[ServiceProvider] = None
 
-        self._tests = [
-            ServiceProviderTest,
-            PublisherTest
-        ]
-
         self._error: bool = False
 
     @staticmethod
-    def block_print():
+    def disable_print():
         sys.stdout = open(os.devnull, 'w')
 
     @staticmethod
@@ -32,36 +31,52 @@ class Test:
     def success(self, message: str):
         self.enable_print()
         print(colored(message, 'green'))
-        self.block_print()
+        self.disable_print()
 
     def failed(self, message: str):
         self.enable_print()
         print(colored(message, 'red'))
-        self.block_print()
+        self.disable_print()
+
+    def exception(self):
+        self.enable_print()
+        print(colored(traceback.format_exc(), 'red'))
+        self.disable_print()
 
     def create(self): pass
 
     def start(self):
-        self.block_print()
+        self.disable_print()
 
         if not self._error:
             try:
-                self._services = ServiceProviderTest.start()
+                ServiceProviderTest.start(self._app_host.services)
                 self.success(f'{ServiceProviderTest.__name__} test succeeded.')
             except Exception as e:
                 self._error = True
                 self.failed(f'{ServiceProviderTest.__name__} test failed!\n{e}')
+                self.exception()
 
         if not self._error:
             try:
-                PublisherTest.start(self._services)
+                LoggerTest.start(self._app_host)
+                self.success(f'{LoggerTest.__name__} test succeeded.')
+            except Exception as e:
+                self._error = True
+                self.failed(f'{LoggerTest.__name__} test failed!\n{e}')
+                self.exception()
+
+        if not self._error:
+            try:
+                PublisherTest.start(self._app_host.services)
                 self.success(f'{PublisherTest.__name__} test succeeded.')
             except Exception as e:
                 self._error = True
                 self.failed(f'{PublisherTest.__name__} test failed!\n{e}')
+                self.exception()
 
 
 if __name__ == '__main__':
-    test = Test()
-    test.create()
-    test.start()
+    tester = Tester()
+    tester.create()
+    tester.start()