PYSCAN-27 Re-raising error should not be too verbose by default (#23)

Author: maksim-grebeniuk-sonarsource

src/py_sonar_scanner/__main__.py

@@ -17,19 +17,22 @@
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 #
-
 from py_sonar_scanner.configuration import Configuration
 from py_sonar_scanner.environment import Environment
+from py_sonar_scanner.logger import ApplicationLogger
 
 
 def scan():
+    log = ApplicationLogger.get_logger()
     cfg = Configuration()
-    cfg.setup()
-
-    env = Environment(cfg)
-    env.setup()
-    env.scanner().scan()
-    env.cleanup()
+    try:
+        cfg.setup()
+        env = Environment(cfg)
+        env.scan()
+    except Exception as e:
+        log.exception("Error during SonarScanner execution: %s", str(e))
+        if not cfg.is_debug():
+            log.info("Re-run SonarScanner using the -X switch to enable full debug logging.")
 
 
 if __name__ == "__main__":

src/py_sonar_scanner/configuration.py

@@ -18,41 +18,55 @@
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 #
 from __future__ import annotations
+
+import argparse
 import os
 import sys
 from logging import Logger
+from typing import Union
 
 import toml
 
 from py_sonar_scanner.logger import ApplicationLogger
 
 
 class Configuration:
+    log: Logger
     sonar_scanner_executable_path: str
     sonar_scanner_path: str
     sonar_scanner_version: str
     scan_arguments: list[str]
-    log: Logger
+    wrapper_arguments: argparse.Namespace
 
     def __init__(self):
+        self.log = ApplicationLogger.get_logger()
         self.sonar_scanner_path = ".scanner"
         self.sonar_scanner_version = "4.6.2.2472"
         self.sonar_scanner_executable_path = ""
         self.scan_arguments = []
-        self.log = ApplicationLogger.get_logger()
+        self.wrapper_arguments = argparse.Namespace(debug=False)
 
     def setup(self) -> None:
         """This is executed when run from the command line"""
+        self._read_wrapper_arguments()
+        ApplicationLogger.set_debug(self.is_debug())
         self.scan_arguments = sys.argv[1:]
         self.scan_arguments.extend(self._read_toml_args())
 
+    def _read_wrapper_arguments(self):
+        argument_parser = argparse.ArgumentParser()
+        argument_parser.add_argument("-toml.path", "-Dtoml.path", "--toml.path", dest="toml_path")
+        argument_parser.add_argument("-project.home", "-Dproject.home", "--project.home", dest="project_home")
+        argument_parser.add_argument("-X", action="store_true", dest="debug")
+        self.wrapper_arguments, _ = argument_parser.parse_known_args(args=sys.argv[1:])
+
     def _read_toml_args(self) -> list[str]:
         scan_arguments: list[str] = []
         toml_data: dict = {}
         try:
             toml_data = self._read_toml_file()
-        except OSError:
-            self.log.error("Test error while opening file.")
+        except OSError as e:
+            self.log.exception("Error while opening .toml file: %s", str(e))
         sonar_properties = self._extract_sonar_properties(toml_data)
         for key, value in sonar_properties.items():
             self._add_parameter_to_scanner_args(scan_arguments, key, value)
@@ -84,30 +98,12 @@ def _read_toml_file(self) -> dict:
             return toml.loads(toml_data)
 
     def _get_toml_file_path(self) -> str:
-        args = self._get_arguments_dict()
-        if "-Dtoml.path" in args:
-            return args["-Dtoml.path"]
-        elif "-Dproject.home" in args:
-            return os.path.join(args["-Dproject.home"], "pyproject.toml")
+        if self.wrapper_arguments.toml_path is not None:
+            return self.wrapper_arguments.toml_path
+        elif self.wrapper_arguments.project_home is not None:
+            return os.path.join(self.wrapper_arguments.project_home, "pyproject.toml")
         else:
             return os.path.join(os.curdir, "pyproject.toml")
 
-    def _get_arguments_dict(self):
-        args = self.scan_arguments
-        arguments_dict = {}
-        i = 0
-        while i < len(args):
-            current_arg = args[i]
-
-            if "=" in current_arg:
-                arg_parts = current_arg.split("=", 1)
-                arguments_dict[arg_parts[0]] = arg_parts[1]
-            else:
-                if i + 1 < len(args) and "=" not in args[i + 1]:
-                    arguments_dict[current_arg] = args[i + 1]
-                    i += 1
-                else:
-                    arguments_dict[current_arg] = None
-
-            i += 1
-        return arguments_dict
+    def is_debug(self) -> bool:
+        return self.wrapper_arguments.debug

src/py_sonar_scanner/environment.py

@@ -44,6 +44,13 @@ def __init__(self, cfg: Configuration):
         self.cfg = cfg
         self.log = ApplicationLogger.get_logger()
 
+    def scan(self):
+        try:
+            self.setup()
+            self.scanner().scan()
+        finally:
+            self.cleanup()
+
     def setup(self):
         self.cleanup()
         if self._is_sonar_scanner_on_path():

src/py_sonar_scanner/logger.py

@@ -17,6 +17,7 @@
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 #
+import functools
 import logging
 from logging import Logger
 from typing import Optional
@@ -37,3 +38,12 @@ def _setup_logger(log: Logger):
         log.setLevel(logging.INFO)
         handler = logging.StreamHandler()
         log.addHandler(handler)
+
+    @classmethod
+    def set_debug(cls, debug: bool) -> None:
+        if debug:
+            cls.get_logger().setLevel(logging.DEBUG)
+            cls.get_logger().exception = functools.partial(cls.get_logger().exception, exc_info=True)
+        else:
+            cls.get_logger().setLevel(logging.INFO)
+            cls.get_logger().exception = functools.partial(cls.get_logger().exception, exc_info=False)

tests/test_configuration.py

@@ -21,6 +21,7 @@
 import unittest
 from unittest.mock import patch, Mock
 from py_sonar_scanner.configuration import Configuration
+from py_sonar_scanner.logger import ApplicationLogger
 
 CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
 
@@ -29,6 +30,7 @@ class TestConfiguration(unittest.TestCase):
     @patch("py_sonar_scanner.configuration.sys")
     def test_argument_parsing(self, mock_sys):
         configuration = Configuration()
+        self.assertFalse(configuration.is_debug())
 
         mock_sys.argv = ["path/to/scanner/py-sonar-scanner"]
         configuration.setup()
@@ -71,6 +73,10 @@ def test_argument_parsing(self, mock_sys):
         configuration.setup()
         self.assertListEqual(configuration.scan_arguments, ["-Dproject.home=tests=2"])
 
+        mock_sys.argv = ["path/to/scanner/py-sonar-scanner", "-X"]
+        configuration.setup()
+        self.assertTrue(configuration.is_debug())
+
     @patch("py_sonar_scanner.configuration.sys")
     def test_dict_with_no_valid_values(self, mock_sys):
         configuration = Configuration()
@@ -134,26 +140,24 @@ def test_toml_with_valid_values(self, mock_sys):
             ],
         )
 
-    @patch("py_sonar_scanner.configuration.ApplicationLogger.get_logger")
     @patch("builtins.open")
     @patch("py_sonar_scanner.configuration.sys")
-    def test_error_while_reading_toml_file(self, mock_sys, mock_open, mock_logger):
+    def test_error_while_reading_toml_file(self, mock_sys, mock_open):
         toml_file_path = os.path.join(CURRENT_DIR, "resources", "test_toml_file.toml")
         mock_sys.argv = ["path/to/scanner/py-sonar-scanner", f"-Dtoml.path={toml_file_path}"]
 
         mock_open.side_effect = OSError("Test error while opening file.")
-
-        mock_logger_instance = Mock()
-        mock_logger_instance.error = Mock()
-        mock_logger.return_value = mock_logger_instance
-
-        configuration = Configuration()
-        configuration.setup()
-
-        self.assertListEqual(
-            configuration.scan_arguments,
-            [
-                f"-Dtoml.path={CURRENT_DIR}/resources/test_toml_file.toml",
-            ],
-        )
-        mock_logger_instance.error.assert_called_once_with("Test error while opening file.")
+        with self.assertLogs(ApplicationLogger.get_logger()) as log:
+            configuration = Configuration()
+            configuration.setup()
+
+            self.assertListEqual(
+                configuration.scan_arguments,
+                [
+                    f"-Dtoml.path={CURRENT_DIR}/resources/test_toml_file.toml",
+                ],
+            )
+
+            self.assertEqual(
+                "Error while opening .toml file: Test error while opening file.", log.records[0].getMessage()
+            )

tests/test_environment.py

@@ -157,3 +157,17 @@ def test_is_sonar_scanner_on_path(self, mock_shutil):
         environment._is_sonar_scanner_on_path()
 
         mock_shutil.which.assert_called_once_with("sonar-scanner")
+
+    def test_env_scan(self):
+        cfg = Configuration()
+        environment = Environment(cfg)
+        environment.setup = Mock()
+        environment.scanner = Mock(side_effect=Exception("Something wrong"))
+        environment.cleanup = Mock()
+
+        with self.assertRaises(Exception):
+            environment.scan()
+
+        environment.setup.assert_called_once()
+        environment.scanner.assert_called_once()
+        environment.cleanup.assert_called_once()

tests/test_main.py

@@ -17,30 +17,62 @@
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 #
+import logging
 import unittest
 from unittest.mock import patch, Mock, MagicMock
 from py_sonar_scanner.__main__ import scan
-from py_sonar_scanner.scanner import Scanner
+from py_sonar_scanner.logger import ApplicationLogger
 
 
 class TestMain(unittest.TestCase):
-    @patch("py_sonar_scanner.scanner.Scanner")
     @patch("py_sonar_scanner.__main__.Environment")
     @patch("py_sonar_scanner.__main__.Configuration")
-    def test_main_scan(self, mock_cfg, mock_env, mock_scanner):
+    def test_main_scan(self, mock_cfg, mock_env):
         configuration_instance = MagicMock()
         configuration_instance.setup = Mock()
         mock_cfg.return_value = configuration_instance
 
         environment_instance = MagicMock()
-        environment_instance.setup = Mock()
-        mock_scanner.scan = Mock()
-        environment_instance.scanner.return_value = mock_scanner
+        environment_instance.scan = Mock()
         mock_env.return_value = environment_instance
 
         scan()
 
         configuration_instance.setup.assert_called_once()
-        environment_instance.setup.assert_called_once()
-        environment_instance.scanner.assert_called_once()
-        mock_scanner.scan.assert_called_once()
+        environment_instance.scan.assert_called_once()
+
+    @patch("py_sonar_scanner.__main__.Environment")
+    @patch("py_sonar_scanner.configuration.sys")
+    def test_main_scan_fail(self, mock_sys, mock_env):
+        mock_sys.argv = ["path/to/scanner/py-sonar-scanner"]
+        environment_instance = MagicMock()
+        environment_instance.scan = Mock(side_effect=Exception("Something"))
+        mock_env.return_value = environment_instance
+
+        with self.assertLogs(ApplicationLogger.get_logger()) as log:
+            scan()
+            self.assertEqual(2, len(log.records))
+            self.assertEqual("Error during SonarScanner execution: Something", log.records[0].getMessage())
+            self.assertEqual(logging.ERROR, log.records[0].levelno)
+            self.assertFalse(log.records[0].exc_info)
+            self.assertEqual(
+                "Re-run SonarScanner using the -X switch to enable full debug logging.", log.records[1].getMessage()
+            )
+            self.assertEqual(logging.INFO, log.records[1].levelno)
+
+    @patch("py_sonar_scanner.scanner.Scanner")
+    @patch("py_sonar_scanner.__main__.Environment")
+    @patch("py_sonar_scanner.configuration.sys")
+    def test_main_scan_debug_fail(self, mock_sys, mock_env, mock_scanner):
+        mock_sys.argv = ["path/to/scanner/py-sonar-scanner", "-X"]
+
+        environment_instance = MagicMock()
+        environment_instance.scan = Mock(side_effect=Exception("Something"))
+        mock_env.return_value = environment_instance
+
+        with self.assertLogs(ApplicationLogger.get_logger()) as log:
+            scan()
+            self.assertEqual(1, len(log.records))
+            self.assertEqual("Error during SonarScanner execution: Something", log.records[0].getMessage())
+            self.assertEqual(logging.ERROR, log.records[0].levelno)
+            self.assertTrue(log.records[0].exc_info)