anncsu-sdk 0.0.10.dev4__tar.gz → 0.0.10.dev5__tar.gz

{anncsu_sdk-0.0.10.dev4 → anncsu_sdk-0.0.10.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anncsu-sdk
-Version: 0.0.10.dev4
+Version: 0.0.10.dev5
 Summary: ANNCSU Software Development Kit for API consumption
 Author-email: Francesco Bartoli <francesco.bartoli@geobeyond.it>
 License-File: LICENSE

{anncsu_sdk-0.0.10.dev4 → anncsu_sdk-0.0.10.dev5}/docs/CLI.md

@@ -1905,7 +1905,7 @@ Options:
 - `--codice-civico-comunale` - Codifica comunale dell'accesso
 - `--coord-x` / `--coord-y` / `--coord-z` - Coordinate (longitudine, latitudine, quota)
 - `--metodo, -m` - Metodo di rilevazione (1-4)
-- `--data-valid-amm` - Data inizio validità amministrativa (formato `dd/MM/yyyy`)
+- `--data-valid-amm` - Data inizio validità amministrativa (valid calendar date, formato `dd/MM/yyyy`). No future-date bound: the accessi OAS declares none (absent = today; for delete it is the *end* of validity)
 - `--token-endpoint, -e` - PDND token endpoint URL
 - `--server-url, -s` - API server URL (auto-discovered from voucher if omitted)
 - `--validation/--production` - Use validation (UAT) or production environment
@@ -1913,6 +1913,10 @@ Options:
 - `--json` - Output as JSON
 - `--raw` - Print raw API response to stderr
 
+All constraints — including the wrapper fields (`--codcom` in Belfiore format X999, `--prognaz` ≤ 10 chars) and the `dd/MM/yyyy` date format — are validated **client-side before any API call** via `ValidatedRichiesta`/`ValidatedAccesso`: invalid input exits with code 1 and a `Validation error:` message without consuming PDND tokens. Server-side rejections (HTTP 400/404/500) are rendered with the structured ANNCSU fields: `Errore ANNCSU (codice N): messaggio` (non-ANNCSU bodies, e.g. RFC 7807 from the GovWay gateway, are shown raw).
+
+> **Known limitation — explicit `null`**: the accessi schema has **11 nullable fields** (`codice_civico_comunale`, `numero`, `esponente`, `specificita`, `metrico`, `data_valid_amm`, `isolato`, and `coordinate.x/y/z/metodo`). The CLI can omit them or set a value, but cannot send an explicit `null` to clear an existing value — same limitation as `codice_comunale` in `odonimo update`. The SDK supports it (fields are `OptionalNullable` with the `UNSET` sentinel).
+
 JSON output:
 ```json
 {

{anncsu_sdk-0.0.10.dev4 → anncsu_sdk-0.0.10.dev5}/docs/sdk-accessi.md

@@ -221,6 +221,22 @@ Le regole sono applicate in ordine in un singolo `@model_validator(mode="after")
 4. **Per `R` / `S`**: `progr_civico` obbligatorio — altrimenti `ProgrCivicoRequiredError`
 5. **Per `I` / `R`**: esattamente uno tra `numero` e `metrico` (XOR strict) — altrimenti `NumeroMetricoMutexError`
 6. **Coordinate**, se presenti, vengono ri-validate via `ValidatedCoordinate` (range Italia, X/Y dependency, `metodo` 1-4, `maxLength` X/Y/Z)
+7. **Per `I` / `R`**: `sezione_censimento` obbligatoria (issue #30; l'OAS la dichiara senza `nullable: true`) — altrimenti `SezioneCensimentoRequiredError`
+8. `data_valid_amm`, se valorizzata, deve essere una data di calendario valida in formato **`dd/MM/yyyy`** — altrimenti `InvalidDateFormatError`. **Nota**: a differenza di odonimi, l'OAS accessi *non* dichiara vincoli sul futuro (assente = data corrente; per `S` è la data di *fine* validità, per `I`/`R` quella di *inizio*) — quindi lato client si valida solo il formato
+
+### `ValidatedRichiesta` — validazione del wrapper
+
+Il wrapper `Richiesta` (che contiene `codcom`, `progr_nazionale` e l'oggetto `accesso`) ha un suo modello validato, usato dalla CLI prima di ogni chiamata:
+
+- `codcom` obbligatorio e in **formato Belfiore X999** (una lettera maiuscola + tre cifre, es. `A062`) — altrimenti `CodcomRequiredError` / `CodcomFormatError`
+- `progr_nazionale` obbligatorio e ≤ 10 caratteri — altrimenti `ProgrNazionaleRequiredError` / `AccessoMaxLengthError`
+- l'`accesso` incorporato viene ri-validato via `ValidatedAccesso` (gli errori risalgono)
+
+```python
+from anncsu.accessi.models.validated import ValidatedRichiesta
+
+ValidatedRichiesta.model_validate(richiesta.model_dump(exclude_unset=True))
+```
 
 ### Uso del Modello Validato
 
@@ -271,6 +287,11 @@ from anncsu.accessi.errors.accesso_validation import (
     NumeroMetricoMutexError,       # both/neither numero+metrico per I/R
     FieldNotAllowedForDeleteError, # campo non valorizzabile per S
     AccessoMaxLengthError,         # campo eccede maxLength
+    SezioneCensimentoRequiredError, # sezione_censimento mancante per I/R
+    InvalidDateFormatError,        # data non valida o non dd/MM/yyyy
+    CodcomRequiredError,           # codcom mancante (wrapper Richiesta)
+    CodcomFormatError,             # codcom non in formato Belfiore X999
+    ProgrNazionaleRequiredError,   # progr_nazionale mancante (wrapper)
 )
 
 # Catch specifico
@@ -359,8 +380,10 @@ except ModIHookError as e:
     # Errore nella generazione degli header ModI
     print(f"ModI Error: {e.message}")
 except RispostaErrore as e:
-    # Errore dall'API (RFC 7807)
-    print(f"API Error code: {e.codice}, msg: {e.messaggio}")
+    # Errore dall'API. NB: il problem+json ANNCSU NON e' RFC 7807 —
+    # schema custom id/codice/messaggio, parsato in e.data.*
+    # (str(e) e' il body JSON grezzo: non usarlo per estrarre i campi).
+    print(f"API Error code: {e.data.codice}, msg: {e.data.messaggio}")
 except APIError as e:
     # Errore HTTP generico
     print(f"HTTP Error: {e.status_code}")

{anncsu_sdk-0.0.10.dev4 → anncsu_sdk-0.0.10.dev5}/src/anncsu/accessi/__init__.py

@@ -10,13 +10,17 @@ from ._version import (
 from .errors.accesso_validation import (
     AccessoMaxLengthError,
     AccessoValidationError,
+    CodcomFormatError,
+    CodcomRequiredError,
     FieldNotAllowedForDeleteError,
     FieldNotAllowedForOperationError,
+    InvalidDateFormatError,
     NumeroMetricoMutexError,
     OperazioneCivicoError,
     ProgrCivicoRequiredError,
+    ProgrNazionaleRequiredError,
 )
-from .models.validated import ValidatedAccesso
+from .models.validated import ValidatedAccesso, ValidatedRichiesta
 from .sdk import AnncsuAccessi
 from .sdkconfiguration import SDKConfiguration
 
@@ -34,13 +38,18 @@ __all__ = [
     "AccessoMaxLengthError",
     "AccessoValidationError",
     "AnncsuAccessi",
+    "CodcomFormatError",
+    "CodcomRequiredError",
     "FieldNotAllowedForDeleteError",
     "FieldNotAllowedForOperationError",
+    "InvalidDateFormatError",
     "NumeroMetricoMutexError",
     "OperazioneCivicoError",
     "ProgrCivicoRequiredError",
+    "ProgrNazionaleRequiredError",
     "SDKConfiguration",
     "ValidatedAccesso",
+    "ValidatedRichiesta",
     "VERSION",
     "OPENAPI_DOC_VERSION",
     "SPEAKEASY_GENERATOR_VERSION",

{anncsu_sdk-0.0.10.dev4 → anncsu_sdk-0.0.10.dev5}/src/anncsu/accessi/errors/accesso_validation.py

@@ -177,6 +177,70 @@ class AccessoMaxLengthError(AccessoValidationError):
         )
 
 
+@dataclass
+class InvalidDateFormatError(AccessoValidationError):
+    """Raised when a date field is not a valid dd/MM/yyyy calendar date.
+
+    Applies to data_valid_amm (OAS example: "08/10/2024"). NOTE: the
+    accessi OAS declares no not-in-future bound (unlike odonimi), so
+    only the format is validated client-side.
+    """
+
+    field_name: str
+    value: str
+
+    def __str__(self) -> str:
+        return (
+            f"Il campo '{self.field_name}' deve essere una data valida nel "
+            f"formato dd/MM/yyyy (es. '08/10/2024'). "
+            f"Valore fornito: {self.value!r}"
+        )
+
+
+@dataclass
+class CodcomRequiredError(AccessoValidationError):
+    """Raised when the Richiesta wrapper is missing codcom.
+
+    Per OAS spec: "Codice del comune (obbligatorio)".
+    """
+
+    def __str__(self) -> str:
+        return "Il campo 'codcom' e' obbligatorio per tutte le operazioni."
+
+
+@dataclass
+class CodcomFormatError(AccessoValidationError):
+    """Raised when codcom does not match the Belfiore format X999.
+
+    Per OAS spec: ``format: X999`` — one uppercase letter followed by
+    three digits (e.g. "A062", "H501").
+    """
+
+    value: str
+
+    def __str__(self) -> str:
+        return (
+            f"Il campo 'codcom' deve essere un codice Belfiore nel formato "
+            f"X999 (una lettera maiuscola + tre cifre, es. 'A062'). "
+            f"Valore fornito: {self.value!r}"
+        )
+
+
+@dataclass
+class ProgrNazionaleRequiredError(AccessoValidationError):
+    """Raised when the Richiesta wrapper is missing progr_nazionale.
+
+    Per OAS spec: "Progressivo nazionale (obbligatorio)" — it identifies
+    the odonimo the accesso belongs to.
+    """
+
+    def __str__(self) -> str:
+        return (
+            "Il campo 'progr_nazionale' e' obbligatorio: identifica "
+            "l'odonimo a cui appartiene l'accesso."
+        )
+
+
 __all__ = [
     "AccessoValidationError",
     "OperazioneCivicoError",
@@ -186,4 +250,8 @@ __all__ = [
     "FieldNotAllowedForOperationError",
     "SezioneCensimentoRequiredError",
     "AccessoMaxLengthError",
+    "InvalidDateFormatError",
+    "CodcomRequiredError",
+    "CodcomFormatError",
+    "ProgrNazionaleRequiredError",
 ]

{anncsu_sdk-0.0.10.dev4 → anncsu_sdk-0.0.10.dev5}/src/anncsu/accessi/models/validated.py

@@ -24,23 +24,37 @@ Rules (derived from the OAS spec):
    1-4, maxLength X/Y/Z).
 7. ``sezione_censimento`` is mandatory for ``I`` and ``R`` (OAS field has
    no ``nullable: true``); rule 4 already forbids it for ``S``.
+8. ``data_valid_amm``, when set, must be a valid ``dd/MM/yyyy`` calendar
+   date. NOTE: the accessi OAS declares no not-in-future bound (unlike
+   odonimi) — absent means "data corrente", for S it is the *end* of
+   validity, for I/R the *start* — so only the format is checked.
+
+``ValidatedRichiesta`` additionally validates the wrapper fields:
+``codcom`` (mandatory, Belfiore format X999) and ``progr_nazionale``
+(mandatory, maxLength 10), re-validating the embedded ``accesso``.
 """
 
 from __future__ import annotations
 
+import datetime
+import re
 from typing import Optional
 
 from pydantic import model_validator
 
 from anncsu.accessi.errors.accesso_validation import (
     AccessoMaxLengthError,
+    CodcomFormatError,
+    CodcomRequiredError,
     FieldNotAllowedForDeleteError,
+    InvalidDateFormatError,
     NumeroMetricoMutexError,
     OperazioneCivicoError,
     ProgrCivicoRequiredError,
+    ProgrNazionaleRequiredError,
     SezioneCensimentoRequiredError,
 )
-from anncsu.accessi.models.richiestaoperazione import Accesso
+from anncsu.accessi.models.richiestaoperazione import Accesso, Richiesta
 from anncsu.coordinate.models.validated import ValidatedCoordinate
 
 VALID_OPERAZIONI = {"I", "R", "S"}
@@ -69,6 +83,15 @@ FIELDS_NOT_ALLOWED_FOR_DELETE: tuple[str, ...] = (
     "isolato",
 )
 
+# Strict dd/MM/yyyy: strptime alone accepts non-zero-padded dates.
+_DATE_PATTERN = re.compile(r"^\d{2}/\d{2}/\d{4}$")
+
+# Belfiore code: one uppercase letter + three digits (OAS format X999).
+_CODCOM_PATTERN = re.compile(r"^[A-Z]\d{3}$")
+
+# Wrapper-level maxLength (Richiesta).
+PROGR_NAZIONALE_MAX_LENGTH = 10
+
 
 class ValidatedAccesso(Accesso):
     """Accesso model with ANNCSU business rule validation.
@@ -136,6 +159,18 @@ class ValidatedAccesso(Accesso):
             # if the embedded coordinates violate any rule.
             ValidatedCoordinate.model_validate(payload)
 
+        # Rule 8: data_valid_amm format (no future bound in the accessi OAS)
+        value = self._get_value(self.data_valid_amm)
+        if value is not None:
+            if not _DATE_PATTERN.match(value):
+                raise InvalidDateFormatError(field_name="data_valid_amm", value=value)
+            try:
+                datetime.datetime.strptime(value, "%d/%m/%Y")
+            except ValueError:
+                raise InvalidDateFormatError(
+                    field_name="data_valid_amm", value=value
+                ) from None
+
         return self
 
     # ------------------------------------------------------------------
@@ -177,4 +212,44 @@ class ValidatedAccesso(Accesso):
                 )
 
 
-__all__ = ["ValidatedAccesso"]
+class ValidatedRichiesta(Richiesta):
+    """Accessi Richiesta wrapper with ANNCSU business rule validation.
+
+    Validates the wrapper fields (``codcom``, ``progr_nazionale``) and
+    re-validates the embedded ``accesso`` via ``ValidatedAccesso``.
+
+    Raises:
+        CodcomRequiredError: ``codcom`` missing
+        CodcomFormatError: ``codcom`` not in Belfiore format X999
+        ProgrNazionaleRequiredError: ``progr_nazionale`` missing
+        AccessoMaxLengthError: ``progr_nazionale`` exceeds 10 chars
+        AccessoValidationError (subclasses): bubbled up from the
+            embedded ``ValidatedAccesso``
+    """
+
+    @model_validator(mode="after")
+    def validate_richiesta_rules(self) -> "ValidatedRichiesta":
+        """Apply wrapper-level ANNCSU rules, then re-validate the accesso."""
+        codcom = self.codcom if self.codcom else None
+        if codcom is None:
+            raise CodcomRequiredError()
+        if not _CODCOM_PATTERN.match(codcom):
+            raise CodcomFormatError(value=codcom)
+
+        prognaz = self.progr_nazionale if self.progr_nazionale else None
+        if prognaz is None:
+            raise ProgrNazionaleRequiredError()
+        if len(prognaz) > PROGR_NAZIONALE_MAX_LENGTH:
+            raise AccessoMaxLengthError(
+                field_name="progr_nazionale",
+                value=prognaz,
+                max_length=PROGR_NAZIONALE_MAX_LENGTH,
+            )
+
+        if self.accesso is not None:
+            ValidatedAccesso.model_validate(self.accesso.model_dump(exclude_unset=True))
+
+        return self
+
+
+__all__ = ["ValidatedAccesso", "ValidatedRichiesta"]

{anncsu_sdk-0.0.10.dev4 → anncsu_sdk-0.0.10.dev5}/src/anncsu/cli/commands/accesso.py

@@ -27,13 +27,14 @@ from rich.console import Console
 from rich.table import Table
 
 from anncsu.accessi import AnncsuAccessi
+from anncsu.accessi.errors import RispostaErrore as AccessiRispostaErrore
 from anncsu.accessi.models import Security
 from anncsu.accessi.models.richiestaoperazione import (
     Accesso,
     Coordinate,
     Richiesta,
 )
-from anncsu.accessi.models.validated import ValidatedAccesso
+from anncsu.accessi.models.validated import ValidatedAccesso, ValidatedRichiesta
 from anncsu.cli.commands.constants import _resolve_token_endpoint
 from anncsu.cli.models import (
     AccessoDryRunResult,
@@ -943,6 +944,23 @@ def _run_delete_dry_run(
         raise typer.Exit(1)
 
 
+def _render_server_error(e: AccessiRispostaErrore) -> None:
+    """Render an ANNCSU RispostaErrore (HTTP 400/404/500) readably.
+
+    The contract's problem+json carries structured ``codice`` +
+    ``messaggio``; bodies without them (e.g. RFC 7807 from the gateway)
+    fall back to the raw body.
+    """
+    codice = getattr(e.data, "codice", None)
+    messaggio = getattr(e.data, "messaggio", None)
+    if codice or messaggio:
+        error_console.print(
+            f"[red]Errore ANNCSU[/red] (codice {codice or '—'}): {messaggio or '—'}"
+        )
+    else:
+        error_console.print(f"[red]Error:[/red] {e}")
+
+
 def _execute_operation(
     *,
     operazione_civico: str,
@@ -961,10 +979,16 @@ def _execute_operation(
     then issues the POST and renders the response either as JSON
     (``--json``) or as a rich table.
     """
-    # Pre-validate with business rules (raises ValidationError / typer.Exit on
-    # invalid input).
+    richiesta = Richiesta(
+        codcom=codcom,
+        progr_nazionale=progr_nazionale,
+        accesso=accesso,
+    )
+
+    # Pre-validate with business rules — wrapper (codcom X999, prognaz <= 10)
+    # AND embedded accesso — BEFORE any API call.
     try:
-        ValidatedAccesso.model_validate(accesso.model_dump(exclude_unset=True))
+        ValidatedRichiesta.model_validate(richiesta.model_dump(exclude_unset=True))
     except Exception as e:
         error_console.print(f"[red]Validation error:[/red] {e}")
         raise typer.Exit(1) from None
@@ -976,14 +1000,11 @@ def _execute_operation(
         modi_audience=server_url,
     )
 
-    richiesta = Richiesta(
-        codcom=codcom,
-        progr_nazionale=progr_nazionale,
-        accesso=accesso,
-    )
-
     try:
         response = sdk.anncsu.gestione_anncsu_pdnd(richiesta=richiesta)
+    except AccessiRispostaErrore as e:
+        _render_server_error(e)
+        raise typer.Exit(1) from None
     except Exception as e:
         error_console.print(f"[red]Error:[/red] API call failed: {e}")
         raise typer.Exit(1) from None

{anncsu_sdk-0.0.10.dev4 → anncsu_sdk-0.0.10.dev5}/tests/accessi/test_accesso_validation.py

@@ -34,14 +34,18 @@ from pydantic import ValidationError
 from anncsu.accessi.errors.accesso_validation import (
     AccessoMaxLengthError,
     AccessoValidationError,
+    CodcomFormatError,
+    CodcomRequiredError,
     FieldNotAllowedForDeleteError,
     FieldNotAllowedForOperationError,
+    InvalidDateFormatError,
     NumeroMetricoMutexError,
     OperazioneCivicoError,
     ProgrCivicoRequiredError,
+    ProgrNazionaleRequiredError,
     SezioneCensimentoRequiredError,
 )
-from anncsu.accessi.models.validated import ValidatedAccesso
+from anncsu.accessi.models.validated import ValidatedAccesso, ValidatedRichiesta
 from anncsu.coordinate.errors.coordinate_validation import (
     CoordinateRangeError,
 )
@@ -618,5 +622,134 @@ class TestAccessoIntegration:
         assert isinstance(accesso.numero, Unset) or accesso.numero is None
 
 
+# ---------------------------------------------------------------------------
+# 8. data_valid_amm format dd/MM/yyyy
+# ---------------------------------------------------------------------------
+
+
+class TestAccessoDataValidAmmFormat:
+    """data_valid_amm, when set, must be a valid dd/MM/yyyy calendar date.
+
+    NOTE: unlike odonimi, the accessi OAS declares NO not-in-future rule
+    ("se assente e' equiparata alla data corrente; per S e' la data di
+    fine validita', per le altre la data di inizio") — only the format
+    is checked client-side.
+    """
+
+    @pytest.mark.parametrize("bad", ["2024-10-08", "31/02/2024", "08.10.2024", "x"])
+    def test_invalid_date_raises(self, bad: str) -> None:
+        with pytest.raises(ValidationError) as exc_info:
+            ValidatedAccesso(
+                operazione_civico="I",
+                numero="12",
+                sezione_censimento="9",
+                data_valid_amm=bad,
+            )
+        cause = get_validation_error_cause(exc_info)
+        assert isinstance(cause, InvalidDateFormatError)
+        assert "data_valid_amm" in str(cause)
+
+    def test_valid_date_accepted(self) -> None:
+        accesso = ValidatedAccesso(
+            operazione_civico="I",
+            numero="12",
+            sezione_censimento="9",
+            data_valid_amm="08/10/2024",
+        )
+        assert accesso.data_valid_amm == "08/10/2024"
+
+    def test_future_date_accepted(self) -> None:
+        """Pins the deliberate difference vs odonimi: accessi OAS has no
+        <= today bound, so future dates pass client-side."""
+        import datetime
+
+        future = (datetime.date.today() + datetime.timedelta(days=30)).strftime(
+            "%d/%m/%Y"
+        )
+        accesso = ValidatedAccesso(
+            operazione_civico="I",
+            numero="12",
+            sezione_censimento="9",
+            data_valid_amm=future,
+        )
+        assert accesso.data_valid_amm == future
+
+
+# ---------------------------------------------------------------------------
+# 9. ValidatedRichiesta — wrapper fields (codcom, progr_nazionale)
+# ---------------------------------------------------------------------------
+
+
+def _valid_accesso_dict() -> dict:
+    return {
+        "operazione_civico": "I",
+        "numero": "12",
+        "sezione_censimento": "9",
+    }
+
+
+class TestValidatedRichiesta:
+    """The Richiesta wrapper carries codcom (format X999) and
+    progr_nazionale (<= 10 chars), both mandatory per OAS."""
+
+    def test_valid_richiesta_accepted(self) -> None:
+        richiesta = ValidatedRichiesta(
+            codcom="A062",
+            progr_nazionale="2000449",
+            accesso=_valid_accesso_dict(),
+        )
+        assert richiesta.codcom == "A062"
+
+    def test_codcom_missing_raises(self) -> None:
+        with pytest.raises(ValidationError) as exc_info:
+            ValidatedRichiesta(progr_nazionale="2000449", accesso=_valid_accesso_dict())
+        cause = get_validation_error_cause(exc_info)
+        assert isinstance(cause, CodcomRequiredError)
+
+    @pytest.mark.parametrize("bad", ["ROMA", "1234", "A06", "A0622", "a062", "A06B"])
+    def test_codcom_invalid_format_raises(self, bad: str) -> None:
+        with pytest.raises(ValidationError) as exc_info:
+            ValidatedRichiesta(
+                codcom=bad,
+                progr_nazionale="2000449",
+                accesso=_valid_accesso_dict(),
+            )
+        cause = get_validation_error_cause(exc_info)
+        assert isinstance(cause, CodcomFormatError)
+
+    def test_progr_nazionale_missing_raises(self) -> None:
+        with pytest.raises(ValidationError) as exc_info:
+            ValidatedRichiesta(codcom="A062", accesso=_valid_accesso_dict())
+        cause = get_validation_error_cause(exc_info)
+        assert isinstance(cause, ProgrNazionaleRequiredError)
+
+    def test_progr_nazionale_max_length_10_raises(self) -> None:
+        with pytest.raises(ValidationError) as exc_info:
+            ValidatedRichiesta(
+                codcom="A062",
+                progr_nazionale="12345678901",
+                accesso=_valid_accesso_dict(),
+            )
+        cause = get_validation_error_cause(exc_info)
+        assert isinstance(cause, AccessoMaxLengthError)
+        assert "progr_nazionale" in str(cause)
+
+    def test_invalid_accesso_bubbles_up(self) -> None:
+        """The embedded accesso is re-validated via ValidatedAccesso."""
+        with pytest.raises(ValidationError) as exc_info:
+            ValidatedRichiesta(
+                codcom="A062",
+                progr_nazionale="2000449",
+                accesso={"operazione_civico": "I", "numero": "12"},
+            )
+        cause = get_validation_error_cause(exc_info)
+        assert isinstance(cause, SezioneCensimentoRequiredError)
+
+    def test_accesso_missing_accepted(self) -> None:
+        """No accesso object: wrapper-only validation still applies."""
+        richiesta = ValidatedRichiesta(codcom="A062", progr_nazionale="2000449")
+        assert richiesta.accesso is None
+
+
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])