properly enforce some data constraints

Author: mathiasertl

pyproject.toml

@@ -35,6 +35,7 @@ show_error_codes = true
 plugins = ["pydantic.mypy"]
 
 [tool.pytest.ini_options]
+collect_imported_tests = false
 addopts = [
     "--cov",
     "--cov-report=html",

structured_tutorials/models.py

@@ -1,12 +1,15 @@
 """Basic tutorial structure."""
 
 from pathlib import Path
-from typing import Any, Literal, Self
+from typing import Annotated, Any, Literal, Self
 
 from pydantic import BaseModel, Field, field_validator, model_validator
 from pydantic_core.core_schema import ValidationInfo
 from yaml import safe_load
 
+PositiveInt = Annotated[int, Field(ge=0)]
+PositiveFloat = Annotated[float, Field(ge=0)]
+
 
 def default_cwd_factory(data: dict[str, Any]) -> Path:
     """Default factory for the path variable."""
@@ -16,15 +19,15 @@ def default_cwd_factory(data: dict[str, Any]) -> Path:
 class CommandBaseModel(BaseModel):
     """Base model for commands."""
 
-    status_code: int = 0
+    status_code: Annotated[int, Field(ge=0, le=255)] = 0
 
 
 class TestSpecificationMixin:
     """Mixin for specifying tests."""
 
-    delay: int = 0
-    retry: int = 0
-    backoff_factor: float = 0  # {backoff factor} * (2 ** ({number of previous retries}))
+    delay: Annotated[float, Field(ge=0)] = 0
+    retry: PositiveInt = 0
+    backoff_factor: PositiveFloat = 0  # {backoff factor} * (2 ** ({number of previous retries}))
 
 
 class CleanupCommandModel(CommandBaseModel):
@@ -43,7 +46,7 @@ class TestPortModel(TestSpecificationMixin, BaseModel):
     """Model for testing connectivity after a command is run."""
 
     host: str
-    port: int
+    port: Annotated[int, Field(ge=0, le=65535)]
 
 
 class CommandRuntimeConfigurationModel(CommandBaseModel):
@@ -85,6 +88,13 @@ class FilePartModel(BaseModel):
     destination: Path
     template: bool = True
 
+    @field_validator("source", mode="after")
+    @classmethod
+    def validate_source(cls, value: Path) -> Path:
+        if value.is_absolute():
+            raise ValueError(f"{value}: Must be a relative path (relative to the current cwd).")
+        return value
+
     @model_validator(mode="after")
     def validate_contents_or_source(self) -> Self:
         if self.contents is None and self.source is None:
@@ -140,7 +150,7 @@ class TutorialModel(BaseModel):
 
     @field_validator("path", mode="after")
     @classmethod
-    def resolve_path(cls, value: Path, info: ValidationInfo) -> Path:
+    def validate_path(cls, value: Path, info: ValidationInfo) -> Path:
         if not value.is_absolute():
             raise ValueError(f"{value}: Must be an absolute path.")
         return value

tests/test_models.py

@@ -4,8 +4,15 @@
 from typing import Any
 
 import pytest
+from pydantic import BaseModel
 
-from structured_tutorials.models import FilePartModel, TutorialModel
+from structured_tutorials.models import (
+    CommandBaseModel,
+    FilePartModel,
+    TestCommandModel,
+    TestPortModel,
+    TutorialModel,
+)
 
 
 def test_from_file(tutorial_paths: Path) -> None:
@@ -44,7 +51,58 @@ def test_absolute_cwd() -> None:
         TutorialModel.model_validate({"path": "/foo/test.yaml", "cwd": "/foo", "parts": []})
 
 
+def test_file_part_with_absolute_source() -> None:
+    """Test that file parts have an absolute source (if set)."""
+    with pytest.raises(ValueError, match=r"/foo: Must be a relative path"):
+        FilePartModel.model_validate({"source": "/foo", "destination": "foo.txt"})
+
+
 def test_file_part_with_no_source_and_no_contents() -> None:
     """Test that file parts have either contents or a source."""
     with pytest.raises(ValueError, match=r"Either contents or source is required\."):
         FilePartModel.model_validate({"destination": "foo.txt"})
+
+
+@pytest.mark.parametrize(
+    ("model", "data", "error"),
+    (
+        (CommandBaseModel, {"status_code": -1}, r"status_code\s*Input should be greater than or equal to 0"),
+        (CommandBaseModel, {"status_code": 256}, r"status_code\s*Input should be less than or equal to 255"),
+        (TestCommandModel, {"delay": -1}, r"delay\s*Input should be greater than or equal to 0"),
+        (TestCommandModel, {"retry": -1}, r"retry\s*Input should be greater than or equal to 0"),
+        (
+            TestCommandModel,
+            {"backoff_factor": -1},
+            r"backoff_factor\s*Input should be greater than or equal to 0",
+        ),
+        (
+            TestPortModel,
+            {"host": "example.com", "port": 443, "delay": -1},
+            r"delay\s*Input should be greater than or equal to 0",
+        ),
+        (
+            TestPortModel,
+            {"host": "example.com", "port": 443, "retry": -1},
+            r"retry\s*Input should be greater than or equal to 0",
+        ),
+        (
+            TestPortModel,
+            {"host": "example.com", "port": 443, "backoff_factor": -1},
+            r"backoff_factor\s*Input should be greater than or equal to 0",
+        ),
+        (
+            TestPortModel,
+            {"host": "example.com", "port": -1},
+            r"port\s*Input should be greater than or equal to 0",
+        ),
+        (
+            TestPortModel,
+            {"host": "example.com", "port": 65536},
+            r"port\s*Input should be less than or equal to 65535",
+        ),
+    ),
+)
+def test_annotated_field_constraints(model: type[BaseModel], data: dict[str, Any], error: str) -> None:
+    """Test annotated field constraints."""
+    with pytest.raises(ValueError, match=error):
+        model.model_validate(data)