444 lines
15 KiB
Python
444 lines
15 KiB
Python
"""Tests for mobile.de service: field mapping, push, update, delete, status, retry."""
|
|
|
|
import uuid
|
|
from datetime import date, datetime, timezone
|
|
from decimal import Decimal
|
|
from unittest.mock import AsyncMock, MagicMock, patch
|
|
|
|
import pytest
|
|
|
|
from app.models.vehicle import MobileDeListing, Vehicle
|
|
from app.services import mobilede_service
|
|
from app.utils.mobilede_mapping import map_fields
|
|
|
|
|
|
def _make_vehicle(**overrides) -> Vehicle:
|
|
"""Create a Vehicle instance with defaults and optional overrides."""
|
|
defaults = {
|
|
"make": "Mercedes-Benz",
|
|
"model": "Actros",
|
|
"fin": "WDB9066351L123456",
|
|
"year": 2020,
|
|
"first_registration": date(2020, 3, 15),
|
|
"power_kw": 300,
|
|
"power_hp": 408,
|
|
"fuel_type": "Diesel",
|
|
"transmission": "Manual",
|
|
"color": "White",
|
|
"condition": "used",
|
|
"location": "Berlin",
|
|
"availability": "available",
|
|
"price": Decimal("45000.00"),
|
|
"vehicle_type": "lkw",
|
|
"lkw_type": "sattelzugmaschine",
|
|
"mileage_km": 120000,
|
|
"description": "Well maintained truck",
|
|
}
|
|
defaults.update(overrides)
|
|
vehicle = Vehicle(**defaults)
|
|
vehicle.id = uuid.uuid4()
|
|
return vehicle
|
|
|
|
|
|
class TestFieldMapping:
|
|
"""Tests for mobile.de field mapping (map_fields)."""
|
|
|
|
def test_map_fields_basic_lkw(self):
|
|
"""map_fields produces correct ad format for LKW."""
|
|
vehicle = _make_vehicle()
|
|
ad = map_fields(vehicle)
|
|
|
|
assert ad["vin"] == "WDB9066351L123456"
|
|
assert ad["make"] == "Mercedes-Benz"
|
|
assert ad["model"] == "Actros"
|
|
assert ad["category"] == "SemiTractor"
|
|
assert ad["price"] == {"amount": 45000.0, "currency": "EUR"}
|
|
assert ad["availabilityStatus"] == "available"
|
|
assert ad["condition"] == "used"
|
|
assert ad["firstRegistration"] == "2020-03"
|
|
assert ad["mileage"] == {"value": 120000, "unit": "km"}
|
|
assert ad["power"] == {"powerKw": 300, "powerHp": 408}
|
|
assert ad["fuelType"] == "Diesel"
|
|
assert ad["transmission"] == "Manual"
|
|
assert ad["color"] == "White"
|
|
assert ad["sellerLocation"] == "Berlin"
|
|
assert ad["description"] == "Well maintained truck"
|
|
|
|
def test_map_fields_baumaschine_with_operating_hours(self):
|
|
"""map_fields maps operating_hours to mileage for baumaschine."""
|
|
vehicle = _make_vehicle(
|
|
vehicle_type="baumaschine",
|
|
machine_type="Bagger",
|
|
operating_hours=Decimal("3500.5"),
|
|
operating_hours_unit="h",
|
|
mileage_km=None,
|
|
lkw_type=None,
|
|
)
|
|
ad = map_fields(vehicle)
|
|
|
|
assert ad["category"] == "ConstructionMachine"
|
|
assert ad["mileage"] == {"value": 3500.5, "unit": "h"}
|
|
assert ad["bodyType"] == "Bagger"
|
|
|
|
def test_map_fields_pkw(self):
|
|
"""map_fields maps PKW correctly."""
|
|
vehicle = _make_vehicle(
|
|
vehicle_type="pkw",
|
|
lkw_type=None,
|
|
body_type="Limousine",
|
|
)
|
|
ad = map_fields(vehicle)
|
|
assert ad["category"] == "Car"
|
|
assert ad["bodyType"] == "Limousine"
|
|
|
|
def test_map_fields_stapler(self):
|
|
"""map_fields maps Stapler correctly."""
|
|
vehicle = _make_vehicle(
|
|
vehicle_type="stapler",
|
|
lkw_type=None,
|
|
operating_hours=Decimal("12000"),
|
|
operating_hours_unit="h",
|
|
mileage_km=None,
|
|
)
|
|
ad = map_fields(vehicle)
|
|
assert ad["category"] == "ForkliftTruck"
|
|
assert ad["mileage"] == {"value": 12000.0, "unit": "h"}
|
|
|
|
def test_map_fields_transporter(self):
|
|
"""map_fields maps Transporter correctly."""
|
|
vehicle = _make_vehicle(
|
|
vehicle_type="transporter",
|
|
lkw_type=None,
|
|
)
|
|
ad = map_fields(vehicle)
|
|
assert ad["category"] == "Van"
|
|
|
|
def test_map_fields_no_optional_fields(self):
|
|
"""map_fields handles vehicle with no optional fields."""
|
|
vehicle = Vehicle(
|
|
make="Test",
|
|
model="Model",
|
|
fin="WDB9066351L123456",
|
|
condition="new",
|
|
availability="available",
|
|
price=Decimal("10000.00"),
|
|
vehicle_type="pkw",
|
|
)
|
|
ad = map_fields(vehicle)
|
|
assert ad["vin"] == "WDB9066351L123456"
|
|
assert ad["make"] == "Test"
|
|
assert "firstRegistration" not in ad
|
|
assert "mileage" not in ad
|
|
assert "power" not in ad
|
|
assert "fuelType" not in ad
|
|
|
|
def test_map_fields_lkw_type_with_prefix(self):
|
|
"""map_fields strips lkw_ prefix for category lookup."""
|
|
vehicle = _make_vehicle(lkw_type="lkw_kipper")
|
|
ad = map_fields(vehicle)
|
|
assert ad["category"] == "Tipper"
|
|
|
|
def test_map_fields_lkw_type_unknown_falls_back(self):
|
|
"""map_fields falls back to base category for unknown lkw_type."""
|
|
vehicle = _make_vehicle(lkw_type="unknown_type")
|
|
ad = map_fields(vehicle)
|
|
assert ad["category"] == "Truck"
|
|
|
|
|
|
class TestPushListing:
|
|
"""Tests for mobilede_service.push_listing."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_push_listing_success(self, db_session):
|
|
"""push_listing creates listing with synced status on success."""
|
|
vehicle = _make_vehicle()
|
|
db_session.add(vehicle)
|
|
await db_session.flush()
|
|
|
|
with patch(
|
|
"app.services.mobilede_service.httpx.AsyncClient"
|
|
) as mock_client_cls:
|
|
mock_response = MagicMock()
|
|
mock_response.status_code = 201
|
|
mock_response.json.return_value = {"id": "ad-123"}
|
|
mock_response.raise_for_status = MagicMock()
|
|
mock_client = AsyncMock()
|
|
mock_client.post = AsyncMock(return_value=mock_response)
|
|
mock_client.__aenter__ = AsyncMock(return_value=mock_client)
|
|
mock_client.__aexit__ = AsyncMock(return_value=None)
|
|
mock_client_cls.return_value = mock_client
|
|
|
|
listing = await mobilede_service.push_listing(db_session, vehicle)
|
|
|
|
assert listing.sync_status == "synced"
|
|
assert listing.ad_id == "ad-123"
|
|
assert listing.synced_at is not None
|
|
assert listing.error_log is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_push_listing_http_error(self, db_session):
|
|
"""push_listing sets fehler status on HTTP error."""
|
|
import httpx
|
|
|
|
vehicle = _make_vehicle()
|
|
db_session.add(vehicle)
|
|
await db_session.flush()
|
|
|
|
with patch(
|
|
"app.services.mobilede_service.httpx.AsyncClient"
|
|
) as mock_client_cls:
|
|
mock_response = MagicMock()
|
|
mock_response.status_code = 400
|
|
mock_response.text = "Bad Request"
|
|
mock_response.raise_for_status.side_effect = httpx.HTTPStatusError(
|
|
"Bad Request", request=MagicMock(), response=mock_response
|
|
)
|
|
mock_client = AsyncMock()
|
|
mock_client.post = AsyncMock(return_value=mock_response)
|
|
mock_client.__aenter__ = AsyncMock(return_value=mock_client)
|
|
mock_client.__aexit__ = AsyncMock(return_value=None)
|
|
mock_client_cls.return_value = mock_client
|
|
|
|
listing = await mobilede_service.push_listing(db_session, vehicle)
|
|
|
|
assert listing.sync_status == "fehler"
|
|
assert listing.error_log is not None
|
|
assert "400" in listing.error_log
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_push_listing_request_error(self, db_session):
|
|
"""push_listing sets fehler status on request error."""
|
|
import httpx
|
|
|
|
vehicle = _make_vehicle()
|
|
db_session.add(vehicle)
|
|
await db_session.flush()
|
|
|
|
with patch(
|
|
"app.services.mobilede_service.httpx.AsyncClient"
|
|
) as mock_client_cls:
|
|
mock_client = AsyncMock()
|
|
mock_client.post = AsyncMock(
|
|
side_effect=httpx.ConnectError("Connection refused")
|
|
)
|
|
mock_client.__aenter__ = AsyncMock(return_value=mock_client)
|
|
mock_client.__aexit__ = AsyncMock(return_value=None)
|
|
mock_client_cls.return_value = mock_client
|
|
|
|
listing = await mobilede_service.push_listing(db_session, vehicle)
|
|
|
|
assert listing.sync_status == "fehler"
|
|
assert "Connection refused" in listing.error_log
|
|
|
|
|
|
class TestUpdateListing:
|
|
"""Tests for mobilede_service.update_listing."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_update_listing_success(self, db_session):
|
|
"""update_listing updates synced status on success."""
|
|
vehicle = _make_vehicle()
|
|
db_session.add(vehicle)
|
|
await db_session.flush()
|
|
|
|
listing = MobileDeListing(
|
|
vehicle_id=vehicle.id,
|
|
ad_id="ad-123",
|
|
sync_status="synced",
|
|
)
|
|
db_session.add(listing)
|
|
await db_session.flush()
|
|
|
|
with patch(
|
|
"app.services.mobilede_service.httpx.AsyncClient"
|
|
) as mock_client_cls:
|
|
mock_response = MagicMock()
|
|
mock_response.status_code = 200
|
|
mock_response.raise_for_status = MagicMock()
|
|
mock_client = AsyncMock()
|
|
mock_client.put = AsyncMock(return_value=mock_response)
|
|
mock_client.__aenter__ = AsyncMock(return_value=mock_client)
|
|
mock_client.__aexit__ = AsyncMock(return_value=None)
|
|
mock_client_cls.return_value = mock_client
|
|
|
|
result = await mobilede_service.update_listing(db_session, vehicle, listing)
|
|
|
|
assert result.sync_status == "synced"
|
|
assert result.synced_at is not None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_update_listing_no_ad_id(self, db_session):
|
|
"""update_listing sets fehler when listing has no ad_id."""
|
|
vehicle = _make_vehicle()
|
|
db_session.add(vehicle)
|
|
await db_session.flush()
|
|
|
|
listing = MobileDeListing(
|
|
vehicle_id=vehicle.id,
|
|
sync_status="pending",
|
|
)
|
|
db_session.add(listing)
|
|
await db_session.flush()
|
|
|
|
result = await mobilede_service.update_listing(db_session, vehicle, listing)
|
|
|
|
assert result.sync_status == "fehler"
|
|
assert "ad_id" in result.error_log
|
|
|
|
|
|
class TestDeleteListing:
|
|
"""Tests for mobilede_service.delete_listing."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_delete_listing_success(self, db_session):
|
|
"""delete_listing sets deleted status on success."""
|
|
vehicle = _make_vehicle()
|
|
db_session.add(vehicle)
|
|
await db_session.flush()
|
|
|
|
listing = MobileDeListing(
|
|
vehicle_id=vehicle.id,
|
|
ad_id="ad-123",
|
|
sync_status="synced",
|
|
)
|
|
db_session.add(listing)
|
|
await db_session.flush()
|
|
|
|
with patch(
|
|
"app.services.mobilede_service.httpx.AsyncClient"
|
|
) as mock_client_cls:
|
|
mock_response = MagicMock()
|
|
mock_response.status_code = 204
|
|
mock_response.raise_for_status = MagicMock()
|
|
mock_client = AsyncMock()
|
|
mock_client.delete = AsyncMock(return_value=mock_response)
|
|
mock_client.__aenter__ = AsyncMock(return_value=mock_client)
|
|
mock_client.__aexit__ = AsyncMock(return_value=None)
|
|
mock_client_cls.return_value = mock_client
|
|
|
|
result = await mobilede_service.delete_listing(db_session, listing)
|
|
|
|
assert result.sync_status == "deleted"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_delete_listing_no_ad_id(self, db_session):
|
|
"""delete_listing sets fehler when listing has no ad_id."""
|
|
vehicle = _make_vehicle()
|
|
db_session.add(vehicle)
|
|
await db_session.flush()
|
|
|
|
listing = MobileDeListing(
|
|
vehicle_id=vehicle.id,
|
|
sync_status="pending",
|
|
)
|
|
db_session.add(listing)
|
|
await db_session.flush()
|
|
|
|
result = await mobilede_service.delete_listing(db_session, listing)
|
|
|
|
assert result.sync_status == "fehler"
|
|
assert "ad_id" in result.error_log
|
|
|
|
|
|
class TestGetListingStatus:
|
|
"""Tests for mobilede_service.get_listing_status."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_listing_status_returns_latest(self, db_session):
|
|
"""get_listing_status returns the most recent listing."""
|
|
vehicle = _make_vehicle()
|
|
db_session.add(vehicle)
|
|
await db_session.flush()
|
|
|
|
listing1 = MobileDeListing(
|
|
vehicle_id=vehicle.id,
|
|
sync_status="fehler",
|
|
error_log="First attempt failed",
|
|
created_at=datetime(2025, 1, 1, 12, 0, 0, tzinfo=timezone.utc),
|
|
)
|
|
db_session.add(listing1)
|
|
await db_session.flush()
|
|
|
|
listing2 = MobileDeListing(
|
|
vehicle_id=vehicle.id,
|
|
ad_id="ad-456",
|
|
sync_status="synced",
|
|
created_at=datetime(2025, 1, 2, 12, 0, 0, tzinfo=timezone.utc),
|
|
)
|
|
db_session.add(listing2)
|
|
await db_session.flush()
|
|
|
|
result = await mobilede_service.get_listing_status(db_session, vehicle.id)
|
|
|
|
assert result is not None
|
|
assert result.sync_status == "synced"
|
|
assert result.ad_id == "ad-456"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_listing_status_returns_none_when_no_listing(self, db_session):
|
|
"""get_listing_status returns None when no listing exists."""
|
|
vehicle_id = uuid.uuid4()
|
|
result = await mobilede_service.get_listing_status(db_session, vehicle_id)
|
|
assert result is None
|
|
|
|
|
|
class TestRetryFailedListing:
|
|
"""Tests for mobilede_service.retry_failed_listing."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_retry_succeeds_within_max_retries(self, db_session):
|
|
"""retry_failed_listing re-attempts push when under max retries."""
|
|
vehicle = _make_vehicle()
|
|
db_session.add(vehicle)
|
|
await db_session.flush()
|
|
|
|
listing = MobileDeListing(
|
|
vehicle_id=vehicle.id,
|
|
sync_status="fehler",
|
|
error_log="[retry 1] HTTP 500: Internal Server Error",
|
|
)
|
|
db_session.add(listing)
|
|
await db_session.flush()
|
|
|
|
with patch(
|
|
"app.services.mobilede_service.httpx.AsyncClient"
|
|
) as mock_client_cls:
|
|
mock_response = MagicMock()
|
|
mock_response.status_code = 201
|
|
mock_response.json.return_value = {"id": "ad-789"}
|
|
mock_response.raise_for_status = MagicMock()
|
|
mock_client = AsyncMock()
|
|
mock_client.post = AsyncMock(return_value=mock_response)
|
|
mock_client.__aenter__ = AsyncMock(return_value=mock_client)
|
|
mock_client.__aexit__ = AsyncMock(return_value=None)
|
|
mock_client_cls.return_value = mock_client
|
|
|
|
result = await mobilede_service.retry_failed_listing(
|
|
db_session, listing, vehicle
|
|
)
|
|
|
|
assert result.sync_status == "synced"
|
|
assert result.ad_id == "ad-789"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_retry_exceeds_max_retries(self, db_session):
|
|
"""retry_failed_listing marks as permanently failed after max retries."""
|
|
vehicle = _make_vehicle()
|
|
db_session.add(vehicle)
|
|
await db_session.flush()
|
|
|
|
listing = MobileDeListing(
|
|
vehicle_id=vehicle.id,
|
|
sync_status="fehler",
|
|
error_log=f"[retry {mobilede_service.MAX_RETRIES}] Last error",
|
|
)
|
|
db_session.add(listing)
|
|
await db_session.flush()
|
|
|
|
result = await mobilede_service.retry_failed_listing(
|
|
db_session, listing, vehicle
|
|
)
|
|
|
|
assert result.sync_status == "fehler"
|
|
assert "Max retries" in result.error_log
|