fix: restore validation and add tests for PathData.from_dict

- Add back input validation for data type and required keys
- Restore error logging for invalid input
- Add debug logging for value creation
- Add tests for validation and error handling:
  - Test invalid data type
  - Test missing required keys
  - Test value path mismatch

This ensures proper error handling and logging when creating
PathData instances from dictionaries, with full test coverage.

Author: ritwik-g

helm_values_manager/models/path_data.py

@@ -126,11 +126,27 @@ def from_dict(
 
         Returns:
             PathData: New PathData instance
+
+        Raises:
+            ValueError: If the dictionary structure is invalid
         """
+        if not isinstance(data, dict):
+            logger.error("Invalid data type provided: %s", type(data))
+            raise ValueError("Data must be a dictionary")
+
+        logger.debug("Creating PathData from dict with path: %s", data.get("path"))
+
+        required_keys = {"path", "metadata", "values"}
+        if not all(key in data for key in required_keys):
+            missing = required_keys - set(data.keys())
+            logger.error("Missing required keys in data: %s", missing)
+            raise ValueError(f"Missing required keys: {missing}")
+
         path_data = cls(path=data["path"], metadata=data["metadata"])
 
         # Create Value instances for each environment
         for env, value_data in data.get("values", {}).items():
+            logger.debug("Creating value for environment %s", env)
             value = create_value_fn(data["path"], env, value_data)
             path_data.set_value(env, value)
 

tests/unit/models/test_path_data.py

@@ -156,3 +156,33 @@ def create_value_fn(path, env, value_data):
     }
     assert len(list(path_data.get_environments())) == 1
     assert "test_env" in path_data._values
+
+
+def test_from_dict_invalid_type():
+    """Test from_dict with invalid data type."""
+    with pytest.raises(ValueError, match="Data must be a dictionary"):
+        PathData.from_dict(["not a dict"], lambda p, e, d: None)
+
+
+def test_from_dict_missing_keys():
+    """Test from_dict with missing required keys."""
+    data = {"path": "test.path"}  # Missing metadata and values
+    with pytest.raises(ValueError, match="Missing required keys: {'metadata', 'values'}"):
+        PathData.from_dict(data, lambda p, e, d: None)
+
+
+def test_from_dict_value_path_mismatch():
+    """Test from_dict when create_value_fn returns value with wrong path."""
+    data = {
+        "path": "test.path",
+        "metadata": {"required": True},
+        "values": {"test_env": {"value": "test"}},
+    }
+
+    def create_value_fn(path, env, value_data):
+        mock_value = Mock(spec=Value)
+        mock_value.path = "wrong.path"  # Mismatched path
+        return mock_value
+
+    with pytest.raises(ValueError, match=r"Value path wrong\.path doesn't match PathData path test\.path"):
+        PathData.from_dict(data, create_value_fn)