PYSCAN-28: Refactor scanner to use the application logger (#11)

Author: joke1196

src/py_sonar_scanner/logger.py

@@ -36,5 +36,4 @@ def get_logger(cls) -> Logger:
     def _setup_logger(log: Logger):
         log.setLevel(logging.INFO)
         handler = logging.StreamHandler()
-        handler.terminator = ""
         log.addHandler(handler)

src/py_sonar_scanner/scanner.py

@@ -18,12 +18,11 @@
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 #
 from __future__ import annotations
-import logging
 from logging import Logger
-import threading
 from threading import Thread
 from subprocess import Popen, PIPE
 
+from py_sonar_scanner.logger import ApplicationLogger
 from py_sonar_scanner.configuration import Configuration
 
 
@@ -33,19 +32,12 @@ class Scanner:
 
     def __init__(self, cfg: Configuration):
         self.cfg = cfg
-        self.log = logging.getLogger(__name__)
-        self._setup_logger(self.log)
-
-    def _setup_logger(self, log: Logger):
-        log.setLevel(logging.INFO)
-        handler = logging.StreamHandler()
-        handler.terminator = ""
-        log.addHandler(handler)
+        self.log = ApplicationLogger.get_logger()
 
     def scan(self):
         process = self.execute_command()
-        output_thread = threading.Thread(target=self._log_output, args=(process.stdout,))
-        error_thread = threading.Thread(target=self._log_output, args=(process.stderr,))
+        output_thread = Thread(target=self._log_output, args=(process.stdout,))
+        error_thread = Thread(target=self._log_output, args=(process.stderr,))
         return self.process_output(output_thread, error_thread, process)
 
     def process_output(self, output_thread: Thread, error_thread: Thread, process: Popen) -> int:
@@ -68,5 +60,5 @@ def compute_command(self) -> list[str]:
 
     def _log_output(self, stream: list[bytes]):
         for line in stream:
-            decoded_line = line.decode("utf-8")
+            decoded_line = line.decode("utf-8").rstrip()
             self.log.info(decoded_line)

tests/test_scanner.py

@@ -18,7 +18,7 @@
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 #
 import unittest
-from unittest.mock import Mock
+from unittest.mock import Mock, patch, call
 import threading
 from py_sonar_scanner.scanner import Scanner
 from py_sonar_scanner.configuration import Configuration
@@ -31,13 +31,13 @@ def test_scanner_compute_command(self):
         cfg.scan_arguments = ["a", "b"]
         scanner = Scanner(cfg)
 
-        assert scanner.compute_command() == ["test", "a", "b"]
+        self.assertEqual(scanner.compute_command(), ["test", "a", "b"])
 
         cfg.sonar_scanner_executable_path = "test"
         cfg.scan_arguments = []
         scanner = Scanner(cfg)
 
-        assert scanner.compute_command() == ["test"]
+        self.assertEqual(scanner.compute_command(), ["test"])
 
         cfg.sonar_scanner_executable_path = ""
         cfg.scan_arguments = []
@@ -49,8 +49,8 @@ def test_process_output(self):
         scanner = Scanner(Configuration())
         output_thread = threading.Thread()
         error_thread = threading.Thread()
-
-        process = Mock()
+        success_code = 0
+        process = Mock(returncode=success_code)
         output_thread.start = Mock()
         error_thread.start = Mock()
         output_thread.join = Mock()
@@ -64,14 +64,48 @@ def test_process_output(self):
         output_thread.join.assert_called_once()
         error_thread.join.assert_called_once()
         process.wait.assert_called_once()
+        self.assertEqual(return_code, success_code)
 
-    def test_scan(self):
+    @patch("py_sonar_scanner.scanner.Thread")
+    def test_scan(self, mock_thread):
         scanner = Scanner(Configuration())
-
-        scanner.execute_command = Mock()
+        process = Mock()
+        scanner.execute_command = Mock(return_value=process)
         scanner.process_output = Mock()
 
         scanner.scan()
 
         scanner.execute_command.assert_called_once()
+        call_thread_stdout = call(target=scanner._log_output, args=(process.stdout,))
+        call_thread_stderr = call(target=scanner._log_output, args=(process.stderr,))
+        mock_thread.assert_has_calls([call_thread_stdout, call_thread_stderr])
+        self.assertEqual(mock_thread.call_count, 2)
         scanner.process_output.assert_called_once()
+
+    @patch("py_sonar_scanner.scanner.Popen")
+    def test_execute_command(self, mock_popen):
+        from subprocess import PIPE
+
+        scanner = Scanner(Configuration())
+        command = "test"
+        scanner.compute_command = Mock(return_value=command)
+
+        scanner.execute_command()
+
+        scanner.compute_command.assert_called_once()
+        mock_popen.assert_called_once_with(command, stdout=PIPE, stderr=PIPE)
+
+    def test_log_output(self):
+        scanner = Scanner(Configuration())
+        input_lines = [
+            bytes("test\n", encoding="utf-8"),
+            bytes("\nother line\n\n", encoding="utf-8"),
+            bytes("", encoding="utf-8"),
+            bytes("last \n line", encoding="utf-8"),
+        ]
+        with self.assertLogs(scanner.log) as log:
+            scanner._log_output(input_lines)
+            self.assertEqual(log.records[0].getMessage(), "test")
+            self.assertEqual(log.records[1].getMessage(), "\nother line")
+            self.assertEqual(log.records[2].getMessage(), "")
+            self.assertEqual(log.records[3].getMessage(), "last \n line")