fastapi-cloud-cli 0.1.1__tar.gz → 0.1.2__tar.gz

{fastapi_cloud_cli-0.1.1 → fastapi_cloud_cli-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-cloud-cli
-Version: 0.1.1
+Version: 0.1.2
 Summary: Deploy and manage FastAPI Cloud apps from the command line 🚀
 Author-Email: Patrick Arminio <patrick@fastapilabs.com>
 License: MIT
@@ -35,7 +35,7 @@ Requires-Python: >=3.8
 Requires-Dist: typer>=0.12.3
 Requires-Dist: uvicorn[standard]>=0.15.0
 Requires-Dist: rignore>=0.5.1
-Requires-Dist: httpx<0.28.0,>=0.27.0
+Requires-Dist: httpx>=0.27.0
 Requires-Dist: rich-toolkit>=0.14.5
 Requires-Dist: pydantic[email]>=1.6.1
 Requires-Dist: sentry-sdk>=2.20.0

{fastapi_cloud_cli-0.1.1 → fastapi_cloud_cli-0.1.2}/pyproject.toml

@@ -35,12 +35,12 @@ dependencies = [
     "typer >= 0.12.3",
     "uvicorn[standard] >= 0.15.0",
     "rignore >= 0.5.1",
-    "httpx >= 0.27.0,< 0.28.0",
+    "httpx >= 0.27.0",
     "rich-toolkit >= 0.14.5",
     "pydantic[email] >= 1.6.1",
     "sentry-sdk >= 2.20.0",
 ]
-version = "0.1.1"
+version = "0.1.2"
 
 [project.license]
 text = "MIT"

fastapi_cloud_cli-0.1.2/src/fastapi_cloud_cli/__init__.py

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

{fastapi_cloud_cli-0.1.1 → fastapi_cloud_cli-0.1.2}/src/fastapi_cloud_cli/commands/deploy.py

@@ -375,12 +375,12 @@ def _wait_for_deployment(
                 raise typer.Exit(1)
 
             if time_elapsed > 30:
-                messages = cycle(LONG_WAIT_MESSAGES)
+                messages = cycle(LONG_WAIT_MESSAGES)  # pragma: no cover
 
             if (time.monotonic() - last_message_changed_at) > 2:
-                progress.title = next(messages)
+                progress.title = next(messages)  # pragma: no cover
 
-                last_message_changed_at = time.monotonic()
+                last_message_changed_at = time.monotonic()  # pragma: no cover
 
 
 def _setup_environment_variables(toolkit: RichToolkit, app_id: str) -> None:

{fastapi_cloud_cli-0.1.1 → fastapi_cloud_cli-0.1.2}/src/fastapi_cloud_cli/commands/env.py

@@ -161,11 +161,9 @@ def delete(
                     {"name": env_var.name, "value": env_var.name}
                     for env_var in environment_variables.data
                 ],
-                default=None,
             )
 
-            if not name:
-                return
+            assert name
         else:
             if not validate_environment_variable_name(name):
                 toolkit.print(

{fastapi_cloud_cli-0.1.1 → fastapi_cloud_cli-0.1.2}/src/fastapi_cloud_cli/commands/whoami.py

@@ -17,11 +17,11 @@ def whoami() -> Any:
         return
 
     with APIClient() as client:
-        with Progress(title="⚡Fetching profile", transient=True) as progress:
+        with Progress(title="⚡ Fetching profile", transient=True) as progress:
             with handle_http_errors(progress, message=""):
                 response = client.get("/users/me")
                 response.raise_for_status()
 
         data = response.json()
 
-        print(f"⚡[bold]{data['email']}[/bold]")
+        print(f"⚡ [bold]{data['email']}[/bold]")

{fastapi_cloud_cli-0.1.1 → fastapi_cloud_cli-0.1.2}/src/fastapi_cloud_cli/utils/cli.py

@@ -85,7 +85,7 @@ def handle_http_errors(
 
         # Handle validation errors from Pydantic models, this should make it easier to debug :)
         if isinstance(e, HTTPStatusError) and e.response.status_code == 422:
-            logger.debug(e.response.json())
+            logger.debug(e.response.json())  # pragma: no cover
 
         if isinstance(e, HTTPStatusError) and e.response.status_code in (401, 403):
             message = "The specified token is not valid. Use `fastapi login` to generate a new token."

{fastapi_cloud_cli-0.1.1 → fastapi_cloud_cli-0.1.2}/tests/conftest.py

@@ -25,15 +25,17 @@ def setup_terminal() -> None:
 
 
 @pytest.fixture
-def logged_in_cli() -> Generator[None, None, None]:
-    with patch("fastapi_cloud_cli.utils.auth.get_auth_token", return_value=True):
-        yield
+def logged_in_cli(temp_auth_config: Path) -> Generator[None, None, None]:
+    temp_auth_config.write_text('{"access_token": "test_token_12345"}')
+
+    yield
 
 
 @pytest.fixture
-def logged_out_cli() -> Generator[None, None, None]:
-    with patch("fastapi_cloud_cli.utils.auth.get_auth_token", return_value=None):
-        yield
+def logged_out_cli(temp_auth_config: Path) -> Generator[None, None, None]:
+    assert not temp_auth_config.exists()
+
+    yield
 
 
 @dataclass
@@ -54,3 +56,13 @@ def configured_app(tmp_path: Path) -> ConfiguredApp:
     config_path.write_text(f'{{"app_id": "{app_id}", "team_id": "{team_id}"}}')
 
     return ConfiguredApp(app_id=app_id, team_id=team_id, path=tmp_path)
+
+
+@pytest.fixture
+def temp_auth_config(tmp_path: Path) -> Generator[Path, None, None]:
+    """Provides a temporary auth config setup for testing file operations."""
+
+    with patch(
+        "fastapi_cloud_cli.utils.config.get_config_folder", return_value=tmp_path
+    ):
+        yield tmp_path / "auth.json"

fastapi_cloud_cli-0.1.2/tests/test_cli.py

@@ -0,0 +1,11 @@
+import subprocess
+import sys
+
+
+def test_script() -> None:
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", "-m", "fastapi_cloud_cli", "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

{fastapi_cloud_cli-0.1.1 → fastapi_cloud_cli-0.1.2}/tests/test_cli_deploy.py

@@ -652,3 +652,149 @@ def test_does_not_duplicate_entry_in_git_ignore(
     _deploy_without_waiting(respx_mock, tmp_path)
 
     assert git_ignore_path.read_text() == ".fastapicloud\n"
+
+
+@pytest.mark.respx(base_url=settings.base_api_url)
+def test_creates_environment_variables_during_app_setup(
+    logged_in_cli: None, tmp_path: Path, respx_mock: respx.MockRouter
+) -> None:
+    steps = [
+        Keys.ENTER,  # Setup and deploy
+        Keys.ENTER,  # Select team
+        Keys.ENTER,  # Create new app
+        *"demo",  # App name
+        Keys.ENTER,
+        Keys.ENTER,  # Setup environment variables (Yes)
+        *"API_KEY",  # Environment variable name
+        Keys.ENTER,
+        *"secret123",  # Environment variable value
+        Keys.ENTER,
+        Keys.ENTER,  # Empty key to finish
+        Keys.CTRL_C,  # Exit before deployment
+    ]
+
+    team = _get_random_team()
+    app_data = _get_random_app(team_id=team["id"])
+
+    respx_mock.get("/teams/").mock(return_value=Response(200, json={"data": [team]}))
+
+    respx_mock.post("/apps/", json={"name": "demo", "team_id": team["id"]}).mock(
+        return_value=Response(201, json=app_data)
+    )
+
+    env_vars_request = respx_mock.patch(
+        f"/apps/{app_data['id']}/environment-variables/", json={"API_KEY": "secret123"}
+    ).mock(return_value=Response(200))
+
+    with changing_dir(tmp_path), patch("click.getchar") as mock_getchar:
+        mock_getchar.side_effect = steps
+
+        result = runner.invoke(app, ["deploy"])
+
+        assert result.exit_code == 1
+        assert env_vars_request.called
+        assert "Environment variables set up successfully!" in result.output
+
+
+@pytest.mark.respx(base_url=settings.base_api_url)
+def test_rejects_invalid_environment_variable_names(
+    logged_in_cli: None, tmp_path: Path, respx_mock: respx.MockRouter
+) -> None:
+    steps = [
+        Keys.ENTER,  # Setup and deploy
+        Keys.ENTER,  # Select team
+        Keys.ENTER,  # Create new app
+        *"demo",  # App name
+        Keys.ENTER,
+        Keys.ENTER,  # Setup environment variables (Yes)
+        *"123-invalid",  # Invalid environment variable name (starts with digit, contains hyphen)
+        Keys.ENTER,
+        *"VALID_KEY",  # Valid environment variable name
+        Keys.ENTER,
+        *"value123",  # Environment variable value
+        Keys.ENTER,
+        Keys.ENTER,  # Empty key to finish
+        Keys.CTRL_C,  # Exit before deployment
+    ]
+
+    team = _get_random_team()
+    app_data = _get_random_app(team_id=team["id"])
+
+    respx_mock.get("/teams/").mock(return_value=Response(200, json={"data": [team]}))
+
+    respx_mock.post("/apps/", json={"name": "demo", "team_id": team["id"]}).mock(
+        return_value=Response(201, json=app_data)
+    )
+
+    env_vars_request = respx_mock.patch(
+        f"/apps/{app_data['id']}/environment-variables/", json={"VALID_KEY": "value123"}
+    ).mock(return_value=Response(200))
+
+    with changing_dir(tmp_path), patch("click.getchar") as mock_getchar:
+        mock_getchar.side_effect = steps
+
+        result = runner.invoke(app, ["deploy"])
+
+        assert result.exit_code == 1
+        assert env_vars_request.called
+        assert "Invalid environment variable name." in result.output
+        assert "Environment variables set up successfully!" in result.output
+
+
+@pytest.mark.respx(base_url=settings.base_api_url)
+def test_shows_error_for_invalid_waitlist_form_data(
+    logged_out_cli: None, tmp_path: Path, respx_mock: respx.MockRouter
+) -> None:
+    steps = [
+        *"test@example.com",
+        Keys.ENTER,
+        Keys.ENTER,  # Choose to provide more information
+        Keys.CTRL_C,  # Interrupt to avoid infinite loop
+    ]
+
+    with changing_dir(tmp_path), patch(
+        "rich_toolkit.menu.click.getchar"
+    ) as mock_getchar, patch("rich_toolkit.form.Form.run") as mock_form_run:
+        mock_getchar.side_effect = steps
+        # Simulate form returning data with invalid email field to trigger ValidationError
+        mock_form_run.return_value = {
+            "email": "invalid-email-format",
+            "name": "John Doe",
+        }
+
+        result = runner.invoke(app, ["deploy"])
+
+        assert result.exit_code == 1
+        assert "Invalid form data. Please try again." in result.output
+
+
+@pytest.mark.respx(base_url=settings.base_api_url)
+def test_shows_no_apps_found_message_when_team_has_no_apps(
+    logged_in_cli: None, tmp_path: Path, respx_mock: respx.MockRouter
+) -> None:
+    steps = [
+        Keys.ENTER,  # Setup and deploy
+        Keys.ENTER,  # Select team
+        Keys.RIGHT_ARROW,  # Choose existing app (No)
+        Keys.ENTER,
+    ]
+
+    team = _get_random_team()
+
+    respx_mock.get("/teams/").mock(return_value=Response(200, json={"data": [team]}))
+
+    # Mock empty apps list for the team
+    respx_mock.get("/apps/", params={"team_id": team["id"]}).mock(
+        return_value=Response(200, json={"data": []})
+    )
+
+    with changing_dir(tmp_path), patch("click.getchar") as mock_getchar:
+        mock_getchar.side_effect = steps
+
+        result = runner.invoke(app, ["deploy"])
+
+        assert result.exit_code == 1
+        assert (
+            "No apps found in this team. You can create a new app instead."
+            in result.output
+        )

fastapi_cloud_cli-0.1.2/tests/test_cli_login.py

@@ -0,0 +1,163 @@
+from pathlib import Path
+from unittest.mock import patch
+
+import httpx
+import pytest
+import respx
+from httpx import Response
+from typer.testing import CliRunner
+
+from fastapi_cloud_cli.cli import app
+from fastapi_cloud_cli.config import settings
+
+runner = CliRunner()
+
+assets_path = Path(__file__).parent / "assets"
+
+
+@pytest.mark.respx(base_url=settings.base_api_url)
+def test_shows_a_message_if_something_is_wrong(respx_mock: respx.MockRouter) -> None:
+    with patch("fastapi_cloud_cli.commands.login.typer.launch") as mock_open:
+        respx_mock.post(
+            "/login/device/authorization", data={"client_id": settings.client_id}
+        ).mock(return_value=Response(500))
+
+        result = runner.invoke(app, ["login"])
+
+        assert result.exit_code == 1
+        assert (
+            "Something went wrong while contacting the FastAPI Cloud server."
+            in result.output
+        )
+
+        assert not mock_open.called
+
+
+@pytest.mark.respx(base_url=settings.base_api_url)
+def test_full_login(respx_mock: respx.MockRouter, temp_auth_config: Path) -> None:
+    with patch("fastapi_cloud_cli.commands.login.typer.launch") as mock_open:
+        respx_mock.post(
+            "/login/device/authorization", data={"client_id": settings.client_id}
+        ).mock(
+            return_value=Response(
+                200,
+                json={
+                    "verification_uri_complete": "http://test.com",
+                    "verification_uri": "http://test.com",
+                    "user_code": "1234",
+                    "device_code": "5678",
+                },
+            )
+        )
+        respx_mock.post(
+            "/login/device/token",
+            data={
+                "device_code": "5678",
+                "client_id": settings.client_id,
+                "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+            },
+        ).mock(return_value=Response(200, json={"access_token": "test_token_1234"}))
+
+        # Verify no auth file exists before login
+        assert not temp_auth_config.exists()
+
+        result = runner.invoke(app, ["login"])
+
+        assert result.exit_code == 0
+        assert mock_open.called
+        assert mock_open.call_args.args == ("http://test.com",)
+        assert "Now you are logged in!" in result.output
+
+        # Verify auth file was created with correct content
+        assert temp_auth_config.exists()
+        assert '"access_token":"test_token_1234"' in temp_auth_config.read_text()
+
+
+@pytest.mark.respx(base_url=settings.base_api_url)
+def test_fetch_access_token_success_immediately(respx_mock: respx.MockRouter) -> None:
+    from fastapi_cloud_cli.commands.login import _fetch_access_token
+    from fastapi_cloud_cli.utils.api import APIClient
+
+    respx_mock.post(
+        "/login/device/token",
+        data={
+            "device_code": "test_device_code",
+            "client_id": settings.client_id,
+            "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+        },
+    ).mock(return_value=Response(200, json={"access_token": "test_token_success"}))
+
+    with APIClient() as client:
+        access_token = _fetch_access_token(client, "test_device_code", 5)
+
+    assert access_token == "test_token_success"
+
+
+@pytest.mark.respx(base_url=settings.base_api_url)
+def test_fetch_access_token_authorization_pending_then_success(
+    respx_mock: respx.MockRouter,
+) -> None:
+    from fastapi_cloud_cli.commands.login import _fetch_access_token
+    from fastapi_cloud_cli.utils.api import APIClient
+
+    # First call returns authorization pending, second call succeeds
+    respx_mock.post(
+        "/login/device/token",
+        data={
+            "device_code": "test_device_code",
+            "client_id": settings.client_id,
+            "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+        },
+    ).mock(
+        side_effect=[
+            Response(400, json={"error": "authorization_pending"}),
+            Response(200, json={"access_token": "test_token_after_pending"}),
+        ]
+    )
+
+    with patch("fastapi_cloud_cli.commands.login.time.sleep") as mock_sleep:
+        with APIClient() as client:
+            access_token = _fetch_access_token(client, "test_device_code", 3)
+
+        assert access_token == "test_token_after_pending"
+        mock_sleep.assert_called_once_with(3)
+
+
+@pytest.mark.respx(base_url=settings.base_api_url)
+def test_fetch_access_token_handles_400_error_not_authorization_pending(
+    respx_mock: respx.MockRouter,
+) -> None:
+    from fastapi_cloud_cli.commands.login import _fetch_access_token
+    from fastapi_cloud_cli.utils.api import APIClient
+
+    respx_mock.post(
+        "/login/device/token",
+        data={
+            "device_code": "test_device_code",
+            "client_id": settings.client_id,
+            "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+        },
+    ).mock(return_value=Response(400, json={"error": "access_denied"}))
+
+    with APIClient() as client:
+        with pytest.raises(httpx.HTTPStatusError):
+            _fetch_access_token(client, "test_device_code", 5)
+
+
+@pytest.mark.respx(base_url=settings.base_api_url)
+def test_fetch_access_token_handles_500_error(respx_mock: respx.MockRouter) -> None:
+    from fastapi_cloud_cli.commands.login import _fetch_access_token
+    from fastapi_cloud_cli.utils.api import APIClient
+
+    respx_mock.post(
+        "/login/device/token",
+        data={
+            "device_code": "test_device_code",
+            "client_id": settings.client_id,
+            "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+        },
+    ).mock(return_value=Response(500))
+
+    with APIClient() as client:
+        with pytest.raises(httpx.HTTPStatusError):
+            _fetch_access_token(client, "test_device_code", 5)

fastapi_cloud_cli-0.1.2/tests/test_cli_logout.py

@@ -0,0 +1,31 @@
+from pathlib import Path
+
+from typer.testing import CliRunner
+
+from fastapi_cloud_cli.cli import app
+
+runner = CliRunner()
+
+
+def test_logout_with_existing_auth_file(temp_auth_config: Path) -> None:
+    temp_auth_config.write_text('{"access_token": "test_token"}')
+
+    assert temp_auth_config.exists()
+
+    result = runner.invoke(app, ["logout"])
+
+    assert result.exit_code == 0
+    assert "You are now logged out! 🚀" in result.output
+
+    assert not temp_auth_config.exists()
+
+
+def test_logout_with_no_auth_file(temp_auth_config: Path) -> None:
+    assert not temp_auth_config.exists()
+
+    result = runner.invoke(app, ["logout"])
+
+    assert result.exit_code == 0
+    assert "You are now logged out! 🚀" in result.output
+
+    assert not temp_auth_config.exists()

{fastapi_cloud_cli-0.1.1 → fastapi_cloud_cli-0.1.2}/tests/test_cli_whoami.py

@@ -14,20 +14,24 @@ assets_path = Path(__file__).parent / "assets"
 
 
 @pytest.mark.respx(base_url=settings.base_api_url)
-def test_shows_a_message_if_something_is_wrong(respx_mock: respx.MockRouter) -> None:
+def test_shows_a_message_if_something_is_wrong(
+    logged_in_cli: None, respx_mock: respx.MockRouter
+) -> None:
     respx_mock.get("/users/me").mock(return_value=Response(500))
 
     result = runner.invoke(app, ["whoami"])
 
-    assert result.exit_code == 1
     assert (
         "Something went wrong while contacting the FastAPI Cloud server."
         in result.output
     )
+    assert result.exit_code == 1
 
 
 @pytest.mark.respx(base_url=settings.base_api_url)
-def test_shows_a_message_when_not_logged_in(respx_mock: respx.MockRouter) -> None:
+def test_shows_a_message_when_token_is_invalid(
+    logged_in_cli: None, respx_mock: respx.MockRouter
+) -> None:
     respx_mock.get("/users/me").mock(return_value=Response(401))
 
     result = runner.invoke(app, ["whoami"])
@@ -37,7 +41,7 @@ def test_shows_a_message_when_not_logged_in(respx_mock: respx.MockRouter) -> Non
 
 
 @pytest.mark.respx(base_url=settings.base_api_url)
-def test_shows_email(respx_mock: respx.MockRouter) -> None:
+def test_shows_email(logged_in_cli: None, respx_mock: respx.MockRouter) -> None:
     respx_mock.get("/users/me").mock(
         return_value=Response(200, json={"email": "email@fastapi.com"})
     )
@@ -49,10 +53,19 @@ def test_shows_email(respx_mock: respx.MockRouter) -> None:
 
 
 @pytest.mark.respx(base_url=settings.base_api_url)
-def test_handles_read_timeout(respx_mock: respx.MockRouter) -> None:
+def test_handles_read_timeout(
+    logged_in_cli: None, respx_mock: respx.MockRouter
+) -> None:
     respx_mock.get("/users/me").mock(side_effect=ReadTimeout)
 
     result = runner.invoke(app, ["whoami"])
 
     assert result.exit_code == 1
     assert "The request to the FastAPI Cloud server timed out" in result.output
+
+
+def test_prints_not_logged_in(logged_out_cli: None) -> None:
+    result = runner.invoke(app, ["whoami"])
+
+    assert result.exit_code == 0
+    assert "No credentials found. Use `fastapi login` to login." in result.output

fastapi_cloud_cli-0.1.2/tests/test_deploy_utils.py

@@ -0,0 +1,64 @@
+from pathlib import Path
+
+import pytest
+
+from fastapi_cloud_cli.commands.deploy import DeploymentStatus, _should_exclude_entry
+
+
+@pytest.mark.parametrize(
+    "path",
+    [
+        Path("/project/.venv/lib/python3.11/site-packages/some_package"),
+        Path("/project/src/__pycache__/module.cpython-311.pyc"),
+        Path("/project/.mypy_cache/3.11/module.meta.json"),
+        Path("/project/.pytest_cache/v/cache/lastfailed"),
+        Path("/project/src/module.pyc"),
+        Path("/project/src/subdir/another/module.pyc"),
+        Path("/project/subproject/.venv/lib/python3.11/site-packages"),
+        Path("/project/.venv/lib/__pycache__/module.pyc"),
+        Path(".venv"),
+        Path("__pycache__"),
+        Path("module.pyc"),
+    ],
+)
+def test_excludes_paths(path: Path) -> None:
+    """Should exclude paths that match exclusion criteria."""
+    assert _should_exclude_entry(path) is True
+
+
+@pytest.mark.parametrize(
+    "path",
+    [
+        Path("/project/src/module.py"),
+        Path("/project/src/utils"),
+        Path("/project/src/my_cache_utils.py"),
+        Path("/project/venv/lib/python3.11/site-packages"),  # no leading dot
+        Path("/project/pycache/some_file.py"),  # no underscores
+        Path("/project/src/module.pyx"),  # similar to .pyc but different
+        Path("/project/config.json"),
+        Path("/project/README.md"),
+    ],
+)
+def test_includes_paths(path: Path) -> None:
+    """Should not exclude paths that don't match exclusion criteria."""
+    assert _should_exclude_entry(path) is False
+
+
+@pytest.mark.parametrize(
+    "status,expected",
+    [
+        (DeploymentStatus.waiting_upload, "Waiting for upload"),
+        (DeploymentStatus.ready_for_build, "Ready for build"),
+        (DeploymentStatus.building, "Building"),
+        (DeploymentStatus.extracting, "Extracting"),
+        (DeploymentStatus.building_image, "Building image"),
+        (DeploymentStatus.deploying, "Deploying"),
+        (DeploymentStatus.success, "Success"),
+        (DeploymentStatus.failed, "Failed"),
+    ],
+)
+def test_deployment_status_to_human_readable(
+    status: DeploymentStatus, expected: str
+) -> None:
+    """Should convert deployment status to human readable format."""
+    assert DeploymentStatus.to_human_readable(status) == expected

fastapi_cloud_cli-0.1.2/tests/test_sentry.py

@@ -0,0 +1,22 @@
+from pathlib import Path
+from unittest.mock import ANY, patch
+
+from fastapi_cloud_cli.utils.sentry import SENTRY_DSN, init_sentry
+
+
+def test_init_sentry_when_logged_in(logged_in_cli: Path) -> None:
+    with patch("fastapi_cloud_cli.utils.sentry.sentry_sdk.init") as mock_init:
+        init_sentry()
+
+        mock_init.assert_called_once_with(
+            dsn=SENTRY_DSN,
+            integrations=[ANY],  # TyperIntegration instance
+            send_default_pii=False,
+        )
+
+
+def test_init_sentry_when_logged_out(logged_out_cli: Path) -> None:
+    with patch("fastapi_cloud_cli.utils.sentry.sentry_sdk.init") as mock_init:
+        init_sentry()
+
+        mock_init.assert_not_called()

fastapi_cloud_cli-0.1.1/src/fastapi_cloud_cli/__init__.py

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

fastapi_cloud_cli-0.1.1/tests/test_cli_login.py

@@ -1,65 +0,0 @@
-from pathlib import Path
-from unittest.mock import patch
-
-import pytest
-import respx
-from httpx import Response
-from typer.testing import CliRunner
-
-from fastapi_cloud_cli.cli import app
-from fastapi_cloud_cli.config import settings
-
-runner = CliRunner()
-
-assets_path = Path(__file__).parent / "assets"
-
-
-@pytest.mark.respx(base_url=settings.base_api_url)
-def test_shows_a_message_if_something_is_wrong(respx_mock: respx.MockRouter) -> None:
-    with patch("fastapi_cloud_cli.commands.login.typer.launch") as mock_open:
-        respx_mock.post(
-            "/login/device/authorization", data={"client_id": settings.client_id}
-        ).mock(return_value=Response(500))
-
-        result = runner.invoke(app, ["login"])
-
-        assert result.exit_code == 1
-        assert (
-            "Something went wrong while contacting the FastAPI Cloud server."
-            in result.output
-        )
-
-        assert not mock_open.called
-
-
-@pytest.mark.respx(base_url=settings.base_api_url)
-def test_full_login(respx_mock: respx.MockRouter) -> None:
-    with patch("fastapi_cloud_cli.commands.login.typer.launch") as mock_open:
-        respx_mock.post(
-            "/login/device/authorization", data={"client_id": settings.client_id}
-        ).mock(
-            return_value=Response(
-                200,
-                json={
-                    "verification_uri_complete": "http://test.com",
-                    "verification_uri": "http://test.com",
-                    "user_code": "1234",
-                    "device_code": "5678",
-                },
-            )
-        )
-        respx_mock.post(
-            "/login/device/token",
-            data={
-                "device_code": "5678",
-                "client_id": settings.client_id,
-                "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
-            },
-        ).mock(return_value=Response(200, json={"access_token": "1234"}))
-
-        result = runner.invoke(app, ["login"])
-
-        assert result.exit_code == 0
-        assert mock_open.called
-        assert mock_open.call_args.args == ("http://test.com",)
-        assert "Now you are logged in!" in result.output