SCANPY-155 Provide properties computed during bootstrapping to the scanner engine (#166)

Author: guillaume-dequenne

src/pysonar_scanner/__main__.py

@@ -20,11 +20,20 @@
 
 from pysonar_scanner import app_logging
 from pysonar_scanner import cache
-from pysonar_scanner.api import get_base_urls, SonarQubeApi
+from pysonar_scanner.api import get_base_urls, SonarQubeApi, BaseUrls, MIN_SUPPORTED_SQ_VERSION
 from pysonar_scanner.configuration import configuration_loader
 from pysonar_scanner.configuration.configuration_loader import ConfigurationLoader
-from pysonar_scanner.configuration.properties import SONAR_VERBOSE
-from pysonar_scanner.scannerengine import ScannerEngine
+from pysonar_scanner.configuration.properties import (
+    SONAR_VERBOSE,
+    SONAR_HOST_URL,
+    SONAR_SCANNER_API_BASE_URL,
+    SONAR_SCANNER_SONARCLOUD_URL,
+    SONAR_SCANNER_PROXY_PORT,
+    SONAR_SCANNER_JAVA_EXE_PATH,
+)
+from pysonar_scanner.exceptions import SQTooOldException
+from pysonar_scanner.jre import JREResolvedPath, JREProvisioner, JREResolver, JREResolverConfiguration
+from pysonar_scanner.scannerengine import ScannerEngine, ScannerEngineProvisioner
 
 
 def scan():
@@ -34,16 +43,53 @@ def scan():
     set_logging_options(config)
 
     cache_manager = cache.get_default()
-    api = __build_api(config)
-    scanner = ScannerEngine(api, cache_manager)
+
+    api = build_api(config)
+    check_version(api)
+    update_config_with_api_urls(config, api.base_urls)
+
+    scanner = create_scanner_engine(api, cache_manager, config)
+
     return scanner.run(config)
 
 
 def set_logging_options(config):
     app_logging.configure_logging_level(verbose=config.get(SONAR_VERBOSE, False))
 
 
-def __build_api(config: dict[str, any]) -> SonarQubeApi:
+def build_api(config: dict[str, any]) -> SonarQubeApi:
     token = configuration_loader.get_token(config)
     base_urls = get_base_urls(config)
     return SonarQubeApi(base_urls, token)
+
+
+def check_version(api):
+    if api.is_sonar_qube_cloud():
+        return
+    version = api.get_analysis_version()
+    if not version.does_support_bootstrapping():
+        raise SQTooOldException(
+            f"Only SonarQube versions >= {MIN_SUPPORTED_SQ_VERSION} are supported, but got {version}"
+        )
+
+
+def update_config_with_api_urls(config, base_urls: BaseUrls):
+    config[SONAR_HOST_URL] = base_urls.base_url
+    config[SONAR_SCANNER_API_BASE_URL] = base_urls.api_base_url
+    if base_urls.is_sonar_qube_cloud:
+        config[SONAR_SCANNER_SONARCLOUD_URL] = base_urls.base_url
+    config[SONAR_SCANNER_PROXY_PORT] = "443" if base_urls.base_url.startswith("https") else "80"
+
+
+def create_scanner_engine(api, cache_manager, config):
+    jre_path = create_jre(api, cache_manager, config)
+    config[SONAR_SCANNER_JAVA_EXE_PATH] = str(jre_path.path)
+    scanner_engine_path = ScannerEngineProvisioner(api, cache_manager).provision()
+    scanner = ScannerEngine(jre_path, scanner_engine_path)
+    return scanner
+
+
+def create_jre(api, cache, config: dict[str, any]) -> JREResolvedPath:
+    jre_provisioner = JREProvisioner(api, cache)
+    jre_resolver = JREResolver(JREResolverConfiguration.from_dict(config), jre_provisioner)
+    return jre_resolver.resolve_jre()

src/pysonar_scanner/jre.py

@@ -38,6 +38,7 @@
     SONAR_SCANNER_SKIP_JRE_PROVISIONING,
     SONAR_SCANNER_OS,
     Key,
+    SONAR_SCANNER_ARCH,
 )
 
 

src/pysonar_scanner/scannerengine.py

@@ -17,23 +17,18 @@
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 #
-from enum import Enum
 import json
 import logging
-from operator import le
 import pathlib
+from dataclasses import dataclass
+from subprocess import Popen, PIPE
 from threading import Thread
 from typing import IO, Callable, Optional
 
-from dataclasses import dataclass
-
-import pysonar_scanner.api as api
-
 from pysonar_scanner.api import SonarQubeApi
 from pysonar_scanner.cache import Cache, CacheFile
-from pysonar_scanner.exceptions import ChecksumException, SQTooOldException
-from pysonar_scanner.jre import JREProvisioner, JREResolvedPath, JREResolver, JREResolverConfiguration
-from subprocess import Popen, PIPE
+from pysonar_scanner.exceptions import ChecksumException
+from pysonar_scanner.jre import JREResolvedPath
 
 
 @dataclass(frozen=True)
@@ -139,18 +134,12 @@ def __download_scanner_engine(self, cache_file: CacheFile) -> None:
 
 
 class ScannerEngine:
-    def __init__(self, api: SonarQubeApi, cache: Cache):
-        self.api = api
-        self.cache = cache
-
-    def __fetch_scanner_engine(self) -> pathlib.Path:
-        return ScannerEngineProvisioner(self.api, self.cache).provision()
+    def __init__(self, jre_path: JREResolvedPath, scanner_engine_path: pathlib.Path):
+        self.jre_path = jre_path
+        self.scanner_engine_path = scanner_engine_path
 
     def run(self, config: dict[str, any]):
-        self.__version_check()
-        jre_path = self.__resolve_jre(config)
-        scanner_engine_path = self.__fetch_scanner_engine()
-        cmd = self.__build_command(jre_path, scanner_engine_path)
+        cmd = self.__build_command(self.jre_path, self.scanner_engine_path)
         properties_str = self.__config_to_json(config)
         return CmdExecutor(cmd, properties_str).execute()
 
@@ -164,17 +153,3 @@ def __build_command(self, jre_path: JREResolvedPath, scanner_engine_path: pathli
     def __config_to_json(self, config: dict[str, any]) -> str:
         scanner_properties = [{"key": k, "value": v} for k, v in config.items()]
         return json.dumps({"scannerProperties": scanner_properties})
-
-    def __version_check(self):
-        if self.api.is_sonar_qube_cloud():
-            return
-        version = self.api.get_analysis_version()
-        if not version.does_support_bootstrapping():
-            raise SQTooOldException(
-                f"Only SonarQube versions >= {api.MIN_SUPPORTED_SQ_VERSION} are supported, but got {version}"
-            )
-
-    def __resolve_jre(self, config: dict[str, any]) -> JREResolvedPath:
-        jre_provisionner = JREProvisioner(self.api, self.cache)
-        jre_resolver = JREResolver(JREResolverConfiguration.from_dict(config), jre_provisionner)
-        return jre_resolver.resolve_jre()

tests/unit/test_main.py

@@ -17,19 +17,96 @@
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 #
-from unittest.mock import patch
+import pathlib
+from pathlib import Path
+from unittest.mock import patch, Mock
 
 from pyfakefs import fake_filesystem_unittest as pyfakefs
 
-from pysonar_scanner.__main__ import scan
+from pysonar_scanner.__main__ import scan, check_version, create_jre
+from pysonar_scanner.api import SQVersion, SonarQubeApi
+from pysonar_scanner.cache import Cache
 from pysonar_scanner.configuration.configuration_loader import ConfigurationLoader
-from pysonar_scanner.configuration.properties import SONAR_PROJECT_KEY, SONAR_TOKEN
-from pysonar_scanner.scannerengine import ScannerEngine
+from pysonar_scanner.configuration.properties import (
+    SONAR_PROJECT_KEY,
+    SONAR_TOKEN,
+    SONAR_HOST_URL,
+    SONAR_SCANNER_API_BASE_URL,
+    SONAR_SCANNER_SONARCLOUD_URL,
+    SONAR_SCANNER_PROXY_PORT,
+    SONAR_SCANNER_OS,
+    SONAR_SCANNER_ARCH,
+    SONAR_SCANNER_JAVA_EXE_PATH,
+)
+from pysonar_scanner.exceptions import SQTooOldException
+from pysonar_scanner.jre import JREResolvedPath, JREResolver
+from pysonar_scanner.scannerengine import ScannerEngine, ScannerEngineProvisioner
+from tests.unit import sq_api_utils
 
 
 class TestMain(pyfakefs.TestCase):
-    @patch.object(ConfigurationLoader, "load", return_value={SONAR_TOKEN: "myToken", SONAR_PROJECT_KEY: "myProjectKey"})
+    @patch.object(
+        ConfigurationLoader,
+        "load",
+        return_value={
+            SONAR_TOKEN: "myToken",
+            SONAR_PROJECT_KEY: "myProjectKey",
+            SONAR_SCANNER_OS: "linux",
+            SONAR_SCANNER_ARCH: "x64",
+        },
+    )
+    @patch.object(ScannerEngineProvisioner, "provision", return_value=JREResolvedPath(Path("scanner_engine_path")))
+    @patch("pysonar_scanner.__main__.create_jre", return_value=JREResolvedPath(Path("jre_path")))
     @patch.object(ScannerEngine, "run", return_value=0)
-    def test_minimal_success_run(self, load_mock, run_mock):
+    def test_minimal_success_run(self, run_mock, create_jre_mock, provision_mock, load_mock):
         exitcode = scan()
         self.assertEqual(exitcode, 0)
+
+        # Verify that run was called with the expected configuration
+        run_mock.assert_called_once()
+        config = run_mock.call_args[0][0]  # Extract the configuration arg
+
+        # Check expected configuration with a single assertion
+        expected_config = {
+            SONAR_TOKEN: "myToken",
+            SONAR_PROJECT_KEY: "myProjectKey",
+            SONAR_SCANNER_OS: "linux",
+            SONAR_SCANNER_ARCH: "x64",
+            SONAR_HOST_URL: "https://sonarcloud.io",
+            SONAR_SCANNER_API_BASE_URL: "https://api.sonarcloud.io",
+            SONAR_SCANNER_SONARCLOUD_URL: "https://sonarcloud.io",
+            SONAR_SCANNER_PROXY_PORT: "443",
+            SONAR_SCANNER_JAVA_EXE_PATH: "jre_path",
+        }
+
+        self.assertEqual(expected_config, config)
+
+    def test_version_check_outdated_sonarqube(self):
+        sq_cloud_api = sq_api_utils.get_sq_server()
+        sq_cloud_api.get_analysis_version = Mock(return_value=SQVersion.from_str("9.9.9"))
+
+        with self.assertRaises(SQTooOldException):
+            check_version(sq_cloud_api)
+
+    def test_version_check_recent_sonarqube(self):
+        sq_cloud_api = sq_api_utils.get_sq_server()
+        sq_cloud_api.get_analysis_version = Mock(return_value=SQVersion.from_str("10.7"))
+
+        check_version(sq_cloud_api)
+        sq_cloud_api.get_analysis_version.assert_called_once()
+
+    def test_version_check_sonarqube_cloud(self):
+        sq_cloud_api = sq_api_utils.get_sq_cloud()
+        sq_cloud_api.get_analysis_version = Mock()
+
+        check_version(sq_cloud_api)
+        sq_cloud_api.get_analysis_version.assert_not_called()
+
+
+@patch("pysonar_scanner.scannerengine.CmdExecutor")
+@patch.object(JREResolver, "resolve_jre")
+def test_get_jre(self, resolve_jre_mock):
+    resolve_jre_mock.return_value = JREResolvedPath(pathlib.Path("jre/bin/java"))
+    api = SonarQubeApi(Mock(), Mock())
+    cache = Cache(Mock())
+    create_jre(api, cache, {SONAR_SCANNER_OS: "linux", SONAR_SCANNER_ARCH: "x64"})

tests/unit/test_scannerengine.py

@@ -19,29 +19,26 @@
 #
 import json
 import logging
-from math import log
-from subprocess import PIPE
-import unittest
 import pathlib
+import unittest
+from subprocess import PIPE
+from unittest.mock import Mock
+from unittest.mock import patch, MagicMock
+
 import pyfakefs.fake_filesystem_unittest as pyfakefs
 
-from pysonar_scanner import app_logging, cache
+from pysonar_scanner import cache
 from pysonar_scanner import scannerengine
+from pysonar_scanner.api import SQVersion
 from pysonar_scanner.exceptions import ChecksumException, SQTooOldException
-from pysonar_scanner.jre import JREProvisioner, JREResolvedPath, JREResolver
+from pysonar_scanner.jre import JREResolvedPath, JREResolver
 from pysonar_scanner.scannerengine import (
-    CmdExecutor,
     LogLine,
     ScannerEngine,
     ScannerEngineProvisioner,
     default_log_line_listener,
-    parse_log_line,
 )
-from unittest.mock import Mock
-
-from pysonar_scanner.api import SQVersion
 from tests.unit import sq_api_utils
-from unittest.mock import patch, MagicMock
 
 
 class TestLogLine(unittest.TestCase):
@@ -138,59 +135,36 @@ def setUp(self):
         self.setUpPyfakefs()
 
     @patch("pysonar_scanner.scannerengine.CmdExecutor")
-    @patch.object(JREResolver, "resolve_jre")
-    @patch.object(ScannerEngineProvisioner, "provision")
-    def test_command_building(self, provision_mock, resolve_jre_mock, execute_mock):
-        provision_mock.return_value = pathlib.Path("/test/scanner-engine.jar")
-        resolve_jre_mock.return_value = JREResolvedPath(pathlib.Path("jre/bin/java"))
-
+    def test_command_building(self, execute_mock):
         config = {
             "sonar.token": "myToken",
             "sonar.projectKey": "myProjectKey",
+            "sonar.scanner.os": "linux",
+            "sonar.scanner.arch": "x64",
+            "sonar.scanner.javaExePath": "jre/bin/java",
         }
 
         expected_std_in = json.dumps(
             {
                 "scannerProperties": [
                     {"key": "sonar.token", "value": "myToken"},
                     {"key": "sonar.projectKey", "value": "myProjectKey"},
+                    {"key": "sonar.scanner.os", "value": "linux"},
+                    {"key": "sonar.scanner.arch", "value": "x64"},
+                    {"key": "sonar.scanner.javaExePath", "value": "jre/bin/java"},
                 ]
             }
         )
+        jre_resolve_path_mock = Mock()
+        jre_resolve_path_mock.path = pathlib.Path("jre/bin/java")
+        scanner_engine_mock = pathlib.Path("/test/scanner-engine.jar")
 
-        scannerengine.ScannerEngine(sq_api_utils.get_sq_cloud(), cache.get_default()).run(config)
+        scannerengine.ScannerEngine(jre_resolve_path_mock, scanner_engine_mock).run(config)
 
         execute_mock.assert_called_once_with(
             [pathlib.Path("jre/bin/java"), "-jar", pathlib.Path("/test/scanner-engine.jar")], expected_std_in
         )
 
-    def test_version_check(self):
-        with self.subTest("SQ:Server is too old"):
-            sq_cloud_api = sq_api_utils.get_sq_server()
-            sq_cloud_api.get_analysis_version = Mock(return_value=SQVersion.from_str("9.9.9"))
-            scannerengine = ScannerEngine(sq_cloud_api, cache.get_default())
-
-            with self.assertRaises(SQTooOldException):
-                scannerengine._ScannerEngine__version_check()
-
-        with self.subTest("SQ:Server that is new than 10.6"):
-            sq_cloud_api = sq_api_utils.get_sq_server()
-            sq_cloud_api.get_analysis_version = Mock(return_value=SQVersion.from_str("10.7"))
-            scannerengine = ScannerEngine(sq_cloud_api, cache.get_default())
-
-            scannerengine._ScannerEngine__version_check()
-
-            sq_cloud_api.get_analysis_version.assert_called_once()
-
-        with self.subTest("SQ:Cloud "):
-            sq_cloud_api = sq_api_utils.get_sq_cloud()
-            sq_cloud_api.get_analysis_version = Mock()
-            scannerengine = ScannerEngine(sq_cloud_api, cache.get_default())
-
-            scannerengine._ScannerEngine__version_check()
-
-            sq_cloud_api.get_analysis_version.assert_not_called()
-
 
 class TestScannerEngineProvisioner(pyfakefs.TestCase):
     def setUp(self):