Feature/logger setup

.gitignore

@@ -38,5 +38,9 @@
 *.pyc
 *__pycache__
 
+
+# Log files
+*.log
+
 # IDE-related files
-.idea/*
+.idea/*

logger/log-levels.md

@@ -0,0 +1,21 @@
+
+# make sure to sync these up with _speedups.pyx
+CRITICAL = 15
+ERROR = 14
+WARNING = 13
+NOTICE = 12
+INFO = 11
+DEBUG = 10
+TRACE = 9
+NOTSET = 0
+
+_level_names = {
+    CRITICAL:   'CRITICAL',
+    ERROR:      'ERROR',
+    WARNING:    'WARNING',
+    NOTICE:     'NOTICE',
+    INFO:       'INFO',
+    DEBUG:      'DEBUG',
+    TRACE:      'TRACE',
+    NOTSET:     'NOTSET'
+}

logger/log-setup.md

@@ -0,0 +1,16 @@
+# Installation of Logbook
+```
+cd Aerocube
+pip install logbook
+# pip3 install logbook
+cd logger/tests
+# python3 TestLogger.py
+# python3.5 TestLogger.py
+``` 
+
+
+# Todo's for Log book
+1. Initialize a handler for streaming logs to sys.stdout
+2. Initialize a handler for streaming logs to arbitrary files
+
+```

logger/tests/TestFileLogHandler.py

@@ -0,0 +1,127 @@
+import unittest
+from tempfile import NamedTemporaryFile
+from logbook import FileHandler, Logger, TestHandler
+
+
+class TestFileLogHandler(unittest.TestCase):
+
+    def setUp(self):
+        """
+        Initialize Handler for arbitrary streams
+        with a parameter to log to the standard output.
+        Logger can be any name. The logger itself is a log channel
+        or a record dispatcher. In this case, the logger is set to
+        channel logs to the standard output
+        :return:
+        """
+        # Create an arbitrary temporary file
+        self._tempfile = NamedTemporaryFile(delete=True)
+
+        # Setup logging handler for standard output purposes
+        self._output_stream = FileHandler(
+            filename=self._tempfile.name,
+            encoding='UTF-8',
+            bubble=True
+        )
+        self._ctx = self._output_stream.push_application()
+
+        # Setup logging handler for testing purposes
+        self._log_handler = TestHandler(bubble=True)
+        self._log_handler.push_thread()
+
+        # Initialize Logger
+        # Apply both standard-output and test log-handlers to the newly, initialized logger
+        self._log = Logger('TestLog')
+        self._log.handlers = [self._log_handler, self._output_stream]
+
+        # string helper
+        self._tempfile_buffer = ''
+
+    def tearDown(self):
+        """
+        Close the output stream.
+        :return:
+        """
+        self._output_stream.close()
+        self._log_handler.pop_thread()
+        self._log_handler.close()
+        self._tempfile.close()
+
+
+    def test_logger_init(self):
+        """
+        Call all log methods
+        :return:
+        """
+        self.assertIsNotNone(self._log, msg='Logger resource not found')
+
+    def test_warn_logging(self):
+        self._log.warn('warn000.log')
+        self._tempfile_buffer = str(self._tempfile.read())
+        self.assertTrue('warn000.log' in self._tempfile_buffer)
+
+        self._log.warn('warn001.log')
+        self._tempfile_buffer = str(self._tempfile.read())
+        self.assertTrue('warn001.log' in self._tempfile_buffer)
+        self.assertFalse('warn002.log' in self._tempfile_buffer)
+
+
+    def test_error_logging(self):
+        self._log.error('error000.log')
+        self._tempfile_buffer = str(self._tempfile.read())
+        self.assertTrue('error000.log' in self._tempfile_buffer)
+
+        self._log.error('error001.log')
+        self._tempfile_buffer = str(self._tempfile.read())
+        self.assertTrue('error001.log' in self._tempfile_buffer)
+        self.assertFalse('error002.log' in self._tempfile_buffer)
+
+    def test_critical_logging(self):
+        self._log.critical('critical000.log')
+        self._tempfile_buffer = str(self._tempfile.read())
+        self.assertTrue('critical000.log' in self._tempfile_buffer)
+
+        self._log.critical('critical001.log')
+        self._tempfile_buffer = str(self._tempfile.read())
+        self.assertTrue('critical001.log' in self._tempfile_buffer)
+        self.assertFalse('critical002.log' in self._tempfile_buffer)
+
+    def test_debug_logging(self):
+        self._log.debug('debug000.log')
+        self._tempfile_buffer = str(self._tempfile.read())
+        self.assertTrue('debug000.log' in self._tempfile_buffer)
+
+        self._log.debug('debug001.log')
+        self._tempfile_buffer = str(self._tempfile.read())
+        self.assertTrue('debug001.log' in self._tempfile_buffer)
+        self.assertFalse('debug002.log' in self._tempfile_buffer)
+
+    def test_info_logging(self):
+        self._log.info('info000.log')
+        self._tempfile_buffer = str(self._tempfile.read())
+        self.assertTrue('info000.log' in self._tempfile_buffer)
+
+        self._log.info('info001.log')
+        self._tempfile_buffer = str(self._tempfile.read())
+        self.assertTrue('info001.log' in self._tempfile_buffer)
+        self.assertFalse('info002.log' in self._tempfile_buffer)
+
+    def test_notice_logging(self):
+        self._log.notice('notice000.log')
+        self._tempfile_buffer = str(self._tempfile.read())
+        self.assertTrue('notice000.log' in self._tempfile_buffer)
+
+        self._log.notice('notice001.log')
+        self._tempfile_buffer = str(self._tempfile.read())
+        self.assertTrue('notice001.log' in self._tempfile_buffer)
+        self.assertFalse('notice002.log' in self._tempfile_buffer)
+
+    def test_trace_logging(self):
+        self._log.trace('trace000.log')
+        self._tempfile_buffer = str(self._tempfile.read())
+        self.assertTrue('trace000.log' in self._tempfile_buffer)
+
+        self._log.trace('trace001.log')
+        self._tempfile_buffer = str(self._tempfile.read())
+        self.assertTrue('trace001.log' in self._tempfile_buffer)
+        self.assertFalse('trace002.log' in self._tempfile_buffer)

logger/tests/TestLogbook.py

@@ -0,0 +1,112 @@
+import unittest
+import sys
+from logbook import StreamHandler, Logger, TestHandler
+
+
+class TestLogbook(unittest.TestCase):
+
+    def setUp(self):
+        """
+        Initialize Handler for arbitrary streams
+        with a parameter to log to the standard output.
+        Logger can be any name. The logger itself is a log channel
+        or a record dispatcher. In this case, the logger is set to
+        channel logs to the standard output
+        :return:
+        """
+        # Setup logging handler for standard output purposes
+        self._output_stream = StreamHandler(sys.stdout)
+        self._ctx = self._output_stream.push_application()
+
+        # Setup logging handler for testing purposes
+        self._log_handler = TestHandler(bubble=True)
+        self._log_handler.push_thread()
+
+        # Initialize Logger
+        # Apply both standard-output and test log-handlers to the newly, initialized logger
+        self._log = Logger('TestLog')
+        self._log.handlers = [self._log_handler, self._output_stream]
+
+    def tearDown(self):
+        """
+        Close the output stream.
+        :return:
+        """
+        self._output_stream.close()
+        self._log_handler.pop_thread()
+        self._log_handler.close()
+
+    def test_logger_init(self):
+        """
+        Call all log methods
+        :return:
+        """
+        self.assertIsNotNone(self._log, msg='Logger resource not found')
+
+    def test_warn_logging(self):
+        self.assertFalse(self._log_handler.has_warning('warn000.log'))
+        self._log.warn('warn000.log')
+        self.assertTrue(self._log_handler.has_warning)
+        self._log.warn('warn001.log')
+        self.assertTrue(self._log_handler.has_warning('warn000.log'))
+        self.assertTrue(self._log_handler.has_warning('warn001.log'))
+        self.assertFalse(self._log_handler.has_warning('warn002.log'))
+
+    def test_error_logging(self):
+        self.assertFalse(self._log_handler.has_errors)
+        self.assertFalse(self._log_handler.has_error('error000.log'))
+        self._log.error('error000.log')
+        self.assertTrue(self._log_handler.has_error)
+        self._log.error('error001.log')
+        self.assertTrue(self._log_handler.has_error('error000.log'))
+        self.assertTrue(self._log_handler.has_error('error001.log'))
+        self.assertFalse(self._log_handler.has_error('error002.log'))
+        self.assertTrue(self._log_handler.has_errors)
+
+    def test_critical_logging(self):
+        self.assertFalse(self._log_handler.has_criticals)
+        self.assertFalse(self._log_handler.has_critical('critical000.log'))
+        self._log.critical('critical000.log')
+        self.assertTrue(self._log_handler.has_error)
+        self._log.critical('critical001.log')
+        self.assertTrue(self._log_handler.has_critical('critical000.log'))
+        self.assertTrue(self._log_handler.has_critical('critical001.log'))
+        self.assertFalse(self._log_handler.has_critical('critical002.log'))
+        self.assertTrue(self._log_handler.has_criticals)
+
+    def test_debug_logging(self):
+        self.assertFalse(self._log_handler.has_debugs)
+        self.assertFalse(self._log_handler.has_debug('debug000.log'))
+        self._log.debug('debug000.log')
+        self.assertTrue(self._log_handler.has_debug)
+        self._log.debug('debug001.log')
+        self.assertTrue(self._log_handler.has_debug('debug000.log'))
+        self.assertTrue(self._log_handler.has_debug('debug001.log'))
+        self.assertFalse(self._log_handler.has_debug('debug002.log'))
+        self.assertTrue(self._log_handler.has_debugs)
+
+    def test_info_logging(self):
+        self.assertFalse(self._log_handler.has_infos)
+        self.assertFalse(self._log_handler.has_info('info000.log'))
+        self._log.info('info000.log')
+        self.assertTrue(self._log_handler.has_info)
+        self._log.info('info001.log')
+        self.assertTrue(self._log_handler.has_info('info000.log'))
+        self.assertTrue(self._log_handler.has_info('info001.log'))
+        self.assertFalse(self._log_handler.has_info('info002.log'))
+        self.assertTrue(self._log_handler.has_infos)
+
+    def test_notice_logging(self):
+        self.assertFalse(self._log_handler.has_notices)
+        self.assertFalse(self._log_handler.has_notice('notice000.log'))
+        self._log.notice('notice000.log')
+        self.assertTrue(self._log_handler.has_notice)
+        self._log.notice('notice001.log')
+        self.assertTrue(self._log_handler.has_notice('notice000.log'))
+        self.assertTrue(self._log_handler.has_notice('notice001.log'))
+        self.assertFalse(self._log_handler.has_notice('notice002.log'))
+        self.assertTrue(self._log_handler.has_notices)
+
+    @unittest.skip('Trace test is skipped, because the log handler has no `has_trace` field\n')
+    def test_trace_logging(self):
+        self._log.trace('Trace')

logger/tests/TestLogger.py

@@ -0,0 +1,24 @@
+from logbook import Logger
+import unittest
+#from ../Logger import Logger
+
+class TestLogger(unittest.TestCase):
+
+  def setUp(self):
+    # Declare the Logger
+    self._log_handler = logbook.TestHandler()
+    self._log_handler.push_thread()
+    self._logger = Logger('TestLogger')
+
+  def tearDown(self):
+    self._log_handler.pop_thread()
+    self._logger = None
+
+  #@classmethod
+  #def instantiateState(logger):
+
+
+  def testLoggerWithWarning():
+    with logbook.TestHandler() as handler:
+      _logger.warn('A warning')
+      assert logger.has_warning('A warning')