regscale-cli 6.20.7.0__py3-none-any.whl → 6.20.9.0__py3-none-any.whl

tests/regscale/core/test_app.py

@@ -54,29 +54,31 @@ class TestApplication:
     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_response.json.return_value = '{"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"
+        with patch.object(self.app, "_decrypt_config", return_value='{"key": "value"}'):
+            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_response.json.return_value = '{"key": "value"}'
         mock_get.return_value = mock_response
         envars = os.environ.copy()
         envars["REGSCALE_DOMAIN"] = self.test_domain
         envars["REGSCALE_TOKEN"] = self.test_token
         with patch.dict(os.environ, envars, clear=True):
-            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"
+            with patch.object(self.app, "_decrypt_config", return_value='{"key": "value"}'):
+                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):
@@ -88,12 +90,396 @@ class TestApplication:
         envars["REGSCALE_DOMAIN"] = self.test_domain
         envars["REGSCALE_TOKEN"] = self.test_token
         with patch.dict(os.environ, envars, clear=True):
-            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 == {}
+                empty_config = self.app._fetch_config_from_regscale()
+                assert empty_config == {}
+                mock_logger_error.assert_called()
+
+    @patch("regscale.core.app.internal.login.parse_user_id_from_jwt")
+    @patch("requests.get")
+    def test_fetch_config_from_regscale_unencrypted_dict(self, mock_get, mock_parse_user_id):
+        """Test the case where the response is already a dictionary (not encrypted)"""
+        mock_parse_user_id.return_value = "test_user_id"
+        mock_response = MagicMock()
+        mock_response.json.return_value = {"key": "value", "userId": "test_user_id"}
+        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_no_cli_config(self, mock_get, mock_parse_user_id):
+        """Test error handling when the cliConfig field is missing from the response"""
+        mock_parse_user_id.return_value = "test_user_id"
+        mock_response = MagicMock()
+        mock_response.json.return_value = ""
+        mock_get.return_value = mock_response
+        with patch.object(self.app.logger, "warning") as mock_logger_warning:
+            config = self.app._fetch_config_from_regscale(config={})
+            mock_logger_warning.assert_called_once()
+            assert config == {}
+
+    @patch("regscale.core.app.internal.login.parse_user_id_from_jwt")
+    @patch("requests.get")
+    def test_fetch_config_from_regscale_with_existing_user_id(self, mock_get, mock_parse_user_id):
+        """Test that existing userId in response is preserved"""
+        mock_response = MagicMock()
+        mock_response.json.return_value = '{"key": "value", "userId": "existing_user"}'
+        mock_get.return_value = mock_response
+
+        with patch.object(self.app, "_decrypt_config", return_value='{"key": "value", "userId": "existing_user"}'):
+            config = self.app._fetch_config_from_regscale(config=self.app.config)
+            assert config["userId"] == "existing_user"
+            # parse_user_id_from_jwt should not be called since userId already exists
+            mock_parse_user_id.assert_not_called()
+
+    @patch("regscale.core.app.internal.login.parse_user_id_from_jwt")
+    @patch("requests.get")
+    def test_fetch_config_from_regscale_empty_response(self, mock_get, mock_parse_user_id):
+        """Test handling of empty response"""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {}
+        mock_get.return_value = mock_response
+
+        with patch.object(self.app.logger, "warning") as mock_logger_warning:
+            config = self.app._fetch_config_from_regscale(config=self.app.config)
+            assert config == {}
+            mock_logger_warning.assert_called_once()
+
+    @patch("regscale.core.app.internal.login.parse_user_id_from_jwt")
+    @patch("requests.get")
+    def test_fetch_config_from_regscale_no_token(self, mock_get, mock_parse_user_id):
+        """Test handling when no token is provided"""
+        envars = os.environ.copy()
+        envars.pop("REGSCALE_TOKEN", None)
+        envars.pop("REGSCALE_DOMAIN", None)
+
+        with patch.dict(os.environ, envars, clear=True):
+            config = self.app._fetch_config_from_regscale(config={})
+            assert config == {}
+            mock_get.assert_not_called()
+
+    @patch("regscale.core.app.internal.login.parse_user_id_from_jwt")
+    @patch("requests.get")
+    def test_fetch_config_from_regscale_no_domain(self, mock_get, mock_parse_user_id):
+        """Test handling when no domain is provided"""
+        envars = os.environ.copy()
+        envars["REGSCALE_TOKEN"] = self.test_token
+        envars.pop("REGSCALE_DOMAIN", None)
+
+        with patch.dict(os.environ, envars, clear=True):
+            with patch.object(self.app, "retrieve_domain", return_value="https://default.com"):
+                _ = self.app._fetch_config_from_regscale(config={})
+                # Should still attempt to make the request with default domain
+                mock_get.assert_called_once()
+
+    @patch("regscale.core.app.internal.login.parse_user_id_from_jwt")
+    @patch("requests.get")
+    def test_fetch_config_from_regscale_request_exception(self, mock_get, mock_parse_user_id):
+        """Test handling of request exceptions"""
+        mock_get.side_effect = Exception("Network error")
+
+        with patch.object(self.app.logger, "error") as mock_logger_error:
+            config = self.app._fetch_config_from_regscale(config=self.app.config)
+            assert config == {}
+            mock_logger_error.assert_called_once()
+
+    @patch("regscale.core.app.internal.login.parse_user_id_from_jwt")
+    @patch("requests.get")
+    def test_fetch_config_from_regscale_correct_endpoint(self, mock_get, mock_parse_user_id):
+        """Test that the correct API endpoint is called"""
+        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
+
+        with patch.object(self.app, "_decrypt_config", return_value='{"key": "value"}'):
+            self.app._fetch_config_from_regscale(config=self.app.config)
+
+            # Verify the correct endpoint was called
+            mock_get.assert_called_once()
+            call_args = mock_get.call_args
+            assert "/api/tenants/getDetailedCliConfig" in call_args[1]["url"]
+
+    @patch("regscale.core.app.internal.login.parse_user_id_from_jwt")
+    @patch("requests.get")
+    def test_fetch_config_from_regscale_headers_verification(self, mock_get, mock_parse_user_id):
+        """Test that the correct headers are sent with the request"""
+        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
+
+        with patch.object(self.app, "_decrypt_config", return_value='{"key": "value"}'):
+            self.app._fetch_config_from_regscale(config=self.app.config)
+
+            # Verify the correct headers were sent
+            mock_get.assert_called_once()
+            call_args = mock_get.call_args
+            headers = call_args[1]["headers"]
+            assert headers["Content-Type"] == "application/json"
+            assert headers["Accept"] == "application/json"
+            assert headers["Authorization"] == self.app.config.get("token")
+
+    def test_fetch_config_from_regscale_json_decode_error(self):
+        """Test handling of JSON decode errors in decrypted config"""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {"cliConfig": "encrypted_data"}
+
+        with patch("requests.get", return_value=mock_response):
+            with patch.object(self.app, "_decrypt_config", return_value="invalid json"):
+                with patch.object(self.app.logger, "error") as mock_logger_error:
+                    config = self.app._fetch_config_from_regscale(config=self.app.config)
+                    assert config == {}
+                    mock_logger_error.assert_called_once()
+
+    def test_decrypt_config(self):
+        """Test the _decrypt_config method with a mock encrypted string"""
+        # Mock the cryptography imports
+        with patch("cryptography.hazmat.primitives.ciphers.Cipher") as mock_cipher:
+            with patch("cryptography.hazmat.backends.default_backend") as mock_backend:
+                with patch("base64.b64decode") as mock_b64decode:
+                    with patch("hashlib.sha256") as mock_sha256:
+                        # Setup mocks
+                        mock_backend.return_value = "backend"
+                        mock_b64decode.side_effect = [
+                            b"iv_data_cipher_text",  # First call for combined data
+                            b"key_data",  # Second call for token
+                        ]
+                        mock_sha256_instance = MagicMock()
+                        mock_sha256_instance.digest.return_value = b"key" * 8  # 32 bytes for AES-256
+                        mock_sha256.return_value = mock_sha256_instance
+
+                        mock_decryptor = MagicMock()
+                        mock_decryptor.update.return_value = b'{"key": "value"}'
+                        mock_decryptor.finalize.return_value = b""
+
+                        mock_cipher_instance = MagicMock()
+                        mock_cipher_instance.decryptor.return_value = mock_decryptor
+                        mock_cipher.return_value = mock_cipher_instance
+
+                        # Test the method
+                        result = self.app._decrypt_config(
+                            "encrypted_string", os.getenv("REGSCALE_TOKEN", self.app.config["token"])
+                        )
+
+                        # Verify the result
+                        assert result == '{"key": "value"}'
+
+                        # Verify the mocks were called correctly
+                        mock_b64decode.assert_called()
+                        mock_sha256.assert_called_once()
+                        mock_cipher.assert_called_once()
+
+    def test_decrypt_config_with_trailing_characters(self):
+        """Test the _decrypt_config method handles trailing control characters"""
+        with patch("cryptography.hazmat.primitives.ciphers.Cipher") as mock_cipher:
+            with patch("cryptography.hazmat.backends.default_backend") as mock_backend:
+                with patch("base64.b64decode") as mock_b64decode:
+                    with patch("hashlib.sha256") as mock_sha256:
+                        # Setup mocks
+                        mock_backend.return_value = "backend"
+                        mock_b64decode.side_effect = [
+                            b"iv_data_cipher_text",  # First call for combined data
+                            b"key_data",  # Second call for token
+                        ]
+                        mock_sha256_instance = MagicMock()
+                        mock_sha256_instance.digest.return_value = b"key" * 8  # 32 bytes for AES-256
+                        mock_sha256.return_value = mock_sha256_instance
+
+                        mock_decryptor = MagicMock()
+                        # Simulate decrypted data with trailing control characters
+                        mock_decryptor.update.return_value = b'{"key": "value"}\x00\x08\x07'
+                        mock_decryptor.finalize.return_value = b""
+
+                        mock_cipher_instance = MagicMock()
+                        mock_cipher_instance.decryptor.return_value = mock_decryptor
+                        mock_cipher.return_value = mock_cipher_instance
+
+                        # Test the method
+                        result = self.app._decrypt_config("encrypted_string", "Bearer test_token")
+
+                        # Verify the result is cleaned
+                        assert result == '{"key": "value"}'
+
+    def test_decrypt_config_invalid_base64(self):
+        """Test _decrypt_config with invalid base64 input"""
+        with patch("base64.b64decode", side_effect=Exception("Invalid base64")):
+            with patch.object(self.app.logger, "error") as mock_logger_error:
+                result = self.app._decrypt_config("invalid_base64", "Bearer test_token")
+                # Should raise an exception that gets caught by the calling method
+                assert result is None or mock_logger_error.called
+                assert mock_logger_error.call_count == 1
+
+    def test_decrypt_config_short_data(self):
+        """Test _decrypt_config with data too short for IV extraction"""
+        with patch("base64.b64decode", return_value=b"short"):
+            with patch.object(self.app.logger, "error") as mock_logger_error:
+                result = self.app._decrypt_config("short_data", "Bearer test_token")
+                # Should handle the short data gracefully
+                assert result is None or mock_logger_error.called
+
+    def test_decrypt_config_decryption_failure(self):
+        """Test _decrypt_config when decryption fails"""
+        with patch("cryptography.hazmat.primitives.ciphers.Cipher") as mock_cipher:
+            with patch("cryptography.hazmat.backends.default_backend") as mock_backend:
+                with patch("base64.b64decode") as mock_b64decode:
+                    with patch("hashlib.sha256") as mock_sha256:
+                        # Setup mocks
+                        mock_backend.return_value = "backend"
+                        mock_b64decode.return_value = b"iv_data_cipher_text"
+                        mock_sha256_instance = MagicMock()
+                        mock_sha256_instance.digest.return_value = b"key" * 8  # 32 bytes for AES-256
+                        mock_sha256.return_value = mock_sha256_instance
+
+                        mock_cipher.side_effect = Exception("Decryption failed")
+
+                        with patch.object(self.app.logger, "error") as mock_logger_error:
+                            result = self.app._decrypt_config("encrypted_string", "Bearer test_token")
+                            # Should handle decryption failure gracefully
+                            assert result is None or mock_logger_error.called
+                            assert mock_logger_error.call_count == 1
+
+    def test_decrypt_config_unicode_decode_error(self):
+        """Test _decrypt_config when UTF-8 decode fails"""
+        with patch("cryptography.hazmat.primitives.ciphers.Cipher") as mock_cipher:
+            with patch("cryptography.hazmat.backends.default_backend") as mock_backend:
+                with patch("base64.b64decode") as mock_b64decode:
+                    with patch("hashlib.sha256") as mock_sha256:
+                        # Setup mocks
+                        mock_backend.return_value = "backend"
+                        mock_b64decode.return_value = b"iv_data_cipher_text"
+                        mock_sha256_instance = MagicMock()
+                        mock_sha256_instance.digest.return_value = b"key" * 8  # 32 bytes for AES-256
+                        mock_sha256.return_value = mock_sha256_instance
+
+                        mock_decryptor = MagicMock()
+                        # Return bytes that can't be decoded as UTF-8
+                        mock_decryptor.update.return_value = b"\xff\xfe\xfd"
+                        mock_decryptor.finalize.return_value = b""
+
+                        mock_cipher_instance = MagicMock()
+                        mock_cipher_instance.decryptor.return_value = mock_decryptor
+                        mock_cipher.return_value = mock_cipher_instance
+
+                        with patch.object(self.app.logger, "error") as mock_logger_error:
+                            result = self.app._decrypt_config("encrypted_string", "Bearer test_token")
+                            # Should handle decode error gracefully
+                            assert result is None or mock_logger_error.called
+
+    def test_decrypt_config_multiple_null_bytes(self):
+        """Test _decrypt_config with multiple trailing null bytes"""
+        with patch("cryptography.hazmat.primitives.ciphers.Cipher") as mock_cipher:
+            with patch("cryptography.hazmat.backends.default_backend") as mock_backend:
+                with patch("base64.b64decode") as mock_b64decode:
+                    with patch("hashlib.sha256") as mock_sha256:
+                        # Setup mocks
+                        mock_backend.return_value = "backend"
+                        mock_b64decode.return_value = b"iv_data_cipher_text"
+                        mock_sha256_instance = MagicMock()
+                        mock_sha256_instance.digest.return_value = b"key" * 8  # 32 bytes for AES-256
+                        mock_sha256.return_value = mock_sha256_instance
+
+                        mock_decryptor = MagicMock()
+                        # Simulate decrypted data with multiple null bytes
+                        mock_decryptor.update.return_value = b'{"key": "value"}\x00\x08\x07\x0f\x1b\x1c\x1d'
+                        mock_decryptor.finalize.return_value = b""
+
+                        mock_cipher_instance = MagicMock()
+                        mock_cipher_instance.decryptor.return_value = mock_decryptor
+                        mock_cipher.return_value = mock_cipher_instance
+
+                        # Test the method
+                        result = self.app._decrypt_config("encrypted_string", "Bearer test_token")
+
+                        # Verify the result is cleaned
+                        assert result == '{"key": "value"}'
+
+    def test_decrypt_config_mixed_trailing_characters(self):
+        """Test _decrypt_config with mixed trailing characters"""
+        with patch("cryptography.hazmat.primitives.ciphers.Cipher") as mock_cipher:
+            with patch("cryptography.hazmat.backends.default_backend") as mock_backend:
+                with patch("base64.b64decode") as mock_b64decode:
+                    with patch("hashlib.sha256") as mock_sha256:
+                        # Setup mocks
+                        mock_backend.return_value = "backend"
+                        mock_b64decode.return_value = b"iv_data_cipher_text"
+                        mock_sha256_instance = MagicMock()
+                        mock_sha256_instance.digest.return_value = b"key" * 8  # 32 bytes for AES-256
+                        mock_sha256.return_value = mock_sha256_instance
+
+                        mock_decryptor = MagicMock()
+                        # Simulate decrypted data with mixed trailing characters
+                        mock_decryptor.update.return_value = b'{"key": "value"} \t\n\r\x00\x08\x07\x0f'
+                        mock_decryptor.finalize.return_value = b""
+
+                        mock_cipher_instance = MagicMock()
+                        mock_cipher_instance.decryptor.return_value = mock_decryptor
+                        mock_cipher.return_value = mock_cipher_instance
+
+                        # Test the method
+                        result = self.app._decrypt_config("encrypted_string", "Bearer test_token")
+
+                        # Verify the result is cleaned
+                        assert result == '{"key": "value"} '
+
+    def test_decrypt_config_with_trailing_backslash(self):
+        """Test _decrypt_config with trailing backslash and characters after it"""
+        with patch("cryptography.hazmat.primitives.ciphers.Cipher") as mock_cipher:
+            with patch("cryptography.hazmat.backends.default_backend") as mock_backend:
+                with patch("base64.b64decode") as mock_b64decode:
+                    with patch("hashlib.sha256") as mock_sha256:
+                        # Setup mocks
+                        mock_backend.return_value = "backend"
+                        mock_b64decode.return_value = b"iv_data_cipher_text"
+                        mock_sha256_instance = MagicMock()
+                        mock_sha256_instance.digest.return_value = b"key" * 8  # 32 bytes for AES-256
+                        mock_sha256.return_value = mock_sha256_instance
+
+                        mock_decryptor = MagicMock()
+                        # Simulate decrypted data with trailing backslash and characters
+                        mock_decryptor.update.return_value = b'{"key": "value"}\\abc123'
+                        mock_decryptor.finalize.return_value = b""
+
+                        mock_cipher_instance = MagicMock()
+                        mock_cipher_instance.decryptor.return_value = mock_decryptor
+                        mock_cipher.return_value = mock_cipher_instance
+
+                        # Test the method
+                        result = self.app._decrypt_config("encrypted_string", "Bearer test_token")
+
+                        # Verify the result is cleaned - should remove \abc123
+                        assert result == '{"key": "value"}'
+
+    def test_decrypt_config_with_multiple_backslashes(self):
+        """Test _decrypt_config with multiple backslashes in the string"""
+        with patch("cryptography.hazmat.primitives.ciphers.Cipher") as mock_cipher:
+            with patch("cryptography.hazmat.backends.default_backend") as mock_backend:
+                with patch("base64.b64decode") as mock_b64decode:
+                    with patch("hashlib.sha256") as mock_sha256:
+                        # Setup mocks
+                        mock_backend.return_value = "backend"
+                        mock_b64decode.return_value = b"iv_data_cipher_text"
+                        mock_sha256_instance = MagicMock()
+                        mock_sha256_instance.digest.return_value = b"key" * 8  # 32 bytes for AES-256
+                        mock_sha256.return_value = mock_sha256_instance
+
+                        mock_decryptor = MagicMock()
+                        # Simulate decrypted data with multiple backslashes but only remove trailing one
+                        mock_decryptor.update.return_value = b'{"key": "value\\nested"}\\trailing'
+                        mock_decryptor.finalize.return_value = b""
+
+                        mock_cipher_instance = MagicMock()
+                        mock_cipher_instance.decryptor.return_value = mock_decryptor
+                        mock_cipher.return_value = mock_cipher_instance
+
+                        # Test the method
+                        result = self.app._decrypt_config("encrypted_string", "Bearer test_token")
+
+                        # Verify the result - should keep nested backslash but remove trailing one
+                        assert result == '{"key": "value\\nested"}'
 
     def test_gen_config(self):
         self.app.local_config = True

tests/regscale/core/test_version_regscale.py

@@ -0,0 +1,62 @@
+import os
+import pytest
+from click.testing import CliRunner
+from unittest import mock
+import warnings
+import regscale.regscale as regscale
+
+
+class TestRegscaleCLIVersion:
+
+    @pytest.fixture(autouse=True)
+    def patch_env(self, tmp_path):
+        """
+        Fixture to patch environment variables for CLI tests to avoid side effects.
+        """
+        with mock.patch.dict(
+            os.environ,
+            {
+                "REGSCALE_WORKDIR": str(tmp_path),
+                "REGSCALE_USER": "testuser",
+                "REGSCALE_PASSWORD": "testpass",
+                "REGSCALE_DOMAIN": "https://testdomain.com",
+                "REGSCALE_USER_ID": "1",
+                "REGSCALE_TOKEN": "token",
+            },
+            clear=True,
+        ):
+            yield
+
+    def test_cli_version_command(self):
+        """
+        Test that the CLI 'version' command prints the local RegScale version and exits successfully.
+        """
+        runner = CliRunner()
+        result = runner.invoke(regscale.cli, ["version"])
+        assert result.exit_code == 0
+        assert regscale.__version__ in result.output
+
+    def test_cli_version_server(self):
+        """
+        Test that the CLI 'version --server' command prints the server version if available.
+        Mocks the API call to return a dummy version.
+        """
+
+        class DummyApi:
+            def __init__(self):
+                self.app = type("App", (), {"config": {"domain": "https://test.com"}})()
+
+            def get(self, url):
+                class DummyRes:
+                    ok = True
+
+                    def json(self):
+                        return {"version": "1.2.3"}
+
+                return DummyRes()
+
+        with mock.patch("regscale.core.app.api.Api", DummyApi):
+            runner = CliRunner()
+            result = runner.invoke(regscale.cli, ["version", "--server"])
+            assert result.exit_code == 0
+            assert "1.2.3" in result.output or "Unable to get version from server." not in result.output

tests/regscale/test_init.py

@@ -20,6 +20,8 @@ airflow_operators_python = types.ModuleType("airflow.operators.python")
 
 class DummyPythonOperator:
     def __init__(self, *args, **kwargs):
+        # This dummy operator is intentionally left empty because it is only used
+        # to mock Airflow's PythonOperator for testing purposes. No initialization logic is needed.
         pass