SCANPY-126 Serialize the scanner properties to JSON (#139)

Author: thomas-serre-sonarsource

src/pysonar_scanner/configuration.py

@@ -18,10 +18,11 @@
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 #
 import time
+import json
 import argparse
 from dataclasses import dataclass
 from enum import Enum
-from typing import Optional
+from typing import Optional, Dict
 
 
 class JRECacheStatus(Enum):
@@ -89,6 +90,50 @@ class Sonar:
 class Configuration:
     sonar: Sonar = Sonar()
 
+    def __to_dict(self) -> Dict:
+        scanner = self.sonar.scanner
+        sonar = self.sonar
+
+        properties = [
+            {"key": "sonar.scanner.app", "value": scanner.app},
+            {"key": "sonar.scanner.appVersion", "value": scanner.app_version},
+            {"key": "sonar.token", "value": sonar.token},
+        ]
+
+        optional_properties = [
+            ("sonar.region", sonar.region),
+            ("sonar.host.url", sonar.host_url),
+            ("sonar.projectBaseDir", sonar.project_base_dir),
+            ("sonar.verbose", sonar.verbose),
+            ("sonar.userHome", sonar.user_home),
+            ("sonar.scanner.apiBaseUrl", scanner.api_base_url),
+            ("sonar.scanner.bootstrapStartTime", scanner.bootstrap_start_time),
+            ("sonar.scanner.os", scanner.os),
+            ("sonar.scanner.arch", scanner.arch),
+            ("sonar.scanner.connectTimeout", scanner.connect_timeout),
+            ("sonar.scanner.socketTimeout", scanner.socket_timeout),
+            ("sonar.scanner.responseTimeout", scanner.response_timeout),
+            ("sonar.scanner.truststorePath", scanner.truststore_path),
+            ("sonar.scanner.truststorePassword", scanner.truststore_password),
+            ("sonar.scanner.keystorePath", scanner.keystore_path),
+            ("sonar.scanner.keystorePassword", scanner.keystore_password),
+            ("sonar.scanner.proxyHost", scanner.proxy_host),
+            ("sonar.scanner.proxyPort", scanner.proxy_port),
+            ("sonar.scanner.proxyUser", scanner.proxy_user),
+            ("sonar.scanner.proxyPassword", scanner.proxy_password),
+            ("sonar.scanner.wasJreCacheHit", scanner.was_jre_cache_hit.name if scanner.was_jre_cache_hit else None),
+            ("sonar.scanner.wasEngineCacheHit", scanner.was_engine_cache_hit),
+        ]
+
+        for key, value in optional_properties:
+            if value is not None and value != "":
+                properties.append({"key": key, "value": value})
+
+        return {"scannerProperties": properties}
+
+    def to_json(self) -> str:
+        return json.dumps(self.__to_dict(), indent=2)
+
 
 class ConfigurationLoader:
 

tests/test_configuration.py

@@ -18,11 +18,13 @@
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 #
 import unittest
+import json
+import time
 
 from unittest.mock import patch
 from io import StringIO
 
-from pysonar_scanner.configuration import ConfigurationLoader, Configuration, Scanner, Internal, Sonar
+from pysonar_scanner.configuration import ConfigurationLoader, Configuration, JRECacheStatus, Scanner, Internal, Sonar
 
 
 class TestMain(unittest.TestCase):
@@ -161,3 +163,120 @@ def test_all_cli_args(self):
 
         expected_configuration = Configuration(sonar=expected_sonar)
         self.assertEqual(configuration, expected_configuration)
+
+    def test_minimal_json(self):
+        minimal_json = Configuration(sonar=Sonar(token="MyToken")).to_json()
+
+        minimal_dict = json.loads(minimal_json)
+        self.assertIn("scannerProperties", minimal_dict)
+        self.assertIn("sonar.scanner.bootstrapStartTime", [prop["key"] for prop in minimal_dict["scannerProperties"]])
+        bootstrap_start_time = [
+            prop["value"]
+            for prop in minimal_dict["scannerProperties"]
+            if prop["key"] == "sonar.scanner.bootstrapStartTime"
+        ][0]
+        self.assertAlmostEqual(
+            bootstrap_start_time, int(time.time() * 1000), delta=1000 * 60
+        )  # 1 minute delta between the configuration creation and this test
+
+        expected_json = json.dumps(
+            {
+                "scannerProperties": [
+                    {"key": "sonar.scanner.app", "value": "python"},
+                    {"key": "sonar.scanner.appVersion", "value": "1.0"},
+                    {"key": "sonar.token", "value": "MyToken"},
+                    {"key": "sonar.verbose", "value": False},
+                    {"key": "sonar.scanner.bootstrapStartTime", "value": bootstrap_start_time},
+                ]
+            }
+        )
+        expected_dict = json.loads(expected_json)
+        self.assertDictEqual(minimal_dict, expected_dict)
+
+    def test_full_json(self):
+        internal = Internal(
+            dump_to_file="mySonarScannerInternalDumpToFile", sq_version="mySonarScannerInternalSqVersion"
+        )
+
+        scanner = Scanner(
+            internal=internal,
+            os="windows",
+            arch="x64",
+            connect_timeout=42,
+            socket_timeout=43,
+            response_timeout=44,
+            truststore_path="mySonarScannerTruststorePath",
+            truststore_password="mySonarScannerTruststorePassword",
+            keystore_path="mySonarScannerKeystorePath",
+            keystore_password="mySonarScannerKeystorePassword",
+            proxy_host="mySonarScannerProxyHost",
+            proxy_port=45,
+            proxy_user="mySonarScannerProxyUser",
+            proxy_password="mySonarScannerProxyPassword",
+            skip_jre_provisioning=True,
+            java_exe_path="mySonarScannerJavaExePath",
+            java_opts="mySonarScannerJavaOpts",
+            sonarcloud_url="mySonarScannerCloudUrl",
+            api_base_url="mySonarScannerApiUrl",
+            was_engine_cache_hit=True,
+            was_jre_cache_hit=JRECacheStatus.HIT,
+        )
+
+        sonar = Sonar(
+            scanner=scanner,
+            token="MyToken",
+            verbose=True,
+            host_url="mySonarHostUrl",
+            region="us",
+            user_home="mySonarUserHome",
+            project_base_dir="mySonarProjectBaseDir",
+        )
+
+        full_configuration = Configuration(sonar=sonar)
+
+        full_json = full_configuration.to_json()
+        full_dict = json.loads(full_json)
+        self.assertIn("scannerProperties", full_dict)
+        self.assertIn("sonar.scanner.bootstrapStartTime", [prop["key"] for prop in full_dict["scannerProperties"]])
+        bootstrap_start_time = [
+            prop["value"]
+            for prop in full_dict["scannerProperties"]
+            if prop["key"] == "sonar.scanner.bootstrapStartTime"
+        ][0]
+        self.assertAlmostEqual(
+            bootstrap_start_time, int(time.time() * 1000), delta=1000 * 60
+        )  # 1 minute delta between the configuration creation and this test
+
+        expected_json = json.dumps(
+            {
+                "scannerProperties": [
+                    {"key": "sonar.scanner.app", "value": "python"},
+                    {"key": "sonar.scanner.appVersion", "value": "1.0"},
+                    {"key": "sonar.token", "value": "MyToken"},
+                    {"key": "sonar.region", "value": "us"},
+                    {"key": "sonar.host.url", "value": "mySonarHostUrl"},
+                    {"key": "sonar.projectBaseDir", "value": "mySonarProjectBaseDir"},
+                    {"key": "sonar.verbose", "value": True},
+                    {"key": "sonar.userHome", "value": "mySonarUserHome"},
+                    {"key": "sonar.scanner.apiBaseUrl", "value": "mySonarScannerApiUrl"},
+                    {"key": "sonar.scanner.bootstrapStartTime", "value": bootstrap_start_time},
+                    {"key": "sonar.scanner.os", "value": "windows"},
+                    {"key": "sonar.scanner.arch", "value": "x64"},
+                    {"key": "sonar.scanner.connectTimeout", "value": 42},
+                    {"key": "sonar.scanner.socketTimeout", "value": 43},
+                    {"key": "sonar.scanner.responseTimeout", "value": 44},
+                    {"key": "sonar.scanner.truststorePath", "value": "mySonarScannerTruststorePath"},
+                    {"key": "sonar.scanner.truststorePassword", "value": "mySonarScannerTruststorePassword"},
+                    {"key": "sonar.scanner.keystorePath", "value": "mySonarScannerKeystorePath"},
+                    {"key": "sonar.scanner.keystorePassword", "value": "mySonarScannerKeystorePassword"},
+                    {"key": "sonar.scanner.proxyHost", "value": "mySonarScannerProxyHost"},
+                    {"key": "sonar.scanner.proxyPort", "value": 45},
+                    {"key": "sonar.scanner.proxyUser", "value": "mySonarScannerProxyUser"},
+                    {"key": "sonar.scanner.proxyPassword", "value": "mySonarScannerProxyPassword"},
+                    {"key": "sonar.scanner.wasJreCacheHit", "value": "HIT"},
+                    {"key": "sonar.scanner.wasEngineCacheHit", "value": True},
+                ]
+            }
+        )
+        expected_dict = json.loads(expected_json)
+        self.assertDictEqual(full_dict, expected_dict)