refactor: update PathData validation and ADR status

- Move required value validation into PathData.validate() loop
- Add environment context to validation error messages
- Add tests for PathData serialization methods
- Mark ADR-005 (Unified Backend Approach) as Accepted
- Mark ADR-007 (Sensitive Value Storage) as Accepted
- Fix ADR-007 number in title
- Update README.md to reflect ADR status changes

This change improves error messages by including environment context
and keeps validation close to the data it validates. PathData now
has 100% test coverage.

Author: ritwik-g

docs/ADRs/005-unified-backend-approach.md

@@ -1,7 +1,7 @@
 # ADR-005: Unified Backend Approach for Value Storage
 
 ## Status
-Proposed
+Accepted
 
 ## Context
 Currently, the Value class handles two distinct storage types: local and remote. This creates a split in logic within the Value class, requiring different code paths and validation rules based on the storage type. This complexity makes the code harder to maintain and test.

docs/ADRs/007-sensitive-value-storage.md

@@ -1,7 +1,7 @@
-# ADR 0002: Sensitive Value Storage
+# ADR 007: Sensitive Value Storage
 
 ## Status
-Proposed
+Accepted
 
 ## Context
 The helm-values-manager needs to handle both sensitive and non-sensitive configuration values. While non-sensitive values can be stored directly in the configuration files, sensitive values require special handling to ensure security.

docs/ADRs/README.md

@@ -35,7 +35,7 @@ An Architecture Decision Record (ADR) is a document that captures an important a
 - **Dependencies**: ADR-003
 
 ### [ADR-005: Unified Backend Approach](005-unified-backend-approach.md)
-- **Status**: Proposed
+- **Status**: Accepted
 - **Context**: Split logic in Value class for different storage types
 - **Decision**: Remove storage type distinction, use SimpleValueBackend
 - **Impact**: Simplifies Value class and unifies storage interface
@@ -49,7 +49,7 @@ An Architecture Decision Record (ADR) is a document that captures an important a
 - **Dependencies**: ADR-001
 
 ### [ADR-007: Sensitive Value Storage](007-sensitive-value-storage.md)
-- **Status**: Proposed
+- **Status**: Accepted
 - **Context**: Need for secure handling of sensitive configuration values
 - **Decision**: Store sensitive values using reference-based approach in secure backends
 - **Impact**: Ensures security while maintaining flexibility and traceability

helm_values_manager/models/path_data.py

@@ -31,24 +31,27 @@ def validate(self) -> None:
         Validate the PathData instance.
 
         Ensures that:
-        1. If path is marked as required, all environments have values
-        2. All Value instances use the same path as this PathData
+        1. All Value instances use the same path as this PathData
+        2. If path is marked as required, each environment has a non-empty value
 
         Raises:
             ValueError: If validation fails
         """
         logger.debug("Validating PathData for path: %s", self.path)
 
-        # Validate path consistency
+        # Validate path consistency and required values
         for env, value in self._values.items():
+            # Check path consistency
             if value.path != self.path:
                 logger.error("Path mismatch for environment %s: %s != %s", env, value.path, self.path)
-                raise ValueError(f"Value path {value.path} doesn't match PathData path {self.path}")
-
-        # If path is required, ensure all environments have values
-        if self.metadata.get("required", False) and not self._values:
-            logger.error("Missing required value for path %s", self.path)
-            raise ValueError("Missing required value")
+                raise ValueError(f"Value for environment {env} has inconsistent path: {value.path} != {self.path}")
+
+            # Check required values
+            if self.metadata.get("required", False):
+                val = value.get()
+                if val is None or val == "":
+                    logger.error("Missing required value for path %s in environment %s", self.path, env)
+                    raise ValueError(f"Missing required value for path {self.path} in environment {env}")
 
     def set_value(self, environment: str, value: Value) -> None:
         """

tests/unit/models/test_path_data.py

@@ -63,3 +63,96 @@ def test_get_environments(path_data, mock_value):
     assert len(environments) == 2
     assert "test1" in environments
     assert "test2" in environments
+
+
+def test_validate_path_mismatch(path_data):
+    """Test validation with mismatched paths."""
+    mock_value = Mock(spec=Value)
+    mock_value.path = "wrong.path"
+    path_data.set_value("test_env", mock_value)
+
+    with pytest.raises(
+        ValueError, match=r"Value for environment test_env has inconsistent path: wrong\.path != test\.path"
+    ):
+        path_data.validate()
+
+
+def test_validate_required_missing_value(path_data):
+    """Test validation with missing required value."""
+    mock_value = Mock(spec=Value)
+    mock_value.path = "test.path"
+    mock_value.get.return_value = None
+    path_data.set_value("test_env", mock_value)
+
+    with pytest.raises(ValueError, match=r"Missing required value for path test\.path in environment test_env"):
+        path_data.validate()
+
+
+def test_validate_required_empty_value(path_data):
+    """Test validation with empty required value."""
+    mock_value = Mock(spec=Value)
+    mock_value.path = "test.path"
+    mock_value.get.return_value = ""
+    path_data.set_value("test_env", mock_value)
+
+    with pytest.raises(ValueError, match=r"Missing required value for path test\.path in environment test_env"):
+        path_data.validate()
+
+
+def test_validate_success(path_data, mock_value):
+    """Test successful validation."""
+    mock_value.get.return_value = "test_value"
+    path_data.set_value("test_env", mock_value)
+    path_data.validate()  # Should not raise any error
+
+
+def test_validate_not_required(path_data, mock_value):
+    """Test validation when path is not required."""
+    path_data.metadata["required"] = False
+    mock_value.get.return_value = None
+    path_data.set_value("test_env", mock_value)
+    path_data.validate()  # Should not raise any error
+
+
+def test_to_dict(path_data, mock_value):
+    """Test converting PathData to dictionary."""
+    mock_value.to_dict.return_value = {"value": "test_value"}
+    path_data.set_value("test_env", mock_value)
+
+    result = path_data.to_dict()
+    assert result["path"] == "test.path"
+    assert result["metadata"] == {
+        "description": "Test description",
+        "required": True,
+        "sensitive": False,
+    }
+    assert result["values"] == {"test_env": {"value": "test_value"}}
+
+
+def test_from_dict():
+    """Test creating PathData from dictionary."""
+    data = {
+        "path": "test.path",
+        "metadata": {
+            "description": "Test description",
+            "required": True,
+            "sensitive": False,
+        },
+        "values": {"test_env": {"value": "test_value"}},
+    }
+
+    def create_value_fn(path, env, value_data):
+        mock_value = Mock(spec=Value)
+        mock_value.path = path
+        mock_value.environment = env
+        return mock_value
+
+    path_data = PathData.from_dict(data, create_value_fn)
+    assert path_data.path == "test.path"
+    assert path_data.metadata == {
+        "description": "Test description",
+        "required": True,
+        "sensitive": False,
+    }
+    assert len(list(path_data.get_environments())) == 1
+    assert "test_env" in path_data._values