feat(submissions): query bounded anonymous performance snapshots

backend/tests/test_performance_queries.py

@@ -0,0 +1,112 @@
+"""Integer-domain tests and finite PG read integration, not measured executions."""
+
+import asyncio
+from datetime import UTC, datetime
+
+import pytest
+from test_coordinator import claim, fixture, manifest, stages, synthetic_report, worker_headers
+
+from kf_oj.contracts.judging import I64_MAX
+from kf_oj.modules.submissions.performance import metric
+
+
+@pytest.mark.parametrize(
+    "current,values,greater,ties",
+    [
+        (0, [0, 0, 1, 2, 2], 3, 2),
+        (
+            9_007_199_254_740_993,
+            [9_007_199_254_740_992, 9_007_199_254_740_993, 9_007_199_254_740_994, I64_MAX, 0],
+            2,
+            1,
+        ),
+        (I64_MAX, [0, 1, 2, 3, 4], 0, 0),
+        (0, [0, 0, 0, 0, 0], 0, 5),
+    ],
+)
+def test_exact_metrics_keep_zero_ties_and_extreme_values(current, values, greater, ties):
+    now = datetime.now(UTC)
+    result = metric("cpu_microseconds", current, [(v, now) for v in values])
+    assert result.available and result.current == str(current)
+    assert result.strictly_slower_count == greater and result.tied_count == ties
+    assert sum(b.count for b in result.buckets) == len(values)
+    assert len(result.buckets) <= 24
+    for value in values:
+        assert (
+            sum(
+                int(b.start) <= value < int(b.end) or (b.upper_inclusive and value == int(b.end))
+                for b in result.buckets
+            )
+            == 1
+        )
+
+
+def test_recent_window_missing_and_insufficient_are_distinct():
+    now = datetime.now(UTC)
+    limited = metric("bytes", 0, [(1, now)] * 10_001)
+    assert limited.sample_count == 10_000 and limited.window_truncated
+    assert limited.strictly_slower_count == 10_000
+    assert metric("bytes", None).reason == "measurement_missing"
+    assert metric("bytes", 0).reason == "insufficient_samples"
+    assert metric("bytes", 0, [(0, now)] * 4).buckets == ()
+
+
+def test_actual_owned_read_snapshot_cache_invalidation_and_history(
+    postgres_url, tmp_path, monkeypatch
+):
+    async def run():
+        async with fixture(
+            postgres_url, tmp_path, monkeypatch, measurement_epochs=["a" * 64] * 2
+        ) as (client, connection, workers, _, create):
+            app = client.fixture_app
+            owner = client.fixture_account
+            created_items = []
+            for _ in range(6):
+                created = await create()
+                grant = await claim(client, created, workers[0])
+                await stages(client, workers[0], grant)
+                report = synthetic_report(grant, await manifest(connection, grant))
+                result = await client.post(
+                    "/internal/report", json=report, headers=worker_headers(workers[0], grant)
+                )
+                assert result.status_code == 204, result.text
+                created_items.append(created)
+            target = created_items[0].submission_id
+            first = await app.state.submission_performance.detail(owner, target)
+            assert first.cpu.sample_count == 5 and first.cpu.tied_count == 5
+            assert first.cpu.strictly_slower_count == 0 and first.memory.tied_count == 5
+            cached = await app.state.submission_performance.detail(owner, target)
+            assert cached == first
+            pending = await create()
+            assert (
+                await app.state.submission_performance.detail(owner, pending.submission_id)
+            ).cpu.reason == "not_accepted"
+            grant = await claim(client, pending, workers[0])
+            await stages(client, workers[0], grant)
+            report = synthetic_report(grant, await manifest(connection, grant))
+            assert (
+                await client.post(
+                    "/internal/report", json=report, headers=worker_headers(workers[0], grant)
+                )
+            ).status_code == 204
+            updated = await app.state.submission_performance.detail(owner, target)
+            assert updated.cpu.sample_count == 6 and updated.cpu.tied_count == 6
+            assert updated.as_of >= first.as_of
+            page = await app.state.submission_queries.page(
+                owner, None, 2, client.fixture_version, "c17"
+            )
+            assert len(page.items) == 2 and page.next_after
+            older = await app.state.submission_queries.page(
+                owner, page.next_after, 2, client.fixture_version, "c17"
+            )
+            assert len(older.items) == 2
+            assert not {i.submission_id for i in page.items} & {
+                i.submission_id for i in older.items
+            }
+            assert not (
+                await app.state.submission_queries.page(
+                    owner, None, 2, client.fixture_version, "java21"
+                )
+            ).items
+
+    asyncio.run(run())