fluidattacks_core_git 12.0.0__tar.gz → 12.1.1__tar.gz

{fluidattacks_core_git-12.0.0 → fluidattacks_core_git-12.1.1}/.gitignore

@@ -1,5 +1,9 @@
+dist/
+dist-*/
+/.cargo-cache
 target/
 .direnv/
 .venv/
 .vscode/settings.json
 .zed/settings.json
+*.so

{fluidattacks_core_git-12.0.0 → fluidattacks_core_git-12.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: fluidattacks_core_git
-Version: 12.0.0
+Version: 12.1.1
 Summary: Fluid Attacks Core Git Library
 Author-email: Development <development@fluidattacks.com>
 License: MPL-2.0
@@ -16,7 +16,7 @@ Requires-Dist: aiohttp>=3.10.0
 Requires-Dist: anyio>=4.7.0
 Requires-Dist: boto3>=1.34
 Requires-Dist: botocore>=1.40.18
-Requires-Dist: fluidattacks-core-http>=12.0.0
+Requires-Dist: fluidattacks-core-http>=12.1.0
 Requires-Dist: gitpython>=3.1.41
 Requires-Dist: pathspec>=0.12.1
 Requires-Dist: urllib3>=2.6.1

{fluidattacks_core_git-12.0.0 → fluidattacks_core_git-12.1.1}/fluidattacks_core/git/download_repo.py

@@ -46,13 +46,7 @@ def remove_symlinks_in_directory(directory: str) -> None:
                 Path(file_path).unlink(missing_ok=True)
 
 
-def _reset_repo_sync(repo_path: str) -> bool:
-    try:
-        Path.cwd()
-    except OSError:
-        LOGGER.exception("Failed to get the working directory: %s", repo_path)
-        os.chdir(repo_path)
-
+def _mark_safe_directory(repo_path: str) -> None:
     try:
         Git().execute(
             [
@@ -67,6 +61,16 @@ def _reset_repo_sync(repo_path: str) -> bool:
     except GitError:
         LOGGER.exception("Failed to add safe directory %s", repo_path)
 
+
+def _reset_repo_sync(repo_path: str) -> bool:
+    try:
+        Path.cwd()
+    except OSError:
+        LOGGER.exception("Failed to get the working directory: %s", repo_path)
+        os.chdir(repo_path)
+
+    _mark_safe_directory(repo_path)
+
     try:
         repo = Repo(repo_path)
         repo.git.reset("--hard", "HEAD")
@@ -114,7 +118,16 @@ async def download_repo_from_s3(
     git_ignore: list[str] | None = None,
     *,
     download_buffer_size: int = DEFAULT_DOWNLOAD_BUFFER_SIZE,
+    checkout: bool = True,
 ) -> bool:
+    """Download the repository archived in s3 at `download_url`.
+
+    The archive holds only `.git`, so the working tree is restored with a
+    `git reset --hard`. Pass `checkout=False` to keep just the history: peak
+    disk stays at the size of the archive plus `.git`, which is what a
+    consumer that walks commits needs. `git_ignore` prunes working-tree files
+    and has no effect on a history-only download.
+    """
     await anyio.Path(destination_path.parent).mkdir(parents=True, exist_ok=True)
     with tempfile.TemporaryDirectory(prefix="fluidattacks_", ignore_cleanup_errors=True) as tmpdir:
         tmp_path = Path(tmpdir)
@@ -139,6 +152,13 @@ async def download_repo_from_s3(
             )
             return False
 
+    if not checkout:
+        # Nothing was extracted but `.git`, so there is no working tree to
+        # reset or prune. Callers still read the repository through git, which
+        # refuses a directory it considers foreign.
+        await anyio.to_thread.run_sync(_mark_safe_directory, str(destination_path))
+        return True
+
     if not await reset_repo(str(destination_path)):
         shutil.rmtree(destination_path, ignore_errors=True)
         return False

{fluidattacks_core_git-12.0.0 → fluidattacks_core_git-12.1.1}/import-linter.cfg

@@ -1,17 +1,7 @@
 [importlinter]
-  root_package = fluidattacks_core
+  root_package = fluidattacks_core.git
   include_external_packages = True
 
-[importlinter:contract:portion]
-  name = Single Portion
-  type = layers
-  containers =
-    fluidattacks_core
-  exhaustive = true
-  layers =
-    git
-    http
-
 [importlinter:contract:dag]
   name = Direct Acyclic Graph
   type = layers

{fluidattacks_core_git-12.0.0 → fluidattacks_core_git-12.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fluidattacks_core_git"
-version = "12.0.0"
+version = "12.1.1"
 description = "Fluid Attacks Core Git Library"
 authors = [{ name = "Development", email = "development@fluidattacks.com" }]
 license = { text = "MPL-2.0" }
@@ -19,7 +19,7 @@ dependencies = [
   "anyio>=4.7.0",
   "boto3>=1.34",
   "botocore>=1.40.18",
-  "fluidattacks-core-http>=12.0.0",
+  "fluidattacks-core-http>=12.1.0",
   "GitPython>=3.1.41",
   "pathspec>=0.12.1",
   "urllib3>=2.6.1",
@@ -32,6 +32,7 @@ dev = [
   "deptry>=0.23.1",
   "import-linter==2.11",
   "mypy==1.19.1",
+  "pytest-asyncio>=1.1.0",
   "pytest-cov>=7.0.0",
   "pytest==9.0.3",
   "ruff==0.15.0",

{fluidattacks_core_git-12.0.0 → fluidattacks_core_git-12.1.1}/tests/test_git.py

@@ -1,3 +1,5 @@
+import shutil
+import tarfile
 import tempfile
 from pathlib import Path
 
@@ -6,7 +8,7 @@ from git.repo import Repo
 from pathspec import PathSpec
 from pathspec import util as pathspec_util
 
-from fluidattacks_core.git import rebase
+from fluidattacks_core.git import download_repo, download_repo_from_s3, rebase
 from fluidattacks_core.git.delete_files import delete_out_of_scope_files
 from fluidattacks_core.git.download_repo import remove_symlinks_in_directory
 
@@ -171,3 +173,76 @@ def test_rebase_preserves_ascii_renamed_path() -> None:
         assert result.path == renamed
         assert result.line == 1
         assert result.rev == rev_b
+
+
+def _archive_git_dir(repo_path: Path, archive_path: Path, name: str) -> None:
+    # Mimics `_create_tar_archive`: the archive uploaded to s3 carries `.git`
+    # and no tracked file.
+    with tarfile.open(archive_path, "w:gz") as tar_handler:
+        tar_handler.add(str(repo_path / ".git"), arcname=f"{name}/.git", recursive=True)
+
+
+def _committed_repo(path: Path, tracked: str) -> str:
+    repo = _init_repo(path)
+    (path / tracked).write_text("content\n", encoding="utf-8")
+    repo.index.add([tracked])
+    revision = repo.index.commit("add tracked file").hexsha
+    repo.close()
+    return revision
+
+
+@pytest.fixture
+def s3_archive(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> str:
+    # `git config --global` writes to $HOME, so keep it inside the test.
+    monkeypatch.setenv("HOME", str(tmp_path / "home"))
+    (tmp_path / "home").mkdir()
+
+    source = tmp_path / "source"
+    source.mkdir()
+    revision = _committed_repo(source, "tracked.txt")
+    archive = tmp_path / "repo.tar.gz"
+    _archive_git_dir(source, archive, "source")
+    shutil.rmtree(source)
+
+    async def _fake_download(
+        *,
+        url: str,  # noqa: ARG001
+        destination_path: str,
+        download_buffer_size: int,  # noqa: ARG001
+    ) -> bool:
+        shutil.copyfile(archive, destination_path)
+        return True
+
+    monkeypatch.setattr(download_repo, "download_file", _fake_download)
+    return revision
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("s3_archive")
+async def test_download_repo_from_s3_restores_working_tree(tmp_path: Path) -> None:
+    destination = tmp_path / "groups" / "group" / "root"
+
+    assert await download_repo_from_s3("https://s3/repo.tar.gz", destination)
+
+    assert (destination / "tracked.txt").is_file()
+
+
+@pytest.mark.asyncio
+async def test_download_repo_from_s3_without_checkout_keeps_only_history(
+    tmp_path: Path,
+    s3_archive: str,
+) -> None:
+    destination = tmp_path / "groups" / "group" / "root"
+
+    assert await download_repo_from_s3("https://s3/repo.tar.gz", destination, checkout=False)
+
+    # The point of the flag: the history is complete and readable, and not one
+    # byte of the working tree was written.
+    repo = Repo(destination)
+    assert repo.head.commit.hexsha == s3_archive
+    repo.close()
+    assert not (destination / "tracked.txt").exists()
+    assert [entry.name for entry in destination.iterdir()] == [".git"]

fluidattacks_core_git-12.1.1/tests/test_remote.py

@@ -0,0 +1,106 @@
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from fluidattacks_core.git.remote import ls_remote
+
+_SSH_PATH = "fluidattacks_core.git.remote.call_ssh_ls_remote"
+_CODECOMMIT_PATH = "fluidattacks_core.git.remote.call_codecommit_ls_remote"
+_HTTPS_PATH = "fluidattacks_core.git.remote.call_https_ls_remote"
+
+_SHA = "0" * 40
+_CREDENTIAL = "a-token"
+
+
+@pytest.mark.asyncio
+async def test_ls_remote_with_a_credential_key_goes_over_ssh() -> None:
+    with (
+        patch(_SSH_PATH, AsyncMock(return_value=(_SHA, None))) as ssh,
+        patch(_CODECOMMIT_PATH, AsyncMock()) as codecommit,
+        patch(_HTTPS_PATH, AsyncMock()) as https,
+    ):
+        sha, error = await ls_remote(
+            repo_url="git@github.com:fluidattacks/universe",
+            repo_branch="main",
+            credential_key="a-key",
+            arn="an-arn",
+            org_external_id="an-id",
+        )
+
+    assert (sha, error) == (_SHA, None)
+    ssh.assert_awaited_once_with("git@github.com:fluidattacks/universe", "a-key", "main")
+    codecommit.assert_not_awaited()
+    https.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_ls_remote_with_an_arn_and_an_external_id_goes_over_codecommit() -> None:
+    with (
+        patch(_SSH_PATH, AsyncMock()) as ssh,
+        patch(_CODECOMMIT_PATH, AsyncMock(return_value=(_SHA, None))) as codecommit,
+        patch(_HTTPS_PATH, AsyncMock()) as https,
+    ):
+        sha, error = await ls_remote(
+            repo_url="codecommit://a-repo",
+            repo_branch="main",
+            arn="an-arn",
+            org_external_id="an-id",
+            follow_redirects=True,
+        )
+
+    assert (sha, error) == (_SHA, None)
+    codecommit.assert_awaited_once_with(
+        "codecommit://a-repo",
+        "an-arn",
+        "main",
+        org_external_id="an-id",
+        follow_redirects=True,
+    )
+    ssh.assert_not_awaited()
+    https.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_ls_remote_without_ssh_or_codecommit_inputs_goes_over_https() -> None:
+    with (
+        patch(_SSH_PATH, AsyncMock()) as ssh,
+        patch(_CODECOMMIT_PATH, AsyncMock()) as codecommit,
+        patch(_HTTPS_PATH, AsyncMock(return_value=(_SHA, None))) as https,
+    ):
+        sha, error = await ls_remote(
+            repo_url="https://github.com/fluidattacks/universe",
+            repo_branch="main",
+            token=_CREDENTIAL,
+            provider="GITHUB",
+            is_pat=True,
+        )
+
+    assert (sha, error) == (_SHA, None)
+    https.assert_awaited_once_with(
+        repo_url="https://github.com/fluidattacks/universe",
+        user=None,
+        password=None,
+        token=_CREDENTIAL,
+        branch="main",
+        provider="GITHUB",
+        is_pat=True,
+        follow_redirects=False,
+    )
+    ssh.assert_not_awaited()
+    codecommit.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_ls_remote_forwards_the_error_from_the_transport() -> None:
+    with (
+        patch(_SSH_PATH, AsyncMock()),
+        patch(_CODECOMMIT_PATH, AsyncMock()),
+        patch(_HTTPS_PATH, AsyncMock(return_value=(None, "Repository not found"))),
+    ):
+        sha, error = await ls_remote(
+            repo_url="https://github.com/fluidattacks/nope",
+            repo_branch="main",
+        )
+
+    assert sha is None
+    assert error == "Repository not found"

fluidattacks_core_git-12.1.1/tests/test_upload_repo.py

@@ -0,0 +1,559 @@
+import math
+import tarfile
+import tempfile
+from pathlib import Path
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from fluidattacks_core.git.constants import MAX_S3_PARTS, MULTIPART_PART_SIZE
+from fluidattacks_core.git.upload_repo import (
+    MultipartCallbacks,
+    PartUploadConfig,
+    UploadPartResult,
+    _complete_with_retry,
+    _compute_part_size,
+    _create_tar_archive,
+    _do_part_upload,
+    _file_chunks,
+    _initiate_with_retry,
+    _upload_all_parts,
+    _upload_part_with_retry,
+    upload_repo_to_s3,
+)
+
+_SLEEP_PATH = "fluidattacks_core.git.upload_repo.anyio.sleep"
+_PART_RETRY_PATH = "fluidattacks_core.git.upload_repo._upload_part_with_retry"
+_SESSION_PATH = "fluidattacks_core.git.upload_repo.aiohttp.ClientSession"
+_THRESHOLD_PATH = "fluidattacks_core.git.upload_repo.MULTIPART_THRESHOLD"
+
+
+def _fake_git_repo(base: Path) -> Path:
+    repo = base / "repo"
+    git_dir = repo / ".git"
+    git_dir.mkdir(parents=True)
+    (git_dir / "HEAD").write_text("ref: refs/heads/main\n")
+    return repo
+
+
+def _fake_file(base: Path, content: bytes = b"x" * 512) -> Path:
+    path = base / "data.bin"
+    path.write_bytes(content)
+    return path
+
+
+def _make_mock_session(status: int = 200, etag: str = '"etag-value"') -> MagicMock:
+    mock_response = MagicMock()
+    mock_response.status = status
+    mock_response.headers = {"ETag": etag}
+    mock_response.text = AsyncMock(return_value="error body")
+
+    mock_put_cm = MagicMock()
+    mock_put_cm.__aenter__ = AsyncMock(return_value=mock_response)
+    mock_put_cm.__aexit__ = AsyncMock(return_value=None)
+
+    mock_session = MagicMock()
+    mock_session.__aenter__ = AsyncMock(return_value=mock_session)
+    mock_session.__aexit__ = AsyncMock(return_value=None)
+    mock_session.put = MagicMock(return_value=mock_put_cm)
+
+    return mock_session
+
+
+@pytest.mark.asyncio
+async def test_create_tar_archive_produces_valid_gzip_with_git_entries() -> None:
+    with tempfile.TemporaryDirectory() as tmp:
+        repo_path = _fake_git_repo(Path(tmp))
+        output = Path(tmp) / "archive.tar.gz"
+
+        result = await _create_tar_archive(repo_path, output, "my-repo")
+
+        assert result is True
+        assert output.exists()
+        with tarfile.open(output, "r:gz") as tf:
+            names = tf.getnames()
+        assert all(name.startswith("my-repo/.git") for name in names)
+
+
+@pytest.mark.asyncio
+async def test_create_tar_archive_returns_false_when_git_dir_missing() -> None:
+    with tempfile.TemporaryDirectory() as tmp:
+        repo_path = Path(tmp) / "no-git-here"
+        repo_path.mkdir()
+        output = Path(tmp) / "archive.tar.gz"
+
+        result = await _create_tar_archive(repo_path, output, "my-repo")
+
+        assert result is False
+        assert not output.exists()
+
+
+@pytest.mark.asyncio
+async def test_create_tar_archive_returns_false_on_io_error() -> None:
+    with tempfile.TemporaryDirectory() as tmp:
+        repo_path = _fake_git_repo(Path(tmp))
+        invalid_output = Path(tmp) / "nonexistent_dir" / "archive.tar.gz"
+
+        result = await _create_tar_archive(repo_path, invalid_output, "my-repo")
+
+        assert result is False
+
+
+@pytest.mark.asyncio
+async def test_file_chunks_yields_complete_file_content() -> None:
+    with tempfile.TemporaryDirectory() as tmp:
+        content = b"abcdefgh" * 10_000
+        file_path = Path(tmp) / "test.bin"
+        file_path.write_bytes(content)
+
+        received = [chunk async for chunk in _file_chunks(file_path)]
+
+        assert b"".join(received) == content
+
+
+@pytest.mark.asyncio
+async def test_file_chunks_empty_file_yields_nothing() -> None:
+    with tempfile.TemporaryDirectory() as tmp:
+        file_path = Path(tmp) / "empty.bin"
+        file_path.write_bytes(b"")
+
+        received = [chunk async for chunk in _file_chunks(file_path)]
+
+        assert received == []
+
+
+@pytest.mark.asyncio
+async def test_do_part_upload_returns_etag_on_200() -> None:
+    mock_session = _make_mock_session(status=200, etag='"abc-etag"')
+
+    result = await _do_part_upload(mock_session, "https://example.com/part", b"data")
+
+    assert result == '"abc-etag"'
+
+
+@pytest.mark.asyncio
+async def test_do_part_upload_preserves_etag_quotes_for_s3_completion() -> None:
+    mock_session = _make_mock_session(status=200, etag='"quoted-etag"')
+
+    result = await _do_part_upload(mock_session, "https://example.com/part", b"data")
+
+    assert result == '"quoted-etag"'
+    assert result is not None
+    assert result.startswith('"')
+    assert result.endswith('"')
+
+
+@pytest.mark.asyncio
+async def test_do_part_upload_returns_none_on_non_200_status() -> None:
+    mock_session = _make_mock_session(status=403, etag="")
+
+    result = await _do_part_upload(mock_session, "https://example.com/part", b"data")
+
+    assert result is None
+
+
+@pytest.mark.asyncio
+async def test_initiate_with_retry_returns_upload_id_on_first_attempt() -> None:
+    initiate = AsyncMock(return_value="upload-id-123")
+
+    result = await _initiate_with_retry(initiate)
+
+    assert result == "upload-id-123"
+    assert initiate.call_count == 1
+
+
+@pytest.mark.asyncio
+async def test_initiate_with_retry_retries_after_none_and_succeeds() -> None:
+    initiate = AsyncMock(side_effect=[None, None, "upload-id-ok"])
+
+    with patch(_SLEEP_PATH, new_callable=AsyncMock):
+        result = await _initiate_with_retry(initiate)
+
+    assert result == "upload-id-ok"
+    assert initiate.call_count == 3
+
+
+@pytest.mark.asyncio
+async def test_initiate_with_retry_returns_none_after_all_attempts_fail() -> None:
+    initiate = AsyncMock(return_value=None)
+
+    with patch(_SLEEP_PATH, new_callable=AsyncMock):
+        result = await _initiate_with_retry(initiate)
+
+    assert result is None
+    assert initiate.call_count == 3
+
+
+@pytest.mark.asyncio
+async def test_complete_with_retry_returns_true_on_first_success() -> None:
+    complete = AsyncMock(return_value=True)
+
+    result = await _complete_with_retry("uid", [], complete)
+
+    assert result is True
+    assert complete.call_count == 1
+
+
+@pytest.mark.asyncio
+async def test_complete_with_retry_retries_on_false_then_succeeds() -> None:
+    complete = AsyncMock(side_effect=[False, False, True])
+
+    with patch(_SLEEP_PATH, new_callable=AsyncMock):
+        result = await _complete_with_retry("uid", [], complete)
+
+    assert result is True
+    assert complete.call_count == 3
+
+
+@pytest.mark.asyncio
+async def test_complete_with_retry_returns_false_after_all_attempts_fail() -> None:
+    complete = AsyncMock(return_value=False)
+
+    with patch(_SLEEP_PATH, new_callable=AsyncMock):
+        result = await _complete_with_retry("uid", [], complete)
+
+    assert result is False
+    assert complete.call_count == 3
+
+
+@pytest.mark.asyncio
+async def test_upload_part_with_retry_returns_result_on_first_success() -> None:
+    with tempfile.TemporaryDirectory() as tmp:
+        file_path = _fake_file(Path(tmp))
+        config = PartUploadConfig(
+            file_path=file_path,
+            part_number=2,
+            start_byte=0,
+            end_byte=512,
+            upload_id="upload-id",
+        )
+        get_part_url = AsyncMock(return_value="https://s3.example.com/part")
+
+        with (
+            patch(_SESSION_PATH, return_value=_make_mock_session()),
+            patch(
+                "fluidattacks_core.git.upload_repo._do_part_upload",
+                new_callable=AsyncMock,
+                return_value="part-etag",
+            ),
+        ):
+            result = await _upload_part_with_retry(config, get_part_url)
+
+    assert result is not None
+    assert result.part_number == 2
+    assert result.etag == "part-etag"
+
+
+@pytest.mark.asyncio
+async def test_upload_part_with_retry_succeeds_on_second_attempt() -> None:
+    with tempfile.TemporaryDirectory() as tmp:
+        file_path = _fake_file(Path(tmp))
+        config = PartUploadConfig(
+            file_path=file_path,
+            part_number=1,
+            start_byte=0,
+            end_byte=512,
+            upload_id="upload-id",
+        )
+        get_part_url = AsyncMock(return_value="https://s3.example.com/part")
+
+        with (
+            patch(_SESSION_PATH, return_value=_make_mock_session()),
+            patch(
+                "fluidattacks_core.git.upload_repo._do_part_upload",
+                new_callable=AsyncMock,
+                side_effect=[None, "recovered-etag"],
+            ),
+            patch(_SLEEP_PATH, new_callable=AsyncMock),
+        ):
+            result = await _upload_part_with_retry(config, get_part_url)
+
+    assert result is not None
+    assert result.etag == "recovered-etag"
+
+
+@pytest.mark.asyncio
+async def test_upload_part_with_retry_returns_none_after_all_attempts_exhausted() -> None:
+    with tempfile.TemporaryDirectory() as tmp:
+        file_path = _fake_file(Path(tmp))
+        config = PartUploadConfig(
+            file_path=file_path,
+            part_number=1,
+            start_byte=0,
+            end_byte=512,
+            upload_id="upload-id",
+        )
+        get_part_url = AsyncMock(return_value="https://s3.example.com/part")
+
+        with (
+            patch(_SESSION_PATH, return_value=_make_mock_session()),
+            patch(
+                "fluidattacks_core.git.upload_repo._do_part_upload",
+                new_callable=AsyncMock,
+                return_value=None,
+            ),
+            patch(_SLEEP_PATH, new_callable=AsyncMock),
+        ):
+            result = await _upload_part_with_retry(config, get_part_url)
+
+    assert result is None
+
+
+@pytest.mark.asyncio
+async def test_upload_part_with_retry_skips_attempt_when_presigned_url_empty() -> None:
+    with tempfile.TemporaryDirectory() as tmp:
+        file_path = _fake_file(Path(tmp))
+        config = PartUploadConfig(
+            file_path=file_path,
+            part_number=1,
+            start_byte=0,
+            end_byte=512,
+            upload_id="upload-id",
+        )
+        get_part_url = AsyncMock(return_value="")
+
+        with (
+            patch(_SESSION_PATH, return_value=_make_mock_session()),
+            patch(_SLEEP_PATH, new_callable=AsyncMock),
+        ):
+            result = await _upload_part_with_retry(config, get_part_url)
+
+    assert result is None
+
+
+@pytest.mark.asyncio
+async def test_upload_all_parts_collects_results_indexed_by_part_number() -> None:
+    with tempfile.TemporaryDirectory() as tmp:
+        file_path = _fake_file(Path(tmp), content=b"x" * 100)
+
+        def _make_result(config: PartUploadConfig, _: object) -> UploadPartResult:
+            return UploadPartResult(
+                part_number=config.part_number, etag=f"etag-{config.part_number}"
+            )
+
+        with patch(_PART_RETRY_PATH, new_callable=AsyncMock, side_effect=_make_result):
+            result = await _upload_all_parts(
+                file_path=file_path,
+                file_size=100,
+                upload_id="uid",
+                get_part_url=AsyncMock(return_value="url"),
+                part_size=100,
+            )
+
+    assert result is not None
+    assert result[0].part_number == 1
+    assert result[0].etag == "etag-1"
+
+
+@pytest.mark.asyncio
+async def test_upload_all_parts_returns_none_when_any_part_fails() -> None:
+    with tempfile.TemporaryDirectory() as tmp:
+        file_path = _fake_file(Path(tmp), content=b"x" * 100)
+
+        with patch(_PART_RETRY_PATH, new_callable=AsyncMock, return_value=None):
+            result = await _upload_all_parts(
+                file_path=file_path,
+                file_size=100,
+                upload_id="uid",
+                get_part_url=AsyncMock(return_value="url"),
+                part_size=100,
+            )
+
+    assert result is None
+
+
+@pytest.mark.asyncio
+async def test_upload_repo_to_s3_returns_false_for_nonexistent_path() -> None:
+    result = await upload_repo_to_s3(
+        repo_path=Path("/does/not/exist"),
+        archive_name="test",
+        upload_url="https://example.com",
+    )
+
+    assert result is False
+
+
+@pytest.mark.asyncio
+async def test_upload_repo_to_s3_returns_false_when_upload_url_missing_for_small_file() -> None:
+    with tempfile.TemporaryDirectory() as tmp:
+        repo_path = _fake_git_repo(Path(tmp))
+
+        result = await upload_repo_to_s3(repo_path=repo_path, archive_name="test")
+
+    assert result is False
+
+
+@pytest.mark.asyncio
+async def test_upload_repo_to_s3_returns_false_when_multipart_missing_for_large_file() -> None:
+    with tempfile.TemporaryDirectory() as tmp:
+        repo_path = _fake_git_repo(Path(tmp))
+
+        with patch(_THRESHOLD_PATH, 0):
+            result = await upload_repo_to_s3(
+                repo_path=repo_path,
+                archive_name="test",
+                upload_url="https://example.com",
+            )
+
+    assert result is False
+
+
+@pytest.mark.asyncio
+async def test_upload_repo_to_s3_single_part_returns_true_on_200() -> None:
+    with tempfile.TemporaryDirectory() as tmp:
+        repo_path = _fake_git_repo(Path(tmp))
+
+        with patch(_SESSION_PATH, return_value=_make_mock_session(status=200)):
+            result = await upload_repo_to_s3(
+                repo_path=repo_path,
+                archive_name="test-repo",
+                upload_url="https://s3.example.com/upload",
+            )
+
+    assert result is True
+
+
+@pytest.mark.asyncio
+async def test_upload_repo_to_s3_single_part_returns_false_on_non_200() -> None:
+    with tempfile.TemporaryDirectory() as tmp:
+        repo_path = _fake_git_repo(Path(tmp))
+
+        with patch(_SESSION_PATH, return_value=_make_mock_session(status=500)):
+            result = await upload_repo_to_s3(
+                repo_path=repo_path,
+                archive_name="test-repo",
+                upload_url="https://s3.example.com/upload",
+            )
+
+    assert result is False
+
+
+@pytest.mark.asyncio
+async def test_upload_repo_to_s3_multipart_path_returns_true_on_success() -> None:
+    with tempfile.TemporaryDirectory() as tmp:
+        repo_path = _fake_git_repo(Path(tmp))
+
+        multipart = MultipartCallbacks(
+            initiate_upload=AsyncMock(return_value="upload-id"),
+            get_part_url=AsyncMock(return_value="https://s3.example.com/part"),
+            complete_upload=AsyncMock(return_value=True),
+            abort_upload=AsyncMock(),
+        )
+
+        with (
+            patch(_THRESHOLD_PATH, 0),
+            patch(
+                _PART_RETRY_PATH,
+                new_callable=AsyncMock,
+                return_value=UploadPartResult(part_number=1, etag="etag-1"),
+            ),
+        ):
+            result = await upload_repo_to_s3(
+                repo_path=repo_path,
+                archive_name="test-repo",
+                multipart=multipart,
+            )
+
+    assert result is True
+
+
+@pytest.mark.asyncio
+async def test_upload_repo_to_s3_multipart_calls_abort_when_parts_fail() -> None:
+    with tempfile.TemporaryDirectory() as tmp:
+        repo_path = _fake_git_repo(Path(tmp))
+
+        abort_mock = AsyncMock()
+        multipart = MultipartCallbacks(
+            initiate_upload=AsyncMock(return_value="upload-id"),
+            get_part_url=AsyncMock(return_value="https://s3.example.com/part"),
+            complete_upload=AsyncMock(return_value=True),
+            abort_upload=abort_mock,
+        )
+
+        with (
+            patch(_THRESHOLD_PATH, 0),
+            patch(_PART_RETRY_PATH, new_callable=AsyncMock, return_value=None),
+        ):
+            result = await upload_repo_to_s3(
+                repo_path=repo_path,
+                archive_name="test-repo",
+                multipart=multipart,
+            )
+
+    assert result is False
+    abort_mock.assert_called_once_with("upload-id")
+
+
+@pytest.mark.asyncio
+async def test_upload_repo_to_s3_multipart_calls_abort_when_complete_fails() -> None:
+    with tempfile.TemporaryDirectory() as tmp:
+        repo_path = _fake_git_repo(Path(tmp))
+
+        abort_mock = AsyncMock()
+        multipart = MultipartCallbacks(
+            initiate_upload=AsyncMock(return_value="upload-id"),
+            get_part_url=AsyncMock(return_value="https://s3.example.com/part"),
+            complete_upload=AsyncMock(return_value=False),
+            abort_upload=abort_mock,
+        )
+
+        with (
+            patch(_THRESHOLD_PATH, 0),
+            patch(
+                _PART_RETRY_PATH,
+                new_callable=AsyncMock,
+                return_value=UploadPartResult(part_number=1, etag="etag-1"),
+            ),
+            patch(_SLEEP_PATH, new_callable=AsyncMock),
+        ):
+            result = await upload_repo_to_s3(
+                repo_path=repo_path,
+                archive_name="test-repo",
+                multipart=multipart,
+            )
+
+    assert result is False
+    abort_mock.assert_called_once_with("upload-id")
+
+
+@pytest.mark.asyncio
+async def test_upload_repo_to_s3_multipart_aborts_on_unexpected_exception() -> None:
+    with tempfile.TemporaryDirectory() as tmp:
+        repo_path = _fake_git_repo(Path(tmp))
+
+        abort_mock = AsyncMock()
+        multipart = MultipartCallbacks(
+            initiate_upload=AsyncMock(return_value="upload-id"),
+            get_part_url=AsyncMock(return_value="https://s3.example.com/part"),
+            complete_upload=AsyncMock(return_value=True),
+            abort_upload=abort_mock,
+        )
+
+        with (
+            pytest.raises(ValueError, match="unexpected callback error"),
+            patch(_THRESHOLD_PATH, 0),
+            patch(
+                "fluidattacks_core.git.upload_repo._upload_all_parts",
+                new_callable=AsyncMock,
+                side_effect=ValueError("unexpected callback error"),
+            ),
+        ):
+            await upload_repo_to_s3(
+                repo_path=repo_path,
+                archive_name="test-repo",
+                multipart=multipart,
+            )
+
+    abort_mock.assert_called_once_with("upload-id")
+
+
+def test_compute_part_size_returns_default_for_small_files() -> None:
+    small_file = MULTIPART_PART_SIZE * 100
+    assert _compute_part_size(small_file) == MULTIPART_PART_SIZE
+
+
+def test_compute_part_size_scales_up_for_files_exceeding_10000_parts() -> None:
+    huge_file = MULTIPART_PART_SIZE * (MAX_S3_PARTS + 1)
+    result = _compute_part_size(huge_file)
+    assert result > MULTIPART_PART_SIZE
+    assert math.ceil(huge_file / result) <= MAX_S3_PARTS

{fluidattacks_core_git-12.0.0 → fluidattacks_core_git-12.1.1}/uv.lock

@@ -432,7 +432,7 @@ wheels = [
 
 [[package]]
 name = "fluidattacks-core-git"
-version = "12.0.0"
+version = "12.1.1"
 source = { editable = "." }
 dependencies = [
     { name = "aiofiles" },
@@ -454,6 +454,7 @@ dev = [
     { name = "import-linter" },
     { name = "mypy" },
     { name = "pytest" },
+    { name = "pytest-asyncio" },
     { name = "pytest-cov" },
     { name = "ruff" },
     { name = "types-aiofiles" },
@@ -466,7 +467,7 @@ requires-dist = [
     { name = "anyio", specifier = ">=4.7.0" },
     { name = "boto3", specifier = ">=1.34" },
     { name = "botocore", specifier = ">=1.40.18" },
-    { name = "fluidattacks-core-http", specifier = ">=12.0.0" },
+    { name = "fluidattacks-core-http", specifier = ">=12.1.0" },
     { name = "gitpython", specifier = ">=3.1.41" },
     { name = "pathspec", specifier = ">=0.12.1" },
     { name = "urllib3", specifier = ">=2.6.1" },
@@ -480,6 +481,7 @@ dev = [
     { name = "import-linter", specifier = "==2.11" },
     { name = "mypy", specifier = "==1.19.1" },
     { name = "pytest", specifier = "==9.0.3" },
+    { name = "pytest-asyncio", specifier = ">=1.1.0" },
     { name = "pytest-cov", specifier = ">=7.0.0" },
     { name = "ruff", specifier = "==0.15.0" },
     { name = "types-aiofiles", specifier = "==24.1.0.20240626" },
@@ -487,16 +489,16 @@ dev = [
 
 [[package]]
 name = "fluidattacks-core-http"
-version = "12.0.0"
+version = "12.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohttp" },
     { name = "certifi" },
     { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/cf/89/51755605b83f8ce87624badb0b54bdc5787b06c8fd47047c2c0c6cb50772/fluidattacks_core_http-12.0.0.tar.gz", hash = "sha256:5f4111394c194fb10a869f6ee0ea7d76f313c85a0dedbbc3d26f9c9d9d33aa13", size = 86512, upload-time = "2026-08-18T20:17:39.722Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/6c/a2/822f0a6d06cffea448cb7be1d731c028a0df6d5e657700fabd749f176f8d/fluidattacks_core_http-12.1.0.tar.gz", hash = "sha256:b3ef49420da9a3bd24e050b0b5b7a6666b1a0e7b308e97a59e871d80e27aa222", size = 89677, upload-time = "2026-08-27T19:19:54.15Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9e/9f/42ff5b135fe9fcf30d14b08a8b68a404f9b0e7338166952ab75539911a52/fluidattacks_core_http-12.0.0-py3-none-any.whl", hash = "sha256:e6f41f6a1683fa04f0867e0867d6922be2332f776ef651bec12d56c5d18caff2", size = 3707, upload-time = "2026-08-18T20:17:41.207Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/cd/1beca25745de6058a43ee5c417c064c42ac645990fbdfd739ec4a2fe2f33/fluidattacks_core_http-12.1.0-py3-none-any.whl", hash = "sha256:6f15e283f8ebed0fcf73cb9cd2be268f1d891c1e3e9635b6cd2323c1084f014c", size = 4403, upload-time = "2026-08-27T19:19:54.855Z" },
 ]
 
 [[package]]
@@ -1331,6 +1333,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" },
 ]
 
+[[package]]
+name = "pytest-asyncio"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/43/7c/d36d04db312ecf4298932ef77e6e4a9e8ad017906e24e34f0b0c361a2473/pytest_asyncio-1.4.0.tar.gz", hash = "sha256:c6c0d2259945122819f171a32ecea2c349ead889ee28176caaf492143424be42", size = 58514, upload-time = "2026-05-26T09:56:04.083Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/03/e2/08a497ef684b88559c9cc5f4ad53a37e7b99e727094a86d6ea32536d5d3c/pytest_asyncio-1.4.0-py3-none-any.whl", hash = "sha256:933ca923a23075a87fb7070c0ec272a6848489824d887c85c812670932835aa1", size = 16930, upload-time = "2026-05-26T09:56:02.576Z" },
+]
+
 [[package]]
 name = "pytest-cov"
 version = "7.1.0"