anncsu-sdk 0.0.9.dev29__tar.gz → 0.0.10.dev1__tar.gz

{anncsu_sdk-0.0.9.dev29 → anncsu_sdk-0.0.10.dev1}/.github/workflows/publish.yml

@@ -16,7 +16,7 @@ jobs:
   publish:
     runs-on: ubuntu-latest
     permissions:
-      contents: read
+      contents: write # Required for softprops/action-gh-release to create GitHub Releases on tag pushes
       id-token: write # Required for trusted publishing (optional but recommended)
 
     steps:

{anncsu_sdk-0.0.9.dev29 → anncsu_sdk-0.0.10.dev1}/PKG-INFO

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

{anncsu_sdk-0.0.9.dev29 → anncsu_sdk-0.0.10.dev1}/docs/CLI.md

@@ -877,22 +877,40 @@ Original coordinates to restore manually:
   metodo: 4
 ```
 
-**Handling Access Points Without Coordinates**: When an access point has no existing coordinates (X, Y, and metodo are all empty), the dry-run uses temporary test coordinates for the update test:
+**Safety skip on legacy NULL `metodo`**: a dry-run **guarantees zero changes** in production. If the target record has an original `metodo` that is not one of the valid OAS values (`"1"`, `"2"`, `"3"`, `"4"`) — typically legacy data imported before the validation rule was enforced — the restore step would fail (ANNCSU error 130, *"Il metodo deve essere obbligatorio e compreso tra 1 e 4"*) and the test update would remain committed permanently.
 
-| Field | Test Value | Description |
-|-------|------------|-------------|
-| X | `12.4922309` | Longitude (Roma Colosseo area) |
-| Y | `41.8902102` | Latitude (Roma Colosseo area) |
-| Z | `null` | Altitude not specified |
-| metodo | `4` | "Altro" (other method) |
+To preserve the dry-run guarantee, the CLI **skips** such records **before any API write call**:
 
-After the test update, the command restores the original empty state. A note is displayed when test coordinates are used:
+- No `gestionecoordinate` request is sent.
+- A warning is printed (or, with `--json`, a structured payload with `"skipped": true` and `"skip_reason": "original_metodo_null_or_invalid"`).
+- Exit code is `0` (the dry-run completed as designed, the record was simply not testable).
 
-```
-Note: Access has no coordinates. Using test coordinates (will be cleared after test).
+JSON output when a record is skipped:
+
+```json
+{
+  "success": true,
+  "original_coordinates": {
+    "prognazacc": "5256880",
+    "codcom": "H501",
+    "civico": "1",
+    "coord_x": null,
+    "coord_y": null,
+    "quota": null,
+    "metodo": null
+  },
+  "test_update": null,
+  "restore": null,
+  "restore_failed": false,
+  "skipped": true,
+  "skip_reason": "original_metodo_null_or_invalid",
+  "error_message": null
+}
 ```
 
-**Note**: If the API does not allow restoring an access point without valid coordinates, the restore operation may fail. In this case, manual intervention may be needed.
+> **Removed in this release**: the prior fallback that injected Roma Colosseo coordinates (`X=12.4922309`, `Y=41.8902102`, `metodo=4`) when the access had no original coordinates. That fallback violated the "dry-run = zero changes" guarantee because the eventual restore to `metodo=NULL` could not succeed. Skip is now the only behaviour.
+
+**Warning Handling (legacy)**: if a restore fails for any *other* reason (e.g. transient network error during the round-trip on a record that did pass the safety check), the command will still display original values for manual recovery — same as before.
 
 ---
 
@@ -1225,12 +1243,13 @@ Dry-Run Results:
 ┌──────────────────────┬───────┐
 │ Metric               │ Value │
 ├──────────────────────┼───────┤
-│ Total tested         │ 10    │
-│ Updates succeeded    │ 10    │
+│ Total tested         │ 8     │
+│ Updates succeeded    │ 8     │
 │ Updates failed       │ 0     │
-│ Restores succeeded   │ 10    │
+│ Restores succeeded   │ 8     │
 │ Restores failed      │ 0     │
 │ Lookup failures      │ 0     │
+│ Metodo NULL skipped  │ 2     │
 └──────────────────────┴───────┘
 ```
 
@@ -1238,12 +1257,13 @@ JSON output:
 ```json
 {
   "run_id": "abc123-def456",
-  "total_tested": 10,
-  "updates_succeeded": 8,
+  "total_tested": 8,
+  "updates_succeeded": 6,
   "updates_failed": 2,
-  "restores_succeeded": 8,
+  "restores_succeeded": 6,
   "restores_failed": 0,
   "lookup_failures": 0,
+  "metodo_null_skipped": 2,
   "errors": [
     {
       "row_id": 4,
@@ -1258,15 +1278,24 @@ JSON output:
       "operation": "dryrun_update",
       "http_status": 400,
       "error_detail": "body.richiesta.accesso.coordinate.x: Max length is '12', found '14'"
+    },
+    {
+      "row_id": 12,
+      "progr_civico": "33013500",
+      "operation": "dryrun_skip",
+      "http_status": null,
+      "error_detail": "original_metodo_null_or_invalid: None"
     }
   ]
 }
 ```
 
+**Safety skip on legacy NULL `metodo`**: same semantics as `coordinate dry-run` — records whose original `metodo` is not in `{"1", "2", "3", "4"}` are skipped **before any API write** to preserve the "dry-run = zero changes" guarantee. Counted in the dedicated `metodo_null_skipped` field; logged in `bulk_results` with `operation = 'dryrun_skip'` and `error_detail = 'original_metodo_null_or_invalid: <value>'`, so they appear in the **Error Details** section alongside other failures (distinguishable by the `operation` column).
+
 When there are errors, the text output also includes an **Error Details** table showing
 row, progr_civico, operation, HTTP status, and error message for each failed operation.
 
-Exits with code 1 if any restores failed (manual intervention may be needed).
+Exits with code 1 if any restores failed (manual intervention may be needed). Skipped records do NOT cause a non-zero exit.
 
 #### `anncsu coordinate bulk resume`
 

{anncsu_sdk-0.0.9.dev29 → anncsu_sdk-0.0.10.dev1}/src/anncsu/cli/commands/bulk.py

@@ -572,6 +572,7 @@ def bulk_dry_run(
                     "restores_succeeded": dry_result.restores_succeeded,
                     "restores_failed": dry_result.restores_failed,
                     "lookup_failures": dry_result.lookup_failures,
+                    "metodo_null_skipped": dry_result.metodo_null_skipped,
                     "errors": [
                         {
                             "row_id": e[0],
@@ -605,6 +606,10 @@ def bulk_dry_run(
                     "Restores failed", f"[red]{dry_result.restores_failed}[/red]"
                 )
                 table.add_row("Lookup failures", str(dry_result.lookup_failures))
+                table.add_row(
+                    "Metodo NULL skipped",
+                    f"[yellow]{dry_result.metodo_null_skipped}[/yellow]",
+                )
                 console.print(table)
 
                 if errors:

{anncsu_sdk-0.0.9.dev29 → anncsu_sdk-0.0.10.dev1}/src/anncsu/cli/commands/coordinate.py

@@ -40,6 +40,7 @@ from anncsu.common.modi import AuditContext, ModIConfig
 from anncsu.common.security import Security as PASecurity
 from anncsu.common.session import get_config_dir
 from anncsu.coordinate import AnncsuCoordinate
+from anncsu.coordinate.bulk.dryrun import _is_safely_restorable
 from anncsu.coordinate.models import Accesso, Coordinate, Richiesta, Security
 from anncsu.coordinate.models.validated import ValidatedRispostaOperazione
 from anncsu.pa import AnncsuConsultazione
@@ -829,6 +830,32 @@ def dry_run(
         console.print(f"  Quota: {original.quota or 'N/A'}")
         console.print(f"  Metodo: {original.metodo or 'N/A'}\n")
 
+    # Pre-flight safety check: skip records whose original ``metodo`` is not
+    # one of the valid OAS values (``"1".."4"``). For such legacy records the
+    # update would succeed but the restore would fail with ANNCSU code 130,
+    # leaving the production data permanently overwritten. The dry-run
+    # guarantees "zero changes", so we bail out before any API write.
+    if not _is_safely_restorable(original.metodo):
+        if not json_output:
+            console.print(
+                "[yellow]Skipped:[/yellow] original ``metodo`` is "
+                f"{original.metodo!r}, which is not a valid restorable value "
+                "(expected '1', '2', '3', or '4'). No update or restore was "
+                "attempted to preserve the dry-run guarantee.\n"
+            )
+        skip_result = DryRunResult(
+            success=True,
+            original_coordinates=original,
+            test_update=None,
+            restore=None,
+            restore_failed=False,
+            skipped=True,
+            skip_reason="original_metodo_null_or_invalid",
+        )
+        if json_output:
+            print(skip_result.model_dump_json(indent=2))
+        return
+
     # Step 2: Perform test update
     if not json_output:
         console.print("[bold]Step 2:[/bold] Performing test update...\n")
@@ -841,31 +868,13 @@ def dry_run(
         modi_audience=coord_server,
     )
 
-    # Check if access has existing coordinates
-    has_coordinates = original.coord_x and original.coord_y and original.metodo
-
-    if has_coordinates:
-        # Use existing coordinates for test
-        test_coordinate = Coordinate(
-            x=original.coord_x,
-            y=original.coord_y,
-            z=original.quota,
-            metodo=original.metodo,
-        )
-    else:
-        # Access has no coordinates - use test values (Roma Colosseo area)
-        # These will be restored to empty after the test
-        if not json_output:
-            console.print(
-                "[yellow]Note:[/yellow] Access has no coordinates. "
-                "Using test coordinates (will be cleared after test).\n"
-            )
-        test_coordinate = Coordinate(
-            x="12.4922309",  # Roma - Colosseo longitude
-            y="41.8902102",  # Roma - Colosseo latitude
-            z=None,
-            metodo="4",  # Metodo 4 = Altro
-        )
+    # Use the original coordinates as test payload (round-trip).
+    test_coordinate = Coordinate(
+        x=original.coord_x,
+        y=original.coord_y,
+        z=original.quota,
+        metodo=original.metodo,
+    )
 
     test_richiesta = Richiesta(
         accesso=Accesso(

{anncsu_sdk-0.0.9.dev29 → anncsu_sdk-0.0.10.dev1}/src/anncsu/cli/models.py

@@ -324,7 +324,13 @@ class DryRunResult(BaseModel):
     original_coordinates: OriginalCoordinates = Field(
         description="Original coordinates before the test"
     )
-    test_update: CoordinateUpdateResult = Field(description="Result of the test update")
+    test_update: CoordinateUpdateResult | None = Field(
+        default=None,
+        description=(
+            "Result of the test update. ``None`` when the dry-run was skipped "
+            "(see ``skipped`` / ``skip_reason``) because no API write was attempted."
+        ),
+    )
     restore: CoordinateUpdateResult | None = Field(
         default=None, description="Result of the restore operation"
     )
@@ -332,6 +338,20 @@ class DryRunResult(BaseModel):
         default=False,
         description="Whether restore failed (requires manual intervention)",
     )
+    skipped: bool = Field(
+        default=False,
+        description=(
+            "Whether the dry-run was skipped before any API write because the "
+            "original record cannot be safely restored (e.g. legacy NULL metodo)."
+        ),
+    )
+    skip_reason: str | None = Field(
+        default=None,
+        description=(
+            "Machine-readable reason when ``skipped`` is ``True``. "
+            "Currently the only value is ``original_metodo_null_or_invalid``."
+        ),
+    )
     error_message: str | None = Field(
         default=None, description="Error message if operation failed"
     )

{anncsu_sdk-0.0.9.dev29 → anncsu_sdk-0.0.10.dev1}/src/anncsu/coordinate/bulk/dryrun.py

@@ -13,6 +13,7 @@ from anncsu.coordinate.models.richiestaoperazione import (
 )
 
 DEFAULT_MAX_RECORDS = 10
+VALID_METODO_VALUES = frozenset({"1", "2", "3", "4"})
 
 
 def _extract_http_error(e: Exception) -> tuple[int | None, str]:
@@ -22,6 +23,20 @@ def _extract_http_error(e: Exception) -> tuple[int | None, str]:
     return http_status, error_detail
 
 
+def _is_safely_restorable(metodo: str | None) -> bool:
+    """A record can be safely dry-run-tested only if its original ``metodo``
+    is one of the valid OAS values (``"1".."4"``).
+
+    Records with NULL / empty / out-of-range ``metodo`` are legacy data
+    that pre-date the current API validation rule. The update would
+    succeed (the new CSV value is valid) but the restore would fail with
+    ANNCSU error 130 — leaving the record permanently overwritten. To
+    preserve the "dry-run = zero changes" guarantee, such records are
+    skipped before any write call.
+    """
+    return metodo in VALID_METODO_VALUES
+
+
 @dataclass
 class DryRunResult:
     """Result of a bulk dry-run operation."""
@@ -33,6 +48,7 @@ class DryRunResult:
     restores_failed: int
     lookup_failures: int
     run_id: str
+    metodo_null_skipped: int = 0
 
 
 class BulkDryRunner:
@@ -77,6 +93,7 @@ class BulkDryRunner:
         restores_succeeded = 0
         restores_failed = 0
         lookup_failures = 0
+        metodo_null_skipped = 0
 
         # Track which rows were successfully updated (need restore)
         rows_to_restore: list[dict] = []
@@ -130,6 +147,21 @@ class BulkDryRunner:
                 original_metodo=lookup_data.metodo,
             )
 
+            # Step 2b: Pre-flight — skip records whose original metodo is not
+            # one of {"1","2","3","4"}. Otherwise the restore would fail
+            # (ANNCSU error 130) and leave the record permanently overwritten.
+            if not _is_safely_restorable(lookup_data.metodo):
+                metodo_null_skipped += 1
+                self.db.insert_result(
+                    row_id=row_id,
+                    run_id=self.run_id,
+                    operation="dryrun_skip",
+                    error_detail=(
+                        f"original_metodo_null_or_invalid: {lookup_data.metodo!r}"
+                    ),
+                )
+                continue
+
             # Step 3: Update with new coordinates from CSV
             try:
                 response = self._call_update(row)
@@ -216,6 +248,7 @@ class BulkDryRunner:
             restores_succeeded=restores_succeeded,
             restores_failed=restores_failed,
             lookup_failures=lookup_failures,
+            metodo_null_skipped=metodo_null_skipped,
             run_id=self.run_id,
         )
 

{anncsu_sdk-0.0.9.dev29 → anncsu_sdk-0.0.10.dev1}/tests/cli/test_coordinate.py

@@ -964,10 +964,17 @@ class TestCoordinateDryRun:
             )
             assert call_kwargs[1]["accparz"] == "10"
 
-    def test_dry_run_access_without_coordinates_uses_test_values(
+    def test_dry_run_skips_access_without_metodo_via_search(
         self, cli_runner: CliRunner, tmp_path: Path, mock_private_key: Path
     ) -> None:
-        """Test that dry-run uses test coordinates when access has no existing coordinates."""
+        """Access with NULL ``metodo`` reached via --codcom/--denom search must
+        be skipped — no test coordinates are invented, no API write occurs.
+
+        This replaces the prior ``..._uses_test_values`` test (the Colosseo
+        fallback) which violated the "dry-run = zero changes" guarantee
+        because the eventual restore to NULL metodo always failed with
+        ANNCSU error 130.
+        """
         from anncsu.cli import app
 
         with cli_runner.isolated_filesystem(temp_dir=tmp_path):
@@ -990,21 +997,20 @@ class TestCoordinateDryRun:
                         "anncsu.cli.commands.coordinate.AnncsuConsultazione"
                     ) as mock_consult_sdk:
                         consult_sdk = MagicMock()
-                        # Mock odonimo response
                         odonimo_response = MagicMock()
                         odonimo_response.data = [MagicMock()]
                         odonimo_response.data[0].prognaz = "987654"
                         odonimo_response.data[0].dug = "VIA"
                         odonimo_response.data[0].denomuff = "ROMA"
                         consult_sdk.queryparam.elencoodonimiprog_get_query_param.return_value = odonimo_response
-                        # Mock access response - NO COORDINATES
+                        # Access with NO metodo (legacy data)
                         search_response = MagicMock()
                         search_response.data = [MagicMock()]
                         search_response.data[0].prognazacc = "5256880"
-                        search_response.data[0].coord_x = None  # No X
-                        search_response.data[0].coord_y = None  # No Y
+                        search_response.data[0].coord_x = None
+                        search_response.data[0].coord_y = None
                         search_response.data[0].quota = None
-                        search_response.data[0].metodo = None  # No metodo
+                        search_response.data[0].metodo = None
                         search_response.data[0].civico = "1"
                         consult_sdk.queryparam.elencoaccessiprog_get_query_param.return_value = search_response
                         mock_consult_sdk.return_value = consult_sdk
@@ -1013,22 +1019,6 @@ class TestCoordinateDryRun:
                             "anncsu.cli.commands.coordinate.AnncsuCoordinate"
                         ) as mock_coord_sdk:
                             coord_sdk = MagicMock()
-                            # Test update succeeds
-                            update_response = create_mock_response(
-                                id_richiesta="REQ-TEST-123",
-                                esito="0",
-                                messaggio="Test update OK",
-                            )
-                            # Restore succeeds
-                            restore_response = create_mock_response(
-                                id_richiesta="REQ-RESTORE-456",
-                                esito="0",
-                                messaggio="Restore OK",
-                            )
-                            coord_sdk.json_post.gestionecoordinate.side_effect = [
-                                update_response,
-                                restore_response,
-                            ]
                             mock_coord_sdk.return_value = coord_sdk
 
                             result = cli_runner.invoke(
@@ -1043,23 +1033,195 @@ class TestCoordinateDryRun:
                                 ],
                             )
 
-            assert result.exit_code == 0
-            # Should show note about using test coordinates
-            assert "no coordinates" in result.output.lower()
-            # Verify gestionecoordinate was called twice (test + restore)
-            assert coord_sdk.json_post.gestionecoordinate.call_count == 2
-            # Verify test update used Roma Colosseo test coordinates
-            test_call = coord_sdk.json_post.gestionecoordinate.call_args_list[0]
-            test_richiesta = test_call[1]["richiesta"]
-            assert test_richiesta.accesso.coordinate.x == "12.4922309"
-            assert test_richiesta.accesso.coordinate.y == "41.8902102"
-            assert test_richiesta.accesso.coordinate.metodo == "4"
-            # Verify restore uses original empty values
-            restore_call = coord_sdk.json_post.gestionecoordinate.call_args_list[1]
-            restore_richiesta = restore_call[1]["richiesta"]
-            assert restore_richiesta.accesso.coordinate.x is None
-            assert restore_richiesta.accesso.coordinate.y is None
-            assert restore_richiesta.accesso.coordinate.metodo is None
+            assert result.exit_code == 0, result.output
+            # Critical: no API write was attempted
+            assert coord_sdk.json_post.gestionecoordinate.call_count == 0
+            # User informed about the skip
+            assert "skip" in result.output.lower()
+
+    def test_dry_run_skips_when_original_metodo_is_null(
+        self, cli_runner: CliRunner, tmp_path: Path, mock_private_key: Path
+    ) -> None:
+        """Single dry-run must skip records whose original ``metodo`` is NULL.
+
+        The dry-run guarantee is "zero changes": if the original record has
+        no valid metodo (1-4), the restore step would fail and leave the
+        update committed. The CLI must:
+
+        - emit a warning explaining the skip
+        - perform zero ``gestionecoordinate`` calls (no write whatsoever)
+        - exit 0 (the dry-run completed as designed)
+        """
+        from anncsu.cli import app
+
+        with cli_runner.isolated_filesystem(temp_dir=tmp_path):
+            Path("private_key.pem").write_text(mock_private_key.read_text())
+            with patch(
+                "anncsu.cli.commands.coordinate.ClientAssertionSettings"
+            ) as mock_settings:
+                mock_settings.return_value = MagicMock()
+                with patch(
+                    "anncsu.cli.commands.coordinate.PDNDAuthManager"
+                ) as mock_manager_cls:
+                    manager = MagicMock()
+                    manager.get_access_token.return_value = "tok"
+                    mock_manager_cls.return_value = manager
+                    with patch(
+                        "anncsu.cli.commands.coordinate.AnncsuConsultazione"
+                    ) as mock_consult_cls:
+                        consult_sdk = MagicMock()
+                        resp = MagicMock()
+                        d = MagicMock()
+                        d.prognazacc = "5256880"
+                        d.prognaz = "907156"
+                        d.dug = "VIA"
+                        d.denomuff = "ROMA"
+                        d.civico = "1"
+                        d.coord_x = None
+                        d.coord_y = None
+                        d.quota = None
+                        d.metodo = None
+                        resp.data = [d]
+                        consult_sdk.queryparam.prognazacc_get_query_param.return_value = resp
+                        mock_consult_cls.return_value = consult_sdk
+                        with patch(
+                            "anncsu.cli.commands.coordinate.AnncsuCoordinate"
+                        ) as mock_coord_cls:
+                            coord_sdk = MagicMock()
+                            mock_coord_cls.return_value = coord_sdk
+
+                            result = cli_runner.invoke(
+                                app,
+                                [
+                                    "coordinate",
+                                    "dry-run",
+                                    "--prognazacc",
+                                    "5256880",
+                                ],
+                            )
+
+        assert result.exit_code == 0, result.output
+        # The whole point: no API write was attempted
+        assert coord_sdk.json_post.gestionecoordinate.call_count == 0
+        # User must be informed why we did nothing
+        assert "skip" in result.output.lower() or "metodo" in result.output.lower()
+
+    def test_dry_run_skip_emits_json_output(
+        self, cli_runner: CliRunner, tmp_path: Path, mock_private_key: Path
+    ) -> None:
+        """``--json`` flag during a skip must produce a structured payload
+        with ``skipped: true`` and a machine-readable ``skip_reason``."""
+        import json as json_lib
+
+        from anncsu.cli import app
+
+        with cli_runner.isolated_filesystem(temp_dir=tmp_path):
+            Path("private_key.pem").write_text(mock_private_key.read_text())
+            with patch(
+                "anncsu.cli.commands.coordinate.ClientAssertionSettings"
+            ) as mock_settings:
+                mock_settings.return_value = MagicMock()
+                with patch(
+                    "anncsu.cli.commands.coordinate.PDNDAuthManager"
+                ) as mock_manager_cls:
+                    manager = MagicMock()
+                    manager.get_access_token.return_value = "tok"
+                    mock_manager_cls.return_value = manager
+                    with patch(
+                        "anncsu.cli.commands.coordinate.AnncsuConsultazione"
+                    ) as mock_consult_cls:
+                        consult_sdk = MagicMock()
+                        resp = MagicMock()
+                        d = MagicMock()
+                        d.prognazacc = "5256880"
+                        d.prognaz = "907156"
+                        d.dug = "VIA"
+                        d.denomuff = "ROMA"
+                        d.civico = "1"
+                        d.coord_x = "12.0"
+                        d.coord_y = "42.0"
+                        d.quota = None
+                        d.metodo = ""  # empty string also non-restorable
+                        resp.data = [d]
+                        consult_sdk.queryparam.prognazacc_get_query_param.return_value = resp
+                        mock_consult_cls.return_value = consult_sdk
+                        with patch(
+                            "anncsu.cli.commands.coordinate.AnncsuCoordinate"
+                        ) as mock_coord_cls:
+                            coord_sdk = MagicMock()
+                            mock_coord_cls.return_value = coord_sdk
+
+                            result = cli_runner.invoke(
+                                app,
+                                [
+                                    "coordinate",
+                                    "dry-run",
+                                    "--prognazacc",
+                                    "5256880",
+                                    "--json",
+                                ],
+                            )
+
+        assert result.exit_code == 0, result.output
+        assert coord_sdk.json_post.gestionecoordinate.call_count == 0
+        payload = json_lib.loads(result.output)
+        assert payload.get("skipped") is True
+        assert payload.get("skip_reason") == "original_metodo_null_or_invalid", payload
+
+    def test_dry_run_skips_when_original_metodo_out_of_range(
+        self, cli_runner: CliRunner, tmp_path: Path, mock_private_key: Path
+    ) -> None:
+        """metodo values outside {"1","2","3","4"} are non-restorable."""
+        from anncsu.cli import app
+
+        with cli_runner.isolated_filesystem(temp_dir=tmp_path):
+            Path("private_key.pem").write_text(mock_private_key.read_text())
+            with patch(
+                "anncsu.cli.commands.coordinate.ClientAssertionSettings"
+            ) as mock_settings:
+                mock_settings.return_value = MagicMock()
+                with patch(
+                    "anncsu.cli.commands.coordinate.PDNDAuthManager"
+                ) as mock_manager_cls:
+                    manager = MagicMock()
+                    manager.get_access_token.return_value = "tok"
+                    mock_manager_cls.return_value = manager
+                    with patch(
+                        "anncsu.cli.commands.coordinate.AnncsuConsultazione"
+                    ) as mock_consult_cls:
+                        consult_sdk = MagicMock()
+                        resp = MagicMock()
+                        d = MagicMock()
+                        d.prognazacc = "5256880"
+                        d.prognaz = "907156"
+                        d.dug = "VIA"
+                        d.denomuff = "ROMA"
+                        d.civico = "1"
+                        d.coord_x = "12.0"
+                        d.coord_y = "42.0"
+                        d.quota = None
+                        d.metodo = "5"
+                        resp.data = [d]
+                        consult_sdk.queryparam.prognazacc_get_query_param.return_value = resp
+                        mock_consult_cls.return_value = consult_sdk
+                        with patch(
+                            "anncsu.cli.commands.coordinate.AnncsuCoordinate"
+                        ) as mock_coord_cls:
+                            coord_sdk = MagicMock()
+                            mock_coord_cls.return_value = coord_sdk
+
+                            result = cli_runner.invoke(
+                                app,
+                                [
+                                    "coordinate",
+                                    "dry-run",
+                                    "--prognazacc",
+                                    "5256880",
+                                ],
+                            )
+
+        assert result.exit_code == 0, result.output
+        assert coord_sdk.json_post.gestionecoordinate.call_count == 0
 
     def test_dry_run_with_prognazacc_skips_search(
         self, cli_runner: CliRunner, tmp_path: Path, mock_private_key: Path