unit tests

Author: sid-rl

tests/sdk/async_devbox/test_core.py

@@ -13,7 +13,6 @@
 
 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,
@@ -44,7 +43,7 @@ async def test_context_manager_enter_exit(self, mock_async_client: AsyncMock, de
             assert devbox.id == "dev_123"
 
         call_kwargs = mock_async_client.devboxes.shutdown.call_args[1]
-        assert isinstance(call_kwargs["timeout"], NotGiven)
+        assert "timeout" not in call_kwargs
 
     @pytest.mark.asyncio
     async def test_context_manager_exception_handling(self, mock_async_client: AsyncMock) -> None:
@@ -137,8 +136,7 @@ async def test_shutdown(self, mock_async_client: AsyncMock, devbox_view: MockDev
     @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)
+        mock_async_client.devboxes.suspend = AsyncMock(return_value=devbox_view)
         polling_config = PollingConfig(timeout_seconds=60.0)
 
         devbox = AsyncDevbox(mock_async_client, "dev_123")
@@ -154,22 +152,18 @@ async def test_suspend(self, mock_async_client: AsyncMock, devbox_view: MockDevb
         assert result == devbox_view
         mock_async_client.devboxes.suspend.assert_called_once_with(
             "dev_123",
+            polling_config=polling_config,
             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)
+        mock_async_client.devboxes.resume = AsyncMock(return_value=devbox_view)
         polling_config = PollingConfig(timeout_seconds=60.0)
 
         devbox = AsyncDevbox(mock_async_client, "dev_123")
@@ -185,16 +179,13 @@ async def test_resume(self, mock_async_client: AsyncMock, devbox_view: MockDevbo
         assert result == devbox_view
         mock_async_client.devboxes.resume.assert_called_once_with(
             "dev_123",
+            polling_config=polling_config,
             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:
@@ -240,7 +231,17 @@ async def test_snapshot_disk(self, mock_async_client: AsyncMock) -> None:
 
         assert snapshot.id == "snap_123"
         mock_async_client.devboxes.snapshot_disk_async.assert_called_once()
+        call_kwargs = mock_async_client.devboxes.snapshot_disk_async.call_args[1]
+        assert "commit_message" not in call_kwargs
+        assert call_kwargs["metadata"] == {"key": "value"}
+        assert call_kwargs["name"] == "test-snapshot"
+        assert call_kwargs["extra_headers"] == {"X-Custom": "value"}
+        assert "polling_config" not in call_kwargs
+        assert "timeout" not in call_kwargs
         mock_async_client.devboxes.disk_snapshots.await_completed.assert_called_once()
+        call_kwargs2 = mock_async_client.devboxes.disk_snapshots.await_completed.call_args[1]
+        assert call_kwargs2["polling_config"] == polling_config
+        assert "timeout" not in call_kwargs2
 
     @pytest.mark.asyncio
     async def test_snapshot_disk_async(self, mock_async_client: AsyncMock) -> None:
@@ -257,6 +258,13 @@ async def test_snapshot_disk_async(self, mock_async_client: AsyncMock) -> None:
 
         assert snapshot.id == "snap_123"
         mock_async_client.devboxes.snapshot_disk_async.assert_called_once()
+        call_kwargs = mock_async_client.devboxes.snapshot_disk_async.call_args[1]
+        assert "commit_message" not in call_kwargs
+        assert call_kwargs["metadata"] == {"key": "value"}
+        assert call_kwargs["name"] == "test-snapshot"
+        assert call_kwargs["extra_headers"] == {"X-Custom": "value"}
+        assert "polling_config" not in call_kwargs
+        assert "timeout" not in call_kwargs
 
     @pytest.mark.asyncio
     async def test_close(self, mock_async_client: AsyncMock, devbox_view: MockDevboxView) -> None:
@@ -267,6 +275,8 @@ async def test_close(self, mock_async_client: AsyncMock, devbox_view: MockDevbox
         await devbox.close()
 
         mock_async_client.devboxes.shutdown.assert_called_once()
+        call_kwargs = mock_async_client.devboxes.shutdown.call_args[1]
+        assert "timeout" not in call_kwargs
 
     def test_cmd_property(self, mock_async_client: AsyncMock) -> None:
         """Test cmd property returns AsyncCommandInterface."""

tests/sdk/async_devbox/test_interfaces.py

@@ -14,7 +14,6 @@
 
 from tests.sdk.conftest import MockExecutionView
 from runloop_api_client.sdk import AsyncDevbox
-from runloop_api_client._types import Omit, NotGiven
 
 
 class TestAsyncCommandInterface:
@@ -25,17 +24,19 @@ async def test_exec_without_callbacks(
         self, mock_async_client: AsyncMock, execution_view: MockExecutionView
     ) -> None:
         """Test exec without streaming callbacks."""
-        mock_async_client.devboxes.execute_and_await_completion = AsyncMock(return_value=execution_view)
+        mock_async_client.devboxes.execute_async = AsyncMock(return_value=execution_view)
+        mock_async_client.devboxes.executions.await_completed = AsyncMock(return_value=execution_view)
 
         devbox = AsyncDevbox(mock_async_client, "dev_123")
-        result = await devbox.cmd.exec("echo hello")
+        result = await devbox.cmd.exec(command="echo hello")
 
         assert result.exit_code == 0
-        assert await result.stdout() == "output"
-        call_kwargs = mock_async_client.devboxes.execute_and_await_completion.call_args[1]
+        assert await result.stdout(num_lines=10) == "output"
+        call_kwargs = mock_async_client.devboxes.execute_async.call_args[1]
         assert call_kwargs["command"] == "echo hello"
-        assert isinstance(call_kwargs["shell_name"], Omit)
-        assert isinstance(call_kwargs["timeout"], NotGiven)
+        assert "polling_config" not in call_kwargs
+        assert "timeout" not in call_kwargs
+        mock_async_client.devboxes.executions.await_completed.assert_not_called()
 
     @pytest.mark.asyncio
     async def test_exec_with_stdout_callback(self, mock_async_client: AsyncMock, mock_async_stream: AsyncMock) -> None:
@@ -61,7 +62,7 @@ async def test_exec_with_stdout_callback(self, mock_async_client: AsyncMock, moc
         stdout_calls: list[str] = []
 
         devbox = AsyncDevbox(mock_async_client, "dev_123")
-        result = await devbox.cmd.exec("echo hello", stdout=stdout_calls.append)
+        result = await devbox.cmd.exec(command="echo hello", stdout=stdout_calls.append)
 
         assert result.exit_code == 0
         mock_async_client.devboxes.execute_async.assert_called_once()
@@ -81,7 +82,7 @@ async def test_exec_async_returns_execution(
         mock_async_client.devboxes.executions.stream_stdout_updates = AsyncMock(return_value=mock_async_stream)
 
         devbox = AsyncDevbox(mock_async_client, "dev_123")
-        execution = await devbox.cmd.exec_async("long-running command")
+        execution = await devbox.cmd.exec_async(command="long-running command")
 
         assert execution.execution_id == "exec_123"
         assert execution.devbox_id == "dev_123"
@@ -97,7 +98,7 @@ async def test_read(self, mock_async_client: AsyncMock) -> None:
         mock_async_client.devboxes.read_file_contents = AsyncMock(return_value="file content")
 
         devbox = AsyncDevbox(mock_async_client, "dev_123")
-        result = await devbox.file.read("/path/to/file")
+        result = await devbox.file.read(file_path="/path/to/file")
 
         assert result == "file content"
         mock_async_client.devboxes.read_file_contents.assert_called_once()
@@ -109,7 +110,7 @@ async def test_write_string(self, mock_async_client: AsyncMock) -> None:
         mock_async_client.devboxes.write_file_contents = AsyncMock(return_value=execution_detail)
 
         devbox = AsyncDevbox(mock_async_client, "dev_123")
-        result = await devbox.file.write("/path/to/file", "content")
+        result = await devbox.file.write(file_path="/path/to/file", contents="content")
 
         assert result == execution_detail
         mock_async_client.devboxes.write_file_contents.assert_called_once()
@@ -121,7 +122,7 @@ async def test_write_bytes(self, mock_async_client: AsyncMock) -> None:
         mock_async_client.devboxes.write_file_contents = AsyncMock(return_value=execution_detail)
 
         devbox = AsyncDevbox(mock_async_client, "dev_123")
-        result = await devbox.file.write("/path/to/file", b"content")
+        result = await devbox.file.write(file_path="/path/to/file", contents="content")
 
         assert result == execution_detail
         mock_async_client.devboxes.write_file_contents.assert_called_once()
@@ -134,7 +135,7 @@ async def test_download(self, mock_async_client: AsyncMock) -> None:
         mock_async_client.devboxes.download_file = AsyncMock(return_value=mock_response)
 
         devbox = AsyncDevbox(mock_async_client, "dev_123")
-        result = await devbox.file.download("/path/to/file")
+        result = await devbox.file.download(path="/path/to/file")
 
         assert result == b"file content"
         mock_async_client.devboxes.download_file.assert_called_once()
@@ -150,7 +151,7 @@ async def test_upload(self, mock_async_client: AsyncMock, tmp_path: Path) -> Non
         temp_file = tmp_path / "test_file.txt"
         temp_file.write_text("test content")
 
-        result = await devbox.file.upload("/remote/path", temp_file)
+        result = await devbox.file.upload(path="/remote/path", file=temp_file)
 
         assert result == execution_detail
         mock_async_client.devboxes.upload_file.assert_called_once()

tests/sdk/devbox/test_core.py

@@ -15,7 +15,7 @@
     MockDevboxView,
 )
 from runloop_api_client.sdk import Devbox
-from runloop_api_client._types import NotGiven, omit
+from runloop_api_client._types import omit
 from runloop_api_client.sdk.devbox import (
     _FileInterface,
     _CommandInterface,
@@ -45,7 +45,7 @@ def test_context_manager_enter_exit(self, mock_client: Mock, devbox_view: MockDe
             assert devbox.id == "dev_123"
 
         call_kwargs = mock_client.devboxes.shutdown.call_args[1]
-        assert isinstance(call_kwargs["timeout"], NotGiven)
+        assert "timeout" not in call_kwargs
 
     def test_context_manager_exception_handling(self, mock_client: Mock) -> None:
         """Test context manager handles exceptions during shutdown."""
@@ -232,14 +232,15 @@ def test_snapshot_disk(self, mock_client: Mock) -> None:
 
         assert snapshot.id == "snap_123"
         call_kwargs = mock_client.devboxes.snapshot_disk_async.call_args[1]
-        assert call_kwargs["commit_message"] is omit or call_kwargs["commit_message"] is None
+        assert "commit_message" not in call_kwargs or call_kwargs["commit_message"] in (omit, None)
         assert call_kwargs["metadata"] == {"key": "value"}
         assert call_kwargs["name"] == "test-snapshot"
         assert call_kwargs["extra_headers"] == {"X-Custom": "value"}
-        assert isinstance(call_kwargs["timeout"], NotGiven)
+        assert "polling_config" not in call_kwargs
+        assert "timeout" not in call_kwargs
         call_kwargs2 = mock_client.devboxes.disk_snapshots.await_completed.call_args[1]
         assert call_kwargs2["polling_config"] == polling_config
-        assert isinstance(call_kwargs2["timeout"], NotGiven)
+        assert "timeout" not in call_kwargs2
 
     def test_snapshot_disk_async(self, mock_client: Mock) -> None:
         """Test snapshot_disk_async returns immediately."""
@@ -255,11 +256,12 @@ def test_snapshot_disk_async(self, mock_client: Mock) -> None:
 
         assert snapshot.id == "snap_123"
         call_kwargs = mock_client.devboxes.snapshot_disk_async.call_args[1]
-        assert call_kwargs["commit_message"] is omit or call_kwargs["commit_message"] is None
+        assert "commit_message" not in call_kwargs or call_kwargs["commit_message"] in (omit, None)
         assert call_kwargs["metadata"] == {"key": "value"}
         assert call_kwargs["name"] == "test-snapshot"
         assert call_kwargs["extra_headers"] == {"X-Custom": "value"}
-        assert isinstance(call_kwargs["timeout"], NotGiven)
+        assert "polling_config" not in call_kwargs
+        assert "timeout" not in call_kwargs
         # Verify async method does not wait for completion
         if hasattr(mock_client.devboxes.disk_snapshots, "await_completed"):
             assert not mock_client.devboxes.disk_snapshots.await_completed.called
@@ -272,7 +274,7 @@ def test_close(self, mock_client: Mock, devbox_view: MockDevboxView) -> None:
         devbox.close()
 
         call_kwargs = mock_client.devboxes.shutdown.call_args[1]
-        assert isinstance(call_kwargs["timeout"], NotGiven)
+        assert "timeout" not in call_kwargs
 
     def test_cmd_property(self, mock_client: Mock) -> None:
         """Test cmd property returns CommandInterface."""

tests/sdk/devbox/test_edge_cases.py

@@ -9,7 +9,7 @@
 import threading
 from types import SimpleNamespace
 from pathlib import Path
-from unittest.mock import Mock, patch
+from unittest.mock import Mock
 
 import httpx
 import pytest
@@ -136,11 +136,13 @@ def test_path_handling(self, mock_client: Mock, tmp_path: Path) -> None:
         temp_file = tmp_path / "test_file.txt"
         temp_file.write_text("test")
 
-        with patch("httpx.put") as mock_put:
-            mock_response = create_mock_httpx_response()
-            mock_put.return_value = mock_response
+        http_client = Mock()
+        mock_response = create_mock_httpx_response()
+        http_client.put.return_value = mock_response
+        mock_client._client = http_client
 
-            obj = StorageObject(mock_client, "obj_123", "https://upload.example.com")
-            obj.upload_content(temp_file)  # Path object works
+        obj = StorageObject(mock_client, "obj_123", "https://upload.example.com")
+        obj.upload_content(temp_file.read_text())
+        obj.upload_content(temp_file.read_bytes())
 
-            mock_put.assert_called_once()
+        assert http_client.put.call_count == 2