fastapi-cloud-cli 0.13.0__tar.gz → 0.14.0__tar.gz

{fastapi_cloud_cli-0.13.0 → fastapi_cloud_cli-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-cloud-cli
-Version: 0.13.0
+Version: 0.14.0
 Summary: Deploy and manage FastAPI Cloud apps from the command line 🚀
 Author-Email: Patrick Arminio <patrick@fastapilabs.com>
 License: MIT
@@ -33,7 +33,7 @@ Requires-Dist: typer>=0.16.0
 Requires-Dist: uvicorn[standard]>=0.17.6
 Requires-Dist: rignore>=0.5.1
 Requires-Dist: httpx>=0.27.0
-Requires-Dist: rich-toolkit>=0.19.4
+Requires-Dist: rich-toolkit>=0.19.7
 Requires-Dist: pydantic[email]>=2.7.4; python_version < "3.13"
 Requires-Dist: pydantic[email]>=2.8.0; python_version == "3.13"
 Requires-Dist: pydantic[email]>=2.12.0; python_version >= "3.14"

{fastapi_cloud_cli-0.13.0 → fastapi_cloud_cli-0.14.0}/pyproject.toml

@@ -33,14 +33,14 @@ dependencies = [
     "uvicorn[standard] >= 0.17.6",
     "rignore >= 0.5.1",
     "httpx >= 0.27.0",
-    "rich-toolkit >= 0.19.4",
+    "rich-toolkit >= 0.19.7",
     "pydantic[email] >= 2.7.4; python_version < '3.13'",
     "pydantic[email] >= 2.8.0; python_version == '3.13'",
     "pydantic[email] >= 2.12.0; python_version >= '3.14'",
     "sentry-sdk >= 2.20.0",
     "fastar >= 0.8.0",
 ]
-version = "0.13.0"
+version = "0.14.0"
 
 [project.license]
 text = "MIT"

fastapi_cloud_cli-0.14.0/src/fastapi_cloud_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.14.0"

{fastapi_cloud_cli-0.13.0 → fastapi_cloud_cli-0.14.0}/src/fastapi_cloud_cli/commands/deploy.py

@@ -4,7 +4,6 @@ import re
 import subprocess
 import tempfile
 import time
-from enum import Enum
 from itertools import cycle
 from pathlib import Path, PurePosixPath
 from textwrap import dedent
@@ -20,7 +19,13 @@ from rich_toolkit import RichToolkit
 from rich_toolkit.menu import Option
 
 from fastapi_cloud_cli.commands.login import login
-from fastapi_cloud_cli.utils.api import APIClient, StreamLogError, TooManyRetriesError
+from fastapi_cloud_cli.utils.api import (
+    SUCCESSFUL_STATUSES,
+    APIClient,
+    DeploymentStatus,
+    StreamLogError,
+    TooManyRetriesError,
+)
 from fastapi_cloud_cli.utils.apps import AppConfig, get_app_config, write_app_config
 from fastapi_cloud_cli.utils.auth import Identity
 from fastapi_cloud_cli.utils.cli import get_rich_toolkit, handle_http_errors
@@ -174,42 +179,6 @@ def _create_app(team_id: str, app_name: str, directory: str | None) -> AppRespon
         return AppResponse.model_validate(response.json())
 
 
-class DeploymentStatus(str, Enum):
-    waiting_upload = "waiting_upload"
-    ready_for_build = "ready_for_build"
-    building = "building"
-    extracting = "extracting"
-    extracting_failed = "extracting_failed"
-    building_image = "building_image"
-    building_image_failed = "building_image_failed"
-    deploying = "deploying"
-    deploying_failed = "deploying_failed"
-    verifying = "verifying"
-    verifying_failed = "verifying_failed"
-    verifying_skipped = "verifying_skipped"
-    success = "success"
-    failed = "failed"
-
-    @classmethod
-    def to_human_readable(cls, status: "DeploymentStatus") -> str:
-        return {
-            cls.waiting_upload: "Waiting for upload",
-            cls.ready_for_build: "Ready for build",
-            cls.building: "Building",
-            cls.extracting: "Extracting",
-            cls.extracting_failed: "Extracting failed",
-            cls.building_image: "Building image",
-            cls.building_image_failed: "Build failed",
-            cls.deploying: "Deploying",
-            cls.deploying_failed: "Deploying failed",
-            cls.verifying: "Verifying",
-            cls.verifying_failed: "Verifying failed",
-            cls.verifying_skipped: "Verification skipped",
-            cls.success: "Success",
-            cls.failed: "Failed",
-        }[status]
-
-
 class CreateDeploymentResponse(BaseModel):
     id: str
     app_id: str
@@ -440,6 +409,42 @@ def _configure_app(toolkit: RichToolkit, path_to_deploy: Path) -> AppConfig:
     return app_config
 
 
+def _verify_deployment(
+    toolkit: RichToolkit,
+    client: APIClient,
+    app_id: str,
+    deployment: CreateDeploymentResponse,
+) -> None:
+    with toolkit.progress(
+        title="Verifying deployment...",
+        inline_logs=True,
+        done_emoji="✅",
+    ) as progress:
+        try:
+            final_status = client.poll_deployment_status(app_id, deployment.id)
+        except (TimeoutError, TooManyRetriesError, StreamLogError):
+            progress.metadata["done_emoji"] = "⚠️"
+            progress.current_message = (
+                f"Could not confirm deployment status. "
+                f"Check the dashboard: [link={deployment.dashboard_url}]{deployment.dashboard_url}[/link]"
+            )
+            return
+
+        if final_status in SUCCESSFUL_STATUSES:
+            progress.current_message = f"Ready the chicken! 🐔 Your app is ready at [link={deployment.url}]{deployment.url}[/link]"
+        else:
+            progress.metadata["done_emoji"] = "❌"
+            progress.current_message = "Deployment failed"
+
+            human_status = DeploymentStatus.to_human_readable(final_status)
+
+            progress.log(
+                f"😔 Oh no! Deployment failed: {human_status}. "
+                f"Check out the logs at [link={deployment.dashboard_url}]{deployment.dashboard_url}[/link]"
+            )
+            raise typer.Exit(1)
+
+
 def _wait_for_deployment(
     toolkit: RichToolkit, app_id: str, deployment: CreateDeploymentResponse
 ) -> None:
@@ -451,11 +456,6 @@ def _wait_for_deployment(
     )
     toolkit.print_line()
 
-    toolkit.print(
-        f"You can also check the status at [link={deployment.dashboard_url}]{deployment.dashboard_url}[/link]",
-    )
-    toolkit.print_line()
-
     time_elapsed = 0.0
 
     started_at = time.monotonic()
@@ -464,10 +464,15 @@ def _wait_for_deployment(
 
     with (
         toolkit.progress(
-            next(messages), inline_logs=True, lines_to_show=20
+            next(messages),
+            inline_logs=True,
+            lines_to_show=20,
+            done_emoji="🚀",
         ) as progress,
         APIClient() as client,
     ):
+        build_complete = False
+
         try:
             for log in client.stream_build_logs(deployment.id):
                 time_elapsed = time.monotonic() - started_at
@@ -476,17 +481,8 @@ def _wait_for_deployment(
                     progress.log(Text.from_ansi(log.message.rstrip()))
 
                 if log.type == "complete":
-                    progress.log("")
-                    progress.log(
-                        f"You can also check the app logs at [link={deployment.dashboard_url}]{deployment.dashboard_url}[/link]"
-                    )
-
-                    progress.log("")
-
-                    progress.log(
-                        f"🐔 Ready the chicken! Your app is ready at [link={deployment.url}]{deployment.url}[/link]"
-                    )
-
+                    build_complete = True
+                    progress.title = "Build complete!"
                     break
 
                 if log.type == "failed":
@@ -515,6 +511,11 @@ def _wait_for_deployment(
 
             raise typer.Exit(1) from None
 
+        if build_complete:
+            toolkit.print_line()
+
+            _verify_deployment(toolkit, client, app_id, deployment)
+
 
 class SignupToWaitingList(BaseModel):
     email: EmailStr
@@ -753,7 +754,9 @@ def deploy(
             archive(path or Path.cwd(), archive_path)
 
             with (
-                toolkit.progress(title="Creating deployment") as progress,
+                toolkit.progress(
+                    title="Creating deployment", done_emoji="📦"
+                ) as progress,
                 handle_http_errors(progress),
             ):
                 logger.debug("Creating deployment for app: %s", app.id)

{fastapi_cloud_cli-0.13.0 → fastapi_cloud_cli-0.14.0}/src/fastapi_cloud_cli/utils/api.py

@@ -4,6 +4,7 @@ import time
 from collections.abc import Callable, Generator
 from contextlib import contextmanager
 from datetime import timedelta
+from enum import Enum
 from functools import wraps
 from typing import (
     Annotated,
@@ -138,6 +139,57 @@ def attempts(
     return decorator
 
 
+class DeploymentStatus(str, Enum):
+    waiting_upload = "waiting_upload"
+    ready_for_build = "ready_for_build"
+    building = "building"
+    extracting = "extracting"
+    extracting_failed = "extracting_failed"
+    building_image = "building_image"
+    building_image_failed = "building_image_failed"
+    deploying = "deploying"
+    deploying_failed = "deploying_failed"
+    verifying = "verifying"
+    verifying_failed = "verifying_failed"
+    verifying_skipped = "verifying_skipped"
+    success = "success"
+    failed = "failed"
+
+    @classmethod
+    def to_human_readable(cls, status: "DeploymentStatus") -> str:
+        return {
+            cls.waiting_upload: "Waiting for upload",
+            cls.ready_for_build: "Ready for build",
+            cls.building: "Building",
+            cls.extracting: "Extracting",
+            cls.extracting_failed: "Extracting failed",
+            cls.building_image: "Building image",
+            cls.building_image_failed: "Build failed",
+            cls.deploying: "Deploying",
+            cls.deploying_failed: "Deploying failed",
+            cls.verifying: "Verifying",
+            cls.verifying_failed: "Verifying failed",
+            cls.verifying_skipped: "Verification skipped",
+            cls.success: "Success",
+            cls.failed: "Failed",
+        }[status]
+
+
+SUCCESSFUL_STATUSES = {DeploymentStatus.success, DeploymentStatus.verifying_skipped}
+FAILED_STATUSES = {
+    DeploymentStatus.failed,
+    DeploymentStatus.verifying_failed,
+    DeploymentStatus.deploying_failed,
+    DeploymentStatus.building_image_failed,
+    DeploymentStatus.extracting_failed,
+}
+TERMINAL_STATUSES = SUCCESSFUL_STATUSES | FAILED_STATUSES
+
+POLL_INTERVAL = 2.0
+POLL_TIMEOUT = timedelta(seconds=120)
+POLL_MAX_RETRIES = 5
+
+
 class APIClient(httpx.Client):
     def __init__(self) -> None:
         settings = Settings.get()
@@ -241,3 +293,33 @@ class APIClient(httpx.Client):
                 except ValidationError as e:  # pragma: no cover
                     logger.debug("Failed to parse log entry: %s - %s", data, e)
                     continue
+
+    def poll_deployment_status(
+        self,
+        app_id: str,
+        deployment_id: str,
+    ) -> DeploymentStatus:
+        start = time.monotonic()
+        error_count = 0
+
+        while True:
+            if time.monotonic() - start > POLL_TIMEOUT.total_seconds():
+                raise TimeoutError("Deployment verification timed out")
+
+            with attempt(error_count):
+                response = self.get(f"/apps/{app_id}/deployments/{deployment_id}")
+                response.raise_for_status()
+                status = DeploymentStatus(response.json()["status"])
+                error_count = 0
+
+                if status in TERMINAL_STATUSES:
+                    return status
+
+                time.sleep(POLL_INTERVAL)
+                continue
+
+            error_count += 1
+            if error_count >= POLL_MAX_RETRIES:
+                raise TooManyRetriesError(
+                    f"Failed after {POLL_MAX_RETRIES} attempts polling deployment status"
+                )

{fastapi_cloud_cli-0.13.0 → fastapi_cloud_cli-0.14.0}/src/fastapi_cloud_cli/utils/cli.py

@@ -1,7 +1,7 @@
 import contextlib
 import logging
 from collections.abc import Generator
-from typing import Any
+from typing import Any, Literal
 
 import typer
 from httpx import HTTPError, HTTPStatusError, ReadTimeout
@@ -24,9 +24,12 @@ class FastAPIStyle(TaggedStyle):
         metadata: dict[str, Any],
         is_animated: bool = False,
         done: bool = False,
+        animation_status: Literal["started", "stopped", "error"] | None = None,
     ) -> tuple[list[Segment], int]:
         if not is_animated:
-            return super()._get_tag_segments(metadata, is_animated, done)
+            return super()._get_tag_segments(
+                metadata, is_animated, done, animation_status=animation_status
+            )
 
         emojis = [
             "🥚",
@@ -40,7 +43,10 @@ class FastAPIStyle(TaggedStyle):
         tag = emojis[self.animation_counter % len(emojis)]
 
         if done:
-            tag = emojis[-1]
+            tag = metadata.get("done_emoji", emojis[-1])
+
+        if animation_status == "error":
+            tag = "🟡"
 
         left_padding = self.tag_width - 1
         left_padding = max(0, left_padding)

{fastapi_cloud_cli-0.13.0 → fastapi_cloud_cli-0.14.0}/tests/test_api_client.py

@@ -11,6 +11,7 @@ from fastapi_cloud_cli.utils.api import (
     STREAM_LOGS_MAX_RETRIES,
     APIClient,
     BuildLogLineMessage,
+    DeploymentStatus,
     StreamLogError,
     TooManyRetriesError,
 )
@@ -351,3 +352,55 @@ def test_stream_build_logs_retry_timeout(
 
     with patch("time.sleep"), pytest.raises(TimeoutError, match="timed out"):
         list(client.stream_build_logs(deployment_id))
+
+
+@pytest.fixture
+def app_id() -> str:
+    return "test-app-456"
+
+
+@pytest.fixture
+def poll_route(
+    respx_mock: respx.MockRouter, app_id: str, deployment_id: str
+) -> respx.Route:
+    return respx_mock.get(f"/apps/{app_id}/deployments/{deployment_id}")
+
+
+def test_poll_deployment_status_recovers_from_transient_errors(
+    poll_route: respx.Route, client: APIClient, app_id: str, deployment_id: str
+) -> None:
+    call_count = 0
+
+    def handler(request: httpx.Request, route: respx.Route) -> Response:
+        nonlocal call_count
+        call_count += 1
+        if call_count <= 2:
+            return Response(500)
+        return Response(200, json={"status": "success"})
+
+    poll_route.mock(side_effect=handler)
+
+    with patch("time.sleep"):
+        status = client.poll_deployment_status(app_id, deployment_id)
+
+    assert status == DeploymentStatus.success
+    assert call_count == 3
+
+
+def test_poll_deployment_status_raises_after_max_consecutive_errors(
+    poll_route: respx.Route, client: APIClient, app_id: str, deployment_id: str
+) -> None:
+    poll_route.mock(return_value=Response(500))
+
+    with patch("time.sleep"), pytest.raises(TooManyRetriesError):
+        client.poll_deployment_status(app_id, deployment_id)
+
+
+def test_poll_deployment_status_timeout(
+    client: APIClient, app_id: str, deployment_id: str
+) -> None:
+    with (
+        patch("fastapi_cloud_cli.utils.api.POLL_TIMEOUT", timedelta(seconds=-1)),
+        pytest.raises(TimeoutError, match="timed out"),
+    ):
+        client.poll_deployment_status(app_id, deployment_id)

{fastapi_cloud_cli-0.13.0 → fastapi_cloud_cli-0.14.0}/tests/test_cli_deploy.py

@@ -2,7 +2,7 @@ import random
 import string
 from datetime import timedelta
 from pathlib import Path
-from typing import Optional, TypedDict
+from typing import TypedDict
 from unittest.mock import patch
 
 import httpx
@@ -37,14 +37,14 @@ class RandomApp(TypedDict):
     slug: str
     id: str
     team_id: str
-    directory: Optional[str]
+    directory: str | None
 
 
 def _get_random_app(
     *,
-    slug: Optional[str] = None,
-    team_id: Optional[str] = None,
-    directory: Optional[str] = None,
+    slug: str | None = None,
+    team_id: str | None = None,
+    directory: str | None = None,
 ) -> RandomApp:
     name = "".join(random.choices(string.ascii_lowercase, k=10))
     slug = slug or "".join(random.choices(string.ascii_lowercase, k=10))
@@ -62,7 +62,7 @@ def _get_random_app(
 
 def _get_random_deployment(
     *,
-    app_id: Optional[str] = None,
+    app_id: str | None = None,
     status: str = "waiting_upload",
 ) -> dict[str, str]:
     id = "".join(random.choices(string.digits, k=10))
@@ -666,6 +666,10 @@ def test_updates_app_directory_via_api_when_changed(
         )
     )
 
+    respx_mock.get(f"/apps/{app_data['id']}/deployments/{deployment_data['id']}").mock(
+        return_value=Response(200, json={**deployment_data, "status": "success"})
+    )
+
     with (
         changing_dir(tmp_path),
         patch("rich_toolkit.container.getchar") as mock_getchar,
@@ -733,6 +737,10 @@ def test_does_not_update_app_directory_when_unchanged(
         )
     )
 
+    respx_mock.get(f"/apps/{app_data['id']}/deployments/{deployment_data['id']}").mock(
+        return_value=Response(200, json={**deployment_data, "status": "success"})
+    )
+
     with (
         changing_dir(tmp_path),
         patch("rich_toolkit.container.getchar") as mock_getchar,
@@ -807,6 +815,10 @@ def test_exits_successfully_when_deployment_is_done(
         )
     )
 
+    respx_mock.get(f"/apps/{app_data['id']}/deployments/{deployment_data['id']}").mock(
+        return_value=Response(200, json={**deployment_data, "status": "success"})
+    )
+
     with (
         changing_dir(tmp_path),
         patch("rich_toolkit.container.getchar") as mock_getchar,
@@ -817,8 +829,6 @@ def test_exits_successfully_when_deployment_is_done(
 
         assert result.exit_code == 0
 
-        # TODO: show a message when the deployment is done (based on the status)
-
 
 @pytest.mark.respx
 def test_exits_successfully_when_deployment_is_done_when_app_is_configured(
@@ -867,6 +877,10 @@ def test_exits_successfully_when_deployment_is_done_when_app_is_configured(
         f"/deployments/{deployment_data['id']}/upload-complete",
     ).mock(return_value=Response(200))
 
+    respx_mock.get(f"/apps/{app_id}/deployments/{deployment_data['id']}").mock(
+        return_value=Response(200, json={**deployment_data, "status": "success"})
+    )
+
     with changing_dir(tmp_path):
         result = runner.invoke(app, ["deploy"])
 
@@ -875,10 +889,6 @@ def test_exits_successfully_when_deployment_is_done_when_app_is_configured(
         # check that logs are shown
         assert "All good!" in result.output
 
-        # check that the dashboard URL is shown
-        assert "You can also check the app logs at" in result.output
-        assert deployment_data["dashboard_url"] in result.output
-
         # check that the app URL is shown
         assert deployment_data["url"] in result.output
 
@@ -1311,10 +1321,15 @@ def test_short_wait_messages(
         side_effect=build_logs_handler
     )
 
+    respx_mock.get(f"/apps/{app_id}/deployments/{deployment_data['id']}").mock(
+        return_value=Response(200, json={**deployment_data, "status": "success"})
+    )
+
     with changing_dir(tmp_path), patch("time.sleep"):
         result = runner.invoke(app, ["deploy"])
 
-        assert "short wait message" in result.output
+        assert result.exit_code == 0
+        assert "Ready the chicken!" in result.output
 
 
 @pytest.mark.respx
@@ -1379,10 +1394,15 @@ def test_long_wait_messages(
         side_effect=build_logs_handler
     )
 
+    respx_mock.get(f"/apps/{app_id}/deployments/{deployment_data['id']}").mock(
+        return_value=Response(200, json={**deployment_data, "status": "success"})
+    )
+
     with changing_dir(tmp_path), patch("time.sleep"):
         result = runner.invoke(app, ["deploy"])
 
-        assert "long wait message" in result.output
+        assert result.exit_code == 0
+        assert "Ready the chicken!" in result.output
 
 
 @pytest.mark.respx
@@ -1512,6 +1532,11 @@ def test_deploy_successfully_with_token(
         headers={"Authorization": "Bearer hello"},
     ).mock(return_value=Response(200))
 
+    respx_mock.get(
+        f"/apps/{app_id}/deployments/{deployment_data['id']}",
+        headers={"Authorization": "Bearer hello"},
+    ).mock(return_value=Response(200, json={**deployment_data, "status": "success"}))
+
     with changing_dir(tmp_path):
         result = runner.invoke(app, ["deploy"], env={"FASTAPI_CLOUD_TOKEN": "hello"})
 
@@ -1520,10 +1545,6 @@ def test_deploy_successfully_with_token(
         # check that logs are shown
         assert "All good!" in result.output
 
-        # check that the dashboard URL is shown
-        assert "You can also check the app logs at" in result.output
-        assert deployment_data["dashboard_url"] in result.output
-
         # check that the app URL is shown
         assert deployment_data["url"] in result.output
 
@@ -1596,6 +1617,10 @@ def test_deploy_with_app_id_arg(
         )
     )
 
+    respx_mock.get(f"/apps/{app_id}/deployments/{deployment_data['id']}").mock(
+        return_value=Response(200, json={**deployment_data, "status": "success"})
+    )
+
     with changing_dir(tmp_path):
         result = runner.invoke(app, ["deploy", "--app-id", app_id])
 
@@ -1642,6 +1667,10 @@ def test_deploy_with_app_id_from_env_var(
         )
     )
 
+    respx_mock.get(f"/apps/{app_id}/deployments/{deployment_data['id']}").mock(
+        return_value=Response(200, json={**deployment_data, "status": "success"})
+    )
+
     with changing_dir(tmp_path):
         result = runner.invoke(app, ["deploy"], env={"FASTAPI_CLOUD_APP_ID": app_id})
 
@@ -1693,6 +1722,10 @@ def test_deploy_with_app_id_matching_local_config(
         )
     )
 
+    respx_mock.get(f"/apps/{app_id}/deployments/{deployment_data['id']}").mock(
+        return_value=Response(200, json={**deployment_data, "status": "success"})
+    )
+
     with changing_dir(tmp_path):
         result = runner.invoke(app, ["deploy", "--app-id", app_id])
 
@@ -1740,3 +1773,217 @@ def test_deploy_with_app_id_arg_app_not_found(
         assert "App not found" in result.output
         # Should NOT show unlink tip when using --app-id
         assert "unlink" not in result.output
+
+
+def _setup_deployment_mocks(
+    respx_mock: respx.MockRouter,
+    app_id: str,
+    team_id: str,
+    deployment_data: dict[str, str],
+    tmp_path: Path,
+) -> None:
+    """Set up common deployment mocks for a configured app."""
+    config_path = tmp_path / ".fastapicloud" / "cloud.json"
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    config_path.write_text(f'{{"app_id": "{app_id}", "team_id": "{team_id}"}}')
+
+    app_data = _get_random_app()
+    app_data["id"] = app_id
+
+    respx_mock.get(f"/apps/{app_id}").mock(return_value=Response(200, json=app_data))
+    respx_mock.post(f"/apps/{app_id}/deployments/").mock(
+        return_value=Response(201, json=deployment_data)
+    )
+    respx_mock.post(f"/deployments/{deployment_data['id']}/upload").mock(
+        return_value=Response(
+            200, json={"url": "http://test.com", "fields": {"key": "value"}}
+        )
+    )
+    respx_mock.post("http://test.com", data={"key": "value"}).mock(
+        return_value=Response(200)
+    )
+    respx_mock.post(f"/deployments/{deployment_data['id']}/upload-complete").mock(
+        return_value=Response(200)
+    )
+    respx_mock.get(f"/deployments/{deployment_data['id']}/build-logs").mock(
+        return_value=Response(
+            200,
+            content=build_logs_response(
+                {"type": "message", "message": "Building...", "id": "1"},
+                {"type": "complete"},
+            ),
+        )
+    )
+
+
+@pytest.mark.respx
+def test_verification_failure_after_build_complete(
+    logged_in_cli: None, tmp_path: Path, respx_mock: respx.MockRouter
+) -> None:
+    app_data = _get_random_app()
+    app_id = app_data["id"]
+    team_id = "some-team-id"
+    deployment_data = _get_random_deployment(app_id=app_id)
+
+    _setup_deployment_mocks(respx_mock, app_id, team_id, deployment_data, tmp_path)
+
+    respx_mock.get(f"/apps/{app_id}/deployments/{deployment_data['id']}").mock(
+        return_value=Response(
+            200, json={**deployment_data, "status": "verifying_failed"}
+        )
+    )
+
+    with changing_dir(tmp_path):
+        result = runner.invoke(app, ["deploy"])
+
+        assert result.exit_code == 1
+        assert "Deployment failed" in result.output
+        assert "Verifying failed" in result.output
+        assert deployment_data["dashboard_url"] in result.output
+
+
+@pytest.mark.respx
+def test_polling_with_intermediate_states(
+    logged_in_cli: None, tmp_path: Path, respx_mock: respx.MockRouter
+) -> None:
+    app_data = _get_random_app()
+    app_id = app_data["id"]
+    team_id = "some-team-id"
+    deployment_data = _get_random_deployment(app_id=app_id)
+
+    _setup_deployment_mocks(respx_mock, app_id, team_id, deployment_data, tmp_path)
+
+    call_count = 0
+
+    def poll_handler(request: httpx.Request, route: respx.Route) -> Response:
+        nonlocal call_count
+        call_count += 1
+        if call_count <= 2:
+            return Response(200, json={**deployment_data, "status": "verifying"})
+        return Response(200, json={**deployment_data, "status": "success"})
+
+    respx_mock.get(f"/apps/{app_id}/deployments/{deployment_data['id']}").mock(
+        side_effect=poll_handler
+    )
+
+    with changing_dir(tmp_path), patch("time.sleep"):
+        result = runner.invoke(app, ["deploy"])
+
+        assert result.exit_code == 0
+        assert deployment_data["url"] in result.output
+
+
+@pytest.mark.respx
+def test_polling_timeout_shows_dashboard_link(
+    logged_in_cli: None, tmp_path: Path, respx_mock: respx.MockRouter
+) -> None:
+    app_data = _get_random_app()
+    app_id = app_data["id"]
+    team_id = "some-team-id"
+    deployment_data = _get_random_deployment(app_id=app_id)
+
+    _setup_deployment_mocks(respx_mock, app_id, team_id, deployment_data, tmp_path)
+
+    with (
+        changing_dir(tmp_path),
+        patch(
+            "fastapi_cloud_cli.utils.api.APIClient.poll_deployment_status",
+            side_effect=TimeoutError("Deployment verification timed out"),
+        ),
+    ):
+        result = runner.invoke(app, ["deploy"])
+
+        assert result.exit_code == 0
+        assert "Could not confirm deployment status" in result.output
+        assert deployment_data["dashboard_url"] in result.output
+
+
+@pytest.mark.respx
+def test_verifying_skipped_treated_as_success(
+    logged_in_cli: None, tmp_path: Path, respx_mock: respx.MockRouter
+) -> None:
+    app_data = _get_random_app()
+    app_id = app_data["id"]
+    team_id = "some-team-id"
+    deployment_data = _get_random_deployment(app_id=app_id)
+
+    _setup_deployment_mocks(respx_mock, app_id, team_id, deployment_data, tmp_path)
+
+    respx_mock.get(f"/apps/{app_id}/deployments/{deployment_data['id']}").mock(
+        return_value=Response(
+            200, json={**deployment_data, "status": "verifying_skipped"}
+        )
+    )
+
+    with changing_dir(tmp_path):
+        result = runner.invoke(app, ["deploy"])
+
+        assert result.exit_code == 0
+        assert deployment_data["url"] in result.output
+
+
+@pytest.mark.respx
+def test_ctrl_c_during_verification_shows_cancelled(
+    logged_in_cli: None, tmp_path: Path, respx_mock: respx.MockRouter
+) -> None:
+    app_data = _get_random_app()
+    app_id = app_data["id"]
+    team_id = "some-team-id"
+    deployment_data = _get_random_deployment(app_id=app_id)
+
+    _setup_deployment_mocks(respx_mock, app_id, team_id, deployment_data, tmp_path)
+
+    with (
+        changing_dir(tmp_path),
+        patch(
+            "fastapi_cloud_cli.utils.api.APIClient.poll_deployment_status",
+            side_effect=KeyboardInterrupt(),
+        ),
+    ):
+        result = runner.invoke(app, ["deploy"])
+
+        assert "🟡" in result.output
+        assert "Cancelled" in result.output
+        assert "✅" not in result.output
+
+
+@pytest.mark.respx
+def test_ctrl_c_during_build_streaming_shows_cancelled(
+    logged_in_cli: None, tmp_path: Path, respx_mock: respx.MockRouter
+) -> None:
+    app_data = _get_random_app()
+    app_id = app_data["id"]
+    team_id = "some-team-id"
+    deployment_data = _get_random_deployment(app_id=app_id)
+
+    config_path = tmp_path / ".fastapicloud" / "cloud.json"
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    config_path.write_text(f'{{"app_id": "{app_id}", "team_id": "{team_id}"}}')
+
+    respx_mock.get(f"/apps/{app_id}").mock(return_value=Response(200, json=app_data))
+    respx_mock.post(f"/apps/{app_id}/deployments/").mock(
+        return_value=Response(201, json=deployment_data)
+    )
+    respx_mock.post(f"/deployments/{deployment_data['id']}/upload").mock(
+        return_value=Response(
+            200, json={"url": "http://test.com", "fields": {"key": "value"}}
+        )
+    )
+    respx_mock.post("http://test.com", data={"key": "value"}).mock(
+        return_value=Response(200)
+    )
+    respx_mock.post(f"/deployments/{deployment_data['id']}/upload-complete").mock(
+        return_value=Response(200)
+    )
+
+    with (
+        changing_dir(tmp_path),
+        patch(
+            "fastapi_cloud_cli.utils.api.APIClient.stream_build_logs",
+            side_effect=KeyboardInterrupt(),
+        ),
+    ):
+        result = runner.invoke(app, ["deploy"])
+
+        assert "🟡" in result.output
+        assert "Cancelled." in result.output

{fastapi_cloud_cli-0.13.0 → fastapi_cloud_cli-0.14.0}/tests/test_deploy_utils.py

@@ -1,13 +1,12 @@
 from pathlib import Path
-from typing import Optional
 
 import pytest
 
 from fastapi_cloud_cli.commands.deploy import (
-    DeploymentStatus,
     _should_exclude_entry,
     validate_app_directory,
 )
+from fastapi_cloud_cli.utils.api import DeploymentStatus
 
 
 @pytest.mark.parametrize(
@@ -98,9 +97,7 @@ def test_deployment_status_to_human_readable(
         ("a/b/c", "a/b/c"),
     ],
 )
-def test_validate_app_directory_valid(
-    value: Optional[str], expected: Optional[str]
-) -> None:
+def test_validate_app_directory_valid(value: str | None, expected: str | None) -> None:
     """Should accept valid directory values and normalize them."""
     assert validate_app_directory(value) == expected
 

{fastapi_cloud_cli-0.13.0 → fastapi_cloud_cli-0.14.0}/tests/utils.py

@@ -1,14 +1,15 @@
 import base64
 import json
 import os
+import sys
 from collections.abc import Generator
 from contextlib import contextmanager
 from pathlib import Path
-from typing import Any, Union
+from typing import Any
 
 
 @contextmanager
-def changing_dir(directory: Union[str, Path]) -> Generator[None, None, None]:
+def changing_dir(directory: str | Path) -> Generator[None, None, None]:
     initial_dir = os.getcwd()
     os.chdir(directory)
     try:
@@ -22,13 +23,25 @@ def build_logs_response(*logs: dict[str, Any]) -> str:
     return "\n".join(json.dumps(log) for log in logs)
 
 
-class Keys:
-    RIGHT_ARROW = "\x1b[C"
-    DOWN_ARROW = "\x1b[B"
-    ENTER = "\r"
-    CTRL_C = "\x03"
-    TAB = "\t"
-    BACKSPACE = "\x7f"
+if sys.platform == "win32":
+
+    class Keys:
+        RIGHT_ARROW = "\xe0M"
+        DOWN_ARROW = "\xe0P"
+        ENTER = "\r"
+        CTRL_C = "\x03"
+        TAB = "\t"
+        BACKSPACE = "\x08"
+
+else:
+
+    class Keys:
+        RIGHT_ARROW = "\x1b[C"
+        DOWN_ARROW = "\x1b[B"
+        ENTER = "\r"
+        CTRL_C = "\x03"
+        TAB = "\t"
+        BACKSPACE = "\x7f"
 
 
 def create_jwt_token(payload: dict[str, Any]) -> str:

fastapi_cloud_cli-0.13.0/src/fastapi_cloud_cli/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.13.0"