Add MacBook LAN-sender CI job and tests

Add a new GitHub Actions job (macbook-lan-sender) to smoke-test the MacBook one-click stack using deploy/docker-compose.macbook-base.yml. The job loads built Docker images, pulls base images, sets up Python, brings up the MacBook stack, starts lan_sender inside the telemetry container, runs pytest against a new test file, and collects/logs artifacts on failure. Also add tests/universal-telemetry-software/tests/test_macbook_base_lan_sender.py which exercise container health, status page, PECAN, telemetry logs, WebSocket CAN messages, and health metrics. Update CI compose validation to include the macbook compose file and add the new job as a dependency for publish-telemetry.

Author: haoruizhou

.github/workflows/telemetry-ci.yml

@@ -83,6 +83,7 @@ jobs:
         docker compose -f deploy/docker-compose.yml config --quiet
         docker compose -f deploy/docker-compose.test.yml config --quiet
         docker compose -f deploy/docker-compose.rpi-base.yml config --quiet
+        docker compose -f deploy/docker-compose.macbook-base.yml --env-file deploy/.env.macbook config --quiet
         docker compose -f deploy/docker-compose.staging.yml config --quiet
         docker compose -f deploy/docker-compose.can-test.yml config --quiet
         echo "✓ All compose configs valid"
@@ -489,8 +490,87 @@ jobs:
         # lan_sender runs inside the container — docker compose down stops it automatically
         docker compose -f deploy/docker-compose.lan-sender-test.yml down -v
 
+  # ── MacBook one-click stack smoke test with LAN sender fake car ─────────────
+  macbook-lan-sender:
+    runs-on: ubuntu-latest
+    needs: build
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Download Docker image artifacts
+      uses: actions/download-artifact@v4
+      with:
+        name: docker-images
+        path: /tmp
+
+    - name: Load and tag MacBook stack images
+      run: |
+        docker load -i /tmp/telemetry.tar
+        docker load -i /tmp/pecan.tar
+        docker tag universal-telemetry:test ghcr.io/western-formula-racing/data-acquisition/universal-telemetry:latest
+        docker tag pecan:test ghcr.io/western-formula-racing/data-acquisition/pecan:latest
+
+    - name: Pull base images
+      run: docker pull redis:8.2
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.12'
+
+    - name: Install Python test dependencies
+      run: pip install pytest pytest-asyncio pytest-timeout websockets requests
+
+    - name: Start MacBook base stack
+      working-directory: ./universal-telemetry-software
+      run: |
+        docker compose -f deploy/docker-compose.macbook-base.yml --env-file deploy/.env.macbook down -v --remove-orphans || true
+        docker compose -f deploy/docker-compose.macbook-base.yml --env-file deploy/.env.macbook up -d
+        echo "Waiting for telemetry, WS relay, and PECAN to boot..."
+        sleep 30
+
+    - name: Check MacBook stack health
+      working-directory: ./universal-telemetry-software
+      run: |
+        docker compose -f deploy/docker-compose.macbook-base.yml --env-file deploy/.env.macbook ps
+        docker compose -f deploy/docker-compose.macbook-base.yml --env-file deploy/.env.macbook logs --tail 40
+
+    - name: Start lan_sender.py inside telemetry container
+      run: |
+        docker exec -d daq-telemetry python3 /app/src/lan_sender.py 127.0.0.1 5005
+        echo "lan_sender started inside daq-telemetry"
+
+    - name: Run MacBook stack LAN sender tests
+      working-directory: ./universal-telemetry-software
+      run: python -m pytest tests/test_macbook_base_lan_sender.py -v -s --timeout=120
+
+    - name: Collect MacBook stack logs on failure
+      if: failure()
+      working-directory: ./universal-telemetry-software
+      run: |
+        mkdir -p test-logs
+        docker compose -f deploy/docker-compose.macbook-base.yml --env-file deploy/.env.macbook logs --no-color > test-logs/macbook-compose.log 2>&1
+        docker logs daq-telemetry > test-logs/macbook-telemetry.log 2>&1 || true
+        docker logs daq-pecan     > test-logs/macbook-pecan.log 2>&1 || true
+        docker logs daq-redis     > test-logs/macbook-redis.log 2>&1 || true
+
+    - name: Upload MacBook stack logs
+      if: failure()
+      uses: actions/upload-artifact@v4
+      with:
+        name: macbook-lan-sender-test-logs
+        path: universal-telemetry-software/test-logs/
+        retention-days: 7
+
+    - name: Cleanup MacBook stack
+      if: always()
+      working-directory: ./universal-telemetry-software
+      run: docker compose -f deploy/docker-compose.macbook-base.yml --env-file deploy/.env.macbook down -v
+
   publish-telemetry:
-    needs: [unit-tests, integration, vcan, lan-sender]
+    needs: [unit-tests, integration, vcan, lan-sender, macbook-lan-sender]
     runs-on: ubuntu-latest
     if: github.event_name == 'workflow_dispatch' || github.event_name != 'pull_request'
     permissions:

universal-telemetry-software/tests/test_macbook_base_lan_sender.py

@@ -0,0 +1,120 @@
+"""
+Smoke-test the out-of-box MacBook base stack with lan_sender.py as the fake car.
+
+This intentionally targets deploy/docker-compose.macbook-base.yml rather than
+the lean LAN-sender test compose. The MacBook stack exposes telemetry/status,
+PECAN, and the WS relay by default, but it does not expose Redis or TimescaleDB.
+"""
+import asyncio
+import time
+
+import pytest
+import requests
+
+from .test_helpers import DockerHelper, WebSocketHelper, check_http_endpoint, wait_for_service
+
+
+TELEMETRY_CONTAINER = "daq-telemetry"
+PECAN_CONTAINER = "daq-pecan"
+REDIS_CONTAINER = "daq-redis"
+
+STATUS_URL = "http://localhost:8080"
+HEALTH_URL = f"{STATUS_URL}/health"
+PECAN_URL = "http://localhost:3000"
+WS_URL = "ws://localhost:9080"
+
+
+@pytest.fixture(scope="module")
+def docker():
+    return DockerHelper()
+
+
+def _health():
+    response = requests.get(HEALTH_URL, timeout=5)
+    response.raise_for_status()
+    return response.json()
+
+
+def _wait_for_health(predicate, timeout=15):
+    deadline = time.time() + timeout
+    last_payload = None
+    while time.time() < deadline:
+        last_payload = _health()
+        if predicate(last_payload):
+            return last_payload
+        time.sleep(1)
+    raise AssertionError(f"Health condition not met; last payload: {last_payload}")
+
+
+class TestMacBookBaseStack:
+    def test_default_containers_are_running(self, docker):
+        for container in (TELEMETRY_CONTAINER, PECAN_CONTAINER, REDIS_CONTAINER):
+            assert docker.is_container_running(container), f"{container} is not running"
+
+    def test_status_page_is_accessible(self):
+        assert wait_for_service(lambda: check_http_endpoint(STATUS_URL), timeout=10)
+
+    def test_pecan_is_accessible(self):
+        response = requests.get(PECAN_URL, timeout=5)
+        assert response.status_code == 200
+        assert "<div id=\"root\"" in response.text
+
+
+class TestMacBookLanSenderFlow:
+    def test_health_reflects_live_udp_stream(self):
+        payload = _wait_for_health(
+            lambda health: (
+                health.get("car", {}).get("alivable") is True
+                and health.get("components", {}).get("can_bus", {}).get("status") == "ok"
+                and health.get("components", {}).get("udp_listener", {}).get("status") == "ok"
+            ),
+            timeout=20,
+        )
+
+        assert payload["car"]["seen_s_ago"] is not None
+        assert payload["stats"].get("received", 0) >= 0
+
+    def test_telemetry_logs_show_lan_sender_packets(self, docker):
+        logs = docker.get_container_logs(TELEMETRY_CONTAINER, tail=300)
+        assert (
+            "Initial sequence:" in logs
+            or "ECU time sync:" in logs
+            or "Received" in logs
+        ), "Telemetry logs do not show UDP receive activity"
+
+    @pytest.mark.asyncio
+    async def test_websocket_receives_lan_sender_can_data(self):
+        ws = WebSocketHelper(WS_URL)
+        try:
+            await ws.connect()
+            msg = None
+            deadline = asyncio.get_event_loop().time() + 15
+            while asyncio.get_event_loop().time() < deadline:
+                candidate = await ws.receive_message(timeout=2)
+                if isinstance(candidate, list) and candidate:
+                    msg = candidate
+                    break
+
+            assert msg is not None, "No CAN list message received via WebSocket"
+            assert all(k in msg[0] for k in ("time", "canId", "data"))
+        finally:
+            await ws.close()
+
+    @pytest.mark.asyncio
+    async def test_health_splits_internal_relay_and_external_client(self):
+        ws = WebSocketHelper(WS_URL)
+        try:
+            await ws.connect()
+            payload = _wait_for_health(
+                lambda health: (
+                    (health.get("components", {}).get("websocket_bridge", {}).get("internal_clients") or 0) >= 1
+                    and (health.get("components", {}).get("websocket_bridge", {}).get("external_clients") or 0) >= 1
+                ),
+                timeout=15,
+            )
+
+            websocket = payload["components"]["websocket_bridge"]
+            assert websocket["detail"] is None
+            assert websocket["clients"] >= websocket["internal_clients"] + websocket["external_clients"]
+        finally:
+            await ws.close()