chore: update FastAPI and MinIO integration for large file uploads

- Added new feature tests for uploading files of varying sizes.
- Refactored existing MinIO upload scenarios to use a more flexible input method for streams.

Author: HosseinNejatiJavaremi

features/fastapi_minio_upload.feature

@@ -0,0 +1,19 @@
+@needs-minio
+Feature: FastAPI MinIO large file upload
+  As a developer
+  I want to upload a large file through a FastAPI endpoint backed by the MinIO adapter
+  So that streaming uploads work end-to-end
+
+  Scenario Outline: Upload a <size_mb> MB file through a FastAPI endpoint to MinIO
+    Given a bucket named "uploads-bucket" exists
+    And a FastAPI app with a MinIO upload endpoint
+    And a temporary file of <size_mb> MB
+    When I POST the file as "<object>" to the upload endpoint targeting bucket "uploads-bucket"
+    Then the upload response status should be 201
+    And the object "<object>" in bucket "uploads-bucket" should have size of at least <size_mb> MB
+
+    Examples:
+      | size_mb | object          |
+      | 50      | file-50mb.bin   |
+      | 75      | file-75mb.bin   |
+      | 100     | file-100mb.bin  |

features/minio_adapter.feature

@@ -46,14 +46,13 @@ Feature: MinIO Operations Testing
     Then the object "test-copy.txt" should exist in bucket "test-bucket"
     And downloading "test-copy.txt" from "test-bucket" should return content "Hello World"
 
-  Scenario: Upload bytes buffer and retrieve via stream
+  Scenario Outline: Upload via <input_kind> and retrieve via stream
     Given a bucket named "test-bucket" exists
-    When I upload the bytes "Hello Streaming World" as "stream-bytes.txt" to bucket "test-bucket"
-    Then the object "stream-bytes.txt" should exist in bucket "test-bucket"
-    And the streaming download of "stream-bytes.txt" from "test-bucket" should return "Hello Streaming World"
-
-  Scenario: Upload binary stream and retrieve via stream
-    Given a bucket named "test-bucket" exists
-    When I upload a binary stream with content "Binary Stream Data" as "stream-bio.txt" to bucket "test-bucket"
-    Then the object "stream-bio.txt" should exist in bucket "test-bucket"
-    And the streaming download of "stream-bio.txt" from "test-bucket" should return "Binary Stream Data"
+    When I upload <input_kind> "<content>" as "<object>" to bucket "test-bucket"
+    Then the object "<object>" should exist in bucket "test-bucket"
+    And the streaming download of "<object>" from "test-bucket" should return "<content>"
+
+    Examples:
+      | input_kind      | content               | object           |
+      | the bytes       | Hello Streaming World | stream-bytes.txt |
+      | a binary stream | Binary Stream Data    | stream-bio.txt   |

features/steps/fastapi_minio_upload_steps.py

@@ -0,0 +1,76 @@
+import os
+import tempfile
+
+from behave import given, then, when
+from fastapi import UploadFile
+from starlette.responses import JSONResponse
+from starlette.testclient import TestClient
+
+from archipy.adapters.minio.adapters import MinioAdapter
+from archipy.configs.base_config import BaseConfig
+from archipy.helpers.utils.app_utils import AppUtils
+from features.steps.minio_adapter_steps import get_minio_adapter
+from features.test_helpers import get_current_scenario_context
+
+_MB = 1024 * 1024
+
+
+@given("a FastAPI app with a MinIO upload endpoint")
+def step_build_app(context):
+    scenario_context = get_current_scenario_context(context)
+    app = AppUtils.create_fastapi_app(BaseConfig.global_config())
+
+    @app.post("/buckets/{bucket_name}/objects/{object_name}")
+    async def upload(bucket_name: str, object_name: str, file: UploadFile):
+        adapter = MinioAdapter(BaseConfig.global_config().MINIO)
+        adapter.put_object_stream(
+            bucket_name,
+            object_name,
+            file.file,
+            length=file.size or -1,
+            content_type=file.content_type or "application/octet-stream",
+        )
+        return JSONResponse(status_code=201, content={"object": object_name, "size": file.size})
+
+    scenario_context.store("app", app)
+
+
+@given("a temporary file of {size_mb:d} MB")
+def step_make_file(context, size_mb):
+    scenario_context = get_current_scenario_context(context)
+    fd, path = tempfile.mkstemp(suffix=".bin")
+    chunk = b"\0" * _MB
+    with os.fdopen(fd, "wb") as fh:
+        for _ in range(size_mb):
+            fh.write(chunk)
+    scenario_context.store("upload_path", path)
+
+
+@when('I POST the file as "{object_name}" to the upload endpoint targeting bucket "{bucket_name}"')
+def step_post(context, object_name, bucket_name):
+    scenario_context = get_current_scenario_context(context)
+    app = scenario_context.get("app")
+    path = scenario_context.get("upload_path")
+    client = TestClient(app)
+    try:
+        with open(path, "rb") as fh:
+            response = client.post(
+                f"/buckets/{bucket_name}/objects/{object_name}",
+                files={"file": (object_name, fh, "application/octet-stream")},
+            )
+    finally:
+        os.unlink(path)
+    scenario_context.store("response", response)
+
+
+@then("the upload response status should be {code:d}")
+def step_status(context, code):
+    scenario_context = get_current_scenario_context(context)
+    assert scenario_context.get("response").status_code == code
+
+
+@then('the object "{object_name}" in bucket "{bucket_name}" should have size of at least {size_mb:d} MB')
+def step_check_size(context, object_name, bucket_name, size_mb):
+    adapter = get_minio_adapter(context)
+    stat = adapter.stat_object(bucket_name, object_name)
+    assert stat["size"] >= size_mb * _MB, f"size {stat['size']} < {size_mb * _MB}"

features/steps/minio_adapter_steps.py

@@ -221,23 +221,17 @@ def step_verify_policy(context, bucket_name):
     context.logger.info(f"Verified read-only policy for '{bucket_name}'")
 
 
-@when('I upload the bytes "{content}" as "{object_name}" to bucket "{bucket_name}"')
-def step_upload_bytes_stream(context, content, object_name, bucket_name):
-    adapter = get_minio_adapter(context)
-    data = content.encode("utf-8")
-    adapter.put_object_stream(bucket_name, object_name, data, content_type="text/plain; charset=utf-8")
-    context.logger.info(f"Uploaded bytes stream '{object_name}' to '{bucket_name}'")
-
-
-@when('I upload a binary stream with content "{content}" as "{object_name}" to bucket "{bucket_name}"')
-def step_upload_binary_stream(context, content, object_name, bucket_name):
+@when('I upload {input_kind} "{content}" as "{object_name}" to bucket "{bucket_name}"')
+def step_upload_stream(context, input_kind, content, object_name, bucket_name):
     adapter = get_minio_adapter(context)
     raw = content.encode("utf-8")
-    stream = io.BytesIO(raw)
-    adapter.put_object_stream(
-        bucket_name, object_name, stream, length=len(raw), content_type="text/plain; charset=utf-8"
-    )
-    context.logger.info(f"Uploaded binary stream '{object_name}' to '{bucket_name}'")
+    if input_kind == "a binary stream":
+        adapter.put_object_stream(
+            bucket_name, object_name, io.BytesIO(raw), length=len(raw), content_type="text/plain; charset=utf-8",
+        )
+    else:
+        adapter.put_object_stream(bucket_name, object_name, raw, content_type="text/plain; charset=utf-8")
+    context.logger.info(f"Uploaded {input_kind} '{object_name}' to '{bucket_name}'")
 
 
 @then('the streaming download of "{object_name}" from "{bucket_name}" should return "{expected_content}"')

pyproject.toml

@@ -25,13 +25,13 @@ dependency-injection = ["dependency-injector>=4.49.0"]
 elastic-apm = ["elastic-apm>=6.26.1"]
 elasticsearch = ["elasticsearch>=9.4.1"]
 elasticsearch-async = ["elasticsearch[async]>=9.4.1"]
-fakeredis = ["fakeredis>=2.36.1"]
-fastapi = ["fastapi[all]>=0.137.1"]
+fakeredis = ["fakeredis>=2.36.2"]
+fastapi = ["fastapi[all]>=0.137.2"]
 grpc = ["grpcio>=1.81.1", "grpcio-health-checking>=1.81.1", "protobuf>=6.33.6"]
 jwt = ["pyjwt>=2.13.0"]
 kafka = ["confluent-kafka>=2.14.2"]
 keycloak = ["python-keycloak>=7.1.1", "cachetools>=7.1.4", "async-lru>=2.3.0"]
-minio = ["boto3>=1.43.29", "cachetools>=7.1.4", "async-lru>=2.3.0"]
+minio = ["boto3>=1.43.32", "cachetools>=7.1.4", "async-lru>=2.3.0"]
 parsian-ipg = ["zeep>=4.3.2", "requests[socks]>=2.34.2"]
 parsian-ipg-async = ["zeep[async]>=4.3.2", "httpx2[socks]>=2.4.0"]
 postgres = ["psycopg[binary,pool]>=3.3.4"]
@@ -40,9 +40,9 @@ redis = ["redis[hiredis]>=8.0.0"]
 saman-ipg = ["httpx2[socks]>=2.4.0"]
 scheduler = ["apscheduler>=3.11.2"]
 scylladb = ["scylla-driver>=3.29.11", "lz4>=4.4.5", "cachetools>=7.1.4", "async-lru>=2.3.0"]
-sentry = ["sentry-sdk>=2.62.0"]
-sqlalchemy = ["sqlalchemy>=2.0.50"]
-sqlalchemy-async = ["sqlalchemy[asyncio]>=2.0.50"]
+sentry = ["sentry-sdk>=2.63.0"]
+sqlalchemy = ["sqlalchemy>=2.0.51"]
+sqlalchemy-async = ["sqlalchemy[asyncio]>=2.0.51"]
 starrocks = ["starrocks>=1.3.3", "pymysql>=1.2.0"]
 starrocks-async = ["starrocks>=1.3.3", "aiomysql>=0.3.2", "asyncmy2>=0.2.20"]
 temporalio = ["temporalio>=1.24.0"]
@@ -56,14 +56,14 @@ build-backend = "hatchling.build"
 dev = [
     "add-trailing-comma>=4.0.0",
     "bandit>=1.9.4",
-    "boto3-stubs>=1.43.14",
+    "boto3-stubs>=1.43.32",
     "codespell>=2.4.2",
     "pre-commit-hooks>=6.0.0",
     "pre-commit>=4.6.0",
-    "ruff>=0.15.14",
-    "ty>=0.0.39",
+    "ruff>=0.15.17",
+    "ty>=0.0.50",
     "types-cachetools>=7.0.0.20260518",
-    "types-grpcio>=1.0.0.20260518",
+    "types-grpcio>=1.0.0.20260614",
     "types-protobuf>=7.34.1.20260518",
     "types-pymysql>=1.1.0.20260518",
     "types-regex>=2026.5.9.20260518",
@@ -75,7 +75,7 @@ docs = [
     "mkdocs-autorefs>=1.4.4",
     "mkdocs-material>=9.7.6",
     "mkdocs>=1.6.1",
-    "mkdocstrings-python>=2.0.3",
+    "mkdocstrings-python>=2.0.4",
     "mkdocstrings>=1.0.4",
     "pymdown-extensions>=10.21.3",
 ]