fluidattacks_core_git 12.1.0__tar.gz → 12.2.0__tar.gz

{fluidattacks_core_git-12.1.0 → fluidattacks_core_git-12.2.0}/.gitignore

@@ -1,3 +1,4 @@
+dist/
 dist-*/
 /.cargo-cache
 target/
@@ -5,3 +6,4 @@ target/
 .venv/
 .vscode/settings.json
 .zed/settings.json
+*.so

{fluidattacks_core_git-12.1.0 → fluidattacks_core_git-12.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: fluidattacks_core_git
-Version: 12.1.0
+Version: 12.2.0
 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.2.0
 Requires-Dist: gitpython>=3.1.41
 Requires-Dist: pathspec>=0.12.1
 Requires-Dist: urllib3>=2.6.1

{fluidattacks_core_git-12.1.0 → fluidattacks_core_git-12.2.0}/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.1.0 → fluidattacks_core_git-12.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fluidattacks_core_git"
-version = "12.1.0"
+version = "12.2.0"
 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.2.0",
   "GitPython>=3.1.41",
   "pathspec>=0.12.1",
   "urllib3>=2.6.1",

fluidattacks_core_git-12.2.0/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.2.0/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.1.0 → fluidattacks_core_git-12.2.0}/uv.lock

@@ -432,7 +432,7 @@ wheels = [
 
 [[package]]
 name = "fluidattacks-core-git"
-version = "12.1.0"
+version = "12.2.0"
 source = { editable = "." }
 dependencies = [
     { name = "aiofiles" },
@@ -467,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.2.0" },
     { name = "gitpython", specifier = ">=3.1.41" },
     { name = "pathspec", specifier = ">=0.12.1" },
     { name = "urllib3", specifier = ">=2.6.1" },
@@ -489,16 +489,16 @@ dev = [
 
 [[package]]
 name = "fluidattacks-core-http"
-version = "12.0.0"
+version = "12.2.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/6b/99/40c8c8033bbb0b23375420c5b040821a18291b104e8e555c2ea6cd0233f5/fluidattacks_core_http-12.2.0.tar.gz", hash = "sha256:015c4de5181c5a0b56007a2fe9a5791a4bf6507401f11ceb22f264b4131f63d4", size = 89098, upload-time = "2026-09-01T22:06:31.705Z" }
 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/04/bd/82c05bd3ba0a6d7eb86ec8d0ce8294c515bade2b53782de51454dddce678/fluidattacks_core_http-12.2.0-py3-none-any.whl", hash = "sha256:31e5600e0dc7d060f9b6a0df92f19f2516ecded0e341809613533c605939594a", size = 5143, upload-time = "2026-09-01T22:06:32.53Z" },
 ]
 
 [[package]]

fluidattacks_core_git-12.1.0/build/default.nix

@@ -1,24 +0,0 @@
-{
-  nixpkgs,
-  src,
-  workspace_root,
-}:
-{
-  inherit src workspace_root;
-  root_path = "develops/fluidattacks-core/python/git";
-  module_name = "fluidattacks_core";
-  native.nativeBuildInputs = [ nixpkgs.git ];
-  pypi_token = {
-    method = "oidc";
-  };
-  override = {
-    checks = {
-      basedpyright = false;
-    };
-    configs = {
-      import_linter = ../import-linter.cfg;
-      mypy = ../mypy.ini;
-      ruff = ../ruff.toml;
-    };
-  };
-}

fluidattacks_core_git-12.1.0/build/filter.nix

@@ -1,13 +0,0 @@
-path_filter: src:
-path_filter {
-  root = src;
-  include = [
-    "fluidattacks_core"
-    "tests"
-    "import-linter.cfg"
-    "mypy.ini"
-    "pyproject.toml"
-    "ruff.toml"
-    "uv.lock"
-  ];
-}

fluidattacks_core_git-12.1.0/flake.lock

@@ -1,303 +0,0 @@
-{
-  "nodes": {
-    "flake-parts": {
-      "inputs": {
-        "nixpkgs-lib": "nixpkgs-lib"
-      },
-      "locked": {
-        "lastModified": 1762810396,
-        "narHash": "sha256-dxFVgQPG+R72dkhXTtqUm7KpxElw3u6E+YlQ2WaDgt8=",
-        "owner": "hercules-ci",
-        "repo": "flake-parts",
-        "rev": "0bdadb1b265fb4143a75bd1ec7d8c915898a9923",
-        "type": "github"
-      },
-      "original": {
-        "owner": "hercules-ci",
-        "repo": "flake-parts",
-        "type": "github"
-      }
-    },
-    "nix_filter": {
-      "locked": {
-        "lastModified": 1757882181,
-        "narHash": "sha256-+cCxYIh2UNalTz364p+QYmWHs0P+6wDhiWR4jDIKQIU=",
-        "owner": "numtide",
-        "repo": "nix-filter",
-        "rev": "59c44d1909c72441144b93cf0f054be7fe764de5",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "nix-filter",
-        "type": "github"
-      }
-    },
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1758690382,
-        "narHash": "sha256-NY3kSorgqE5LMm1LqNwGne3ZLMF2/ILgLpFr1fS4X3o=",
-        "owner": "nixos",
-        "repo": "nixpkgs",
-        "rev": "e643668fd71b949c53f8626614b21ff71a07379d",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nixos",
-        "ref": "nixos-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "nixpkgs-lib": {
-      "locked": {
-        "lastModified": 1761765539,
-        "narHash": "sha256-b0yj6kfvO8ApcSE+QmA6mUfu8IYG6/uU28OFn4PaC8M=",
-        "owner": "nix-community",
-        "repo": "nixpkgs.lib",
-        "rev": "719359f4562934ae99f5443f20aa06c2ffff91fc",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-community",
-        "repo": "nixpkgs.lib",
-        "type": "github"
-      }
-    },
-    "nixpkgs_2": {
-      "locked": {
-        "lastModified": 1758690382,
-        "narHash": "sha256-NY3kSorgqE5LMm1LqNwGne3ZLMF2/ILgLpFr1fS4X3o=",
-        "owner": "nixos",
-        "repo": "nixpkgs",
-        "rev": "e643668fd71b949c53f8626614b21ff71a07379d",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nixos",
-        "ref": "nixos-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "nixpkgs_3": {
-      "locked": {
-        "lastModified": 1761373498,
-        "narHash": "sha256-Q/uhWNvd7V7k1H1ZPMy/vkx3F8C13ZcdrKjO7Jv7v0c=",
-        "owner": "nixos",
-        "repo": "nixpkgs",
-        "rev": "6a08e6bb4e46ff7fcbb53d409b253f6bad8a28ce",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nixos",
-        "ref": "nixos-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "nixpkgs_flake": {
-      "locked": {
-        "lastModified": 1778253243,
-        "narHash": "sha256-KkH2QvU6iRLDTGGEwH5jnMqHWj4zMTuHxi1S1zdr01w=",
-        "owner": "nixos",
-        "repo": "nixpkgs",
-        "rev": "4fcda7103530b23c5ca44286344912082aad4220",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nixos",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "pyproject-build-systems": {
-      "inputs": {
-        "nixpkgs": "nixpkgs",
-        "pyproject-nix": "pyproject-nix",
-        "uv2nix": "uv2nix"
-      },
-      "locked": {
-        "lastModified": 1761781027,
-        "narHash": "sha256-YDvxPAm2WnxrznRqWwHLjryBGG5Ey1ATEJXrON+TWt8=",
-        "owner": "pyproject-nix",
-        "repo": "build-system-pkgs",
-        "rev": "795a980d25301e5133eca37adae37283ec3c8e66",
-        "type": "github"
-      },
-      "original": {
-        "owner": "pyproject-nix",
-        "repo": "build-system-pkgs",
-        "type": "github"
-      }
-    },
-    "pyproject-nix": {
-      "inputs": {
-        "nixpkgs": [
-          "python_builder",
-          "pyproject-build-systems",
-          "nixpkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1758265079,
-        "narHash": "sha256-amLaLNwKSZPShQHzfgmc/9o76dU8xzN0743dWgvYlr8=",
-        "owner": "nix-community",
-        "repo": "pyproject.nix",
-        "rev": "02e9418fd4af638447dca4b17b1280da95527fc9",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-community",
-        "repo": "pyproject.nix",
-        "type": "github"
-      }
-    },
-    "pyproject-nix_2": {
-      "inputs": {
-        "nixpkgs": "nixpkgs_2"
-      },
-      "locked": {
-        "lastModified": 1762427963,
-        "narHash": "sha256-CkPlAbIQ87wmjy5qHibfzk4DmMGBNqFer+lLfXjpP5M=",
-        "owner": "pyproject-nix",
-        "repo": "pyproject.nix",
-        "rev": "4540ea004e04fcd12dd2738d51383d10f956f7b9",
-        "type": "github"
-      },
-      "original": {
-        "owner": "pyproject-nix",
-        "repo": "pyproject.nix",
-        "type": "github"
-      }
-    },
-    "pyproject-nix_3": {
-      "inputs": {
-        "nixpkgs": [
-          "python_builder",
-          "uv2nix",
-          "nixpkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1760402624,
-        "narHash": "sha256-jF6UKLs2uGc2rtved8Vrt58oTWjTQoAssuYs/0578Z4=",
-        "owner": "pyproject-nix",
-        "repo": "pyproject.nix",
-        "rev": "84c4ea102127c77058ea1ed7be7300261fafc7d2",
-        "type": "github"
-      },
-      "original": {
-        "owner": "pyproject-nix",
-        "repo": "pyproject.nix",
-        "type": "github"
-      }
-    },
-    "python_builder": {
-      "inputs": {
-        "nix_filter": "nix_filter",
-        "nixpkgs_flake": "nixpkgs_flake",
-        "pyproject-build-systems": "pyproject-build-systems",
-        "pyproject-nix": "pyproject-nix_2",
-        "shell-helpers": "shell-helpers",
-        "uv2nix": "uv2nix_2"
-      },
-      "locked": {
-        "dir": "common/utils/python-builder",
-        "lastModified": 1787078362,
-        "narHash": "sha256-HYL7Rn6SuNjYxkt/PwFLksZjsauCiY+ENbOWryLsIlw=",
-        "ref": "refs/heads/trunk",
-        "rev": "09fd25a13309eb5e3b5b2a061bb340df3ae5d281",
-        "shallow": true,
-        "type": "git",
-        "url": "ssh://git@gitlab.com/fluidattacks/universe"
-      },
-      "original": {
-        "dir": "common/utils/python-builder",
-        "rev": "09fd25a13309eb5e3b5b2a061bb340df3ae5d281",
-        "shallow": true,
-        "type": "git",
-        "url": "ssh://git@gitlab.com/fluidattacks/universe"
-      }
-    },
-    "root": {
-      "inputs": {
-        "python_builder": "python_builder"
-      }
-    },
-    "shell-helpers": {
-      "inputs": {
-        "flake-parts": "flake-parts",
-        "nixpkgs": [
-          "python_builder",
-          "nixpkgs_flake"
-        ]
-      },
-      "locked": {
-        "dir": "common/utils/shell-helpers",
-        "lastModified": 1762806066,
-        "narHash": "sha256-Wz99Fl7SpPU1NkTHJ36XOo6DjOEAMXCw3ThRABOS2Hs=",
-        "ref": "refs/heads/trunk",
-        "rev": "d73cfdc7ae9e7f547e22a4481d4c2ccce38b26a8",
-        "shallow": true,
-        "type": "git",
-        "url": "ssh://git@gitlab.com/fluidattacks/universe"
-      },
-      "original": {
-        "dir": "common/utils/shell-helpers",
-        "rev": "d73cfdc7ae9e7f547e22a4481d4c2ccce38b26a8",
-        "shallow": true,
-        "type": "git",
-        "url": "ssh://git@gitlab.com/fluidattacks/universe"
-      }
-    },
-    "uv2nix": {
-      "inputs": {
-        "nixpkgs": [
-          "python_builder",
-          "pyproject-build-systems",
-          "nixpkgs"
-        ],
-        "pyproject-nix": [
-          "python_builder",
-          "pyproject-build-systems",
-          "pyproject-nix"
-        ]
-      },
-      "locked": {
-        "lastModified": 1758933732,
-        "narHash": "sha256-HAmm1GBS1myZCFuog0DC2ZLaynvZtiUI2Crmo+cdQI0=",
-        "owner": "pyproject-nix",
-        "repo": "uv2nix",
-        "rev": "273ce18f913d8559e0d04f820d724308966d7c4d",
-        "type": "github"
-      },
-      "original": {
-        "owner": "pyproject-nix",
-        "repo": "uv2nix",
-        "type": "github"
-      }
-    },
-    "uv2nix_2": {
-      "inputs": {
-        "nixpkgs": "nixpkgs_3",
-        "pyproject-nix": "pyproject-nix_3"
-      },
-      "locked": {
-        "lastModified": 1761872265,
-        "narHash": "sha256-i25GRgp2vUOebY70L3NTAgkd+Pr1hnn5xM3qHxH0ONU=",
-        "owner": "pyproject-nix",
-        "repo": "uv2nix",
-        "rev": "74dfb62871be152ad3673b143b0cc56105a4f3c5",
-        "type": "github"
-      },
-      "original": {
-        "owner": "pyproject-nix",
-        "repo": "uv2nix",
-        "type": "github"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}

fluidattacks_core_git-12.1.0/flake.nix

@@ -1,30 +0,0 @@
-{
-  description = "Fluid Attacks Core git package.";
-
-  inputs = {
-    python_builder = {
-      url = "git+ssh://git@gitlab.com/fluidattacks/universe?shallow=1&rev=09fd25a13309eb5e3b5b2a061bb340df3ae5d281&dir=common/utils/python-builder";
-    };
-  };
-
-  outputs =
-    { self, ... }@inputs:
-    let
-      build_args =
-        {
-          system,
-          python_version,
-          nixpkgs,
-          builders,
-          scripts,
-        }:
-        import ./build {
-          inherit nixpkgs;
-          src = import ./build/filter.nix nixpkgs.nix-filter self;
-          workspace_root = ./.;
-        };
-    in
-    {
-      packages = inputs.python_builder.outputs.build build_args;
-    };
-}