unit test refactoring

Author: sid-rl

.coverage

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Dict, Literal, Mapping, Iterable, Optional
+from typing import Dict, Literal, Mapping, Iterable, Optional
 from pathlib import Path
 
 import httpx
@@ -13,6 +13,7 @@
 from .blueprint import Blueprint
 from ..lib.polling import PollingConfig
 from .storage_object import StorageObject
+from ..types.blueprint_create_params import Service
 from ..types.shared_params.launch_parameters import LaunchParameters
 from ..types.shared_params.code_mount_parameters import CodeMountParameters
 
@@ -263,27 +264,35 @@ def create(
         self,
         *,
         name: str,
-        base_blueprint_id: Optional[str] | NotGiven = NOT_GIVEN,
-        code_mounts: Optional[Iterable[CodeMountParameters]] | NotGiven = NOT_GIVEN,
-        dockerfile: Optional[str] | NotGiven = NOT_GIVEN,
-        file_mounts: Optional[Dict[str, str]] | NotGiven = NOT_GIVEN,
-        launch_parameters: Optional[LaunchParameters] | NotGiven = NOT_GIVEN,
-        services: Optional[Iterable[Any]] | NotGiven = NOT_GIVEN,
-        system_setup_commands: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
+        base_blueprint_id: Optional[str] | Omit = omit,
+        base_blueprint_name: Optional[str] | Omit = omit,
+        build_args: Optional[Dict[str, str]] | Omit = omit,
+        code_mounts: Optional[Iterable[CodeMountParameters]] | Omit = omit,
+        dockerfile: Optional[str] | Omit = omit,
+        file_mounts: Optional[Dict[str, str]] | Omit = omit,
+        launch_parameters: Optional[LaunchParameters] | Omit = omit,
+        metadata: Optional[Dict[str, str]] | Omit = omit,
+        secrets: Optional[Dict[str, str]] | Omit = omit,
+        services: Optional[Iterable[Service]] | Omit = omit,
+        system_setup_commands: Optional[SequenceNotStr[str]] | Omit = omit,
         polling_config: PollingConfig | None = None,
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | Timeout | None | NotGiven = not_given,
+        timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
         idempotency_key: str | None = None,
     ) -> Blueprint:
         blueprint = self._client.blueprints.create_and_await_build_complete(
             name=name,
             base_blueprint_id=base_blueprint_id,
+            base_blueprint_name=base_blueprint_name,
+            build_args=build_args,
             code_mounts=code_mounts,
             dockerfile=dockerfile,
             file_mounts=file_mounts,
             launch_parameters=launch_parameters,
+            metadata=metadata,
+            secrets=secrets,
             services=services,
             system_setup_commands=system_setup_commands,
             polling_config=polling_config,

src/runloop_api_client/sdk/_sync.py

@@ -0,0 +1 @@
+"""Tests for async Devbox functionality."""

tests/sdk/async_devbox/__init__.py

@@ -0,0 +1,6 @@
+"""Shared fixtures and utilities for async Devbox tests.
+
+This module contains fixtures and helpers specific to async devbox testing
+that are shared across multiple test modules in this directory.
+"""
+# Currently minimal - add shared helpers if patterns emerge

tests/sdk/async_devbox/conftest.py

@@ -0,0 +1,290 @@
+"""Tests for core AsyncDevbox functionality.
+
+Tests the primary AsyncDevbox class including initialization, async CRUD
+operations, snapshot creation, blueprint launching, and async execution methods.
+"""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+from unittest.mock import AsyncMock
+
+import pytest
+
+from tests.sdk.conftest import MockDevboxView
+from runloop_api_client.sdk import AsyncDevbox
+from runloop_api_client._types import NotGiven
+from runloop_api_client.lib.polling import PollingConfig
+from runloop_api_client.sdk.async_devbox import (
+    _AsyncFileInterface,
+    _AsyncCommandInterface,
+    _AsyncNetworkInterface,
+)
+
+
+class TestAsyncDevbox:
+    """Tests for AsyncDevbox class."""
+
+    def test_init(self, mock_async_client: AsyncMock) -> None:
+        """Test AsyncDevbox initialization."""
+        devbox = AsyncDevbox(mock_async_client, "dev_123")
+        assert devbox.id == "dev_123"
+
+    def test_repr(self, mock_async_client: AsyncMock) -> None:
+        """Test AsyncDevbox string representation."""
+        devbox = AsyncDevbox(mock_async_client, "dev_123")
+        assert repr(devbox) == "<AsyncDevbox id='dev_123'>"
+
+    @pytest.mark.asyncio
+    async def test_context_manager_enter_exit(self, mock_async_client: AsyncMock, devbox_view: MockDevboxView) -> None:
+        """Test context manager behavior with successful shutdown."""
+        mock_async_client.devboxes.shutdown = AsyncMock(return_value=devbox_view)
+
+        async with AsyncDevbox(mock_async_client, "dev_123") as devbox:
+            assert devbox.id == "dev_123"
+
+        call_kwargs = mock_async_client.devboxes.shutdown.call_args[1]
+        assert isinstance(call_kwargs["timeout"], NotGiven)
+
+    @pytest.mark.asyncio
+    async def test_context_manager_exception_handling(self, mock_async_client: AsyncMock) -> None:
+        """Test context manager handles exceptions during shutdown."""
+        mock_async_client.devboxes.shutdown = AsyncMock(side_effect=RuntimeError("Shutdown failed"))
+
+        with pytest.raises(ValueError, match="Test error"):
+            async with AsyncDevbox(mock_async_client, "dev_123"):
+                raise ValueError("Test error")
+
+        # Shutdown should be called even when body raises exception
+        mock_async_client.devboxes.shutdown.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_get_info(self, mock_async_client: AsyncMock, devbox_view: MockDevboxView) -> None:
+        """Test get_info method."""
+        mock_async_client.devboxes.retrieve = AsyncMock(return_value=devbox_view)
+
+        devbox = AsyncDevbox(mock_async_client, "dev_123")
+        result = await devbox.get_info(
+            extra_headers={"X-Custom": "value"},
+            extra_query={"param": "value"},
+            extra_body={"key": "value"},
+            timeout=30.0,
+        )
+
+        assert result == devbox_view
+        mock_async_client.devboxes.retrieve.assert_called_once_with(
+            "dev_123",
+            extra_headers={"X-Custom": "value"},
+            extra_query={"param": "value"},
+            extra_body={"key": "value"},
+            timeout=30.0,
+        )
+
+    @pytest.mark.asyncio
+    async def test_await_running(self, mock_async_client: AsyncMock, devbox_view: MockDevboxView) -> None:
+        """Test await_running method."""
+        mock_async_client.devboxes.await_running = AsyncMock(return_value=devbox_view)
+        polling_config = PollingConfig(timeout_seconds=60.0)
+
+        devbox = AsyncDevbox(mock_async_client, "dev_123")
+        result = await devbox.await_running(polling_config=polling_config)
+
+        assert result == devbox_view
+        mock_async_client.devboxes.await_running.assert_called_once_with(
+            "dev_123",
+            polling_config=polling_config,
+        )
+
+    @pytest.mark.asyncio
+    async def test_await_suspended(self, mock_async_client: AsyncMock, devbox_view: MockDevboxView) -> None:
+        """Test await_suspended method."""
+        mock_async_client.devboxes.await_suspended = AsyncMock(return_value=devbox_view)
+        polling_config = PollingConfig(timeout_seconds=60.0)
+
+        devbox = AsyncDevbox(mock_async_client, "dev_123")
+        result = await devbox.await_suspended(polling_config=polling_config)
+
+        assert result == devbox_view
+        mock_async_client.devboxes.await_suspended.assert_called_once_with(
+            "dev_123",
+            polling_config=polling_config,
+        )
+
+    @pytest.mark.asyncio
+    async def test_shutdown(self, mock_async_client: AsyncMock, devbox_view: MockDevboxView) -> None:
+        """Test shutdown method."""
+        mock_async_client.devboxes.shutdown = AsyncMock(return_value=devbox_view)
+
+        devbox = AsyncDevbox(mock_async_client, "dev_123")
+        result = await devbox.shutdown(
+            extra_headers={"X-Custom": "value"},
+            extra_query={"param": "value"},
+            extra_body={"key": "value"},
+            timeout=30.0,
+            idempotency_key="key-123",
+        )
+
+        assert result == devbox_view
+        mock_async_client.devboxes.shutdown.assert_called_once_with(
+            "dev_123",
+            extra_headers={"X-Custom": "value"},
+            extra_query={"param": "value"},
+            extra_body={"key": "value"},
+            timeout=30.0,
+            idempotency_key="key-123",
+        )
+
+    @pytest.mark.asyncio
+    async def test_suspend(self, mock_async_client: AsyncMock, devbox_view: MockDevboxView) -> None:
+        """Test suspend method."""
+        mock_async_client.devboxes.suspend = AsyncMock(return_value=None)
+        mock_async_client.devboxes.await_suspended = AsyncMock(return_value=devbox_view)
+        polling_config = PollingConfig(timeout_seconds=60.0)
+
+        devbox = AsyncDevbox(mock_async_client, "dev_123")
+        result = await devbox.suspend(
+            polling_config=polling_config,
+            extra_headers={"X-Custom": "value"},
+            extra_query={"param": "value"},
+            extra_body={"key": "value"},
+            timeout=30.0,
+            idempotency_key="key-123",
+        )
+
+        assert result == devbox_view
+        mock_async_client.devboxes.suspend.assert_called_once_with(
+            "dev_123",
+            extra_headers={"X-Custom": "value"},
+            extra_query={"param": "value"},
+            extra_body={"key": "value"},
+            timeout=30.0,
+            idempotency_key="key-123",
+        )
+        mock_async_client.devboxes.await_suspended.assert_called_once_with(
+            "dev_123",
+            polling_config=polling_config,
+        )
+
+    @pytest.mark.asyncio
+    async def test_resume(self, mock_async_client: AsyncMock, devbox_view: MockDevboxView) -> None:
+        """Test resume method."""
+        mock_async_client.devboxes.resume = AsyncMock(return_value=None)
+        mock_async_client.devboxes.await_running = AsyncMock(return_value=devbox_view)
+        polling_config = PollingConfig(timeout_seconds=60.0)
+
+        devbox = AsyncDevbox(mock_async_client, "dev_123")
+        result = await devbox.resume(
+            polling_config=polling_config,
+            extra_headers={"X-Custom": "value"},
+            extra_query={"param": "value"},
+            extra_body={"key": "value"},
+            timeout=30.0,
+            idempotency_key="key-123",
+        )
+
+        assert result == devbox_view
+        mock_async_client.devboxes.resume.assert_called_once_with(
+            "dev_123",
+            extra_headers={"X-Custom": "value"},
+            extra_query={"param": "value"},
+            extra_body={"key": "value"},
+            timeout=30.0,
+            idempotency_key="key-123",
+        )
+        mock_async_client.devboxes.await_running.assert_called_once_with(
+            "dev_123",
+            polling_config=polling_config,
+        )
+
+    @pytest.mark.asyncio
+    async def test_keep_alive(self, mock_async_client: AsyncMock) -> None:
+        """Test keep_alive method."""
+        mock_async_client.devboxes.keep_alive = AsyncMock(return_value=object())
+
+        devbox = AsyncDevbox(mock_async_client, "dev_123")
+        result = await devbox.keep_alive(
+            extra_headers={"X-Custom": "value"},
+            extra_query={"param": "value"},
+            extra_body={"key": "value"},
+            timeout=30.0,
+            idempotency_key="key-123",
+        )
+
+        assert result is not None  # Verify return value is propagated
+        mock_async_client.devboxes.keep_alive.assert_called_once_with(
+            "dev_123",
+            extra_headers={"X-Custom": "value"},
+            extra_query={"param": "value"},
+            extra_body={"key": "value"},
+            timeout=30.0,
+            idempotency_key="key-123",
+        )
+
+    @pytest.mark.asyncio
+    async def test_snapshot_disk(self, mock_async_client: AsyncMock) -> None:
+        """Test snapshot_disk waits for completion."""
+        snapshot_data = SimpleNamespace(id="snap_123")
+        snapshot_status = SimpleNamespace(status="completed")
+
+        mock_async_client.devboxes.snapshot_disk_async = AsyncMock(return_value=snapshot_data)
+        mock_async_client.devboxes.disk_snapshots.await_completed = AsyncMock(return_value=snapshot_status)
+
+        devbox = AsyncDevbox(mock_async_client, "dev_123")
+        polling_config = PollingConfig(timeout_seconds=60.0)
+        snapshot = await devbox.snapshot_disk(
+            name="test-snapshot",
+            metadata={"key": "value"},
+            polling_config=polling_config,
+            extra_headers={"X-Custom": "value"},
+        )
+
+        assert snapshot.id == "snap_123"
+        mock_async_client.devboxes.snapshot_disk_async.assert_called_once()
+        mock_async_client.devboxes.disk_snapshots.await_completed.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_snapshot_disk_async(self, mock_async_client: AsyncMock) -> None:
+        """Test snapshot_disk_async returns immediately."""
+        snapshot_data = SimpleNamespace(id="snap_123")
+        mock_async_client.devboxes.snapshot_disk_async = AsyncMock(return_value=snapshot_data)
+
+        devbox = AsyncDevbox(mock_async_client, "dev_123")
+        snapshot = await devbox.snapshot_disk_async(
+            name="test-snapshot",
+            metadata={"key": "value"},
+            extra_headers={"X-Custom": "value"},
+        )
+
+        assert snapshot.id == "snap_123"
+        mock_async_client.devboxes.snapshot_disk_async.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_close(self, mock_async_client: AsyncMock, devbox_view: MockDevboxView) -> None:
+        """Test close method calls shutdown."""
+        mock_async_client.devboxes.shutdown = AsyncMock(return_value=devbox_view)
+
+        devbox = AsyncDevbox(mock_async_client, "dev_123")
+        await devbox.close()
+
+        mock_async_client.devboxes.shutdown.assert_called_once()
+
+    def test_cmd_property(self, mock_async_client: AsyncMock) -> None:
+        """Test cmd property returns AsyncCommandInterface."""
+        devbox = AsyncDevbox(mock_async_client, "dev_123")
+        cmd = devbox.cmd
+        assert isinstance(cmd, _AsyncCommandInterface)
+        assert cmd._devbox is devbox
+
+    def test_file_property(self, mock_async_client: AsyncMock) -> None:
+        """Test file property returns AsyncFileInterface."""
+        devbox = AsyncDevbox(mock_async_client, "dev_123")
+        file_interface = devbox.file
+        assert isinstance(file_interface, _AsyncFileInterface)
+        assert file_interface._devbox is devbox
+
+    def test_net_property(self, mock_async_client: AsyncMock) -> None:
+        """Test net property returns AsyncNetworkInterface."""
+        devbox = AsyncDevbox(mock_async_client, "dev_123")
+        net = devbox.net
+        assert isinstance(net, _AsyncNetworkInterface)
+        assert net._devbox is devbox

tests/sdk/async_devbox/test_core.py

@@ -0,0 +1,26 @@
+"""Tests for AsyncDevbox error handling.
+
+Tests async error scenarios including network errors.
+"""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock
+
+import httpx
+import pytest
+
+from runloop_api_client.sdk import AsyncDevbox
+
+
+class TestAsyncDevboxErrorHandling:
+    """Tests for AsyncDevbox error handling scenarios."""
+
+    @pytest.mark.asyncio
+    async def test_async_network_error(self, mock_async_client: AsyncMock) -> None:
+        """Test handling of network errors in async."""
+        mock_async_client.devboxes.retrieve = AsyncMock(side_effect=httpx.NetworkError("Connection failed"))
+
+        devbox = AsyncDevbox(mock_async_client, "dev_123")
+        with pytest.raises(httpx.NetworkError):
+            await devbox.get_info()