145 lines
4.9 KiB
Python
145 lines
4.9 KiB
Python
import asyncio
|
|
import unittest
|
|
from unittest.mock import AsyncMock, MagicMock, patch
|
|
from uuid import uuid4
|
|
|
|
from src.main import upload_attachment_endpoint
|
|
|
|
|
|
class UploadCompensationTests(unittest.IsolatedAsyncioTestCase):
|
|
async def run_failure_scenario(
|
|
self,
|
|
failure_stage,
|
|
verification_result=False,
|
|
verification_error=None,
|
|
):
|
|
chat_id = uuid4()
|
|
user_id = uuid4()
|
|
uploaded_keys = []
|
|
deleted_keys = []
|
|
|
|
request = MagicMock()
|
|
request.headers = {"content-type": "image/png"}
|
|
|
|
async def stream():
|
|
yield b"test-image"
|
|
|
|
request.stream = stream
|
|
|
|
user = MagicMock()
|
|
user.id = user_id
|
|
|
|
session = MagicMock()
|
|
session.commit = AsyncMock()
|
|
session.rollback = AsyncMock()
|
|
|
|
async def fake_put_object(key, body, content_type):
|
|
uploaded_keys.append(key)
|
|
|
|
async def fake_delete_object(key):
|
|
deleted_keys.append(key)
|
|
|
|
with (
|
|
patch("src.main.get_chat_by_id", new_callable=AsyncMock) as get_chat,
|
|
patch("src.main.validate_image", return_value=(10, "test-sha256")),
|
|
patch("src.main.put_object", side_effect=fake_put_object),
|
|
patch("src.main.create_attachment", new_callable=AsyncMock) as create,
|
|
patch("src.main.delete_object", side_effect=fake_delete_object),
|
|
patch("src.main.SessionFactory") as session_factory,
|
|
patch("src.main.attachment_key_exists", new_callable=AsyncMock) as exists,
|
|
):
|
|
get_chat.return_value = MagicMock()
|
|
|
|
verification_session = AsyncMock()
|
|
session_factory.return_value.__aenter__.return_value = verification_session
|
|
|
|
if verification_error is not None:
|
|
exists.side_effect = verification_error
|
|
else:
|
|
exists.return_value = verification_result
|
|
|
|
if failure_stage == "insert":
|
|
create.side_effect = RuntimeError("Simulated INSERT failure")
|
|
expected_error = RuntimeError
|
|
elif failure_stage == "commit":
|
|
create.return_value = MagicMock()
|
|
session.commit.side_effect = RuntimeError("Simulated COMMIT failure")
|
|
expected_error = RuntimeError
|
|
elif failure_stage == "cancel":
|
|
create.side_effect = asyncio.CancelledError()
|
|
expected_error = asyncio.CancelledError
|
|
else:
|
|
raise ValueError("Unknown failure stage")
|
|
|
|
with self.assertRaises(expected_error):
|
|
await upload_attachment_endpoint(
|
|
chat_id=chat_id,
|
|
request=request,
|
|
filename="test.png",
|
|
current_user=user,
|
|
session=session,
|
|
)
|
|
|
|
self.assertEqual(len(uploaded_keys), 1)
|
|
self.assertTrue(
|
|
uploaded_keys[0].startswith(f"attachments/{chat_id}/")
|
|
)
|
|
session.rollback.assert_awaited_once()
|
|
exists.assert_awaited_once_with(
|
|
verification_session,
|
|
uploaded_keys[0],
|
|
)
|
|
|
|
if failure_stage == "commit":
|
|
session.commit.assert_awaited_once()
|
|
else:
|
|
session.commit.assert_not_awaited()
|
|
|
|
return uploaded_keys, deleted_keys
|
|
|
|
async def test_insert_failure_deletes_unregistered_object(self):
|
|
uploaded, deleted = await self.run_failure_scenario(
|
|
failure_stage="insert",
|
|
verification_result=False,
|
|
)
|
|
|
|
self.assertEqual(deleted, uploaded)
|
|
|
|
async def test_commit_failure_deletes_unregistered_object(self):
|
|
uploaded, deleted = await self.run_failure_scenario(
|
|
failure_stage="commit",
|
|
verification_result=False,
|
|
)
|
|
|
|
self.assertEqual(deleted, uploaded)
|
|
|
|
async def test_cancellation_deletes_unregistered_object(self):
|
|
uploaded, deleted = await self.run_failure_scenario(
|
|
failure_stage="cancel",
|
|
verification_result=False,
|
|
)
|
|
|
|
self.assertEqual(deleted, uploaded)
|
|
|
|
async def test_commit_failure_preserves_registered_object(self):
|
|
uploaded, deleted = await self.run_failure_scenario(
|
|
failure_stage="commit",
|
|
verification_result=True,
|
|
)
|
|
|
|
self.assertEqual(len(uploaded), 1)
|
|
self.assertEqual(deleted, [])
|
|
|
|
async def test_database_unavailable_preserves_object(self):
|
|
uploaded, deleted = await self.run_failure_scenario(
|
|
failure_stage="commit",
|
|
verification_error=ConnectionError("Database unavailable"),
|
|
)
|
|
|
|
self.assertEqual(len(uploaded), 1)
|
|
self.assertEqual(deleted, [])
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|