add tests

Author: adam-rl

tests/sdk/test_async_clients.py

@@ -327,6 +327,153 @@ 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 BytesIO object
+        uploaded_content = call_args[1]["content"]
+        assert hasattr(uploaded_content, "read")
+        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."""

tests/smoketests/sdk/test_async_storage_object.py

@@ -157,6 +157,45 @@ async def test_upload_from_file(self, async_sdk_client: AsyncRunloopSDK) -> None
         finally:
             Path(tmp_path).unlink(missing_ok=True)
 
+    @pytest.mark.timeout(THIRTY_SECOND_TIMEOUT)
+    async def test_upload_from_dir(self, async_sdk_client: AsyncRunloopSDK) -> None:
+        """Test uploading from directory as tarball."""
+        # Create temporary directory with files
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            tmp_path = Path(tmp_dir)
+            (tmp_path / "file1.txt").write_text("Async Content 1")
+            (tmp_path / "file2.txt").write_text("Async Content 2")
+            subdir = tmp_path / "subdir"
+            subdir.mkdir()
+            (subdir / "file3.txt").write_text("Async Content 3")
+
+            obj = await async_sdk_client.storage_object.upload_from_dir(
+                tmp_path,
+                unique_name("sdk-async-dir-upload"),
+                metadata={"source": "upload_from_dir"},
+            )
+
+            try:
+                assert obj.id is not None
+
+                # Verify it's a tarball
+                info = await obj.refresh()
+                assert info.content_type == "tgz"
+
+                # Download and verify tarball can be extracted
+                import io
+                import tarfile
+
+                tarball_bytes = await obj.download_as_bytes(duration_seconds=120)
+                with tarfile.open(fileobj=io.BytesIO(tarball_bytes), mode="r:gz") as tar:
+                    # Verify files exist in tarball
+                    names = tar.getnames()
+                    assert any("file1.txt" in name for name in names)
+                    assert any("file2.txt" in name for name in names)
+                    assert any("file3.txt" in name for name in names)
+            finally:
+                await obj.delete()
+
 
 class TestAsyncStorageObjectDownloadMethods:
     """Test async storage object download methods."""

tests/smoketests/sdk/test_storage_object.py

@@ -157,6 +157,45 @@ def test_upload_from_file(self, sdk_client: RunloopSDK) -> None:
         finally:
             Path(tmp_path).unlink(missing_ok=True)
 
+    @pytest.mark.timeout(THIRTY_SECOND_TIMEOUT)
+    def test_upload_from_dir(self, sdk_client: RunloopSDK) -> None:
+        """Test uploading from directory as tarball."""
+        # Create temporary directory with files
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            tmp_path = Path(tmp_dir)
+            (tmp_path / "file1.txt").write_text("Content 1")
+            (tmp_path / "file2.txt").write_text("Content 2")
+            subdir = tmp_path / "subdir"
+            subdir.mkdir()
+            (subdir / "file3.txt").write_text("Content 3")
+
+            obj = sdk_client.storage_object.upload_from_dir(
+                tmp_path,
+                unique_name("sdk-dir-upload"),
+                metadata={"source": "upload_from_dir"},
+            )
+
+            try:
+                assert obj.id is not None
+
+                # Verify it's a tarball
+                info = obj.refresh()
+                assert info.content_type == "tgz"
+
+                # Download and verify tarball can be extracted
+                import io
+                import tarfile
+
+                tarball_bytes = obj.download_as_bytes(duration_seconds=120)
+                with tarfile.open(fileobj=io.BytesIO(tarball_bytes), mode="r:gz") as tar:
+                    # Verify files exist in tarball
+                    names = tar.getnames()
+                    assert any("file1.txt" in name for name in names)
+                    assert any("file2.txt" in name for name in names)
+                    assert any("file3.txt" in name for name in names)
+            finally:
+                obj.delete()
+
 
 class TestStorageObjectDownloadMethods:
     """Test storage object download methods."""