← Argus Live
FlytBase “The Tireless Hand” · Level 2

Is what the screen shows actually true — across a whole workflow?

Level 1 asked whether each screen looks right. Level 2 reads real values out of the live product — a drone's latitude and longitude off the 3D map, the video's decoded frame rate, the movement trail's geometry — and compares them against the simulator's ground truth. So it catches wrong or stale live data with exact evidence, and passes cleanly when the product is correct.

Cesium map · real lat/lon Video frame counters Chrome DevTools timing Ground-truth oracles
5
scenarios, each recorded
2
genuine issues
3
precision passes
110 m
map position error caught
0 m
trail deviation (bonus)
The core idea, on the map

Read the drone's real coordinates off the live map — then compare to truth

The strongest Level‑2 check is geospatial. Argus reaches the running Cesium viewer through the page's React fiber and reads each drone marker's actual position, converting it to latitude/longitude with the map's own WGS‑84 ellipsoid. Ground truth is the simulator's true position; the gap is measured in metres.

In normal flight the marker matches the drone to within a metre. Delay the telemetry by 8 seconds and the marker keeps showing where the drone was — up to 110 m from where it is — with no stale indicator. An operator directing ground crews to that spot would be 110 m off. That is a real, high‑impact bug, proven with coordinates, not pixels.

shown on map true position 110 m off under an 8 s telemetry delay · no stale indicator shown 
UI marker   18.56179, 73.69496
ground truth 18.56247, 73.69572
gap 110 m · stale indicator: none
Architecture

Three deeper probes, each read from the live product and checked against truth

geospatial

Real lat/lon off the 3D map

Reach the live Cesium viewer via React fiber; read marker and trail positions; convert with the map's WGS‑84 ellipsoid; compare to the simulator in metres.

video

Decoded frames + perceptual hash

Liveness from the `<video>` element's frame counter and a frame hash, so a frozen or wrong‑source stream is caught even when the label says “live”.

performance

Chrome DevTools timing

Long‑Tasks blocking, click‑to‑paint latency and JS‑heap size, measured at rest and under a sustained multi‑drone load.

Ground truth (simulator state, backend health, active faults) always comes from the control API and a socket feed subscribed like the cockpit — never from the UI under test. Verdicts are deterministic; symptoms of one root cause are grouped; correct behaviour is reported as PASS.

Scenarios

Two issues, three precision passes

Each scenario below has its own recording with voice narration and a live evidence overlay — turn your sound on 🔊

Scenario 1BUGMap & geospatialhigh impact

The map shows an old drone position as current

Expects
The map marker reflects where the drone actually is; if data is delayed, the UI says so.
Approach
Fly the drone; read the marker's real lat/lon off the live Cesium map and confirm it matches truth to a metre; delay telemetry 8 s and measure how far the marker falls behind, and whether the UI warns.
Result
Marker drifted to 110 m behind the true position, still shown as current, with no stale indicator. Maps to the brief's “an old position looks current.”
UI marker 18.56179, 73.69496 · truth 18.56247, 73.69572 · gap 25→50→75→100→110 m · baseline (live) within 1 m
Scenario 2BUGVideo & media

Frozen drone video still labelled “live”

Expects
If the stream freezes, the operator is not told the picture is live.
Approach
Measure decoded frames per second on the real video element and read the tile's label every second after freezing the stream.
Result
0 frames/second for 5 seconds while labelled “live.” Maps to “a dropped stream still looks live.”
label “live” · 0 fps decoded · fault active: video‑freeze
Scenario 3PASSMapbonus: movement trails

The drone movement trail matches the real flight path

Expects
The drawn trail records where the drone actually flew.
Approach
Sample the drone's true positions through a flight; read the trail polyline from the live map; check every true position lies on the trail and the trail ends at the drone.
Result
49 trail points, 0 m worst deviation, endpoint 10 m from the drone — PASS. Verifies a bonus capability's correctness, not just faults.
Scenario 4PASSFunctional · cross-part

Selecting a drone switches map, video and telemetry together

Expects
Selecting a drone shows that drone's state everywhere at once.
Approach
Select Drone 2; check the video frame changes to a distinct feed (perceptual hash), the telemetry battery matches Drone 2's true battery, and the label follows the selection.
Result
All three switched consistently — PASS. Connects behaviour across related parts of the product with no false positive.
Scenario 5PASSPerformance & long-running

Responsive with 16 flying drones over ~10 simulated minutes

Expects
The cockpit stays usable when many drones fly and data streams for a long time.
Approach
Measure frame timing, Long‑Task blocking, click‑to‑paint latency and JS heap at rest, then add 12 drones, fly all 16 at 5× speed and re‑measure across the run.
Result
Click‑to‑paint 28–123 ms (under 250 ms), no long‑task stalls, heap garbage‑collected (no leak) — PASS. Proves the product scales, measured not assumed.
Bonus-capability coverage

The same ground-truth method extends to the bonus features

Bonus capabilityHow Argus tests it
Movement trails · shownRead the drawn trail polyline from the live map; verify it matches the drone's true flown path within tolerance.
Alerts & notificationsDrive a real condition (low battery, disconnect) via the control API and assert the correct alert appears and clears — never spuriously.
Shared map drawings & markersRead placed markers/shapes from the Cesium viewer; verify coordinates and that they replicate to a second operator.
Synchronized replayCompare the replay's positions and timeline against the recorded ground‑truth trajectory, frame for frame.
Multiple video layoutsVerify each tile shows a distinct, correctly‑labelled feed (perceptual hash per drone) across layouts.
Search & filtering in historyAssert filtered results match the ground‑truth event log — nothing missing, duplicated or misattributed.
Reproduce

Every scenario runs from one command

# start the product
docker compose up --build            # cockpit :4010 · control API :4000/api

# run a Level-2 scenario (a real Chrome opens and records)
argus live run --only S11         # map shows an old position as current
argus live run --only S12         # movement-trail accuracy (bonus)
argus live run                    # the whole suite

Each run writes runs/live/<id>/ — an MP4 with a HUD narrating UI‑claim vs ground‑truth, screenshots, timed samples and a machine‑readable result.json.