Merge pull request #6 from ATNoG/fix-car-names

Random ids

Author: duartebranco

src/services/accident_detector/service.py

@@ -227,6 +227,14 @@ def _detect_sudden_stop(self, update: CarUpdate, state: CarState) -> bool:
     def _on_car_update(self, payload: str):
         try:
             data = json.loads(payload)
+            
+            # Handle test cleanup
+            if data.get("_test_cleanup"):
+                car_id = data.get("car_id")
+                if car_id:
+                    self._cleanup_car(car_id)
+                return
+            
             update = CarUpdate.from_dict(data)
         except Exception as e:
             logger.error(f"Error processing car update: {e}")
@@ -303,6 +311,22 @@ def _on_car_update(self, payload: str):
 
         self._cleanup_expired_accidents()
 
+    def _cleanup_car(self, car_id: str):
+        """Remove all state for a specific car (used for test cleanup)."""
+        # Remove car state
+        if car_id in self.cars:
+            del self.cars[car_id]
+            logger.info(f"[CLEANUP] Removed car state: {car_id}")
+        
+        # Remove any accidents caused by this car
+        accidents_to_remove = [
+            event_id for event_id, accident in self.active_accidents.items()
+            if accident.source_vehicle_id == car_id
+        ]
+        for event_id in accidents_to_remove:
+            del self.active_accidents[event_id]
+            logger.info(f"[CLEANUP] Removed accident {event_id} caused by {car_id}")
+
     def run(self):
         logger.info("Starting Accident Detector...")
         self.mqtt.connect()

src/services/emergency_vehicle_detector/service.py

@@ -41,7 +41,16 @@ def __init__(self, config):
 
     def _on_car_update(self, payload: str):
         try:
-            update = CarUpdate.from_dict(json.loads(payload))
+            data = json.loads(payload)
+            
+            # Handle test cleanup
+            if data.get("_test_cleanup"):
+                car_id = data.get("car_id")
+                if car_id:
+                    self._cleanup_car(car_id)
+                return
+            
+            update = CarUpdate.from_dict(data)
         except Exception as e:
             logger.error(f"Failed to parse car update: {e}")
             return
@@ -86,6 +95,12 @@ def _on_car_update(self, payload: str):
                     f"from {other_id}"
                 )
 
+    def _cleanup_car(self, car_id: str):
+        """Remove all state for a specific car (used for test cleanup)."""
+        if car_id in self.cars:
+            del self.cars[car_id]
+            logger.info(f"[CLEANUP] Removed car state: {car_id}")
+
     def run(self):
         logger.info("Starting Emergency Vehicle Detector...")
         self.mqtt.connect()

src/services/highway_entry_detector/service.py

@@ -276,7 +276,16 @@ def _predict_collision(self, entering_car: CarUpdate, highway_car: CarUpdate) ->
 
     def _on_car_update(self, payload: str):
         try:
-            update = CarUpdate.from_dict(json.loads(payload))
+            data = json.loads(payload)
+            
+            # Handle test cleanup
+            if data.get("_test_cleanup"):
+                car_id = data.get("car_id")
+                if car_id:
+                    self._cleanup_car(car_id)
+                return
+            
+            update = CarUpdate.from_dict(data)
         except Exception as e:
             logger.error(f"Failed to parse car update: {e}")
             return
@@ -318,6 +327,9 @@ def _on_car_update(self, payload: str):
             if dist_to_merge < self.MERGE_POINT_DETECTION_M:
                 logger.info(f"[ENTRY DETECTION] Car {update.car_id} is approaching merge point (distance: {dist_to_merge:.1f}m)")
 
+                # Track if we found any highway cars in detection zone
+                found_highway_car_in_zone = False
+                
                 # Check for potential collisions with highway cars
                 for highway_car_id in self.highway_cars:
                     if highway_car_id not in self.cars:
@@ -339,6 +351,7 @@ def _on_car_update(self, payload: str):
                     )
 
                     if dist_highway_to_merge < self.ENTRY_ZONE_M:
+                        found_highway_car_in_zone = True
                         logger.info(f"[ENTRY DETECTION] Analyzing collision: entering {update.car_id} vs highway {highway_car_id}, dist={dist_highway_to_merge:.1f}m")
                         # Predict collision
                         collision, ttc, min_dist = self._predict_collision(update, highway_car)
@@ -391,6 +404,51 @@ def _on_car_update(self, payload: str):
                                     f"can safely merge. Min distance to {highway_car_id}: {min_dist:.1f}m"
                                 )
                                 self.alerted_pairs.add(pair_key)
+                
+                # If no highway cars found in detection zone, it's safe to enter
+                if not found_highway_car_in_zone:
+                    # Only alert once per entering car
+                    if update.car_id not in [pair[0] for pair in self.alerted_pairs]:
+                        alert = {
+                            "alert_type": "highway_entry_safe",
+                            "entering_car_id": update.car_id,
+                            "highway_car_id": None,
+                            "entering_speed_kmh": update.speed_kmh,
+                            "highway_speed_kmh": None,
+                            "predicted_min_distance_m": None,
+                            "status": "safe",
+                            "timestamp": time.time(),
+                            "latitude": update.latitude,
+                            "longitude": update.longitude,
+                        }
+                        
+                        self.mqtt.publish(self.alert_topic, json.dumps(alert))
+                        logger.info(
+                            f"[HIGHWAY ENTRY - SAFE] Car {update.car_id} "
+                            f"can safely merge - no highway traffic detected in entry zone"
+                        )
+                        # Mark this entering car as alerted
+                        self.alerted_pairs.add((update.car_id, "no-traffic"))
+
+    def _cleanup_car(self, car_id: str):
+        """Remove all state for a specific car (used for test cleanup)."""
+        # Remove from cars dictionary
+        if car_id in self.cars:
+            del self.cars[car_id]
+            logger.info(f"[CLEANUP] Removed car state: {car_id}")
+        
+        # Remove from classification sets
+        self.highway_cars.discard(car_id)
+        self.entering_cars.discard(car_id)
+        
+        # Remove from alerted pairs
+        pairs_to_remove = {
+            pair for pair in self.alerted_pairs 
+            if car_id in pair
+        }
+        self.alerted_pairs -= pairs_to_remove
+        if pairs_to_remove:
+            logger.info(f"[CLEANUP] Removed {len(pairs_to_remove)} alert pairs for {car_id}")
 
     def run(self):
         logger.info("Starting Highway Entry Detector...")

src/services/overtaking_detector/service.py

@@ -63,7 +63,16 @@ def _projection_sign(ax, ay, bx, by, heading_deg) -> int:
 
     def _on_car_update(self, payload: str):
         try:
-            update = CarUpdate.from_dict(json.loads(payload))
+            data = json.loads(payload)
+            
+            # Handle test cleanup
+            if data.get("_test_cleanup"):
+                car_id = data.get("car_id")
+                if car_id:
+                    self._cleanup_car(car_id)
+                return
+            
+            update = CarUpdate.from_dict(data)
         except Exception as e:
             logger.error(f"Failed to parse car update: {e}")
             return
@@ -124,6 +133,23 @@ def _on_car_update(self, payload: str):
             # save new relative sign
             self.relative_positions[key] = sign
 
+    def _cleanup_car(self, car_id: str):
+        """Remove all state for a specific car (used for test cleanup)."""
+        # Remove car state
+        if car_id in self.cars:
+            del self.cars[car_id]
+            logger.info(f"[CLEANUP] Removed car state: {car_id}")
+        
+        # Remove any relative position pairs involving this car
+        pairs_to_remove = [
+            key for key in self.relative_positions.keys()
+            if car_id in key
+        ]
+        for key in pairs_to_remove:
+            del self.relative_positions[key]
+        if pairs_to_remove:
+            logger.info(f"[CLEANUP] Removed {len(pairs_to_remove)} position pairs for {car_id}")
+
     def run(self):
         logger.info("Starting Overtaking Detector...")
         self.mqtt.connect()

src/services/position_processor/service.py

@@ -79,6 +79,15 @@ def _resolve_speed_limit(self, lat: float, lon: float) -> float:
 
 
     def _handle_raw_gps(self, car_id: str, lat: float, lon: float, emergency: bool = False):
+        # Handle test cleanup marker (coordinates at origin with tiny tolerance)
+        if abs(lat) < 0.0001 and abs(lon) < 0.0001:
+            # This is a cleanup signal, remove the car state
+            with self.states_lock:
+                if car_id in self.states:
+                    del self.states[car_id]
+                    logger.info(f"[CLEANUP] Removed car state: {car_id}")
+            return
+        
         now = time.time()
 
         # Thread-safe state access

tests/conftest.py

@@ -0,0 +1,119 @@
+"""Pytest configuration for test suite."""
+import json
+import os
+import time
+import uuid
+from pathlib import Path
+from typing import List
+
+import paho.mqtt.client as mqtt
+import pytest
+
+# Test configuration
+MQTT_HOST = os.getenv("MQTT_HOST", "localhost")
+MQTT_PORT = int(os.getenv("MQTT_PORT", "1884"))
+SIM_DIR = Path(__file__).resolve().parent.parent / "simulations"
+
+
+def pytest_addoption(parser):
+    """Add custom command-line options to pytest."""
+    parser.addoption(
+        "--fixed-ids",
+        action="store_true",
+        default=False,
+        help="Use fixed car IDs instead of random UUIDs (useful for frontend testing)",
+    )
+
+
+@pytest.fixture(scope="session")
+def use_fixed_ids(request):
+    """Fixture that returns whether to use fixed car IDs."""
+    return request.config.getoption("--fixed-ids")
+
+
+@pytest.fixture
+def test_car_registry():
+    """Track all cars created during a test for cleanup."""
+    car_ids = []
+    yield car_ids
+    # Cleanup after test - happens even if test fails
+    _cleanup_test_cars(car_ids)
+
+
+@pytest.fixture
+def get_car_id(use_fixed_ids, test_car_registry):
+    """Fixture that returns a function to generate car IDs and track them for cleanup."""
+    def _get_car_id(base_name: str) -> str:
+        """Generate car ID: random UUID by default, or fixed name with --fixed-ids flag."""
+        if use_fixed_ids:
+            car_id = base_name
+        else:
+            car_id = f"{base_name}-{str(uuid.uuid4())[:8]}"
+        
+        # Register for cleanup
+        test_car_registry.append(car_id)
+        return car_id
+    
+    return _get_car_id
+
+
+def _cleanup_test_cars(car_ids: List[str]) -> None:
+    """
+    Comprehensive cleanup of test cars:
+    1. Send cleanup signals to services via MQTT
+    2. Remove local device files
+    3. Wait for services to process cleanup
+    """
+    if not car_ids:
+        return
+    
+    print(f"\n[CLEANUP] Removing {len(car_ids)} test cars from services...")
+    
+    # Send cleanup messages to services
+    try:
+        client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2)
+        client.connect(MQTT_HOST, MQTT_PORT, keepalive=5)
+        client.loop_start()
+        time.sleep(0.2)  # Ensure connection established
+        
+        for car_id in car_ids:
+            # Send cleanup signal to all services
+            cleanup_msg = json.dumps({
+                "action": "cleanup",
+                "car_id": car_id,
+                "timestamp": time.time()
+            })
+            client.publish(f"test/cleanup/{car_id}", cleanup_msg, qos=1)
+            
+            # Also send a final position update with special marker to trigger state cleanup
+            # This ensures the car is removed from all service states
+            cleanup_update = json.dumps({
+                "car_id": car_id,
+                "latitude": 0.0,
+                "longitude": 0.0,
+                "speed_kmh": None,
+                "heading_deg": None,
+                "speed_limit_kmh": 50.0,
+                "emergency": False,
+                "timestamp": time.time(),
+                "_test_cleanup": True
+            })
+            client.publish("cars/updates", cleanup_update, qos=1)
+            
+        # Give services time to process cleanup messages
+        time.sleep(0.3)
+        client.loop_stop()
+        client.disconnect()
+    except Exception as e:
+        print(f"[CLEANUP] Warning: MQTT cleanup failed: {e}")
+    
+    # Remove local device files
+    for car_id in car_ids:
+        car_file = SIM_DIR / "devices" / f"{car_id}.json"
+        if car_file.exists():
+            try:
+                car_file.unlink()
+            except Exception as e:
+                print(f"[CLEANUP] Warning: Failed to delete {car_file}: {e}")
+    
+    print(f"[CLEANUP] Cleanup complete for {len(car_ids)} cars")