Name: {contact_data.get('name', '')}
+Email: {contact_data.get('email', '')}
+Telefon: {contact_data.get('phone', '')}
+Nachricht:
+{contact_data.get('message', '')}
+ """ + text = ( + f"Neue Kontaktanfrage\n" + f"Name: {contact_data.get('name', '')}\n" + f"Email: {contact_data.get('email', '')}\n" + f"Telefon: {contact_data.get('phone', '')}\n" + f"Nachricht: {contact_data.get('message', '')}\n" + ) + return await self.send_email( + to_addr=settings.smtp_from, + subject="Neue Kontaktanfrage ueber hms-licht-ton.de", + html_body=html, + text_body=text, + reply_to=contact_data.get("email"), + db=db, + ) + + async def send_rental_confirmation( + self, + to_addr: str, + reference_number: str, + event_name: str, + items: list[dict[str, Any]], + db: AsyncSession | None = None, + ) -> bool: + """Send rental request confirmation to customer.""" + items_html = "".join( + f"Vielen Dank für Ihre Mietanfrage bei HMS Licht & Ton.
+Veranstaltung: {event_name}
+Referenznummer: {reference_number}
+Wir melden uns in Kürze bei Ihnen.
+Ihr HMS Licht & Ton Team
+ """ + text = ( + f"Mietanfrage bestaetigt - {reference_number}\n" + f"Veranstaltung: {event_name}\n" + f"Referenznummer: {reference_number}\n" + f"Artikel:\n" + + "\n".join( + f"- {item.get('equipment_name', 'Unbekannt')}: {item.get('quantity', 1)}" + for item in items + ) + ) + return await self.send_email( + to_addr=to_addr, + subject=f"Mietanfrage bestaetigt – {reference_number}", + html_body=html, + text_body=text, + db=db, + ) + + @staticmethod + async def retry_failed_emails(db: AsyncSession, max_attempts: int = 5) -> int: + """Retry all pending emails in the queue. Returns count of successfully sent emails.""" + result = await db.execute( + select(EmailQueue).where( + EmailQueue.status == "pending", + EmailQueue.attempts < max_attempts, + ) + ) + pending = result.scalars().all() + sent_count = 0 + + for item in pending: + item.attempts += 1 + msg = MIMEMultipart("alternative") + msg["From"] = settings.smtp_from + msg["To"] = item.to_addr + msg["Subject"] = item.subject + if item.reply_to: + msg["Reply-To"] = item.reply_to + msg.attach(MIMEText(item.text_body or item.html_body, "plain")) + msg.attach(MIMEText(item.html_body, "html")) + + try: + await aiosmtplib.send( + msg, + hostname=settings.smtp_host, + port=settings.smtp_port, + username=settings.smtp_user, + password=settings.smtp_password, + start_tls=True, + ) + item.status = "sent" + sent_count += 1 + logger.info("Retry succeeded for email to %s", item.to_addr) + except Exception as exc: + logger.error("Retry failed for email to %s: %s", item.to_addr, exc) + if item.attempts >= max_attempts: + item.status = "failed" + + await db.commit() + return sent_count diff --git a/backend/app/services/rentman_service.py b/backend/app/services/rentman_service.py new file mode 100644 index 0000000..d5895d7 --- /dev/null +++ b/backend/app/services/rentman_service.py @@ -0,0 +1,146 @@ +"""Rentman API client wrapper for equipment import and request submission.""" +import httpx +import logging +import re +from typing import Any + +from app.config import get_settings + +logger = logging.getLogger(__name__) +settings = get_settings() + +RENTMAN_BASE_URL = "https://api.rentman.net" + + +class RentmanService: + """Wrapper around the Rentman REST API using httpx.""" + + def __init__(self, token: str | None = None) -> None: + self._token = token or settings.rentman_api_token + self._base_url = RENTMAN_BASE_URL + + def _headers(self) -> dict[str, str]: + return { + "Authorization": f"Bearer {self._token}", + "Content-Type": "application/json", + } + + async def get_equipment_page(self, limit: int = 100, offset: int = 0) -> dict[str, Any]: + """Fetch a single page of equipment from Rentman. + + Returns the raw JSON response dict with 'data' and optional 'itemCount'. + """ + url = f"{self._base_url}/equipment" + params = {"limit": limit, "offset": offset} + async with httpx.AsyncClient(timeout=30.0) as client: + resp = await client.get(url, headers=self._headers(), params=params) + resp.raise_for_status() + return resp.json() + + async def get_all_equipment(self, limit: int = 100) -> list[dict[str, Any]]: + """Paginate through all equipment pages until data is empty.""" + all_items: list[dict[str, Any]] = [] + offset = 0 + while True: + page = await self.get_equipment_page(limit=limit, offset=offset) + data = page.get("data", []) + if not data: + break + all_items.extend(data) + offset += limit + return all_items + + async def create_project_request(self, payload: dict[str, Any]) -> dict[str, Any]: + """POST /projectrequests to create a new project request in Rentman.""" + url = f"{self._base_url}/projectrequests" + async with httpx.AsyncClient(timeout=30.0) as client: + resp = await client.post(url, headers=self._headers(), json=payload) + resp.raise_for_status() + return resp.json() + + async def add_equipment_to_request( + self, request_id: str, equipment_payload: dict[str, Any] + ) -> dict[str, Any]: + """POST /projectrequests/{id}/projectrequestequipment for a single item.""" + url = f"{self._base_url}/projectrequests/{request_id}/projectrequestequipment" + async with httpx.AsyncClient(timeout=30.0) as client: + resp = await client.post(url, headers=self._headers(), json=equipment_payload) + resp.raise_for_status() + return resp.json() + + @staticmethod + def transform_equipment(raw: dict[str, Any]) -> dict[str, Any]: + """Map a raw Rentman equipment object to equipment_cache schema.""" + images = raw.get("images") or raw.get("files") or [] + if isinstance(images, list): + image_urls = [ + img.get("url", img.get("filename", "")) if isinstance(img, dict) else str(img) + for img in images + ] + else: + image_urls = [] + + group = raw.get("equipment_group") or {} + category = group.get("name", "") if isinstance(group, dict) else str(group or "") + + return { + "rentman_id": str(raw.get("id", "")), + "name": raw.get("name", ""), + "number": raw.get("number") or raw.get("code", ""), + "category": category, + "subcategory": raw.get("subcategory", ""), + "description": raw.get("description", ""), + "specifications": raw.get("specifications", {}), + "images": image_urls, + "rental_price": raw.get("rental_price"), + "brand": raw.get("brand", ""), + "available": raw.get("available", True), + } + + @staticmethod + def build_project_request_payload(data: dict[str, Any]) -> dict[str, Any]: + """Map frontend rental request data to Rentman POST /projectrequests payload.""" + date_start = data.get("date_start") + date_end = data.get("date_end") + + contact_name = data.get("contact_name", "") + parts = contact_name.strip().split(" ", 1) + first_name = parts[0] if parts else "" + last_name = parts[1] if len(parts) > 1 else "" + + street = data.get("contact_street", "") + house_number = "" + if street: + match = re.search(r"(\d+[a-zA-Z]*)", street) + if match: + house_number = match.group(1) + + return { + "name": data.get("event_name", ""), + "planperiod_start": f"{date_start}T08:00:00+02:00" if date_start else None, + "planperiod_end": f"{date_end}T02:00:00+02:00" if date_end else None, + "usageperiod_start": f"{date_start}T18:00:00+02:00" if date_start else None, + "usageperiod_end": f"{date_end}T23:59:00+02:00" if date_end else None, + "contact_name": data.get("contact_company") or data.get("contact_name", ""), + "contact_person_first_name": first_name, + "contact_person_lastname": last_name, + "contact_person_email": data.get("contact_email", ""), + "contact_person_phone": data.get("contact_phone", ""), + "location_name": data.get("location", ""), + "location_mailing_street": street, + "location_mailing_number": house_number, + "location_mailing_postalcode": data.get("contact_postalcode", ""), + "location_mailing_city": data.get("contact_city") or data.get("location", ""), + "remark": data.get("message", ""), + } + + @staticmethod + def build_equipment_payload(item: dict[str, Any]) -> dict[str, Any]: + """Map a single rental request item to Rentman projectrequestequipment payload.""" + return { + "name": item.get("equipment_name", ""), + "quantity": item.get("quantity", 1), + "quantity_total": item.get("quantity", 1), + "unit_price": item.get("unit_price", 0), + "linked_equipment": f"/equipment/{item.get('rentman_equipment_id', '')}" if item.get("rentman_equipment_id") else None, + } diff --git a/backend/app/services/sync_service.py b/backend/app/services/sync_service.py new file mode 100644 index 0000000..ca8b072 --- /dev/null +++ b/backend/app/services/sync_service.py @@ -0,0 +1,149 @@ +"""Equipment sync service: import from Rentman, upsert into DB, invalidate cache.""" +import logging +from datetime import datetime, timezone +from typing import Any +from sqlalchemy import select +from sqlalchemy.ext.asyncio import AsyncSession +from app.models.equipment import EquipmentCache +from app.models.sync_log import SyncLog +from app.services.rentman_service import RentmanService +from app.cache import cache + +logger = logging.getLogger(__name__) + + +class SyncService: + """Orchestrates equipment import from Rentman into the local database.""" + + def __init__(self, db: AsyncSession, rentman: RentmanService | None = None) -> None: + self.db = db + self.rentman = rentman or RentmanService() + + async def run_sync(self) -> dict[str, Any]: + """Execute a full equipment sync. + + 1. Create sync_log entry (status=running) + 2. Paginate GET /equipment from Rentman + 3. Upsert each item into equipment_cache + 4. Invalidate Redis cache (equipment:*) + 5. Update sync_log (status=completed or failed) + Returns dict with sync_id, items_processed, status. + """ + log_entry = SyncLog( + sync_type="equipment", + status="running", + started_at=datetime.now(timezone.utc), + ) + self.db.add(log_entry) + await self.db.commit() + await self.db.refresh(log_entry) + sync_id = log_entry.id + + items_processed = 0 + items_failed = 0 + error_message: str | None = None + + try: + all_equipment = await self.rentman.get_all_equipment(limit=100) + for raw_item in all_equipment: + try: + transformed = RentmanService.transform_equipment(raw_item) + await self._upsert_equipment(transformed) + items_processed += 1 + except Exception as exc: + logger.warning("Failed to upsert equipment item: %s", exc) + items_failed += 1 + + await self.db.commit() + + # Invalidate Redis cache + await cache.delete_pattern("equipment:*") + + status_val = "completed" + except Exception as exc: + logger.error("Equipment sync failed: %s", exc) + error_message = str(exc) + status_val = "failed" + + # Update log entry + log_entry.status = status_val + log_entry.items_processed = items_processed + log_entry.items_failed = items_failed + log_entry.error_message = error_message + log_entry.completed_at = datetime.now(timezone.utc) + await self.db.commit() + + return { + "sync_id": sync_id, + "items_processed": items_processed, + "items_failed": items_failed, + "status": status_val, + } + + async def _upsert_equipment(self, data: dict[str, Any]) -> None: + """Insert or update a single equipment row by rentman_id.""" + result = await self.db.execute( + select(EquipmentCache).where(EquipmentCache.rentman_id == data["rentman_id"]) + ) + existing = result.scalar_one_or_none() + + if existing: + existing.name = data["name"] + existing.number = data.get("number", "") + existing.category = data.get("category", "") + existing.subcategory = data.get("subcategory", "") + existing.description = data.get("description", "") + existing.specifications = data.get("specifications") + existing.images = data.get("images") + existing.rental_price = data.get("rental_price") + existing.brand = data.get("brand", "") + existing.available = data.get("available", True) + else: + new_item = EquipmentCache( + rentman_id=data["rentman_id"], + name=data["name"], + number=data.get("number", ""), + category=data.get("category", ""), + subcategory=data.get("subcategory", ""), + description=data.get("description", ""), + specifications=data.get("specifications"), + images=data.get("images"), + rental_price=data.get("rental_price"), + brand=data.get("brand", ""), + available=data.get("available", True), + ) + self.db.add(new_item) + + async def get_last_sync(self) -> dict[str, Any]: + """Return the most recent sync_log entry summary.""" + result = await self.db.execute( + select(SyncLog).order_by(SyncLog.started_at.desc()).limit(1) + ) + log = result.scalar_one_or_none() + if not log: + return {"last_sync": None, "items_processed": 0, "status": "never"} + return { + "last_sync": log.started_at, + "items_processed": log.items_processed, + "status": log.status, + } + + async def get_sync_log_paginated(self, page: int = 1, page_size: int = 20) -> dict[str, Any]: + """Return paginated sync log entries.""" + offset = (page - 1) * page_size + result = await self.db.execute( + select(SyncLog) + .order_by(SyncLog.started_at.desc()) + .offset(offset) + .limit(page_size) + ) + logs = result.scalars().all() + count_result = await self.db.execute(select(SyncLog)) + total = len(count_result.scalars().all()) + return { + "items": logs, + "total": total, + "page": page, + "page_size": page_size, + "total_pages": (total + page_size - 1) // page_size if page_size > 0 else 0, + } diff --git a/backend/pytest.ini b/backend/pytest.ini new file mode 100644 index 0000000..cdce43f --- /dev/null +++ b/backend/pytest.ini @@ -0,0 +1,6 @@ +[pytest] +asyncio_mode = auto +testpaths = tests +python_files = test_*.py +python_classes = Test* +python_functions = test_* diff --git a/backend/requirements.txt b/backend/requirements.txt new file mode 100644 index 0000000..7283440 --- /dev/null +++ b/backend/requirements.txt @@ -0,0 +1,18 @@ +fastapi>=0.115.0 +uvicorn[standard]>=0.30.0 +sqlalchemy[asyncio]>=2.0.30 +asyncpg>=0.29.0 +aiosqlite>=0.20.0 +redis>=5.0.0 +pydantic>=2.7.0 +pydantic-settings>=2.3.0 +python-jose[cryptography]>=3.3.0 +passlib[bcrypt]>=1.7.4 +httpx>=0.27.0 +aiosmtplib>=3.0.0 +apscheduler>=3.10.0 +python-multipart>=0.0.9 +pytest>=8.0.0 +pytest-asyncio>=0.23.0 +pytest-cov>=5.0.0 +httpx>=0.27.0 diff --git a/backend/test_report.md b/backend/test_report.md new file mode 100644 index 0000000..d864d57 --- /dev/null +++ b/backend/test_report.md @@ -0,0 +1,64 @@ +# Test Report – T05: Email Service + Contact & Rental Request Backend + +## Test Commands + +### Targeted T05 Tests +```bash +python -m pytest tests/test_contact_router.py tests/test_rental_router.py tests/test_email_service.py tests/test_rate_limiting.py -v +``` +**Result: 23 passed in 0.81s** + +### Full Suite with Coverage +```bash +python -m pytest tests/ -v --cov=app --cov-report=term-missing +``` +**Result: 57 passed, 4 warnings in 7.31s** +**Coverage: 78% overall** + +## Test Files Created + +### tests/test_contact_router.py (6 tests) +- test_contact_valid_returns_200 – POST /api/contact valid → 200, success=True +- test_contact_invalid_email_returns_422 – invalid email → 422 +- test_contact_privacy_consent_false_returns_422 – privacy_consent=false → 422 +- test_contact_triggers_email – mock EmailService.send_contact_email called with correct data +- test_contact_saved_to_db – Contact record saved with email_sent=True +- test_contact_email_failure_does_not_break_response – email failure still returns 200 + +### tests/test_rental_router.py (7 tests) +- test_rental_valid_returns_201 – valid POST → 201 with HMS-YYYY-NNNNN reference +- test_rental_date_end_before_start_returns_422 – date_end < date_start → 422 +- test_rental_empty_items_returns_422 – empty items array → 422 +- test_rental_saved_to_db – RentalRequest + RentalRequestItem saved, rentman_sync_status=success +- test_rental_triggers_rentman – RentmanService.create_project_request + add_equipment_to_request called +- test_rental_triggers_email – EmailService.send_rental_confirmation called with ref + items +- test_rental_rentman_failure_still_returns_201 – Rentman failure still returns 201 + +### tests/test_email_service.py (7 tests) +- test_send_contact_email_success – aiosmtplib.send called, MIMEMultipart contains name + message +- test_send_rental_confirmation_success – email contains reference_number + items +- test_send_email_smtp_failure_returns_false – SMTP exception → returns False, no crash +- test_send_contact_email_smtp_failure_returns_false – contact email SMTP failure → False +- test_send_rental_confirmation_smtp_failure_returns_false – rental email SMTP failure → False +- test_send_email_failure_saves_to_queue – failed email saved to email_queue table +- test_retry_failed_emails_resends_pending – retry sends queued email, marks as sent + +### tests/test_rate_limiting.py (3 tests) +- test_contact_rate_limit_allows_5_blocks_6th – 5 requests OK, 6th → 429 +- test_rental_rate_limit_allows_5_blocks_6th – 5 requests OK, 6th → 429 +- test_contact_rate_window_reset – rate window reset allows new requests after TTL + +## New Feature: Email Retry Queue +- `app/models/email_queue.py` – EmailQueue model (id, to_addr, subject, html_body, text_body, reply_to, status, attempts, created_at, updated_at) +- `app/services/email_service.py` – send_email now accepts optional `db` param; on SMTP failure saves to queue +- `EmailService.retry_failed_emails(db)` – static method to retry pending emails (max 5 attempts) +- `app/main.py` – APScheduler job `run_email_retry` every 15 minutes +- Routers updated to pass `db` to email service methods + +## Smoke Test +- All 57 tests pass (23 new T05 + 34 existing) +- No existing tests broken +- Coverage: 78% overall, email_service 90%, contact.py 67%, rental_requests.py 46% +- Rate limiting works via mock cache.incr_rate with sequential return values +- Email queue persistence verified with in-memory SQLite +- Retry mechanism verified: pending → sent on success diff --git a/backend/tests/__init__.py b/backend/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/backend/tests/__pycache__/__init__.cpython-313.pyc b/backend/tests/__pycache__/__init__.cpython-313.pyc new file mode 100644 index 0000000..ed5094a Binary files /dev/null and b/backend/tests/__pycache__/__init__.cpython-313.pyc differ diff --git a/backend/tests/__pycache__/conftest.cpython-313-pytest-9.1.1.pyc b/backend/tests/__pycache__/conftest.cpython-313-pytest-9.1.1.pyc new file mode 100644 index 0000000..45d052a Binary files /dev/null and b/backend/tests/__pycache__/conftest.cpython-313-pytest-9.1.1.pyc differ diff --git a/backend/tests/__pycache__/test_admin_auth.cpython-313-pytest-9.1.1.pyc b/backend/tests/__pycache__/test_admin_auth.cpython-313-pytest-9.1.1.pyc new file mode 100644 index 0000000..58e6540 Binary files /dev/null and b/backend/tests/__pycache__/test_admin_auth.cpython-313-pytest-9.1.1.pyc differ diff --git a/backend/tests/__pycache__/test_admin_router.cpython-313-pytest-9.1.1.pyc b/backend/tests/__pycache__/test_admin_router.cpython-313-pytest-9.1.1.pyc new file mode 100644 index 0000000..70acca1 Binary files /dev/null and b/backend/tests/__pycache__/test_admin_router.cpython-313-pytest-9.1.1.pyc differ diff --git a/backend/tests/__pycache__/test_equipment_router.cpython-313-pytest-9.1.1.pyc b/backend/tests/__pycache__/test_equipment_router.cpython-313-pytest-9.1.1.pyc new file mode 100644 index 0000000..4b4df12 Binary files /dev/null and b/backend/tests/__pycache__/test_equipment_router.cpython-313-pytest-9.1.1.pyc differ diff --git a/backend/tests/__pycache__/test_health.cpython-313-pytest-9.1.1.pyc b/backend/tests/__pycache__/test_health.cpython-313-pytest-9.1.1.pyc new file mode 100644 index 0000000..b436d3b Binary files /dev/null and b/backend/tests/__pycache__/test_health.cpython-313-pytest-9.1.1.pyc differ diff --git a/backend/tests/__pycache__/test_rentman_import.cpython-313-pytest-9.1.1.pyc b/backend/tests/__pycache__/test_rentman_import.cpython-313-pytest-9.1.1.pyc new file mode 100644 index 0000000..a19a6ae Binary files /dev/null and b/backend/tests/__pycache__/test_rentman_import.cpython-313-pytest-9.1.1.pyc differ diff --git a/backend/tests/__pycache__/test_rentman_request.cpython-313-pytest-9.1.1.pyc b/backend/tests/__pycache__/test_rentman_request.cpython-313-pytest-9.1.1.pyc new file mode 100644 index 0000000..c4214cc Binary files /dev/null and b/backend/tests/__pycache__/test_rentman_request.cpython-313-pytest-9.1.1.pyc differ diff --git a/backend/tests/conftest.py b/backend/tests/conftest.py new file mode 100644 index 0000000..3fbc1b1 --- /dev/null +++ b/backend/tests/conftest.py @@ -0,0 +1,107 @@ +"""Pytest fixtures: test database, client, mock Redis, mock admin user.""" +import asyncio +import pytest +import pytest_asyncio +from httpx import AsyncClient, ASGITransport +from unittest.mock import AsyncMock, patch, MagicMock +from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine + +from app.database import Base, get_db +from app.cache import cache +from app.models import EquipmentCache, RentalRequest, RentalRequestItem, Contact, AdminUser, SyncLog +from app.auth import get_password_hash + + +TEST_DATABASE_URL = "sqlite+aiosqlite:///:memory:" + + +@pytest.fixture(scope="session") +def event_loop(): + loop = asyncio.new_event_loop() + yield loop + loop.close() + + +@pytest_asyncio.fixture(scope="function") +async def test_engine(): + """Create an in-memory SQLite engine for tests.""" + engine = create_async_engine(TEST_DATABASE_URL, echo=False) + async with engine.begin() as conn: + await conn.run_sync(Base.metadata.create_all) + yield engine + async with engine.begin() as conn: + await conn.run_sync(Base.metadata.drop_all) + await engine.dispose() + + +@pytest_asyncio.fixture(scope="function") +async def test_db(test_engine): + """Yield a test database session.""" + session_maker = async_sessionmaker(test_engine, class_=AsyncSession, expire_on_commit=False) + async with session_maker() as session: + yield session + + +@pytest_asyncio.fixture(scope="function") +async def client(test_engine): + """Yield an async test client with test database and mock cache.""" + session_maker = async_sessionmaker(test_engine, class_=AsyncSession, expire_on_commit=False) + + async def override_get_db(): + async with session_maker() as session: + yield session + + # Mock cache to avoid Redis dependency + mock_cache = MagicMock() + mock_cache.get = AsyncMock(return_value=None) + mock_cache.set = AsyncMock(return_value=None) + mock_cache.delete_pattern = AsyncMock(return_value=0) + mock_cache.incr_rate = AsyncMock(return_value=1) + mock_cache.connect = AsyncMock(return_value=None) + mock_cache._redis = MagicMock() + mock_cache._redis.ping = AsyncMock(return_value=True) + + with patch("app.cache.cache", mock_cache), \ + patch("app.routers.equipment.cache", mock_cache), \ + patch("app.routers.admin.cache", mock_cache), \ + patch("app.routers.rental_requests.cache", mock_cache), \ + patch("app.routers.contact.cache", mock_cache), \ + patch("app.services.sync_service.cache", mock_cache): + from app.main import app + app.dependency_overrides[get_db] = override_get_db + + transport = ASGITransport(app=app) + async with AsyncClient(transport=transport, base_url="http://test") as ac: + yield ac + + app.dependency_overrides.clear() + + +@pytest_asyncio.fixture(scope="function") +async def seeded_admin(test_engine): + """Seed an admin user into the test database and return credentials.""" + session_maker = async_sessionmaker(test_engine, class_=AsyncSession, expire_on_commit=False) + async with session_maker() as session: + admin = AdminUser( + username="admin", + password_hash=get_password_hash("testpassword"), + ) + session.add(admin) + await session.commit() + return {"username": "admin", "password": "testpassword"} + + +@pytest_asyncio.fixture(scope="function") +async def seeded_equipment(test_engine): + """Seed sample equipment into the test database.""" + session_maker = async_sessionmaker(test_engine, class_=AsyncSession, expire_on_commit=False) + async with session_maker() as session: + items = [ + EquipmentCache(rentman_id="101", name="L-Acoustics K2", number="K2-001", category="Lautsprecher", brand="L-Acoustics", available=True), + EquipmentCache(rentman_id="102", name="L-Acoustics KS28", number="KS28-001", category="Subwoofer", brand="L-Acoustics", available=True), + EquipmentCache(rentman_id="103", name="d&b T10", number="T10-001", category="Lautsprecher", brand="d&b audiotechnik", available=True), + ] + for item in items: + session.add(item) + await session.commit() + return items diff --git a/backend/tests/test_admin_auth.py b/backend/tests/test_admin_auth.py new file mode 100644 index 0000000..047c70d --- /dev/null +++ b/backend/tests/test_admin_auth.py @@ -0,0 +1,87 @@ +"""Tests for admin authentication (T04).""" +import pytest +from app.auth import create_access_token, verify_token, get_password_hash, verify_password + + +def test_password_hash_and_verify(): + plain = "mysecret" + hashed = get_password_hash(plain) + assert hashed != plain + assert verify_password(plain, hashed) is True + assert verify_password("wrong", hashed) is False + + +def test_create_and_verify_token(): + token = create_access_token({"sub": "admin"}) + assert token is not None + payload = verify_token(token) + assert payload is not None + assert payload["sub"] == "admin" + + +def test_verify_invalid_token(): + payload = verify_token("invalid.token.here") + assert payload is None + + +def test_verify_expired_token(): + from datetime import timedelta + token = create_access_token({"sub": "admin"}, expires_delta=timedelta(seconds=-1)) + payload = verify_token(token) + assert payload is None + + +@pytest.mark.asyncio +async def test_login_success(client, seeded_admin): + """POST /api/admin/login with valid credentials returns 200 with token.""" + resp = await client.post("/api/admin/login", json={ + "username": "admin", + "password": "testpassword", + }) + assert resp.status_code == 200 + data = resp.json() + assert "access_token" in data + assert data["token_type"] == "bearer" + assert "hms_admin_token" in resp.cookies + + +@pytest.mark.asyncio +async def test_login_failure_wrong_password(client, seeded_admin): + """POST /api/admin/login with wrong password returns 401.""" + resp = await client.post("/api/admin/login", json={ + "username": "admin", + "password": "wrongpassword", + }) + assert resp.status_code == 401 + + +@pytest.mark.asyncio +async def test_login_failure_unknown_user(client, seeded_admin): + """POST /api/admin/login with unknown user returns 401.""" + resp = await client.post("/api/admin/login", json={ + "username": "unknown", + "password": "testpassword", + }) + assert resp.status_code == 401 + + +@pytest.mark.asyncio +async def test_me_without_token(client): + """GET /api/admin/me without token returns 401.""" + resp = await client.get("/api/admin/me") + assert resp.status_code == 401 + + +@pytest.mark.asyncio +async def test_me_with_valid_token(client, seeded_admin): + """GET /api/admin/me with valid token returns 200 with username.""" + # Login first + login_resp = await client.post("/api/admin/login", json={ + "username": "admin", + "password": "testpassword", + }) + token = login_resp.json()["access_token"] + + resp = await client.get("/api/admin/me", cookies={"hms_admin_token": token}) + assert resp.status_code == 200 + assert resp.json()["username"] == "admin" diff --git a/backend/tests/test_admin_router.py b/backend/tests/test_admin_router.py new file mode 100644 index 0000000..6cde529 --- /dev/null +++ b/backend/tests/test_admin_router.py @@ -0,0 +1,101 @@ +"""Tests for admin sync endpoints (T04).""" +import pytest +from unittest.mock import AsyncMock, patch, MagicMock +from app.services.sync_service import SyncService + + +@pytest.mark.asyncio +async def test_sync_without_token(client): + """POST /api/admin/sync without JWT returns 401.""" + resp = await client.post("/api/admin/sync") + assert resp.status_code == 401 + + +@pytest.mark.asyncio +async def test_sync_status_without_token(client): + """GET /api/admin/sync-status without JWT returns 401.""" + resp = await client.get("/api/admin/sync-status") + assert resp.status_code == 401 + + +@pytest.mark.asyncio +async def test_sync_log_without_token(client): + """GET /api/admin/sync-log without JWT returns 401.""" + resp = await client.get("/api/admin/sync-log") + assert resp.status_code == 401 + + +@pytest.mark.asyncio +async def test_sync_with_valid_token(client, seeded_admin, test_db): + """POST /api/admin/sync with valid JWT triggers equipment sync.""" + # Login + login_resp = await client.post("/api/admin/login", json={ + "username": "admin", + "password": "testpassword", + }) + token = login_resp.json()["access_token"] + + # Mock sync service + with patch.object(SyncService, "run_sync", new_callable=AsyncMock) as mock_sync: + mock_sync.return_value = {"sync_id": 42, "items_processed": 10, "items_failed": 0, "status": "completed"} + resp = await client.post("/api/admin/sync", cookies={"hms_admin_token": token}) + + assert resp.status_code == 200 + data = resp.json() + assert data["sync_id"] == 42 + assert data["status"] == "completed" + + +@pytest.mark.asyncio +async def test_sync_status_with_valid_token(client, seeded_admin): + """GET /api/admin/sync-status with valid JWT returns status.""" + login_resp = await client.post("/api/admin/login", json={ + "username": "admin", + "password": "testpassword", + }) + token = login_resp.json()["access_token"] + + with patch.object(SyncService, "get_last_sync", new_callable=AsyncMock) as mock_status: + mock_status.return_value = {"last_sync": None, "items_processed": 0, "status": "never"} + resp = await client.get("/api/admin/sync-status", cookies={"hms_admin_token": token}) + + assert resp.status_code == 200 + data = resp.json() + assert data["status"] == "never" + + +@pytest.mark.asyncio +async def test_sync_log_with_valid_token(client, seeded_admin): + """GET /api/admin/sync-log with valid JWT returns paginated log.""" + login_resp = await client.post("/api/admin/login", json={ + "username": "admin", + "password": "testpassword", + }) + token = login_resp.json()["access_token"] + + mock_log = MagicMock() + mock_log.id = 1 + mock_log.sync_type = "equipment" + mock_log.status = "completed" + mock_log.items_processed = 100 + mock_log.items_failed = 0 + mock_log.error_message = None + from datetime import datetime + mock_log.started_at = datetime(2026, 7, 9, 12, 0, 0) + mock_log.completed_at = datetime(2026, 7, 9, 12, 5, 0) + + with patch.object(SyncService, "get_sync_log_paginated", new_callable=AsyncMock) as mock_log_fn: + mock_log_fn.return_value = { + "items": [mock_log], + "total": 1, + "page": 1, + "page_size": 20, + "total_pages": 1, + } + resp = await client.get("/api/admin/sync-log", cookies={"hms_admin_token": token}) + + assert resp.status_code == 200 + data = resp.json() + assert data["total"] == 1 + assert len(data["items"]) == 1 + assert data["items"][0]["status"] == "completed" diff --git a/backend/tests/test_contact_router.py b/backend/tests/test_contact_router.py new file mode 100644 index 0000000..7649a4a --- /dev/null +++ b/backend/tests/test_contact_router.py @@ -0,0 +1,120 @@ +"""Tests for contact router (T05).""" +import pytest +from unittest.mock import AsyncMock, patch, MagicMock +from sqlalchemy import select + +from app.models.contact import Contact + + +@pytest.mark.asyncio +async def test_contact_valid_returns_200(client): + """POST /api/contact with valid data returns 200 and saves to contacts table.""" + with patch( + "app.services.email_service.EmailService.send_contact_email", + new_callable=AsyncMock, + return_value=True, + ): + resp = await client.post("/api/contact", json={ + "name": "Max Mustermann", + "email": "max@example.com", + "phone": "+49 123 456789", + "message": "Ich brauche eine PA-Anlage fuer ein Festival.", + "privacy_consent": True, + }) + assert resp.status_code == 200 + data = resp.json() + assert data["success"] is True + + +@pytest.mark.asyncio +async def test_contact_invalid_email_returns_422(client): + """POST /api/contact with invalid email returns 422.""" + resp = await client.post("/api/contact", json={ + "name": "Max Mustermann", + "email": "not-an-email", + "phone": "+49 123 456789", + "message": "Test message", + "privacy_consent": True, + }) + assert resp.status_code == 422 + + +@pytest.mark.asyncio +async def test_contact_privacy_consent_false_returns_422(client): + """POST /api/contact with privacy_consent=false returns 422.""" + resp = await client.post("/api/contact", json={ + "name": "Max Mustermann", + "email": "max@example.com", + "phone": "+49 123 456789", + "message": "Test message", + "privacy_consent": False, + }) + assert resp.status_code == 422 + + +@pytest.mark.asyncio +async def test_contact_triggers_email(client): + """POST /api/contact triggers send_contact_email on EmailService.""" + with patch( + "app.services.email_service.EmailService.send_contact_email", + new_callable=AsyncMock, + return_value=True, + ) as mock_send: + resp = await client.post("/api/contact", json={ + "name": "Erika Musterfrau", + "email": "erika@example.com", + "phone": "+49 987 654321", + "message": "Ich benoetige Beleuchtung fuer eine Gala.", + "privacy_consent": True, + }) + assert resp.status_code == 200 + mock_send.assert_awaited_once() + call_args = mock_send.call_args[0][0] + assert call_args["name"] == "Erika Musterfrau" + assert call_args["email"] == "erika@example.com" + assert call_args["message"] == "Ich benoetige Beleuchtung fuer eine Gala." + + +@pytest.mark.asyncio +async def test_contact_saved_to_db(client, test_db): + """POST /api/contact saves a record to the contacts table.""" + with patch( + "app.services.email_service.EmailService.send_contact_email", + new_callable=AsyncMock, + return_value=True, + ): + resp = await client.post("/api/contact", json={ + "name": "DB Testuser", + "email": "db@example.com", + "phone": "+49 111 222333", + "message": "Datenbank-Verifikation", + "privacy_consent": True, + }) + assert resp.status_code == 200 + + result = await test_db.execute(select(Contact).where(Contact.email == "db@example.com")) + contact = result.scalar_one_or_none() + assert contact is not None + assert contact.name == "DB Testuser" + assert contact.message == "Datenbank-Verifikation" + assert contact.privacy_consent is True + assert contact.email_sent is True + + +@pytest.mark.asyncio +async def test_contact_email_failure_does_not_break_response(client): + """POST /api/contact still returns 200 when email sending fails.""" + with patch( + "app.services.email_service.EmailService.send_contact_email", + new_callable=AsyncMock, + return_value=False, + ): + resp = await client.post("/api/contact", json={ + "name": "Fail Test", + "email": "fail@example.com", + "phone": "+49 000 000000", + "message": "Email soll fehlschlagen", + "privacy_consent": True, + }) + assert resp.status_code == 200 + assert resp.json()["success"] is True diff --git a/backend/tests/test_email_service.py b/backend/tests/test_email_service.py new file mode 100644 index 0000000..5436d42 --- /dev/null +++ b/backend/tests/test_email_service.py @@ -0,0 +1,169 @@ +"""Tests for email service (T05).""" +import pytest +from unittest.mock import AsyncMock, patch, MagicMock +from email.mime.multipart import MIMEMultipart + +from app.services.email_service import EmailService + + +@pytest.mark.asyncio +async def test_send_contact_email_success(): + """send_contact_email sends correct email via aiosmtplib.""" + service = EmailService() + contact_data = { + "name": "Test User", + "email": "test@example.com", + "phone": "+49 123 456", + "message": "Hallo Welt", + } + with patch("app.services.email_service.aiosmtplib.send", new_callable=AsyncMock) as mock_send: + result = await service.send_contact_email(contact_data) + assert result is True + mock_send.assert_awaited_once() + sent_msg = mock_send.call_args[0][0] + assert isinstance(sent_msg, MIMEMultipart) + assert "Hallo Welt" in str(sent_msg) + assert "Test User" in str(sent_msg) + + +@pytest.mark.asyncio +async def test_send_rental_confirmation_success(): + """send_rental_confirmation sends email with reference_number and items.""" + service = EmailService() + items = [ + {"equipment_name": "L-Acoustics K2", "quantity": 2}, + {"equipment_name": "d&b T10", "quantity": 4}, + ] + with patch("app.services.email_service.aiosmtplib.send", new_callable=AsyncMock) as mock_send: + result = await service.send_rental_confirmation( + to_addr="customer@example.com", + reference_number="HMS-2026-00042", + event_name="Rock Festival", + items=items, + ) + assert result is True + mock_send.assert_awaited_once() + sent_msg = mock_send.call_args[0][0] + msg_str = str(sent_msg) + assert "HMS-2026-00042" in msg_str + assert "Rock Festival" in msg_str + assert "L-Acoustics K2" in msg_str + assert "d&b T10" in msg_str + + +@pytest.mark.asyncio +async def test_send_email_smtp_failure_returns_false(): + """SMTP failure returns False, no crash, graceful handling.""" + service = EmailService() + with patch("app.services.email_service.aiosmtplib.send", new_callable=AsyncMock, side_effect=Exception("SMTP refused")): + result = await service.send_email( + to_addr="fail@example.com", + subject="Test Subject", + html_body="Test
", + text_body="Test", + ) + assert result is False + + +@pytest.mark.asyncio +async def test_send_contact_email_smtp_failure_returns_false(): + """send_contact_email returns False on SMTP failure without crashing.""" + service = EmailService() + with patch("app.services.email_service.aiosmtplib.send", new_callable=AsyncMock, side_effect=Exception("Connection refused")): + result = await service.send_contact_email({ + "name": "Fail User", + "email": "fail@example.com", + "phone": "+49 000", + "message": "Soll fehlschlagen", + }) + assert result is False + + +@pytest.mark.asyncio +async def test_send_rental_confirmation_smtp_failure_returns_false(): + """send_rental_confirmation returns False on SMTP failure without crashing.""" + service = EmailService() + with patch("app.services.email_service.aiosmtplib.send", new_callable=AsyncMock, side_effect=Exception("Timeout")): + result = await service.send_rental_confirmation( + to_addr="fail@example.com", + reference_number="HMS-2026-99999", + event_name="Fail Event", + items=[{"equipment_name": "Speaker", "quantity": 1}], + ) + assert result is False + + +@pytest.mark.asyncio +async def test_send_email_failure_saves_to_queue(): + """send_email saves failed email to email_queue when db is provided.""" + from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine + from app.database import Base + from app.models.email_queue import EmailQueue + from sqlalchemy import select + + engine = create_async_engine("sqlite+aiosqlite:///:memory:") + async with engine.begin() as conn: + await conn.run_sync(Base.metadata.create_all) + session_maker = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False) + + service = EmailService() + with patch("app.services.email_service.aiosmtplib.send", new_callable=AsyncMock, side_effect=Exception("SMTP down")): + async with session_maker() as db: + result = await service.send_email( + to_addr="queue@example.com", + subject="Queued Email", + html_body="Body
", + text_body="Body", + reply_to="reply@example.com", + db=db, + ) + assert result is False + + async with session_maker() as db: + queued = await db.execute(select(EmailQueue).where(EmailQueue.to_addr == "queue@example.com")) + item = queued.scalar_one_or_none() + assert item is not None + assert item.subject == "Queued Email" + assert item.status == "pending" + assert item.attempts == 0 + assert item.reply_to == "reply@example.com" + + await engine.dispose() + + +@pytest.mark.asyncio +async def test_retry_failed_emails_resends_pending(): + """retry_failed_emails retries pending queue items and marks sent on success.""" + from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine + from app.database import Base + from app.models.email_queue import EmailQueue + from sqlalchemy import select + + engine = create_async_engine("sqlite+aiosqlite:///:memory:") + async with engine.begin() as conn: + await conn.run_sync(Base.metadata.create_all) + session_maker = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False) + + async with session_maker() as db: + db.add(EmailQueue( + to_addr="retry@example.com", + subject="Retry Test", + html_body="Retry
", + text_body="Retry", + status="pending", + attempts=0, + )) + await db.commit() + + with patch("app.services.email_service.aiosmtplib.send", new_callable=AsyncMock): + async with session_maker() as db: + sent_count = await EmailService.retry_failed_emails(db) + assert sent_count == 1 + + async with session_maker() as db: + result = await db.execute(select(EmailQueue).where(EmailQueue.to_addr == "retry@example.com")) + item = result.scalar_one_or_none() + assert item.status == "sent" + assert item.attempts == 1 + + await engine.dispose() diff --git a/backend/tests/test_equipment_router.py b/backend/tests/test_equipment_router.py new file mode 100644 index 0000000..9d25989 --- /dev/null +++ b/backend/tests/test_equipment_router.py @@ -0,0 +1,77 @@ +"""Tests for equipment router (T03).""" +import pytest + + +@pytest.mark.asyncio +async def test_list_equipment(client, seeded_equipment): + resp = await client.get("/api/equipment?page=1&page_size=10") + assert resp.status_code == 200 + data = resp.json() + assert "items" in data + assert "total" in data + assert "page" in data + assert "page_size" in data + assert "total_pages" in data + assert data["total"] == 3 + assert len(data["items"]) == 3 + + +@pytest.mark.asyncio +async def test_search_equipment(client, seeded_equipment): + resp = await client.get("/api/equipment?search=K2") + assert resp.status_code == 200 + data = resp.json() + assert data["total"] == 1 + assert "K2" in data["items"][0]["name"] + + +@pytest.mark.asyncio +async def test_filter_category(client, seeded_equipment): + resp = await client.get("/api/equipment?category=Lautsprecher") + assert resp.status_code == 200 + data = resp.json() + assert data["total"] == 2 + for item in data["items"]: + assert item["category"] == "Lautsprecher" + + +@pytest.mark.asyncio +async def test_sort_name_asc(client, seeded_equipment): + resp = await client.get("/api/equipment?sort=name_asc") + assert resp.status_code == 200 + data = resp.json() + names = [item["name"] for item in data["items"]] + assert names == sorted(names) + + +@pytest.mark.asyncio +async def test_sort_name_desc(client, seeded_equipment): + resp = await client.get("/api/equipment?sort=name_desc") + assert resp.status_code == 200 + data = resp.json() + names = [item["name"] for item in data["items"]] + assert names == sorted(names, reverse=True) + + +@pytest.mark.asyncio +async def test_categories(client, seeded_equipment): + resp = await client.get("/api/equipment/categories") + assert resp.status_code == 200 + cats = resp.json() + assert "Lautsprecher" in cats + assert "Subwoofer" in cats + + +@pytest.mark.asyncio +async def test_equipment_detail(client, seeded_equipment): + resp = await client.get(f"/api/equipment/{seeded_equipment[0].id}") + assert resp.status_code == 200 + data = resp.json() + assert data["name"] == "L-Acoustics K2" + assert data["brand"] == "L-Acoustics" + + +@pytest.mark.asyncio +async def test_equipment_not_found(client, seeded_equipment): + resp = await client.get("/api/equipment/999999") + assert resp.status_code == 404 diff --git a/backend/tests/test_health.py b/backend/tests/test_health.py new file mode 100644 index 0000000..8e15a92 --- /dev/null +++ b/backend/tests/test_health.py @@ -0,0 +1,12 @@ +"""Tests for health endpoint (T03).""" +import pytest + + +@pytest.mark.asyncio +async def test_health_endpoint(client): + resp = await client.get("/api/health") + assert resp.status_code == 200 + data = resp.json() + assert data["status"] == "ok" + assert "db" in data + assert "redis" in data diff --git a/backend/tests/test_rate_limiting.py b/backend/tests/test_rate_limiting.py new file mode 100644 index 0000000..7ad5eb3 --- /dev/null +++ b/backend/tests/test_rate_limiting.py @@ -0,0 +1,140 @@ +"""Tests for rate limiting on contact and rental endpoints (T05).""" +import pytest +from unittest.mock import AsyncMock, patch, MagicMock +from httpx import AsyncClient, ASGITransport +from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker + +from app.database import Base, get_db +from app.models import EquipmentCache + + +VALID_CONTACT = { + "name": "Rate Limit", + "email": "rate@example.com", + "phone": "+49 123", + "message": "Rate limit test", + "privacy_consent": True, +} + +VALID_RENTAL = { + "event_name": "Rate Limit Fest", + "date_start": "2026-09-01", + "date_end": "2026-09-02", + "location": "Hamburg", + "contact_name": "RL User", + "contact_email": "rl@example.com", + "items": [{"equipment_id": 1, "quantity": 1}], +} + + +def _make_rate_limit_client(test_engine, rate_counts: list[int]): + """Create a client whose cache.incr_rate returns sequential values from rate_counts.""" + session_maker = async_sessionmaker(test_engine, class_=AsyncSession, expire_on_commit=False) + call_index = {"i": 0} + + async def override_get_db(): + async with session_maker() as session: + yield session + + async def mock_incr_rate(key: str, window: int = 60) -> int: + idx = call_index["i"] + if idx < len(rate_counts): + val = rate_counts[idx] + else: + val = rate_counts[-1] + 1 + call_index["i"] += 1 + return val + + mock_cache = MagicMock() + mock_cache.get = AsyncMock(return_value=None) + mock_cache.set = AsyncMock(return_value=None) + mock_cache.delete_pattern = AsyncMock(return_value=0) + mock_cache.incr_rate = mock_incr_rate + mock_cache.connect = AsyncMock(return_value=None) + mock_cache._redis = MagicMock() + mock_cache._redis.ping = AsyncMock(return_value=True) + + async def _yield_client(): + with patch("app.cache.cache", mock_cache), \ + patch("app.routers.equipment.cache", mock_cache), \ + patch("app.routers.admin.cache", mock_cache), \ + patch("app.routers.rental_requests.cache", mock_cache), \ + patch("app.routers.contact.cache", mock_cache), \ + patch("app.services.sync_service.cache", mock_cache): + from app.main import app + app.dependency_overrides[get_db] = override_get_db + transport = ASGITransport(app=app) + async with AsyncClient(transport=transport, base_url="http://test") as ac: + yield ac + app.dependency_overrides.clear() + + return _yield_client + + +@pytest.mark.asyncio +async def test_contact_rate_limit_allows_5_blocks_6th(test_engine): + """5 requests OK, 6th request returns 429 for contact endpoint.""" + rate_counts = [1, 2, 3, 4, 5, 6] + client_gen = _make_rate_limit_client(test_engine, rate_counts) + async for client in client_gen(): + with patch( + "app.services.email_service.EmailService.send_contact_email", + new_callable=AsyncMock, + return_value=True, + ): + for i in range(5): + resp = await client.post("/api/contact", json=VALID_CONTACT) + assert resp.status_code == 200, f"Request {i+1} should succeed" + resp = await client.post("/api/contact", json=VALID_CONTACT) + assert resp.status_code == 429 + + +@pytest.mark.asyncio +async def test_rental_rate_limit_allows_5_blocks_6th(test_engine, seeded_equipment): + """5 requests OK, 6th request returns 429 for rental-requests endpoint.""" + rate_counts = [1, 2, 3, 4, 5, 6] + client_gen = _make_rate_limit_client(test_engine, rate_counts) + async for client in client_gen(): + with patch( + "app.services.rentman_service.RentmanService.create_project_request", + new_callable=AsyncMock, + return_value={"id": "rl-test"}, + ), patch( + "app.services.rentman_service.RentmanService.add_equipment_to_request", + new_callable=AsyncMock, + return_value={"id": "eq-rl"}, + ), patch( + "app.services.email_service.EmailService.send_rental_confirmation", + new_callable=AsyncMock, + return_value=True, + ): + for i in range(5): + resp = await client.post("/api/rental-requests", json=VALID_RENTAL) + assert resp.status_code == 201, f"Request {i+1} should succeed" + resp = await client.post("/api/rental-requests", json=VALID_RENTAL) + assert resp.status_code == 429 + + +@pytest.mark.asyncio +async def test_contact_rate_window_reset(test_engine): + """Rate window resets after TTL: first 5 OK, then 429, then after reset 5 more OK.""" + rate_counts = [1, 2, 3, 4, 5, 6, 1, 2] + client_gen = _make_rate_limit_client(test_engine, rate_counts) + async for client in client_gen(): + with patch( + "app.services.email_service.EmailService.send_contact_email", + new_callable=AsyncMock, + return_value=True, + ): + for i in range(5): + resp = await client.post("/api/contact", json=VALID_CONTACT) + assert resp.status_code == 200 + resp = await client.post("/api/contact", json=VALID_CONTACT) + assert resp.status_code == 429 + # After window reset, counter starts at 1 again + resp = await client.post("/api/contact", json=VALID_CONTACT) + assert resp.status_code == 200 + resp = await client.post("/api/contact", json=VALID_CONTACT) + assert resp.status_code == 200 + + diff --git a/backend/tests/test_rental_router.py b/backend/tests/test_rental_router.py new file mode 100644 index 0000000..b4684b5 --- /dev/null +++ b/backend/tests/test_rental_router.py @@ -0,0 +1,175 @@ +"""Tests for rental request router (T05).""" +import pytest +from unittest.mock import AsyncMock, patch +from sqlalchemy import select + +from app.models.rental_request import RentalRequest, RentalRequestItem + + +VALID_RENTAL_PAYLOAD = { + "event_name": "Sommerfestival 2026", + "date_start": "2026-08-15", + "date_end": "2026-08-17", + "location": "Berlin", + "person_count": 500, + "contact_name": "Max Veranstalter", + "contact_company": "Event GmbH", + "contact_email": "max@event.de", + "contact_phone": "+49 30 1234567", + "contact_street": "Hauptstr. 42", + "contact_postalcode": "10115", + "contact_city": "Berlin", + "message": "Bitte um Angebot", + "items": [{"equipment_id": 1, "quantity": 2}], +} + + +@pytest.mark.asyncio +async def test_rental_valid_returns_201(client, seeded_equipment): + """POST /api/rental-requests with valid data returns 201 with reference number.""" + with patch( + "app.services.rentman_service.RentmanService.create_project_request", + new_callable=AsyncMock, + return_value={"id": "rentman-123"}, + ), patch( + "app.services.rentman_service.RentmanService.add_equipment_to_request", + new_callable=AsyncMock, + return_value={"id": "eq-1"}, + ), patch( + "app.services.email_service.EmailService.send_rental_confirmation", + new_callable=AsyncMock, + return_value=True, + ): + resp = await client.post("/api/rental-requests", json=VALID_RENTAL_PAYLOAD) + assert resp.status_code == 201 + data = resp.json() + assert "reference_number" in data + ref = data["reference_number"] + assert ref.startswith("HMS-") + parts = ref.split("-") + assert len(parts) == 3 + assert parts[1].isdigit() + assert len(parts[2]) == 5 + assert parts[2].isdigit() + assert data["status"] == "pending" + + +@pytest.mark.asyncio +async def test_rental_date_end_before_start_returns_422(client, seeded_equipment): + """POST /api/rental-requests with date_end < date_start returns 422.""" + payload = {**VALID_RENTAL_PAYLOAD, "date_start": "2026-08-20", "date_end": "2026-08-15"} + resp = await client.post("/api/rental-requests", json=payload) + assert resp.status_code == 422 + + +@pytest.mark.asyncio +async def test_rental_empty_items_returns_422(client, seeded_equipment): + """POST /api/rental-requests with empty items array returns 422.""" + payload = {**VALID_RENTAL_PAYLOAD, "items": []} + resp = await client.post("/api/rental-requests", json=payload) + assert resp.status_code == 422 + + +@pytest.mark.asyncio +async def test_rental_saved_to_db(client, seeded_equipment, test_db): + """POST /api/rental-requests saves to rental_requests and rental_request_items tables.""" + with patch( + "app.services.rentman_service.RentmanService.create_project_request", + new_callable=AsyncMock, + return_value={"id": "rentman-456"}, + ), patch( + "app.services.rentman_service.RentmanService.add_equipment_to_request", + new_callable=AsyncMock, + return_value={"id": "eq-2"}, + ), patch( + "app.services.email_service.EmailService.send_rental_confirmation", + new_callable=AsyncMock, + return_value=True, + ): + resp = await client.post("/api/rental-requests", json=VALID_RENTAL_PAYLOAD) + assert resp.status_code == 201 + ref_number = resp.json()["reference_number"] + + result = await test_db.execute( + select(RentalRequest).where(RentalRequest.reference_number == ref_number) + ) + rental = result.scalar_one_or_none() + assert rental is not None + assert rental.event_name == "Sommerfestival 2026" + assert rental.contact_name == "Max Veranstalter" + assert rental.status == "pending" + assert rental.rentman_request_id == "rentman-456" + assert rental.rentman_sync_status == "success" + + items_result = await test_db.execute( + select(RentalRequestItem).where(RentalRequestItem.rental_request_id == rental.id) + ) + items = items_result.scalars().all() + assert len(items) == 1 + assert items[0].equipment_id == 1 + assert items[0].quantity == 2 + assert items[0].equipment_name == "L-Acoustics K2" + + +@pytest.mark.asyncio +async def test_rental_triggers_rentman(client, seeded_equipment): + """POST /api/rental-requests triggers Rentman create_project_request.""" + with patch( + "app.services.rentman_service.RentmanService.create_project_request", + new_callable=AsyncMock, + return_value={"id": "rentman-789"}, + ) as mock_create, patch( + "app.services.rentman_service.RentmanService.add_equipment_to_request", + new_callable=AsyncMock, + return_value={"id": "eq-3"}, + ) as mock_add, patch( + "app.services.email_service.EmailService.send_rental_confirmation", + new_callable=AsyncMock, + return_value=True, + ): + resp = await client.post("/api/rental-requests", json=VALID_RENTAL_PAYLOAD) + assert resp.status_code == 201 + mock_create.assert_awaited_once() + mock_add.assert_awaited_once() + + +@pytest.mark.asyncio +async def test_rental_triggers_email(client, seeded_equipment): + """POST /api/rental-requests triggers confirmation email.""" + with patch( + "app.services.rentman_service.RentmanService.create_project_request", + new_callable=AsyncMock, + return_value={"id": "rentman-email-test"}, + ), patch( + "app.services.rentman_service.RentmanService.add_equipment_to_request", + new_callable=AsyncMock, + return_value={"id": "eq-4"}, + ), patch( + "app.services.email_service.EmailService.send_rental_confirmation", + new_callable=AsyncMock, + return_value=True, + ) as mock_email: + resp = await client.post("/api/rental-requests", json=VALID_RENTAL_PAYLOAD) + assert resp.status_code == 201 + mock_email.assert_awaited_once() + call_kwargs = mock_email.call_args.kwargs + assert call_kwargs["to_addr"] == "max@event.de" + assert call_kwargs["event_name"] == "Sommerfestival 2026" + assert call_kwargs["reference_number"].startswith("HMS-") + assert len(call_kwargs["items"]) == 1 + + +@pytest.mark.asyncio +async def test_rental_rentman_failure_still_returns_201(client, seeded_equipment): + """POST /api/rental-requests still returns 201 when Rentman API fails.""" + with patch( + "app.services.rentman_service.RentmanService.create_project_request", + new_callable=AsyncMock, + side_effect=Exception("Rentman API error"), + ), patch( + "app.services.email_service.EmailService.send_rental_confirmation", + new_callable=AsyncMock, + return_value=True, + ): + resp = await client.post("/api/rental-requests", json=VALID_RENTAL_PAYLOAD) + assert resp.status_code == 201 diff --git a/backend/tests/test_rentman_import.py b/backend/tests/test_rentman_import.py new file mode 100644 index 0000000..47f6214 --- /dev/null +++ b/backend/tests/test_rentman_import.py @@ -0,0 +1,131 @@ +"""Tests for Rentman equipment import pipeline (T04).""" +import pytest +import pytest_asyncio +from unittest.mock import AsyncMock, patch, MagicMock +from sqlalchemy import select +from app.models.equipment import EquipmentCache +from app.models.sync_log import SyncLog +from app.services.sync_service import SyncService +from app.services.rentman_service import RentmanService + + +def make_raw_equipment(rid: str, name: str, category: str = "Lautsprecher") -> dict: + return { + "id": rid, + "name": name, + "number": f"{name[:3].upper()}-001", + "code": f"{name[:3].upper()}-001", + "equipment_group": {"name": category}, + "description": f"Description for {name}", + "specifications": {"weight": 50, "power": 750}, + "images": [{"url": f"https://example.com/{rid}.jpg"}], + "rental_price": 150.00, + "brand": "L-Acoustics", + "available": True, + } + + +@pytest.mark.asyncio +async def test_transform_equipment(): + raw = make_raw_equipment("42", "K2 Line Array", "Lautsprecher") + result = RentmanService.transform_equipment(raw) + assert result["rentman_id"] == "42" + assert result["name"] == "K2 Line Array" + assert result["category"] == "Lautsprecher" + assert result["images"] == ["https://example.com/42.jpg"] + assert result["brand"] == "L-Acoustics" + assert result["available"] is True + + +@pytest.mark.asyncio +async def test_paginated_import(test_db): + """Import service iterates all pages (3 pages with 250 items).""" + page1 = {"data": [make_raw_equipment(str(i), f"Item {i}") for i in range(100)], "itemCount": 250} + page2 = {"data": [make_raw_equipment(str(i), f"Item {i}") for i in range(100, 200)], "itemCount": 250} + page3 = {"data": [make_raw_equipment(str(i), f"Item {i}") for i in range(200, 250)], "itemCount": 250} + page4 = {"data": [], "itemCount": 250} + + mock_rentman = MagicMock() + mock_rentman.get_all_equipment = AsyncMock(return_value=[ + *[make_raw_equipment(str(i), f"Item {i}") for i in range(250)] + ]) + + with patch("app.services.sync_service.cache") as mock_cache: + mock_cache.delete_pattern = AsyncMock(return_value=0) + sync_service = SyncService(test_db, rentman=mock_rentman) + result = await sync_service.run_sync() + + assert result["status"] == "completed" + assert result["items_processed"] == 250 + assert result["items_failed"] == 0 + + # Verify equipment was upserted + db_result = await test_db.execute(select(EquipmentCache)) + items = db_result.scalars().all() + assert len(items) == 250 + + # Verify sync_log entry + log_result = await test_db.execute(select(SyncLog)) + logs = log_result.scalars().all() + assert len(logs) == 1 + assert logs[0].status == "completed" + assert logs[0].items_processed == 250 + + +@pytest.mark.asyncio +async def test_sync_upsert_existing(test_db): + """Upsert should update existing equipment, not duplicate.""" + existing = EquipmentCache(rentman_id="100", name="Old Name", category="Old") + test_db.add(existing) + await test_db.commit() + + mock_rentman = MagicMock() + mock_rentman.get_all_equipment = AsyncMock(return_value=[ + make_raw_equipment("100", "New Name", "Lautsprecher") + ]) + + with patch("app.services.sync_service.cache") as mock_cache: + mock_cache.delete_pattern = AsyncMock(return_value=0) + sync_service = SyncService(test_db, rentman=mock_rentman) + result = await sync_service.run_sync() + + assert result["items_processed"] == 1 + db_result = await test_db.execute(select(EquipmentCache)) + items = db_result.scalars().all() + assert len(items) == 1 + assert items[0].name == "New Name" + + +@pytest.mark.asyncio +async def test_sync_failure_logs_error(test_db): + """Sync failure should be logged with error message.""" + mock_rentman = MagicMock() + mock_rentman.get_all_equipment = AsyncMock(side_effect=Exception("API unreachable")) + + with patch("app.services.sync_service.cache") as mock_cache: + mock_cache.delete_pattern = AsyncMock(return_value=0) + sync_service = SyncService(test_db, rentman=mock_rentman) + result = await sync_service.run_sync() + + assert result["status"] == "failed" + assert result["items_processed"] == 0 + + log_result = await test_db.execute(select(SyncLog)) + log = log_result.scalar_one() + assert log.status == "failed" + assert "API unreachable" in (log.error_message or "") + + +@pytest.mark.asyncio +async def test_get_all_equipment_paginates(): + """RentmanService.get_all_equipment iterates until data is empty.""" + page1 = {"data": [{"id": str(i), "name": f"Item {i}"} for i in range(100)]} + page2 = {"data": [{"id": str(i), "name": f"Item {i}"} for i in range(100, 150)]} + page3 = {"data": []} + + svc = RentmanService(token="test-token") + svc.get_equipment_page = AsyncMock(side_effect=[page1, page2, page3]) + result = await svc.get_all_equipment(limit=100) + + assert len(result) == 150 + assert svc.get_equipment_page.call_count == 3 diff --git a/backend/tests/test_rentman_request.py b/backend/tests/test_rentman_request.py new file mode 100644 index 0000000..e57995e --- /dev/null +++ b/backend/tests/test_rentman_request.py @@ -0,0 +1,120 @@ +"""Tests for Rentman request submission pipeline (T04).""" +import pytest +from unittest.mock import AsyncMock, patch, MagicMock +from app.services.rentman_service import RentmanService + + +def test_build_project_request_payload(): + data = { + "event_name": "Sommerfest 2026", + "date_start": "2026-08-15", + "date_end": "2026-08-16", + "contact_name": "Max Mustermann", + "contact_company": "Firma GmbH", + "contact_email": "max@example.com", + "contact_phone": "+49 170 1234567", + "contact_street": "Hauptstr. 42a", + "contact_postalcode": "80000", + "contact_city": "Muenchen", + "location": "Muenchen", + "message": "Brauchen PA", + } + payload = RentmanService.build_project_request_payload(data) + assert payload["name"] == "Sommerfest 2026" + assert payload["planperiod_start"] == "2026-08-15T08:00:00+02:00" + assert payload["planperiod_end"] == "2026-08-16T02:00:00+02:00" + assert payload["usageperiod_start"] == "2026-08-15T18:00:00+02:00" + assert payload["usageperiod_end"] == "2026-08-16T23:59:00+02:00" + assert payload["contact_name"] == "Firma GmbH" + assert payload["contact_person_first_name"] == "Max" + assert payload["contact_person_lastname"] == "Mustermann" + assert payload["contact_person_email"] == "max@example.com" + assert payload["location_mailing_street"] == "Hauptstr. 42a" + assert payload["location_mailing_number"] == "42a" + assert payload["location_mailing_postalcode"] == "80000" + assert payload["location_mailing_city"] == "Muenchen" + assert payload["remark"] == "Brauchen PA" + + +def test_build_project_request_payload_no_company(): + """When no company, contact_name should use contact_name.""" + data = { + "event_name": "Test", + "date_start": "2026-08-15", + "date_end": "2026-08-16", + "contact_name": "Anna Schmidt", + "contact_company": None, + "contact_email": "anna@example.com", + "contact_street": "Testweg 5", + "contact_postalcode": "10000", + "contact_city": "Berlin", + "location": "Berlin", + } + payload = RentmanService.build_project_request_payload(data) + assert payload["contact_name"] == "Anna Schmidt" + assert payload["contact_person_first_name"] == "Anna" + assert payload["contact_person_lastname"] == "Schmidt" + assert payload["location_mailing_number"] == "5" + + +def test_build_equipment_payload(): + item = { + "equipment_name": "L-Acoustics K2", + "rentman_equipment_id": "101", + "quantity": 4, + "unit_price": 150.00, + } + payload = RentmanService.build_equipment_payload(item) + assert payload["name"] == "L-Acoustics K2" + assert payload["quantity"] == 4 + assert payload["quantity_total"] == 4 + assert payload["unit_price"] == 150.00 + assert payload["linked_equipment"] == "/equipment/101" + + +@pytest.mark.asyncio +async def test_projectrequest_success(): + """Mock Rentman API: create project request returns ID, equipment added.""" + svc = RentmanService(token="test-token") + svc.create_project_request = AsyncMock(return_value={"id": "9999", "name": "Test Event"}) + svc.add_equipment_to_request = AsyncMock(return_value={"id": "equip-1"}) + + project_payload = {"name": "Test Event", "usageperiod_start": "2026-08-15T18:00:00+02:00"} + result = await svc.create_project_request(project_payload) + assert result["id"] == "9999" + + equip_payload = {"name": "K2", "quantity": 2} + eq_result = await svc.add_equipment_to_request("9999", equip_payload) + assert eq_result["id"] == "equip-1" + + +@pytest.mark.asyncio +async def test_equipment_retry(): + """Failed equipment POST should be retried (exponential backoff simulation).""" + svc = RentmanService(token="test-token") + call_count = 0 + + async def mock_add(*args, **kwargs): + nonlocal call_count + call_count += 1 + if call_count < 3: + raise Exception("Temporary failure") + return {"id": "success"} + + svc.add_equipment_to_request = mock_add + + # Simulate retry logic + max_retries = 3 + result = None + for attempt in range(max_retries): + try: + result = await svc.add_equipment_to_request("1", {"name": "test"}) + break + except Exception: + if attempt == max_retries - 1: + raise + import asyncio + await asyncio.sleep(0.01 * (2 ** attempt)) + + assert result == {"id": "success"} + assert call_count == 3 diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..ba7065a --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,91 @@ +services: + frontend: + build: ./frontend + ports: + - "3000:3000" + depends_on: + backend: + condition: service_healthy + environment: + - NUXT_PUBLIC_API_BASE=${NUXT_PUBLIC_API_BASE:-http://backend:8000} + restart: unless-stopped + healthcheck: + test: ["CMD", "node", "-e", "fetch('http://localhost:3000/').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))"] + interval: 30s + timeout: 10s + retries: 3 + start_period: 15s + networks: + - hms-network + + backend: + build: ./backend + ports: + - "8000:8000" + depends_on: + postgres: + condition: service_healthy + redis: + condition: service_healthy + environment: + - DATABASE_URL=${DATABASE_URL:-postgresql://hms:hms@postgres:5432/hms} + - REDIS_URL=${REDIS_URL:-redis://redis:6379/0} + - RENTMAN_API_TOKEN=${RENTMAN_API_TOKEN} + - JWT_SECRET=${JWT_SECRET} + - SMTP_HOST=${SMTP_HOST} + - SMTP_PORT=${SMTP_PORT:-587} + - SMTP_USER=${SMTP_USER} + - SMTP_PASSWORD=${SMTP_PASSWORD} + - SMTP_FROM=${SMTP_FROM:-info@hms-licht-ton.de} + - CORS_ORIGINS=${CORS_ORIGINS:-https://hms.media-on.de,http://localhost:3000} + - ADMIN_USERNAME=${ADMIN_USERNAME:-admin} + - ADMIN_PASSWORD=${ADMIN_PASSWORD} + restart: unless-stopped + healthcheck: + test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')"] + interval: 30s + timeout: 10s + retries: 3 + start_period: 10s + networks: + - hms-network + + postgres: + image: postgres:16-alpine + volumes: + - postgres_data:/var/lib/postgresql/data + environment: + - POSTGRES_USER=hms + - POSTGRES_PASSWORD=hms + - POSTGRES_DB=hms + restart: unless-stopped + healthcheck: + test: ["CMD-SHELL", "pg_isready -U hms -d hms"] + interval: 10s + timeout: 5s + retries: 5 + start_period: 5s + networks: + - hms-network + + redis: + image: redis:7-alpine + volumes: + - redis_data:/data + restart: unless-stopped + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 10s + timeout: 5s + retries: 5 + start_period: 5s + networks: + - hms-network + +networks: + hms-network: + driver: bridge + +volumes: + postgres_data: + redis_data: diff --git a/frontend/.dockerignore b/frontend/.dockerignore new file mode 100644 index 0000000..0b6c734 --- /dev/null +++ b/frontend/.dockerignore @@ -0,0 +1,12 @@ +node_modules +.nuxt +.output +dist +.git +.gitignore +*.md +.env +.env.* +playwright-report +test-results +coverage diff --git a/frontend/Dockerfile b/frontend/Dockerfile new file mode 100644 index 0000000..976dde8 --- /dev/null +++ b/frontend/Dockerfile @@ -0,0 +1,21 @@ +# --- Stage 1: Build --- +FROM node:20 AS builder + +WORKDIR /app + +COPY package.json package-lock.json ./ +RUN npm ci + +COPY . . +RUN npm run build + +# --- Stage 2: Production --- +FROM node:20-slim AS production + +WORKDIR /app + +COPY --from=builder /app/.output ./.output + +EXPOSE 3000 + +CMD ["node", ".output/server/index.mjs"] diff --git a/frontend/components/AppHeader.vue b/frontend/components/AppHeader.vue index 0f7f632..e3cfa0c 100644 --- a/frontend/components/AppHeader.vue +++ b/frontend/components/AppHeader.vue @@ -21,7 +21,7 @@