unit test adjustments

Author: sid-rl

tests/sdk/async_devbox/test_core.py

@@ -137,11 +137,9 @@ async def test_shutdown(self, mock_async_client: AsyncMock, devbox_view: MockDev
     async def test_suspend(self, mock_async_client: AsyncMock, devbox_view: MockDevboxView) -> None:
         """Test suspend method."""
         mock_async_client.devboxes.suspend = 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"},
@@ -152,7 +150,6 @@ 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"},
@@ -164,11 +161,9 @@ async def test_suspend(self, mock_async_client: AsyncMock, devbox_view: MockDevb
     async def test_resume(self, mock_async_client: AsyncMock, devbox_view: MockDevboxView) -> None:
         """Test resume method."""
         mock_async_client.devboxes.resume = 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"},
@@ -179,7 +174,6 @@ 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"},

tests/sdk/conftest.py

@@ -55,6 +55,8 @@ class MockExecutionView:
     exit_status: int = 0
     stdout: str = "output"
     stderr: str = ""
+    stdout_truncated: bool = False
+    stderr_truncated: bool = False
 
 
 @dataclass

tests/sdk/test_async_clients.py

@@ -215,20 +215,6 @@ async def test_create(self, mock_async_client: AsyncMock, object_view: MockObjec
             metadata={"key": "value"},
         )
 
-    @pytest.mark.asyncio
-    async def test_create_auto_detect_content_type(
-        self, mock_async_client: AsyncMock, object_view: MockObjectView
-    ) -> None:
-        """Test create auto-detects content type."""
-        mock_async_client.objects.create = AsyncMock(return_value=object_view)
-
-        client = AsyncStorageObjectClient(mock_async_client)
-        obj = await client.create(name="test.txt")
-
-        assert isinstance(obj, AsyncStorageObject)
-        call_kwargs = mock_async_client.objects.create.call_args[1]
-        assert "content_type" not in call_kwargs
-
     def test_from_id(self, mock_async_client: AsyncMock) -> None:
         """Test from_id method."""
         client = AsyncStorageObjectClient(mock_async_client)

tests/sdk/test_async_execution.py

@@ -159,6 +159,8 @@ async def test_result_needs_polling(self, mock_async_client: AsyncMock) -> None:
             exit_status=0,
             stdout="output",
             stderr="",
+            stdout_truncated=False,
+            stderr_truncated=False,
         )
 
         mock_async_client.devboxes.wait_for_command = AsyncMock(return_value=completed_execution)
@@ -263,19 +265,3 @@ async def test_kill(self, mock_async_client: AsyncMock, execution_view: MockExec
             "exec_123",
             devbox_id="dev_123",
         )
-
-    @pytest.mark.asyncio
-    async def test_kill_with_process_group(
-        self, mock_async_client: AsyncMock, execution_view: MockExecutionView
-    ) -> None:
-        """Test kill with kill_process_group."""
-        mock_async_client.devboxes.executions.kill = AsyncMock(return_value=None)
-
-        execution = AsyncExecution(mock_async_client, "dev_123", execution_view)  # type: ignore[arg-type]
-        await execution.kill(kill_process_group=True)
-
-        mock_async_client.devboxes.executions.kill.assert_awaited_once_with(
-            "exec_123",
-            devbox_id="dev_123",
-            kill_process_group=True,
-        )

tests/sdk/test_async_execution_result.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from types import SimpleNamespace
-from unittest.mock import AsyncMock
+from unittest.mock import Mock, AsyncMock
 
 import pytest
 
@@ -45,6 +45,8 @@ def test_exit_code_none(self, mock_async_client: AsyncMock) -> None:
             exit_status=None,
             stdout="",
             stderr="",
+            stdout_truncated=False,
+            stderr_truncated=False,
         )
         result = AsyncExecutionResult(mock_async_client, "dev_123", execution)  # type: ignore[arg-type]
         assert result.exit_code is None
@@ -63,6 +65,8 @@ def test_success_false(self, mock_async_client: AsyncMock) -> None:
             exit_status=1,
             stdout="",
             stderr="error",
+            stdout_truncated=False,
+            stderr_truncated=False,
         )
         result = AsyncExecutionResult(mock_async_client, "dev_123", execution)  # type: ignore[arg-type]
         assert result.success is False
@@ -81,6 +85,8 @@ def test_failed_true(self, mock_async_client: AsyncMock) -> None:
             exit_status=1,
             stdout="",
             stderr="error",
+            stdout_truncated=False,
+            stderr_truncated=False,
         )
         result = AsyncExecutionResult(mock_async_client, "dev_123", execution)  # type: ignore[arg-type]
         assert result.failed is True
@@ -94,6 +100,8 @@ def test_failed_none(self, mock_async_client: AsyncMock) -> None:
             exit_status=None,
             stdout="",
             stderr="",
+            stdout_truncated=False,
+            stderr_truncated=False,
         )
         result = AsyncExecutionResult(mock_async_client, "dev_123", execution)  # type: ignore[arg-type]
         assert result.failed is False
@@ -115,6 +123,8 @@ async def test_stdout_empty(self, mock_async_client: AsyncMock) -> None:
             exit_status=0,
             stdout=None,
             stderr="",
+            stdout_truncated=False,
+            stderr_truncated=False,
         )
         result = AsyncExecutionResult(mock_async_client, "dev_123", execution)  # type: ignore[arg-type]
         assert await result.stdout() == ""
@@ -129,6 +139,8 @@ async def test_stderr(self, mock_async_client: AsyncMock) -> None:
             exit_status=1,
             stdout="",
             stderr="error message",
+            stdout_truncated=False,
+            stderr_truncated=False,
         )
         result = AsyncExecutionResult(mock_async_client, "dev_123", execution)  # type: ignore[arg-type]
         assert await result.stderr() == "error message"
@@ -144,3 +156,171 @@ def test_raw_property(self, mock_async_client: AsyncMock, execution_view: MockEx
         """Test raw property."""
         result = AsyncExecutionResult(mock_async_client, "dev_123", execution_view)  # type: ignore[arg-type]
         assert result.raw == execution_view
+
+    @pytest.mark.asyncio
+    async def test_stdout_with_truncation_and_streaming(
+        self, mock_async_client: AsyncMock, mock_async_stream: AsyncMock
+    ) -> None:
+        """Test stdout streams full output when truncated."""
+        from types import SimpleNamespace as SN
+
+        # Mock chunk data
+        async def mock_iter():
+            yield SN(output="line1\n")
+            yield SN(output="line2\n")
+            yield SN(output="line3\n")
+
+        mock_async_stream.__aiter__ = Mock(return_value=mock_iter())
+
+        # Setup client mock to return our stream
+        mock_async_client.devboxes.executions.stream_stdout_updates = AsyncMock(return_value=mock_async_stream)
+
+        execution = SimpleNamespace(
+            execution_id="exec_123",
+            devbox_id="dev_123",
+            status="completed",
+            exit_status=0,
+            stdout="partial",
+            stderr="",
+            stdout_truncated=True,
+            stderr_truncated=False,
+        )
+        result = AsyncExecutionResult(mock_async_client, "dev_123", execution)  # type: ignore[arg-type]
+
+        # Should stream full output
+        output = await result.stdout()
+        assert output == "line1\nline2\nline3\n"
+        mock_async_client.devboxes.executions.stream_stdout_updates.assert_called_once_with(
+            "exec_123", devbox_id="dev_123"
+        )
+
+    @pytest.mark.asyncio
+    async def test_stderr_with_truncation_and_streaming(
+        self, mock_async_client: AsyncMock, mock_async_stream: AsyncMock
+    ) -> None:
+        """Test stderr streams full output when truncated."""
+        from types import SimpleNamespace as SN
+
+        # Mock chunk data
+        async def mock_iter():
+            yield SN(output="error1\n")
+            yield SN(output="error2\n")
+
+        mock_async_stream.__aiter__ = Mock(return_value=mock_iter())
+
+        # Setup client mock to return our stream
+        mock_async_client.devboxes.executions.stream_stderr_updates = AsyncMock(return_value=mock_async_stream)
+
+        execution = SimpleNamespace(
+            execution_id="exec_123",
+            devbox_id="dev_123",
+            status="completed",
+            exit_status=0,
+            stdout="",
+            stderr="partial error",
+            stdout_truncated=False,
+            stderr_truncated=True,
+        )
+        result = AsyncExecutionResult(mock_async_client, "dev_123", execution)  # type: ignore[arg-type]
+
+        # Should stream full output
+        output = await result.stderr()
+        assert output == "error1\nerror2\n"
+        mock_async_client.devboxes.executions.stream_stderr_updates.assert_called_once_with(
+            "exec_123", devbox_id="dev_123"
+        )
+
+    @pytest.mark.asyncio
+    async def test_stdout_with_num_lines_when_truncated(
+        self, mock_async_client: AsyncMock, mock_async_stream: AsyncMock
+    ) -> None:
+        """Test stdout with num_lines parameter when truncated."""
+        from types import SimpleNamespace as SN
+
+        # Mock chunk data with many lines
+        async def mock_iter():
+            yield SN(output="line1\nline2\nline3\n")
+            yield SN(output="line4\nline5\n")
+
+        mock_async_stream.__aiter__ = Mock(return_value=mock_iter())
+
+        # Setup client mock to return our stream
+        mock_async_client.devboxes.executions.stream_stdout_updates = AsyncMock(return_value=mock_async_stream)
+
+        execution = SimpleNamespace(
+            execution_id="exec_123",
+            devbox_id="dev_123",
+            status="completed",
+            exit_status=0,
+            stdout="line1\n",
+            stderr="",
+            stdout_truncated=True,
+            stderr_truncated=False,
+        )
+        result = AsyncExecutionResult(mock_async_client, "dev_123", execution)  # type: ignore[arg-type]
+
+        # Should stream and return last 2 lines
+        output = await result.stdout(num_lines=2)
+        assert output == "line4\nline5"
+
+    @pytest.mark.asyncio
+    async def test_stdout_no_streaming_when_not_truncated(self, mock_async_client: AsyncMock) -> None:
+        """Test stdout doesn't stream when not truncated."""
+        execution = SimpleNamespace(
+            execution_id="exec_123",
+            devbox_id="dev_123",
+            status="completed",
+            exit_status=0,
+            stdout="complete output",
+            stderr="",
+            stdout_truncated=False,
+            stderr_truncated=False,
+        )
+        result = AsyncExecutionResult(mock_async_client, "dev_123", execution)  # type: ignore[arg-type]
+
+        # Should return existing output without streaming
+        output = await result.stdout()
+        assert output == "complete output"
+
+    @pytest.mark.asyncio
+    async def test_stdout_with_num_lines_no_truncation(self, mock_async_client: AsyncMock) -> None:
+        """Test stdout with num_lines when not truncated."""
+        execution = SimpleNamespace(
+            execution_id="exec_123",
+            devbox_id="dev_123",
+            status="completed",
+            exit_status=0,
+            stdout="line1\nline2\nline3\nline4\nline5",
+            stderr="",
+            stdout_truncated=False,
+            stderr_truncated=False,
+        )
+        result = AsyncExecutionResult(mock_async_client, "dev_123", execution)  # type: ignore[arg-type]
+
+        # Should return last 2 lines without streaming
+        output = await result.stdout(num_lines=2)
+        assert output == "line4\nline5"
+
+    def test_count_non_empty_lines(self, mock_async_client: AsyncMock, execution_view: MockExecutionView) -> None:
+        """Test the _count_non_empty_lines helper method."""
+        result = AsyncExecutionResult(mock_async_client, "dev_123", execution_view)  # type: ignore[arg-type]
+
+        # Test various input strings
+        assert result._count_non_empty_lines("") == 0
+        assert result._count_non_empty_lines("single") == 1
+        assert result._count_non_empty_lines("line1\nline2") == 2
+        assert result._count_non_empty_lines("line1\nline2\n") == 2
+        assert result._count_non_empty_lines("line1\n\nline3") == 2  # Empty line in middle
+        assert result._count_non_empty_lines("line1\nline2\nline3\n\n") == 3  # Trailing newlines
+
+    def test_get_last_n_lines(self, mock_async_client: AsyncMock, execution_view: MockExecutionView) -> None:
+        """Test the _get_last_n_lines helper method."""
+        result = AsyncExecutionResult(mock_async_client, "dev_123", execution_view)  # type: ignore[arg-type]
+
+        # Test various scenarios
+        assert result._get_last_n_lines("", 5) == ""
+        assert result._get_last_n_lines("single", 1) == "single"
+        assert result._get_last_n_lines("line1\nline2\nline3", 2) == "line2\nline3"
+        assert result._get_last_n_lines("line1\nline2\nline3\n", 2) == "line2\nline3"
+        assert result._get_last_n_lines("line1\nline2", 10) == "line1\nline2"  # Request more than available
+        assert result._get_last_n_lines("line1\nline2", 0) == ""  # Zero lines

tests/sdk/test_clients.py

@@ -204,17 +204,6 @@ def test_create(self, mock_client: Mock, object_view: MockObjectView) -> None:
         assert obj.upload_url == "https://upload.example.com/obj_123"
         mock_client.objects.create.assert_called_once()
 
-    def test_create_auto_detect_content_type(self, mock_client: Mock, object_view: MockObjectView) -> None:
-        """Test create auto-detects content type."""
-        mock_client.objects.create.return_value = object_view
-
-        client = StorageObjectClient(mock_client)
-        obj = client.create(name="test.txt")
-
-        assert isinstance(obj, StorageObject)
-        call_kwargs = mock_client.objects.create.call_args[1]
-        assert "content_type" not in call_kwargs
-
     def test_from_id(self, mock_client: Mock) -> None:
         """Test from_id method."""
         client = StorageObjectClient(mock_client)

tests/sdk/test_execution.py

@@ -137,6 +137,8 @@ def test_result_needs_polling(self, mock_client: Mock) -> None:
             exit_status=0,
             stdout="output",
             stderr="",
+            stdout_truncated=False,
+            stderr_truncated=False,
         )
 
         mock_client.devboxes = Mock()
@@ -240,16 +242,3 @@ def test_kill(self, mock_client: Mock, execution_view: MockExecutionView) -> Non
             "exec_123",
             devbox_id="dev_123",
         )
-
-    def test_kill_with_process_group(self, mock_client: Mock, execution_view: MockExecutionView) -> None:
-        """Test kill with kill_process_group."""
-        mock_client.devboxes.executions.kill.return_value = None
-
-        execution = Execution(mock_client, "dev_123", execution_view)  # type: ignore[arg-type]
-        execution.kill(kill_process_group=True)
-
-        mock_client.devboxes.executions.kill.assert_called_once_with(
-            "exec_123",
-            devbox_id="dev_123",
-            kill_process_group=True,
-        )