766 lines
24 KiB
Python
766 lines
24 KiB
Python
from datetime import datetime, timedelta, timezone
|
|
from unittest.mock import AsyncMock
|
|
|
|
import pytest
|
|
from httpx import ASGITransport, AsyncClient
|
|
|
|
from app.api.v1 import visualization
|
|
from app.api.v1.visualization import convert_vessels_to_geojson
|
|
from app.db.session import get_db
|
|
from app.main import app
|
|
from app.models.vessel import AISRawObservation, VesselPosition, VesselStatic
|
|
from app.services import barentswatch
|
|
from app.services.collectors.aisstream import AISStreamCollector
|
|
from app.services.collectors.vessel_ais import VesselAISCollector
|
|
from app.services.vessel_ais_aggregation import (
|
|
aggregate_vessel_observations,
|
|
build_field_conflict_candidates,
|
|
build_observation_hash,
|
|
record_vessel_ais_observation,
|
|
)
|
|
|
|
|
|
def test_vessel_collector_transforms_barentswatch_like_records():
|
|
collector = VesselAISCollector()
|
|
records = collector.transform(
|
|
[
|
|
{
|
|
"mmsi": "257123000",
|
|
"lat": "59.91",
|
|
"lon": "10.73",
|
|
"sog": 12.4,
|
|
"cog": 214,
|
|
"nav_status": 0,
|
|
"shipType": 70,
|
|
"name": "OSLO TRADER",
|
|
},
|
|
{"mmsi": "bad", "lat": 120, "lon": 10},
|
|
]
|
|
)
|
|
|
|
assert len(records) == 1
|
|
assert records[0]["mmsi"] == 257123000
|
|
assert records[0]["vessel_type_name"] == "Cargo"
|
|
assert records[0]["lat"] == pytest.approx(59.91)
|
|
|
|
|
|
def test_vessel_observation_hash_is_stable_for_same_payload():
|
|
observed_at = datetime(2026, 4, 30, 12, 0, tzinfo=timezone.utc)
|
|
payload = {
|
|
"mmsi": 257123000,
|
|
"lat": 59.91,
|
|
"lon": 10.73,
|
|
"received_at": observed_at,
|
|
}
|
|
|
|
first = build_observation_hash(
|
|
source="barentswatch_vessels",
|
|
entity_key="257123000",
|
|
message_type="PositionReport",
|
|
observed_at=observed_at,
|
|
normalized_payload=payload,
|
|
)
|
|
second = build_observation_hash(
|
|
source="barentswatch_vessels",
|
|
entity_key="257123000",
|
|
message_type="PositionReport",
|
|
observed_at=observed_at,
|
|
normalized_payload=dict(reversed(payload.items())),
|
|
)
|
|
|
|
assert first == second
|
|
assert len(first) == 64
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_record_vessel_ais_observation_skips_existing_hash():
|
|
observed_at = datetime(2026, 4, 30, 12, 0, tzinfo=timezone.utc)
|
|
|
|
class _Result:
|
|
def scalar_one_or_none(self):
|
|
return 123
|
|
|
|
class _Session:
|
|
def __init__(self):
|
|
self.added = []
|
|
|
|
async def execute(self, _stmt):
|
|
return _Result()
|
|
|
|
def add(self, item):
|
|
self.added.append(item)
|
|
|
|
db = _Session()
|
|
observation = await record_vessel_ais_observation(
|
|
db,
|
|
source="barentswatch_vessels",
|
|
normalized_payload={
|
|
"mmsi": 257123000,
|
|
"lat": 59.91,
|
|
"lon": 10.73,
|
|
"received_at": observed_at,
|
|
},
|
|
delivery_mode="polling",
|
|
transport="http",
|
|
observed_at=observed_at.isoformat(),
|
|
)
|
|
|
|
assert observation is None
|
|
assert db.added == []
|
|
|
|
|
|
def test_build_field_conflict_candidates_from_raw_observations():
|
|
observations = [
|
|
AISRawObservation(
|
|
source="barentswatch_vessels",
|
|
normalized_payload={"name": "OSLO TRADER", "flag": "NO"},
|
|
),
|
|
AISRawObservation(
|
|
source="aisstream_vessels",
|
|
normalized_payload={"name": "OSLO TRADER II", "flag": "NO"},
|
|
),
|
|
]
|
|
|
|
conflicts = build_field_conflict_candidates(observations)
|
|
|
|
assert conflicts == [
|
|
{
|
|
"field": "name",
|
|
"candidates": {
|
|
"aisstream_vessels": "OSLO TRADER II",
|
|
"barentswatch_vessels": "OSLO TRADER",
|
|
},
|
|
"status": "candidate",
|
|
}
|
|
]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_aggregate_vessel_observations_prefers_realtime_and_records_conflict():
|
|
observed_at = datetime.now(timezone.utc) - timedelta(minutes=5)
|
|
|
|
class _Result:
|
|
def scalar_one_or_none(self):
|
|
return None
|
|
|
|
class _Session:
|
|
def __init__(self):
|
|
self.added = []
|
|
|
|
async def execute(self, _stmt):
|
|
return _Result()
|
|
|
|
def add(self, item):
|
|
self.added.append(item)
|
|
|
|
db = _Session()
|
|
observations = [
|
|
AISRawObservation(
|
|
id=1,
|
|
source="barentswatch_vessels",
|
|
entity_key="257123000",
|
|
delivery_mode="polling",
|
|
transport="http",
|
|
observed_at=observed_at,
|
|
collected_at=observed_at,
|
|
normalized_payload={
|
|
"mmsi": 257123000,
|
|
"name": "OSLO TRADER",
|
|
"lat": 59.91,
|
|
"lon": 10.73,
|
|
},
|
|
),
|
|
AISRawObservation(
|
|
id=2,
|
|
source="aisstream_vessels",
|
|
entity_key="257123000",
|
|
delivery_mode="realtime_stream",
|
|
transport="websocket",
|
|
observed_at=observed_at + timedelta(seconds=10),
|
|
collected_at=observed_at + timedelta(seconds=10),
|
|
normalized_payload={
|
|
"mmsi": 257123000,
|
|
"vessel_type": 79,
|
|
"lat": 59.92,
|
|
"lon": 10.74,
|
|
},
|
|
raw_payload={"MetaData": {"ShipName": "OSLO TRADER II "}},
|
|
),
|
|
]
|
|
|
|
vessels = await aggregate_vessel_observations(db, observations)
|
|
|
|
assert vessels[0]["lat"] == pytest.approx(59.92)
|
|
assert vessels[0]["field_sources"]["lat"] == "aisstream_vessels"
|
|
assert vessels[0]["name"] == "OSLO TRADER II"
|
|
assert vessels[0]["vessel_type_name"] == "Cargo"
|
|
assert vessels[0]["source_summary"]["aisstream_vessels"]["observation_count"] == 1
|
|
assert vessels[0]["source_summary"]["barentswatch_vessels"]["delivery_mode"] == "polling"
|
|
assert vessels[0]["conflict_count"] == 0
|
|
assert db.added == []
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_vessel_collector_writes_raw_observations_only(monkeypatch):
|
|
collector = VesselAISCollector()
|
|
collector.update_progress = AsyncMock()
|
|
record_observation = AsyncMock()
|
|
update_health = AsyncMock()
|
|
broadcast_custom = AsyncMock()
|
|
monkeypatch.setattr(
|
|
"app.services.collectors.vessel_ais.record_vessel_ais_observation",
|
|
record_observation,
|
|
)
|
|
monkeypatch.setattr(
|
|
"app.services.collectors.vessel_ais.update_ais_source_health",
|
|
update_health,
|
|
)
|
|
monkeypatch.setattr(
|
|
"app.services.collectors.vessel_ais.broadcaster.broadcast_custom",
|
|
broadcast_custom,
|
|
)
|
|
|
|
class _Session:
|
|
def __init__(self):
|
|
self.added = []
|
|
self.committed = False
|
|
|
|
async def get(self, *_args):
|
|
return None
|
|
|
|
def add(self, item):
|
|
self.added.append(item)
|
|
|
|
async def execute(self, _stmt):
|
|
return None
|
|
|
|
async def commit(self):
|
|
self.committed = True
|
|
|
|
db = _Session()
|
|
observed_at = datetime(2026, 4, 30, 12, 0, tzinfo=timezone.utc)
|
|
|
|
saved = await collector._save_data(
|
|
db,
|
|
[
|
|
{
|
|
"mmsi": 257123000,
|
|
"name": "OSLO TRADER",
|
|
"lat": 59.91,
|
|
"lon": 10.73,
|
|
"received_at": observed_at,
|
|
}
|
|
],
|
|
)
|
|
|
|
assert saved == 1
|
|
assert db.committed is True
|
|
# BarentsWatch must funnel through the unified AIS pipeline only — no legacy writes.
|
|
assert not any(isinstance(item, VesselStatic) for item in db.added)
|
|
assert not any(isinstance(item, VesselPosition) for item in db.added)
|
|
record_observation.assert_awaited_once()
|
|
assert record_observation.await_args.kwargs["source"] == "barentswatch_vessels"
|
|
assert record_observation.await_args.kwargs["normalized_payload"]["mmsi"] == 257123000
|
|
update_health.assert_awaited_once()
|
|
broadcast_custom.assert_awaited_once()
|
|
assert broadcast_custom.await_args.args[0] == "vessels"
|
|
assert broadcast_custom.await_args.args[1]["action"] == "upsert"
|
|
assert broadcast_custom.await_args.args[1]["vessels"][0]["mmsi_display"] == "257123000"
|
|
|
|
|
|
def test_aisstream_collector_normalizes_position_report():
|
|
collector = AISStreamCollector()
|
|
|
|
records = collector.transform(
|
|
[
|
|
{
|
|
"MessageType": "PositionReport",
|
|
"MetaData": {
|
|
"MMSI": 257123000,
|
|
"ShipName": "OSLO TRADER ",
|
|
"time_utc": "2026-04-30T12:00:00Z",
|
|
},
|
|
"Message": {
|
|
"PositionReport": {
|
|
"Latitude": 59.91,
|
|
"Longitude": 10.73,
|
|
"Sog": 12.4,
|
|
"Cog": 214,
|
|
"TrueHeading": 215,
|
|
"NavigationalStatus": 0,
|
|
}
|
|
},
|
|
}
|
|
]
|
|
)
|
|
|
|
assert len(records) == 1
|
|
assert records[0]["mmsi"] == 257123000
|
|
assert records[0]["lat"] == pytest.approx(59.91)
|
|
assert records[0]["name"] == "OSLO TRADER"
|
|
assert records[0]["_message_type"] == "PositionReport"
|
|
|
|
|
|
def test_aisstream_collector_maps_ship_static_type_name():
|
|
collector = AISStreamCollector()
|
|
|
|
records = collector.transform(
|
|
[
|
|
{
|
|
"MessageType": "ShipStaticData",
|
|
"MetaData": {
|
|
"MMSI": 257123000,
|
|
"time_utc": "2026-04-30T12:00:00Z",
|
|
},
|
|
"Message": {
|
|
"ShipStaticData": {
|
|
"Name": "OSLO TRADER",
|
|
"Type": 79,
|
|
"CallSign": "LAAB",
|
|
}
|
|
},
|
|
}
|
|
]
|
|
)
|
|
|
|
assert len(records) == 1
|
|
assert records[0]["vessel_type"] == 79
|
|
assert records[0]["vessel_type_name"] == "Cargo"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_aisstream_collector_writes_only_raw_observations(monkeypatch):
|
|
collector = AISStreamCollector()
|
|
collector.update_progress = AsyncMock()
|
|
record_observation = AsyncMock(return_value=object())
|
|
update_health = AsyncMock()
|
|
monkeypatch.setattr(
|
|
"app.services.collectors.aisstream.record_vessel_ais_observation",
|
|
record_observation,
|
|
)
|
|
monkeypatch.setattr(
|
|
"app.services.collectors.aisstream.update_ais_source_health",
|
|
update_health,
|
|
)
|
|
|
|
class _Session:
|
|
def __init__(self):
|
|
self.added = []
|
|
self.committed = False
|
|
|
|
def add(self, item):
|
|
self.added.append(item)
|
|
|
|
async def commit(self):
|
|
self.committed = True
|
|
|
|
db = _Session()
|
|
saved = await collector._save_data(
|
|
db,
|
|
[
|
|
{
|
|
"mmsi": 257123000,
|
|
"lat": 59.91,
|
|
"lon": 10.73,
|
|
"received_at": datetime(2026, 4, 30, 12, 0, tzinfo=timezone.utc),
|
|
"_message_type": "PositionReport",
|
|
}
|
|
],
|
|
)
|
|
|
|
assert saved == 1
|
|
assert db.added == []
|
|
assert db.committed is True
|
|
record_observation.assert_awaited_once()
|
|
assert record_observation.await_args.kwargs["source"] == "aisstream_vessels"
|
|
update_health.assert_awaited_once()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_aisstream_stream_record_broadcasts_vessel_delta(monkeypatch):
|
|
collector = AISStreamCollector()
|
|
record_observation = AsyncMock(return_value=object())
|
|
update_health = AsyncMock()
|
|
broadcast_custom = AsyncMock()
|
|
monkeypatch.setattr(
|
|
"app.services.collectors.aisstream.record_vessel_ais_observation",
|
|
record_observation,
|
|
)
|
|
monkeypatch.setattr(
|
|
"app.services.collectors.aisstream.update_ais_source_health",
|
|
update_health,
|
|
)
|
|
monkeypatch.setattr(
|
|
"app.services.collectors.aisstream.broadcaster.broadcast_custom",
|
|
broadcast_custom,
|
|
)
|
|
|
|
class _Session:
|
|
async def commit(self):
|
|
pass
|
|
|
|
created = await collector._save_stream_record(
|
|
_Session(),
|
|
{
|
|
"mmsi": 257123000,
|
|
"lat": 59.91,
|
|
"lon": 10.73,
|
|
"cog": 214,
|
|
"received_at": datetime(2026, 4, 30, 12, 0, tzinfo=timezone.utc),
|
|
},
|
|
)
|
|
|
|
assert created is True
|
|
record_observation.assert_awaited_once()
|
|
broadcast_custom.assert_awaited_once()
|
|
assert broadcast_custom.await_args.args[0] == "vessels"
|
|
assert broadcast_custom.await_args.args[1]["action"] == "upsert"
|
|
assert broadcast_custom.await_args.args[1]["vessels"][0]["mmsi_display"] == "257123000"
|
|
|
|
|
|
def test_barentswatch_reads_credentials_from_zshrc(tmp_path):
|
|
zshrc = tmp_path / ".zshrc"
|
|
zshrc.write_text(
|
|
"\n".join(
|
|
[
|
|
"export BARENTSWATCH_CLIENT_ID='client-from-zshrc'",
|
|
'export BARENTSWATCH_CLIENT_SECRET="secret-from-zshrc" # local dev credential',
|
|
]
|
|
),
|
|
encoding="utf-8",
|
|
)
|
|
|
|
values = barentswatch._read_zshrc_env(zshrc)
|
|
|
|
assert values["BARENTSWATCH_CLIENT_ID"] == "client-from-zshrc"
|
|
assert values["BARENTSWATCH_CLIENT_SECRET"] == "secret-from-zshrc"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_barentswatch_resolves_config_from_zshrc(tmp_path, monkeypatch):
|
|
zshrc = tmp_path / ".zshrc"
|
|
zshrc.write_text(
|
|
"\n".join(
|
|
[
|
|
"export BARENTSWATCH_CLIENT_ID=client-from-zshrc",
|
|
"export BARENTSWATCH_CLIENT_SECRET=secret-from-zshrc",
|
|
]
|
|
),
|
|
encoding="utf-8",
|
|
)
|
|
monkeypatch.delenv("BARENTSWATCH_CLIENT_ID", raising=False)
|
|
monkeypatch.delenv("BARENTSWATCH_CLIENT_SECRET", raising=False)
|
|
monkeypatch.delenv("BARRENTSWATCH_CLIENT_ID", raising=False)
|
|
monkeypatch.delenv("BARRENTSWATCH_CLIENT_SECRET", raising=False)
|
|
monkeypatch.setattr(barentswatch.Path, "home", lambda: tmp_path)
|
|
|
|
config = await barentswatch.resolve_barentswatch_config(None)
|
|
|
|
assert config.client_id == "client-from-zshrc"
|
|
assert config.client_secret == "secret-from-zshrc"
|
|
assert config.credential_source == "~/.zshrc"
|
|
|
|
|
|
def test_convert_vessels_to_geojson():
|
|
position = VesselPosition(
|
|
mmsi=257123000,
|
|
lat=59.91,
|
|
lon=10.73,
|
|
sog=12.4,
|
|
cog=214,
|
|
heading=215,
|
|
nav_status=0,
|
|
received_at=datetime(2026, 4, 28, 1, 0, tzinfo=timezone.utc),
|
|
)
|
|
static = VesselStatic(
|
|
mmsi=257123000,
|
|
name="OSLO TRADER",
|
|
vessel_type=70,
|
|
vessel_type_name="Cargo",
|
|
flag="NO",
|
|
length=185,
|
|
)
|
|
|
|
payload = convert_vessels_to_geojson([(position, static)])
|
|
|
|
assert payload["type"] == "FeatureCollection"
|
|
assert payload["features"][0]["geometry"]["coordinates"] == [10.73, 59.91]
|
|
assert payload["features"][0]["properties"]["mmsi"] == 257123000
|
|
assert payload["features"][0]["properties"]["vessel_type_name"] == "Cargo"
|
|
|
|
|
|
def test_convert_vessels_to_geojson_dedupes_mmsi_rows():
|
|
first = VesselPosition(
|
|
mmsi=257123000,
|
|
lat=59.91,
|
|
lon=10.73,
|
|
received_at=datetime(2026, 4, 28, 1, 0, tzinfo=timezone.utc),
|
|
)
|
|
duplicate = VesselPosition(
|
|
mmsi=257123000,
|
|
lat=60.01,
|
|
lon=10.83,
|
|
received_at=datetime(2026, 4, 28, 1, 0, tzinfo=timezone.utc),
|
|
)
|
|
other = VesselPosition(
|
|
mmsi=257456000,
|
|
lat=60.3,
|
|
lon=5.3,
|
|
received_at=datetime(2026, 4, 28, 0, 59, tzinfo=timezone.utc),
|
|
)
|
|
|
|
payload = convert_vessels_to_geojson(
|
|
[
|
|
(first, VesselStatic(mmsi=257123000, name="OSLO TRADER")),
|
|
(duplicate, VesselStatic(mmsi=257123000, name="OSLO TRADER DUP")),
|
|
(other, VesselStatic(mmsi=257456000, name="BERGEN FERRY")),
|
|
]
|
|
)
|
|
|
|
mmsis = [feature["properties"]["mmsi"] for feature in payload["features"]]
|
|
assert mmsis == [257123000, 257456000]
|
|
assert payload["features"][0]["geometry"]["coordinates"] == [10.73, 59.91]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_vessel_snapshot_filters_type_and_bbox(monkeypatch):
|
|
now = datetime(2026, 4, 28, 1, 0, tzinfo=timezone.utc)
|
|
monkeypatch.setattr(
|
|
visualization,
|
|
"get_aggregated_vessels_snapshot",
|
|
AsyncMock(
|
|
return_value=[
|
|
{
|
|
"mmsi": 1,
|
|
"lat": 59.9,
|
|
"lon": 10.7,
|
|
"received_at": now,
|
|
"name": "Cargo Ship",
|
|
"vessel_type": 70,
|
|
"vessel_type_name": "Cargo",
|
|
},
|
|
{
|
|
"mmsi": 2,
|
|
"lat": 60.3,
|
|
"lon": 5.3,
|
|
"received_at": now - timedelta(minutes=1),
|
|
"name": "Passenger Ship",
|
|
"vessel_type": 60,
|
|
"vessel_type_name": "Passenger",
|
|
},
|
|
]
|
|
),
|
|
)
|
|
|
|
async def override_get_db():
|
|
yield object()
|
|
|
|
app.dependency_overrides[get_db] = override_get_db
|
|
transport = ASGITransport(app=app)
|
|
try:
|
|
async with AsyncClient(transport=transport, base_url="http://test") as client:
|
|
response = await client.get(
|
|
"/api/v1/vessels/snapshot",
|
|
params={"bbox": "0,50,20,70", "zoom": 12, "type": "cargo", "limit": 1000},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["count"] == 1
|
|
assert data["features"][0]["properties"]["name"] == "Cargo Ship"
|
|
assert data["stats"]["by_type"]["Cargo"] == 1
|
|
finally:
|
|
app.dependency_overrides.clear()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_legacy_vessels_geojson_route_is_not_registered():
|
|
transport = ASGITransport(app=app)
|
|
async with AsyncClient(transport=transport, base_url="http://test") as client:
|
|
response = await client.get("/api/v1/visualization/geo/vessels")
|
|
|
|
assert response.status_code == 404
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_vessel_snapshot_requires_bbox():
|
|
transport = ASGITransport(app=app)
|
|
async with AsyncClient(transport=transport, base_url="http://test") as client:
|
|
response = await client.get("/api/v1/vessels/snapshot", params={"zoom": 12})
|
|
|
|
assert response.status_code == 400
|
|
assert response.json()["detail"] == "bbox is required"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_vessel_snapshot_filters_bbox_and_caps_limit(monkeypatch):
|
|
now = datetime(2026, 4, 28, 1, 0, tzinfo=timezone.utc)
|
|
captured = {}
|
|
|
|
async def fake_get_aggregated_vessels_snapshot(db, *, bbox, limit, observed_since):
|
|
captured["bbox"] = bbox
|
|
captured["limit"] = limit
|
|
captured["observed_since"] = observed_since
|
|
return [
|
|
{
|
|
"mmsi": 1,
|
|
"lat": 59.9,
|
|
"lon": 10.7,
|
|
"received_at": now,
|
|
"name": "Cargo Ship",
|
|
"vessel_type": 70,
|
|
"vessel_type_name": "Cargo",
|
|
},
|
|
{
|
|
"mmsi": 2,
|
|
"lat": 60.3,
|
|
"lon": 5.3,
|
|
"received_at": now,
|
|
"name": "Passenger Ship",
|
|
"vessel_type": 60,
|
|
"vessel_type_name": "Passenger",
|
|
},
|
|
]
|
|
|
|
monkeypatch.setattr(
|
|
visualization,
|
|
"get_aggregated_vessels_snapshot",
|
|
fake_get_aggregated_vessels_snapshot,
|
|
)
|
|
|
|
class _Result:
|
|
def all(self):
|
|
return []
|
|
|
|
class _FakeSession:
|
|
async def execute(self, _query):
|
|
return _Result()
|
|
|
|
async def override_get_db():
|
|
yield _FakeSession()
|
|
|
|
app.dependency_overrides[get_db] = override_get_db
|
|
transport = ASGITransport(app=app)
|
|
try:
|
|
async with AsyncClient(transport=transport, base_url="http://test") as client:
|
|
response = await client.get(
|
|
"/api/v1/vessels/snapshot",
|
|
params={
|
|
"bbox": "10,59,11,60",
|
|
"zoom": 12,
|
|
"type": "cargo",
|
|
"limit": 5000,
|
|
"since_minutes": 30,
|
|
},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["count"] == 1
|
|
assert data["features"][0]["properties"]["name"] == "Cargo Ship"
|
|
assert captured["bbox"] == (10.0, 59.0, 11.0, 60.0)
|
|
assert captured["limit"] == 5000
|
|
assert data["diagnostics"]["bbox_applied"] is True
|
|
assert data["diagnostics"]["legacy_feature_count"] == 0
|
|
assert data["diagnostics"]["legacy_backfilled_mmsi"] == 0
|
|
finally:
|
|
app.dependency_overrides.clear()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_vessel_snapshot_uses_legacy_fallback_when_raw_window_is_empty(monkeypatch):
|
|
now = datetime(2026, 4, 28, 1, 0, tzinfo=timezone.utc)
|
|
monkeypatch.setattr(
|
|
visualization,
|
|
"get_aggregated_vessels_snapshot",
|
|
AsyncMock(return_value=[]),
|
|
)
|
|
monkeypatch.setattr(
|
|
visualization,
|
|
"_load_legacy_vessel_snapshot_features",
|
|
AsyncMock(
|
|
return_value=[
|
|
{
|
|
"type": "Feature",
|
|
"id": 257123000,
|
|
"geometry": {"type": "Point", "coordinates": [10.73, 59.91]},
|
|
"properties": {
|
|
"mmsi": 257123000,
|
|
"name": "OSLO TRADER",
|
|
"vessel_type": 70,
|
|
"vessel_type_name": "Cargo",
|
|
"received_at": now.isoformat(),
|
|
},
|
|
}
|
|
]
|
|
),
|
|
)
|
|
|
|
result = await visualization.build_vessel_snapshot_response(
|
|
object(),
|
|
bbox=(10.0, 59.0, 11.0, 60.0),
|
|
zoom=12,
|
|
type_filter=None,
|
|
limit=1000,
|
|
since_minutes=60,
|
|
)
|
|
|
|
assert result["count"] == 1
|
|
assert result["features"][0]["properties"]["name"] == "OSLO TRADER"
|
|
assert result["diagnostics"]["raw_feature_count"] == 0
|
|
assert result["diagnostics"]["legacy_feature_count"] == 1
|
|
assert result["diagnostics"]["legacy_backfilled_mmsi"] == 1
|
|
assert result["diagnostics"]["legacy_fallback_used"] is True
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_vessel_name_fallbacks_reports_mmsi_display_names(monkeypatch):
|
|
now = datetime(2026, 4, 28, 1, 0, tzinfo=timezone.utc)
|
|
monkeypatch.setattr(
|
|
visualization,
|
|
"get_aggregated_vessels",
|
|
AsyncMock(
|
|
return_value=[
|
|
{
|
|
"mmsi": 257123000,
|
|
"lat": 59.9,
|
|
"lon": 10.7,
|
|
"received_at": now,
|
|
"name": "MMSI 257123000",
|
|
"vessel_type_name": "Other",
|
|
"source_summary": {
|
|
"aisstream_vessels": {
|
|
"latest_observed_at": now,
|
|
"message_types": ["PositionReport"],
|
|
}
|
|
},
|
|
}
|
|
]
|
|
),
|
|
)
|
|
|
|
class _Result:
|
|
def all(self):
|
|
return []
|
|
|
|
class _FakeSession:
|
|
async def execute(self, _query):
|
|
return _Result()
|
|
|
|
async def override_get_db():
|
|
yield _FakeSession()
|
|
|
|
app.dependency_overrides[get_db] = override_get_db
|
|
transport = ASGITransport(app=app)
|
|
try:
|
|
async with AsyncClient(transport=transport, base_url="http://test") as client:
|
|
response = await client.get("/api/v1/visualization/vessels/name-fallbacks")
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["count"] == 1
|
|
assert data["items"][0]["mmsi"] == "257123000"
|
|
assert data["items"][0]["message_types"] == ["PositionReport"]
|
|
finally:
|
|
app.dependency_overrides.clear()
|