regscale-cli 6.16.0.0__py3-none-any.whl

tests/regscale/core/test_app.py

@@ -0,0 +1,406 @@
+"""
+Test the Application class used by the RegScale CLI.
+"""
+
+import os
+from unittest.mock import patch, MagicMock
+
+from requests import Response
+
+from regscale.core.app.application import Application
+
+
+class TestApplication:
+    test_config_file = "test_application_config.yaml"
+    os.environ["REGSCALE_CONFIG_FILE"] = test_config_file
+    app = Application()
+    app.config_file = test_config_file
+    test_domain = "https://example.com"
+    test_token = "Bearer test_token"
+
+    def teardown_method(self, method):
+        """
+        Remove the test config file after each test
+        """
+        if os.path.exists(self.test_config_file):
+            os.remove(self.test_config_file)
+
+    def test_init(self):
+        assert isinstance(self.app, Application)
+        assert isinstance(self.app, Application)
+        assert self.app.config != {}
+        assert self.app.local_config is True
+        assert self.app.running_in_airflow is False
+
+    def test_singleton(self):
+        test_config = {"key": "value"}
+        app2 = Application()
+        assert self.app == app2
+        app3 = Application(config=test_config)
+        assert test_config["key"] == app3["key"]
+        assert app3 != self.app
+        assert app3 != app2
+
+    @patch("regscale.core.app.internal.login.parse_user_id_from_jwt")
+    @patch("requests.get")
+    def test_fetch_config_from_regscale_success(self, mock_get, mock_parse_user_id):
+        mock_parse_user_id.return_value = "test_user_id"
+        mock_response = MagicMock()
+        mock_response.json.return_value = {"cliConfig": "key: value"}
+        mock_get.return_value = mock_response
+        config = self.app._fetch_config_from_regscale(config=self.app.config)
+        assert "domain" in config
+        assert config["userId"] == "test_user_id"
+        assert config["key"] == "value"
+
+    @patch("regscale.core.app.internal.login.parse_user_id_from_jwt")
+    @patch("requests.get")
+    def test_fetch_config_from_regscale_success_with_envars(self, mock_get, mock_parse_user_id):
+        mock_parse_user_id.return_value = "test_user_id"
+        mock_response = MagicMock()
+        mock_response.json.return_value = {"cliConfig": "key: value"}
+        mock_get.return_value = mock_response
+        os.environ["REGSCALE_DOMAIN"] = self.test_domain
+        os.environ["REGSCALE_TOKEN"] = self.test_token
+        config = self.app._fetch_config_from_regscale(config={})
+        assert config["domain"] == self.test_domain
+        assert config["token"] == self.test_token
+        assert config["userId"] == "test_user_id"
+        assert config["key"] == "value"
+
+    @patch("requests.get")
+    def test_fetch_config_from_regscale_failure(self, mock_get):
+        mock_response = MagicMock()
+        mock_response.json.return_value = "Not found."
+        mock_response.status_code = 404
+        mock_get.return_value = mock_response
+        os.environ["REGSCALE_DOMAIN"] = self.test_domain
+        os.environ["REGSCALE_TOKEN"] = self.test_token
+        empty_config = self.app._fetch_config_from_regscale()
+        assert empty_config == {}
+        with patch.object(self.app.logger, "error") as mock_logger_error:
+            config = self.app._fetch_config_from_regscale(config=self.app.config)
+            mock_logger_error.assert_called_once()
+            assert config == {}
+
+    def test_gen_config(self):
+        self.app.local_config = True
+        self.app.config_file = "test_gen_config.yaml"
+        config = self.app._gen_config()
+        assert "key" not in config
+        assert "domain" in config
+        assert "token" in config
+
+        small_config = {"key": "value", "domain": self.test_domain}
+        config = self.app._gen_config(small_config)
+        assert config["key"] == "value"
+        assert config["domain"] == self.test_domain
+        os.remove(self.app.config_file)
+
+    def test_gen_config_airflow(self):
+        self.app.running_in_airflow = True
+        with patch.object(self.app, "_get_airflow_config", return_value={"key": "value"}):
+            config = self.app._gen_config()
+            assert config == {"key": "value"}
+
+    def test_gen_config_with_provided_config(self):
+        self.app.local_config = True
+        config = {"key": "value"}
+        with patch.object(self.app, "_get_env", return_value={"env_key": "env_value"}):
+            with patch.object(self.app, "verify_config", return_value={"key": "value", "env_key": "env_value"}):
+                with patch.object(self.app, "save_config") as mock_save_config:
+                    result = self.app._gen_config(config)
+                    assert result == {"key": "value", "env_key": "env_value"}
+                    mock_save_config.assert_called_once()
+
+    def test_gen_config_without_local_config(self):
+        self.app.local_config = False
+        with patch.object(self.app, "_get_env", return_value={"env_key": "env_value"}):
+            with patch.object(self.app, "verify_config", return_value={"env_key": "env_value"}):
+                with patch.object(self.app, "save_config") as mock_save_config:
+                    result = self.app._gen_config()
+                    assert result == {"env_key": "env_value"}
+                    mock_save_config.assert_called_once()
+
+    def test_gen_config_with_file_config(self):
+        self.app.local_config = True
+        with patch.object(self.app, "_get_conf", return_value={"file_key": "file_value"}):
+            with patch.object(self.app, "_get_env", return_value={"env_key": "env_value"}):
+                with patch.object(
+                    self.app, "verify_config", return_value={"file_key": "file_value", "env_key": "env_value"}
+                ):
+                    with patch.object(self.app, "save_config") as mock_save_config:
+                        result = self.app._gen_config()
+                        assert result == {"file_key": "file_value", "env_key": "env_value"}
+                        mock_save_config.assert_called_once()
+
+    def test_gen_config_scanner_error(self):
+        from yaml.scanner import ScannerError
+
+        self.app.local_config = True
+        with patch.object(self.app, "_get_conf", side_effect=ScannerError):
+            with patch.object(self.app, "save_config") as mock_save_config:
+                result = self.app._gen_config()
+                assert result == self.app.template
+                # called twice because the first call is to save the default config
+                mock_save_config.assert_called_once()
+
+    def test_get_airflow_config_with_dict(self):
+        config = {"key": "value"}
+        with patch.object(self.app, "_fetch_config_from_regscale", return_value={"key": "value"}):
+            result = self.app._get_airflow_config(config)
+            assert result == {"key": "value"}
+
+    def test_get_airflow_config_with_str(self):
+        config = "{'key': 'value'}"
+        with patch.object(self.app, "_fetch_config_from_regscale", return_value={"key": "value"}):
+            result = self.app._get_airflow_config(config)
+            assert result == {"key": "value"}
+
+    def test_get_airflow_config_with_env_vars(self):
+        os.environ["REGSCALE_TOKEN"] = self.test_token
+        os.environ["REGSCALE_DOMAIN"] = self.test_domain
+        with patch.object(self.app, "_fetch_config_from_regscale", return_value={"key": "value"}):
+            result = self.app._get_airflow_config()
+            assert result == {"key": "value"}
+
+    def test_get_airflow_config_no_config(self):
+        os.environ["REGSCALE_TOKEN"] = ""
+        os.environ["REGSCALE_DOMAIN"] = ""
+        result = self.app._get_airflow_config()
+        assert result is None
+
+        os.environ["REGSCALE_TOKEN"] = self.test_token
+        os.environ["REGSCALE_DOMAIN"] = self.test_domain
+        with patch.object(
+            self.app, "_fetch_config_from_regscale", return_value={"token": self.test_token, "domain": self.test_domain}
+        ):
+            result = self.app._get_airflow_config()
+            assert result["token"] == self.test_token
+            assert result["domain"] == self.test_domain
+
+    def test_get_airflow_config_invalid_json(self):
+        config = "{'key': 'value'"
+        with patch.object(self.app.logger, "debug") as mock_logger_debug:
+            result = self.app._get_airflow_config(config)
+            assert result is None
+            mock_logger_debug.assert_called()
+
+    def test_get_env_with_matching_keys(self):
+        with patch.object(self.app, "template", {"key1": "value1", "key2": "value2"}):
+            with patch.dict(os.environ, {"key1": "env_value1", "key2": "env_value2"}):
+                result = self.app._get_env()
+                assert result == {"key1": "env_value1", "key2": "env_value2"}
+
+    def test_get_env_with_no_matching_keys(self):
+        with patch.object(self.app, "template", {"key1": "value1", "key2": "value2"}):
+            with patch.dict(os.environ, {"key3": "env_value3"}):
+                result = self.app._get_env()
+                assert result == {"key1": "value1", "key2": "value2"}
+
+    def test_get_env_with_key_error(self):
+        with patch.object(self.app, "template", {"key1": "value1", "key2": "value2"}):
+            with patch.dict(os.environ, {"key1": "env_value1"}):
+                with patch.object(self.app.logger, "error") as mock_logger_error:
+                    result = self.app._get_env()
+                    assert result == {"key1": "env_value1", "key2": "value2"}
+                    mock_logger_error.assert_not_called()
+
+    def test_get_env_with_template_match(self):
+        with patch.object(self.app, "template", {"key1": "value1", "key2": "value2"}):
+            with patch.dict(os.environ, {"key1": "value1", "key2": "value2"}):
+                result = self.app._get_env()
+                assert result == {"key1": "value1", "key2": "value2"}
+                assert self.app.templated is True
+
+    def test_get_env_without_template_match(self):
+        with patch.object(self.app, "template", {"key1": "value1", "key2": "value2"}):
+            with patch.dict(os.environ, {"key1": "env_value1"}):
+                result = self.app._get_env()
+                assert result == {"key1": "env_value1", "key2": "value2"}
+                assert self.app.templated is False
+
+    def test_get_conf(self):
+        self.app.config_file = self.test_config_file
+        self.app = Application(config={"key": "value"})
+        with patch("yaml.safe_load", return_value={"key": "value"}):
+            config = self.app._get_conf()
+            assert config == {"key": "value"}
+        with patch("yaml.safe_load", side_effect=FileNotFoundError):
+            config = self.app._get_conf()
+            assert config is None
+
+    def test_save_config(self):
+        from regscale.core.app.utils.api_handler import APIHandler
+
+        self.app.config_file = "test_save_config.yaml"
+        test_config = {"key": "value"}
+        with patch.object(self.app, "running_in_airflow", True):
+            self.app.save_config(test_config)
+            config = self.app.load_config()
+            assert "key" not in config
+
+        self.app.running_in_airflow = False
+        self.app.save_config(test_config)
+        config = self.app.load_config()
+        assert config is not None
+        assert config["key"] == "value"
+        assert "domain" not in config
+
+        test_api_handler = APIHandler()
+        self.app.api_handler = test_api_handler
+        test_config = {"api_handler": "testing_api_handler", "domain": self.test_domain}
+        self.app.save_config(test_config)
+        config = self.app.load_config()
+        assert config["api_handler"] == "testing_api_handler"
+        assert test_api_handler.domain == self.test_domain
+        assert test_api_handler.config == test_config
+
+        with patch.object(self.app.logger, "error") as mock_logger_error:
+            with patch("yaml.dump", side_effect=OSError):
+                self.app.save_config({})
+                mock_logger_error.assert_called_once()
+
+        os.remove(self.app.config_file)
+
+    def test_get_regscale_license(self):
+        with patch("requests.get"):
+            regscale_license = self.app.get_regscale_license(MagicMock())
+            assert isinstance(regscale_license, MagicMock)
+
+    def test_load_config(self):
+        self.app.config_file = self.test_config_file
+        with patch("yaml.safe_load", side_effect=FileNotFoundError):
+            config = self.app.load_config()
+            assert config == {}
+
+        self.app.save_config({"key": "value"})
+        config = self.app.load_config()
+        assert config == {"key": "value"}
+
+    def test_get_regscale_license_with_config(self):
+        api = MagicMock()
+        api.config = {"domain": self.test_domain}
+        api.get.return_value = Response()
+        self.app.config = api.config
+
+        with patch.object(self.app, "retrieve_domain", return_value=self.test_domain):
+            response = self.app.get_regscale_license(api)
+            api.get.assert_called_once_with(url="https://example.com/api/config/getlicense")
+            assert isinstance(response, Response)
+
+    def test_get_regscale_license_without_config(self):
+        api = MagicMock()
+        api.config = {"domain": self.test_domain}
+        api.get.return_value = Response()
+        self.app.config = None
+
+        with patch.object(self.app, "_gen_config", return_value={"domain": self.test_domain}):
+            with patch.object(self.app, "retrieve_domain", return_value=self.test_domain):
+                response = self.app.get_regscale_license(api)
+                api.get.assert_called_once_with(url="https://example.com/api/config/getlicense")
+                assert isinstance(response, Response)
+
+    def test_get_regscale_license_with_airflow_config(self):
+        api = MagicMock()
+        api.config = None
+        api.get.return_value = Response()
+        self.app.config = None
+        self.app.running_in_airflow = True
+
+        with patch.object(self.app, "_get_airflow_config", return_value={"domain": self.test_domain}):
+            with patch.object(self.app, "retrieve_domain", return_value=self.test_domain):
+                response = self.app.get_regscale_license(api)
+                api.get.assert_called_once_with(url="https://example.com/api/config/getlicense")
+                assert isinstance(response, Response)
+
+    def test_get_regscale_license_with_suppressed_exception(self):
+        import requests
+
+        api = MagicMock()
+        api.config = {"domain": self.test_domain}
+        api.get.side_effect = requests.RequestException
+        self.app.config = {"domain": self.test_domain}
+
+        with patch.object(self.app, "retrieve_domain", return_value=self.test_domain):
+            response = self.app.get_regscale_license(api)
+            api.get.assert_called_once_with(url="https://example.com/api/config/getlicense")
+            assert response is None
+
+    def test_retrieve_domain(self):
+        possible_envars = ["REGSCALE_DOMAIN", "PLATFORM_HOST", "domain"]
+        for envar in possible_envars:
+            with patch("os.environ", {envar: self.test_domain}):
+                domain = self.app.retrieve_domain()
+                assert domain == self.test_domain
+            with patch("os.environ", {envar: "www.example.com"}):
+                domain = self.app.retrieve_domain()
+                assert domain == self.app.template["domain"]
+
+    def test_verify_config(self):
+        template = {"key": "value"}
+        config = {"key": "other_value"}
+        updated_config = self.app.verify_config(template, config)
+        assert updated_config == {"key": "other_value"}
+
+    def test_verify_config_with_missing_keys(self):
+        template = {"key1": "value1", "key2": "value2"}
+        config = {"key1": "value1"}
+        expected_config = {"key1": "value1", "key2": "value2"}
+        updated_config = self.app.verify_config(template, config)
+        assert updated_config == expected_config
+
+    def test_verify_config_with_type_mismatch(self):
+        template = {"key1": "value1", "key2": 2}
+        config = {"key1": "value1", "key2": "wrong_type"}
+        expected_config = {"key1": "value1", "key2": 2}
+        updated_config = self.app.verify_config(template, config)
+        assert updated_config == expected_config
+
+    def test_verify_config_with_nested_dict(self):
+        template = {"key1": "value1", "key2": {"subkey1": "subvalue1"}}
+        config = {"key1": "value1", "key2": {"subkey1": "wrong_value"}}
+        expected_config = {"key1": "value1", "key2": {"subkey1": "wrong_value"}}
+        updated_config = self.app.verify_config(template, config)
+        assert updated_config == expected_config
+
+    def test_verify_config_with_additional_keys(self):
+        template = {"key1": "value1"}
+        config = {"key1": "value1", "key2": "value2"}
+        expected_config = {"key1": "value1", "key2": "value2"}
+        updated_config = self.app.verify_config(template, config)
+        assert updated_config == expected_config
+
+    def test_verify_config_with_empty_config(self):
+        template = {"key1": "value1", "key2": "value2"}
+        config = {}
+        expected_config = {"key1": "value1", "key2": "value2"}
+        updated_config = self.app.verify_config(template, config)
+        assert updated_config == expected_config
+
+    def test_getitem(self):
+        self.app.config = {"key": "value"}
+        assert self.app["key"] == "value"
+
+    def test_setitem(self):
+        self.app.config = {}
+        self.app["key"] = "value"
+        assert self.app.config == {"key": "value"}
+
+    def test_delitem(self):
+        self.app.config = {"key": "value"}
+        del self.app["key"]
+        assert self.app.config == {}
+
+    def test_iter(self):
+        self.app.config = {"key1": "value1", "key2": "value2"}
+        assert list(self.app) == ["key1", "key2"]
+
+    def test_len(self):
+        self.app.config = {"key1": "value1", "key2": "value2"}
+        assert len(self.app) == 2
+
+    def test_contains(self):
+        self.app.config = {"key": "value"}
+        assert "key" in self.app
+        assert "nonexistent_key" not in self.app

tests/regscale/core/test_login.py

@@ -0,0 +1,37 @@
+"""Test the login module."""
+
+from unittest.mock import patch
+
+from regscale.core.login import get_regscale_token
+from regscale.core.app.api import Api
+from regscale.core.app.application import Application
+
+
+@patch("regscale.core.login.Api.post")
+@patch.dict("os.environ", {"REGSCALE_DOMAIN": "example_value"})
+def test_get_regscale_token(mock_post):
+    api = Api()
+    mock_response = mock_post.return_value
+    mock_response.status_code = 200
+    mock_response.json.return_value = {
+        "id": "example_id",
+        "auth_token": "example_token",
+    }
+    result = get_regscale_token(api=api, username="example_user", password="example_password")
+    result2 = get_regscale_token(
+        api=api,
+        username="example_user",
+        password="example_password",
+        domain="example2_domain",
+    )
+    result3 = get_regscale_token(
+        api=api,
+        username="example_user",
+        password="example_password",
+        domain="example3_domain",
+        mfa_token="123456",
+    )
+
+    assert result == ("example_id", "example_token")
+    assert result2 == ("example_id", "example_token")
+    assert result3 == ("example_id", "example_token")

tests/regscale/core/test_logz.py

@@ -0,0 +1,66 @@
+import logging
+import os
+from unittest import mock
+from rich.logging import RichHandler
+from regscale.core.app.logz import create_logger
+
+
+def test_create_logger_creates_logger_with_default_settings():
+    logger = create_logger()
+    assert logger.name == "regscale"
+    assert logger.level == logging.INFO
+
+
+def test_create_logger_respects_propagate_parameter():
+    logger = create_logger(propagate=True)
+    assert logger.propagate is True
+
+
+def test_create_logger_adds_custom_handler():
+    custom_handler = logging.StreamHandler()
+    logger = create_logger(custom_handler=custom_handler)
+    assert any(isinstance(handler, logging.StreamHandler) for handler in logger.handlers)
+
+
+def test_create_logger_creates_file_handler_when_not_in_container():
+    with mock.patch.dict(os.environ, {"REGSCALE_ECS": "False"}):
+        logger = create_logger()
+        assert any(isinstance(handler, logging.handlers.TimedRotatingFileHandler) for handler in logger.handlers)
+
+
+def test_create_logger_does_not_create_file_handler_when_in_container():
+    with mock.patch.dict(os.environ, {"REGSCALE_ECS": "True"}):
+        logger = create_logger()
+        assert not any(isinstance(handler, logging.handlers.TimedRotatingFileHandler) for handler in logger.handlers)
+
+
+def test_create_logger_uses_custom_log_level():
+    with mock.patch.dict(os.environ, {"LOGLEVEL": "DEBUG"}):
+        logger = create_logger()
+        assert logger.level == logging.DEBUG
+
+
+def test_create_logger_uses_custom_log_width():
+    with mock.patch.dict(os.environ, {"REGSCALE_LOG_WIDTH": "100"}):
+        logger = create_logger()
+        assert any(
+            getattr(handler.console, "width", None) == 100
+            for handler in logger.handlers
+            if isinstance(handler, RichHandler)
+        )
+
+
+def test_create_logger_handles_invalid_log_width():
+    with mock.patch.dict(os.environ, {"REGSCALE_LOG_WIDTH": "invalid"}):
+        logger = create_logger()
+        assert any(
+            getattr(handler.console, "width", None) is not None
+            for handler in logger.handlers
+            if isinstance(handler, RichHandler)
+        )
+
+
+def test_getting_regscale_logger():
+    logger = logging.getLogger("regscale")
+    assert logger.name == "regscale"
+    assert len(logger.handlers) > 0

tests/regscale/core/test_sbom_generator.py

@@ -0,0 +1,87 @@
+import logging
+from unittest.mock import Mock
+
+from regscale.models.integration_models.sbom.cyclone_dx import CycloneDXJsonGenerator
+
+
+def test_initialization():
+    device = {"deviceName": "test-device", "manufacturer": "Test Corp"}
+    generator = CycloneDXJsonGenerator(device)
+
+    assert generator.device == device
+    assert isinstance(generator.logger, logging.Logger)
+    assert generator.device_info.name == "test-device"
+    assert generator.device_info.manufacturer == "Test Corp"
+
+
+def test_initialization_custom_logger():
+    logger = Mock()
+    generator = CycloneDXJsonGenerator({}, logger)
+    assert generator.logger == logger
+
+
+def test_device_description_generation():
+    device = {"manufacturer": "Test Corp", "model": "Model X", "deviceType": "Router"}
+    generator = CycloneDXJsonGenerator(device)
+    description = generator.generate_device_description()
+    assert description == "Test Corp Model X Router"
+
+
+def test_device_description_partial_info():
+    device = {"model": "Model X"}
+    generator = CycloneDXJsonGenerator(device)
+    description = generator.generate_device_description()
+    assert description == "Model X"
+
+
+def test_device_description_empty():
+    generator = CycloneDXJsonGenerator({})
+    description = generator.generate_device_description()
+    assert description == "Unknown Device"
+
+
+def test_component_validation():
+    generator = CycloneDXJsonGenerator({})
+    valid_component = {"type": "library", "name": "test-lib"}
+    invalid_type = {"type": "invalid", "name": "test"}
+    missing_field = {"type": "library"}
+
+    assert generator.validate(valid_component)
+    assert not generator.validate(invalid_type)
+    assert not generator.validate(missing_field)
+
+
+def test_generate_sbom():
+    device = {"deviceName": "test-device", "manufacturer": "Test Corp", "easDeviceId": "device-123"}
+    components = [{"type": "library", "name": "lib1"}, {"type": "framework", "name": "framework1"}]
+
+    generator = CycloneDXJsonGenerator(device)
+    sbom = generator.generate_sbom(components)
+
+    assert sbom["bomFormat"] == "CycloneDX"
+    assert sbom["specVersion"] == "1.4"
+    assert len(sbom["components"]) == 3  # device + 2 components
+    assert len(sbom["dependencies"]) == 1
+    assert sbom["dependencies"][0]["ref"] == "device-123"
+    assert len(sbom["dependencies"][0]["dependsOn"]) == 2
+
+
+def test_generate_sbom_invalid_components():
+    device = {"deviceName": "test-device"}
+    components = [
+        {"type": "library", "name": "lib1"},
+        {"type": "invalid", "name": "invalid1"},
+        {"name": "missing-type"},
+    ]
+
+    generator = CycloneDXJsonGenerator(device)
+    sbom = generator.generate_sbom(components)
+
+    assert len(sbom["components"]) == 2  # device + 1 valid component
+
+
+def test_sbom_metadata():
+    generator = CycloneDXJsonGenerator({})
+    sbom = generator.generate_sbom([])
+
+    assert sbom["metadata"]["tools"][0]["name"] == "RegScale CLI"