add tests

Author: adam-rl

src/runloop_api_client/sdk/async_.py

@@ -368,8 +368,8 @@ async def upload_from_file(
     async def upload_from_dir(
         self,
         dir_path: str | Path,
-        name: str | None = None,
         *,
+        name: str | None = None,
         metadata: Optional[Dict[str, str]] = None,
         ttl: timedelta | None = None,
         **options: Unpack[LongRequestOptions],
@@ -395,17 +395,17 @@ async def upload_from_dir(
         name = name or f"{path.name}.tar.gz"
         ttl_ms = int(ttl.total_seconds()) * 1000 if ttl else None
 
-        def synchronous_io() -> io.BytesIO:
-            tar_buffer = io.BytesIO()
-            with tarfile.open(fileobj=tar_buffer, mode="w:gz") as tar:
-                tar.add(path, arcname=".", recursive=True)
-            tar_buffer.seek(0)
-            return tar_buffer
+        def synchronous_io() -> bytes:
+            with io.BytesIO() as tar_buffer:
+                with tarfile.open(fileobj=tar_buffer, mode="w:gz") as tar:
+                    tar.add(path, arcname=".", recursive=True)
+                tar_buffer.seek(0)
+                return tar_buffer.read()
 
-        tar_buffer = await asyncio.to_thread(synchronous_io)
+        tar_bytes = await asyncio.to_thread(synchronous_io)
 
         obj = await self.create(name=name, content_type="tgz", metadata=metadata, ttl_ms=ttl_ms, **options)
-        await obj.upload_content(tar_buffer)
+        await obj.upload_content(tar_bytes)
         await obj.complete()
         return obj
 

src/runloop_api_client/sdk/sync.py

@@ -367,8 +367,8 @@ def upload_from_file(
     def upload_from_dir(
         self,
         dir_path: str | Path,
-        name: str | None = None,
         *,
+        name: str | None = None,
         metadata: Optional[Dict[str, str]] = None,
         ttl: timedelta | None = None,
         **options: Unpack[LongRequestOptions],

tests/sdk/test_async_clients.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import io
+import tarfile
 from types import SimpleNamespace
 from pathlib import Path
 from unittest.mock import AsyncMock
@@ -327,6 +329,161 @@ async def test_upload_from_file_missing_path(self, mock_async_client: AsyncMock,
         with pytest.raises(OSError, match="Failed to read file"):
             await client.upload_from_file(missing_file)
 
+    @pytest.mark.asyncio
+    async def test_upload_from_dir(
+        self, mock_async_client: AsyncMock, object_view: MockObjectView, tmp_path: Path
+    ) -> None:
+        """Test upload_from_dir method."""
+        mock_async_client.objects.create = AsyncMock(return_value=object_view)
+        mock_async_client.objects.complete = AsyncMock(return_value=object_view)
+
+        # Create a temporary directory with some files
+        test_dir = tmp_path / "test_directory"
+        test_dir.mkdir()
+        (test_dir / "file1.txt").write_text("content1")
+        (test_dir / "file2.txt").write_text("content2")
+        subdir = test_dir / "subdir"
+        subdir.mkdir()
+        (subdir / "file3.txt").write_text("content3")
+
+        http_client = AsyncMock()
+        mock_response = create_mock_httpx_response()
+        http_client.put = AsyncMock(return_value=mock_response)
+        mock_async_client._client = http_client
+
+        client = AsyncStorageObjectOps(mock_async_client)
+        obj = await client.upload_from_dir(test_dir, name="archive.tar.gz", metadata={"key": "value"})
+
+        assert isinstance(obj, AsyncStorageObject)
+        assert obj.id == "obj_123"
+        mock_async_client.objects.create.assert_awaited_once_with(
+            name="archive.tar.gz",
+            content_type="tgz",
+            metadata={"key": "value"},
+            ttl_ms=None,
+        )
+        # Verify that put was called with tarball content
+        http_client.put.assert_awaited_once()
+        call_args = http_client.put.call_args
+        assert call_args[0][0] == object_view.upload_url
+
+        # Verify it's a valid gzipped tarball
+        uploaded_content = call_args[1]["content"]
+        with tarfile.open(fileobj=io.BytesIO(uploaded_content), mode="r:gz") as tar:
+            members = tar.getmembers()
+            member_names = [m.name for m in members]
+            # Should contain our test files (may include directory entries)
+            assert any("file1.txt" in name for name in member_names)
+            assert any("file2.txt" in name for name in member_names)
+            assert any("file3.txt" in name for name in member_names)
+
+        mock_async_client.objects.complete.assert_awaited_once()
+
+    @pytest.mark.asyncio
+    async def test_upload_from_dir_default_name(
+        self, mock_async_client: AsyncMock, object_view: MockObjectView, tmp_path: Path
+    ) -> None:
+        """Test upload_from_dir uses directory name by default."""
+        mock_async_client.objects.create = AsyncMock(return_value=object_view)
+        mock_async_client.objects.complete = AsyncMock(return_value=object_view)
+
+        test_dir = tmp_path / "my_folder"
+        test_dir.mkdir()
+        (test_dir / "file.txt").write_text("content")
+
+        http_client = AsyncMock()
+        mock_response = create_mock_httpx_response()
+        http_client.put = AsyncMock(return_value=mock_response)
+        mock_async_client._client = http_client
+
+        client = AsyncStorageObjectOps(mock_async_client)
+        obj = await client.upload_from_dir(test_dir)
+
+        assert isinstance(obj, AsyncStorageObject)
+        # Name should be directory name + .tar.gz
+        mock_async_client.objects.create.assert_awaited_once()
+        call_args = mock_async_client.objects.create.call_args
+        assert call_args[1]["name"] == "my_folder.tar.gz"
+        assert call_args[1]["content_type"] == "tgz"
+
+    @pytest.mark.asyncio
+    async def test_upload_from_dir_with_ttl(
+        self, mock_async_client: AsyncMock, object_view: MockObjectView, tmp_path: Path
+    ) -> None:
+        """Test upload_from_dir with TTL."""
+        from datetime import timedelta
+
+        mock_async_client.objects.create = AsyncMock(return_value=object_view)
+        mock_async_client.objects.complete = AsyncMock(return_value=object_view)
+
+        test_dir = tmp_path / "temp_dir"
+        test_dir.mkdir()
+        (test_dir / "file.txt").write_text("temporary content")
+
+        http_client = AsyncMock()
+        mock_response = create_mock_httpx_response()
+        http_client.put = AsyncMock(return_value=mock_response)
+        mock_async_client._client = http_client
+
+        client = AsyncStorageObjectOps(mock_async_client)
+        obj = await client.upload_from_dir(test_dir, ttl=timedelta(hours=2))
+
+        assert isinstance(obj, AsyncStorageObject)
+        mock_async_client.objects.create.assert_awaited_once()
+        call_args = mock_async_client.objects.create.call_args
+        # 2 hours = 7200 seconds = 7200000 milliseconds
+        assert call_args[1]["ttl_ms"] == 7200000
+
+    @pytest.mark.asyncio
+    async def test_upload_from_dir_empty_directory(
+        self, mock_async_client: AsyncMock, object_view: MockObjectView, tmp_path: Path
+    ) -> None:
+        """Test upload_from_dir with empty directory."""
+        mock_async_client.objects.create = AsyncMock(return_value=object_view)
+        mock_async_client.objects.complete = AsyncMock(return_value=object_view)
+
+        test_dir = tmp_path / "empty_dir"
+        test_dir.mkdir()
+
+        http_client = AsyncMock()
+        mock_response = create_mock_httpx_response()
+        http_client.put = AsyncMock(return_value=mock_response)
+        mock_async_client._client = http_client
+
+        client = AsyncStorageObjectOps(mock_async_client)
+        obj = await client.upload_from_dir(test_dir)
+
+        assert isinstance(obj, AsyncStorageObject)
+        assert obj.id == "obj_123"
+        mock_async_client.objects.create.assert_awaited_once()
+        http_client.put.assert_awaited_once()
+        mock_async_client.objects.complete.assert_awaited_once()
+
+    @pytest.mark.asyncio
+    async def test_upload_from_dir_with_string_path(
+        self, mock_async_client: AsyncMock, object_view: MockObjectView, tmp_path: Path
+    ) -> None:
+        """Test upload_from_dir with string path instead of Path object."""
+        mock_async_client.objects.create = AsyncMock(return_value=object_view)
+        mock_async_client.objects.complete = AsyncMock(return_value=object_view)
+
+        test_dir = tmp_path / "string_path_dir"
+        test_dir.mkdir()
+        (test_dir / "file.txt").write_text("content")
+
+        http_client = AsyncMock()
+        mock_response = create_mock_httpx_response()
+        http_client.put = AsyncMock(return_value=mock_response)
+        mock_async_client._client = http_client
+
+        client = AsyncStorageObjectOps(mock_async_client)
+        # Pass string path instead of Path object
+        obj = await client.upload_from_dir(str(test_dir))
+
+        assert isinstance(obj, AsyncStorageObject)
+        assert obj.id == "obj_123"
+        mock_async_client.objects.create.assert_awaited_once()
+
 
 class TestAsyncRunloopSDK:
     """Tests for AsyncRunloopSDK class."""

tests/sdk/test_clients.py

@@ -306,6 +306,137 @@ def test_upload_from_file_missing_path(self, mock_client: Mock, tmp_path: Path)
         with pytest.raises(OSError, match="Failed to read file"):
             client.upload_from_file(missing_file)
 
+    def test_upload_from_dir(self, mock_client: Mock, object_view: MockObjectView, tmp_path: Path) -> None:
+        """Test upload_from_dir method."""
+        mock_client.objects.create.return_value = object_view
+
+        # Create a temporary directory with some files
+        test_dir = tmp_path / "test_directory"
+        test_dir.mkdir()
+        (test_dir / "file1.txt").write_text("content1")
+        (test_dir / "file2.txt").write_text("content2")
+        subdir = test_dir / "subdir"
+        subdir.mkdir()
+        (subdir / "file3.txt").write_text("content3")
+
+        http_client = Mock()
+        mock_response = create_mock_httpx_response()
+        http_client.put.return_value = mock_response
+        mock_client._client = http_client
+
+        client = StorageObjectOps(mock_client)
+        obj = client.upload_from_dir(test_dir, name="archive.tar.gz", metadata={"key": "value"})
+
+        assert isinstance(obj, StorageObject)
+        assert obj.id == "obj_123"
+        mock_client.objects.create.assert_called_once_with(
+            name="archive.tar.gz",
+            content_type="tgz",
+            metadata={"key": "value"},
+            ttl_ms=None,
+        )
+        # Verify that put was called with tarball content
+        http_client.put.assert_called_once()
+        call_args = http_client.put.call_args
+        assert call_args[0][0] == object_view.upload_url
+        # Verify it's a BytesIO object
+        uploaded_content = call_args[1]["content"]
+        assert hasattr(uploaded_content, "read")
+        mock_client.objects.complete.assert_called_once()
+
+    def test_upload_from_dir_default_name(self, mock_client: Mock, object_view: MockObjectView, tmp_path: Path) -> None:
+        """Test upload_from_dir uses directory name by default."""
+        mock_client.objects.create.return_value = object_view
+
+        test_dir = tmp_path / "my_folder"
+        test_dir.mkdir()
+        (test_dir / "file.txt").write_text("content")
+
+        http_client = Mock()
+        mock_response = create_mock_httpx_response()
+        http_client.put.return_value = mock_response
+        mock_client._client = http_client
+
+        client = StorageObjectOps(mock_client)
+        obj = client.upload_from_dir(test_dir)
+
+        assert isinstance(obj, StorageObject)
+        # Name should be directory name + .tar.gz
+        mock_client.objects.create.assert_called_once()
+        call_args = mock_client.objects.create.call_args
+        assert call_args[1]["name"] == "my_folder.tar.gz"
+        assert call_args[1]["content_type"] == "tgz"
+
+    def test_upload_from_dir_with_ttl(self, mock_client: Mock, object_view: MockObjectView, tmp_path: Path) -> None:
+        """Test upload_from_dir with TTL."""
+        from datetime import timedelta
+
+        mock_client.objects.create.return_value = object_view
+
+        test_dir = tmp_path / "temp_dir"
+        test_dir.mkdir()
+        (test_dir / "file.txt").write_text("temporary content")
+
+        http_client = Mock()
+        mock_response = create_mock_httpx_response()
+        http_client.put.return_value = mock_response
+        mock_client._client = http_client
+
+        client = StorageObjectOps(mock_client)
+        obj = client.upload_from_dir(test_dir, ttl=timedelta(hours=2))
+
+        assert isinstance(obj, StorageObject)
+        mock_client.objects.create.assert_called_once()
+        call_args = mock_client.objects.create.call_args
+        # 2 hours = 7200 seconds = 7200000 milliseconds
+        assert call_args[1]["ttl_ms"] == 7200000
+
+    def test_upload_from_dir_empty_directory(
+        self, mock_client: Mock, object_view: MockObjectView, tmp_path: Path
+    ) -> None:
+        """Test upload_from_dir with empty directory."""
+        mock_client.objects.create.return_value = object_view
+
+        test_dir = tmp_path / "empty_dir"
+        test_dir.mkdir()
+
+        http_client = Mock()
+        mock_response = create_mock_httpx_response()
+        http_client.put.return_value = mock_response
+        mock_client._client = http_client
+
+        client = StorageObjectOps(mock_client)
+        obj = client.upload_from_dir(test_dir)
+
+        assert isinstance(obj, StorageObject)
+        assert obj.id == "obj_123"
+        mock_client.objects.create.assert_called_once()
+        http_client.put.assert_called_once()
+        mock_client.objects.complete.assert_called_once()
+
+    def test_upload_from_dir_with_string_path(
+        self, mock_client: Mock, object_view: MockObjectView, tmp_path: Path
+    ) -> None:
+        """Test upload_from_dir with string path instead of Path object."""
+        mock_client.objects.create.return_value = object_view
+
+        test_dir = tmp_path / "string_path_dir"
+        test_dir.mkdir()
+        (test_dir / "file.txt").write_text("content")
+
+        http_client = Mock()
+        mock_response = create_mock_httpx_response()
+        http_client.put.return_value = mock_response
+        mock_client._client = http_client
+
+        client = StorageObjectOps(mock_client)
+        # Pass string path instead of Path object
+        obj = client.upload_from_dir(str(test_dir))
+
+        assert isinstance(obj, StorageObject)
+        assert obj.id == "obj_123"
+        mock_client.objects.create.assert_called_once()
+
 
 class TestRunloopSDK:
     """Tests for RunloopSDK class."""