feat: Support multiple value types (string, number, boolean, null)

- Update Value class to support multiple data types
- Modify ValueBackend and SimpleValueBackend to handle new types
- Add test cases for type validation and handling
- Improve docstrings with type information

Author: ritwik-g

helm_values_manager/backends/base.py

@@ -5,7 +5,7 @@
 """
 
 from abc import ABC, abstractmethod
-from typing import Dict
+from typing import Dict, Union
 
 
 class ValueBackend(ABC):
@@ -60,34 +60,37 @@ def _validate_auth_config(self, auth_config: Dict[str, str]) -> None:
             raise ValueError(f"Invalid auth type: {auth_config['type']}. " f"Must be one of: {', '.join(valid_types)}")
 
     @abstractmethod
-    def get_value(self, path: str, environment: str, resolve: bool = False) -> str:
+    def get_value(self, path: str, environment: str, resolve: bool = False) -> Union[str, int, float, bool, None]:
         """
-        Get a value from storage.
+        Get a value from the backend.
 
         Args:
-            path: The configuration path
-            environment: The environment name
-            resolve: If True, resolve any secret references to their actual values.
-                    If False, return the raw value which may be a secret reference.
+            path: The configuration path (e.g., "app.replicas")
+            environment: The environment name (e.g., "dev", "prod")
+            resolve: Whether to resolve any secret references
 
         Returns:
-            str: The value (resolved or raw depending on resolve parameter)
+            The value from the backend, can be a string, number, boolean, or None
+
+        Raises:
+            ValueError: If the value doesn't exist
+            RuntimeError: If backend operation fails
         """
         pass
 
     @abstractmethod
-    def set_value(self, path: str, environment: str, value: str) -> None:
-        """Set a value in the storage backend.
+    def set_value(self, path: str, environment: str, value: Union[str, int, float, bool, None]) -> None:
+        """
+        Set a value in the backend.
 
         Args:
             path: The configuration path (e.g., "app.replicas")
             environment: The environment name (e.g., "dev", "prod")
-            value: The value to store. Must be a string.
+            value: The value to store, can be a string, number, boolean, or None
 
         Raises:
-            ValueError: If the value is invalid
-            ConnectionError: If there's an error connecting to the backend
-            PermissionError: If there's an authentication or authorization error
+            ValueError: If the value is not a string, number, boolean, or None
+            RuntimeError: If backend operation fails
         """
         pass
 

helm_values_manager/backends/simple.py

@@ -4,7 +4,7 @@
 This module provides a simple in-memory backend for storing non-sensitive values.
 """
 
-from typing import Dict
+from typing import Dict, Union
 
 from helm_values_manager.backends.base import ValueBackend
 
@@ -19,24 +19,23 @@ class SimpleValueBackend(ValueBackend):
     def __init__(self) -> None:
         """Initialize an empty in-memory storage."""
         super().__init__({"type": "direct"})  # Simple backend doesn't need auth
-        self._storage: Dict[str, str] = {}
+        self._storage: Dict[str, Union[str, int, float, bool, None]] = {}
 
     def _get_storage_key(self, path: str, environment: str) -> str:
         """Generate a unique storage key."""
         return f"{path}:{environment}"
 
-    def get_value(self, path: str, environment: str, resolve: bool = False) -> str:
+    def get_value(self, path: str, environment: str, resolve: bool = False) -> Union[str, int, float, bool, None]:
         """
         Get a value from the in-memory storage.
 
         Args:
             path: The configuration path (e.g., "app.replicas")
             environment: The environment name (e.g., "dev", "prod")
-            resolve: If True, resolve any secret references to their actual values.
-                    If False, return the raw value which may be a secret reference.
+            resolve: Whether to resolve any secret references
 
         Returns:
-            str: The value (resolved or raw depending on resolve parameter)
+            The value from the backend, can be a string, number, boolean, or None
 
         Raises:
             ValueError: If the value doesn't exist
@@ -46,20 +45,21 @@ def get_value(self, path: str, environment: str, resolve: bool = False) -> str:
             raise ValueError(f"No value found for {path} in {environment}")
         return self._storage[key]
 
-    def set_value(self, path: str, environment: str, value: str) -> None:
+    def set_value(self, path: str, environment: str, value: Union[str, int, float, bool, None]) -> None:
         """
         Set a value in the in-memory storage.
 
         Args:
             path: The configuration path (e.g., "app.replicas")
             environment: The environment name (e.g., "dev", "prod")
-            value: The value to store
+            value: The value to store, can be a string, number, boolean, or None
 
         Raises:
-            ValueError: If the value is not a string
+            ValueError: If the value is not a string, number, boolean, or None
         """
-        if not isinstance(value, str):
-            raise ValueError("Value must be a string")
+        if not isinstance(value, (str, int, float, bool, type(None))):
+            raise ValueError("Value must be a string, number, boolean, or None")
+
         key = self._get_storage_key(path, environment)
         self._storage[key] = value
 

helm_values_manager/models/value.py

@@ -6,7 +6,7 @@
 """
 
 from dataclasses import dataclass
-from typing import Any, Dict
+from typing import Any, Dict, Union
 
 from helm_values_manager.backends.base import ValueBackend
 from helm_values_manager.utils.logger import HelmLogger
@@ -31,19 +31,17 @@ def __post_init__(self):
         """Post-initialization validation and logging."""
         HelmLogger.debug("Created Value instance for path %s in environment %s", self.path, self.environment)
 
-    def get(self, resolve: bool = False) -> str:
+    def get(self, resolve: bool = False) -> Union[str, int, float, bool, None]:
         """
-        Get the value.
+        Get the value using the backend.
 
         Args:
-            resolve (bool): If True, resolve any secret references to their actual values.
-                          If False, return the raw value which may be a secret reference.
+            resolve: Whether to resolve any secret references
 
         Returns:
-            str: The value (resolved or raw depending on resolve parameter)
+            The value from the backend, can be a string, number, boolean, or None
 
         Raises:
-            ValueError: If value doesn't exist
             RuntimeError: If backend operation fails
         """
         try:
@@ -54,19 +52,19 @@ def get(self, resolve: bool = False) -> str:
             HelmLogger.error("Failed to get value for path %s in environment %s: %s", self.path, self.environment, e)
             raise
 
-    def set(self, value: str) -> None:
+    def set(self, value: Union[str, int, float, bool, None]) -> None:
         """
         Set the value using the backend.
 
         Args:
-            value: The value to store, can be a raw value or a secret reference
+            value: The value to store, can be a raw value, a secret reference, or None
 
         Raises:
-            ValueError: If value is not a string
+            ValueError: If value is not a string, number, boolean, or None
             RuntimeError: If backend operation fails
         """
-        if not isinstance(value, str):
-            raise ValueError("Value must be a string")
+        if not isinstance(value, (str, int, float, bool, type(None))):
+            raise ValueError("Value must be a string, number, boolean, or None")
 
         try:
             self._backend.set_value(self.path, self.environment, value)

tests/unit/backends/test_simple.py

@@ -24,9 +24,9 @@ def test_set_and_get_value(backend):
 
 
 def test_set_invalid_value_type(backend):
-    """Test setting a non-string value."""
-    with pytest.raises(ValueError, match="Value must be a string"):
-        backend.set_value("app.replicas", "dev", 3)
+    """Test setting an invalid value type."""
+    with pytest.raises(ValueError, match="Value must be a string, number, boolean, or None"):
+        backend.set_value("app.replicas", "dev", {"key": "value"})  # Dictionary is not a valid type
 
 
 def test_remove_value(backend):

tests/unit/models/test_helm_values_config.py

@@ -77,6 +77,20 @@ def test_get_value_nonexistent_value():
     assert config.get_value(path, "dev") is None
 
 
+def test_get_value_returns_none():
+    """Test getting a value when value_obj.get() returns None."""
+    config = HelmValuesConfig()
+    path = "app.config.key1"
+    environment = "dev"
+
+    # Add path and set None value
+    config.add_config_path(path, description="Test config")
+    config.set_value(path, environment, None)
+
+    # Verify that get_value returns None
+    assert config.get_value(path, environment) is None
+
+
 def test_set_value_without_path():
     """Test setting a value without first adding its path."""
     config = HelmValuesConfig()

tests/unit/models/test_value.py

@@ -49,11 +49,36 @@ def test_set_value(mock_backend):
     mock_backend.set_value.assert_called_once_with("app.replicas", "dev", "3")
 
 
+def test_set_valid_types(mock_backend):
+    """Test setting various valid value types."""
+    value = Value(path="app.replicas", environment="dev", _backend=mock_backend)
+
+    # Test string
+    value.set("test-value")
+    mock_backend.set_value.assert_called_with("app.replicas", "dev", "test-value")
+
+    # Test integer
+    value.set(42)
+    mock_backend.set_value.assert_called_with("app.replicas", "dev", 42)
+
+    # Test float
+    value.set(3.14)
+    mock_backend.set_value.assert_called_with("app.replicas", "dev", 3.14)
+
+    # Test boolean
+    value.set(True)
+    mock_backend.set_value.assert_called_with("app.replicas", "dev", True)
+
+    # Test None
+    value.set(None)
+    mock_backend.set_value.assert_called_with("app.replicas", "dev", None)
+
+
 def test_set_invalid_type(mock_backend):
-    """Test setting a non-string value."""
+    """Test setting an invalid value type."""
     value = Value(path="app.replicas", environment="dev", _backend=mock_backend)
-    with pytest.raises(ValueError, match="Value must be a string"):
-        value.set(3)
+    with pytest.raises(ValueError, match="Value must be a string, number, boolean, or None"):
+        value.set({"key": "value"})  # Dictionary is not a valid type
 
 
 def test_to_dict(mock_backend):